Create & Init Project...

app/admin/main/activity/service/BUILD

@@ -0,0 +1,74 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "archive.go",
+        "likes.go",
+        "service.go",
+        "subject.go",
+    ],
+    importpath = "go-common/app/admin/main/activity/service",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/admin/main/activity/conf:go_default_library",
+        "//app/admin/main/activity/dao:go_default_library",
+        "//app/admin/main/activity/model:go_default_library",
+        "//app/interface/main/tag/model:go_default_library",
+        "//app/interface/main/tag/rpc/client:go_default_library",
+        "//app/interface/openplatform/article/model:go_default_library",
+        "//app/interface/openplatform/article/rpc/client:go_default_library",
+        "//app/service/main/account/api:go_default_library",
+        "//app/service/main/archive/api: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/time:go_default_library",
+        "//library/xstr:go_default_library",
+        "//vendor/github.com/jinzhu/gorm:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [
+        ":package-srcs",
+        "//app/admin/main/activity/service/kfc:all-srcs",
+    ],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "archive_test.go",
+        "likes_test.go",
+        "service_test.go",
+        "subject_test.go",
+    ],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/admin/main/activity/conf:go_default_library",
+        "//app/admin/main/activity/model:go_default_library",
+        "//library/time:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)

app/admin/main/activity/service/archive.go

@@ -0,0 +1,27 @@
+package service
+
+import (
+	"context"
+
+	lmdl "go-common/app/admin/main/activity/model"
+	arcmdl "go-common/app/service/main/archive/api"
+	"go-common/library/log"
+)
+
+// Archives get achives info .
+func (s *Service) Archives(c context.Context, p *lmdl.ArchiveParam) (res map[int64]*arcmdl.Arc, err error) {
+	var (
+		arcs *arcmdl.ArcsReply
+	)
+	if arcs, err = s.arcClient.Arcs(c, &arcmdl.ArcsRequest{Aids: p.Aids}); err != nil {
+		log.Error("s.arcClient.Archives3(%v) error(%v)", p.Aids, err)
+		return
+	}
+	res = make(map[int64]*arcmdl.Arc, len(p.Aids))
+	for _, aid := range p.Aids {
+		if arc, ok := arcs.Arcs[aid]; ok && arc.IsNormal() {
+			res[aid] = arc
+		}
+	}
+	return
+}

app/admin/main/activity/service/archive_test.go

@@ -0,0 +1,21 @@
+package service
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	lmdl "go-common/app/admin/main/activity/model"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestService_Archives(t *testing.T) {
+	Convey("service test", t, WithService(func(s *Service) {
+		res, err := s.Archives(context.Background(), &lmdl.ArchiveParam{Aids: []int64{10110582, 10110581}})
+		So(err, ShouldBeNil)
+		for _, v := range res {
+			fmt.Printf("%+v", v)
+		}
+	}))
+}

app/admin/main/activity/service/kfc/BUILD

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

@@ -0,0 +1,40 @@
+package kfc
+
+import (
+	"context"
+
+	"go-common/app/admin/main/activity/conf"
+	kfcDao "go-common/app/admin/main/activity/dao/kfc"
+	kfcmdl "go-common/app/admin/main/activity/model/kfc"
+	"go-common/library/log"
+)
+
+// Service struct
+type Service struct {
+	c   *conf.Config
+	dao *kfcDao.Dao
+}
+
+// Close service
+func (s *Service) Close() {
+	if s.dao != nil {
+		s.dao.Close()
+	}
+}
+
+// New Service
+func New(c *conf.Config) (s *Service) {
+	s = &Service{
+		c:   c,
+		dao: kfcDao.New(c),
+	}
+	return
+}
+
+// List .
+func (s *Service) List(c context.Context, arg *kfcmdl.ListParams) (list []*kfcmdl.BnjKfcCoupon, err error) {
+	if list, err = s.dao.SearchList(c, arg.CouponCode, arg.Mid, arg.Pn, arg.Ps); err != nil {
+		log.Error("s.dao.SearchList(%v) error(%+v)", arg, err)
+	}
+	return
+}

app/admin/main/activity/service/likes.go

@@ -0,0 +1,606 @@
+package service
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net"
+	"time"
+
+	"go-common/app/admin/main/activity/model"
+	tagmdl "go-common/app/interface/main/tag/model"
+	artmdl "go-common/app/interface/openplatform/article/model"
+	acccli "go-common/app/service/main/account/api"
+	arcmdl "go-common/app/service/main/archive/api"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	"go-common/library/net/metadata"
+	"go-common/library/sync/errgroup"
+	xtime "go-common/library/time"
+	"go-common/library/xstr"
+
+	"github.com/jinzhu/gorm"
+)
+
+const (
+	_approved   = 1
+	_pending    = 0
+	_tagArcType = 3
+)
+
+// LikesList .
+func (s *Service) LikesList(c context.Context, arg *model.LikesParam) (outRes *model.LikesRes, err error) {
+	var (
+		likeSubject     *model.ActSubject
+		list            []*model.Like
+		likeList        map[int64]*model.Like
+		ids, wids, mids []int64
+		count           int64
+		offset          int
+	)
+	if likeSubject, err = s.dao.ActSubject(c, arg.Sid); err != nil {
+		return
+	}
+	db := s.DB
+	db = db.Where("sid = ?", likeSubject.ID)
+	if len(arg.States) > 0 {
+		db = db.Where("state in (?)", arg.States)
+	}
+	if arg.Mid > 0 {
+		db = db.Where("mid = ?", arg.Mid)
+	}
+	if arg.Wid > 0 {
+		db = db.Where("wid = ?", arg.Wid)
+	}
+	if err = db.Model(model.Like{}).Count(&count).Error; err != nil {
+		log.Error("db.Model(model.Like{}).Count() arg(%v) error(%v) ", arg, err)
+		return
+	}
+	offset = (arg.Page - 1) * arg.PageSize
+	if err = db.Offset(offset).Limit(arg.PageSize).Order("id asc").Find(&list).Error; err != nil && err != gorm.ErrRecordNotFound {
+		log.Error("db.Model(model.Like{}).Find() arg(%v) error(%v)", arg, err)
+		return
+	}
+	likeList = make(map[int64]*model.Like, len(list))
+	ids = make([]int64, 0, len(list))
+	wids = make([]int64, 0, len(list))
+	mids = make([]int64, 0, len(list))
+	for _, val := range list {
+		ids = append(ids, val.ID)
+		wids = append(wids, val.Wid)
+		mids = append(mids, val.Mid)
+		likeList[val.ID] = val
+		//like 根据最新的逻辑获取，现在无法获取 todo
+		likeList[val.ID].Like = 0
+	}
+	if len(list) > 0 {
+		if err = s.GetContent(c, likeSubject.Type, likeList, ids, wids, mids); err != nil {
+			log.Error("s.GetContent(%d,%v,%v,%v,%v) error(%v)", likeSubject.Type, likeList, ids, mids, wids, err)
+			return
+		}
+	}
+	outRes = &model.LikesRes{
+		Likes: likeList,
+	}
+	outRes.Size = arg.PageSize
+	outRes.Num = arg.Page
+	outRes.Total = count
+	return
+}
+
+// Likes .
+func (s *Service) Likes(c context.Context, Sid int64, lids []int64) (likeList map[int64]*model.Like, err error) {
+	var (
+		likeSubject     *model.ActSubject
+		like            []*model.Like
+		ids, wids, mids []int64
+	)
+	if likeSubject, err = s.dao.ActSubject(c, Sid); err != nil {
+		return
+	}
+	if err = s.DB.Where("id in (?)", lids).Find(&like).Error; err != nil {
+		log.Error("s.DB.Where(id in (%v)).Find() error(%v)", lids, err)
+		return
+	}
+	likeList = make(map[int64]*model.Like, len(like))
+	ids = make([]int64, 0, len(like))
+	wids = make([]int64, 0, len(like))
+	mids = make([]int64, 0, len(like))
+	for _, val := range like {
+		ids = append(ids, val.ID)
+		wids = append(wids, val.Wid)
+		mids = append(mids, val.Mid)
+		likeList[val.ID] = val
+		//like 根据最新的逻辑获取，现在无法获取 todo
+		likeList[val.ID].Like = 0
+	}
+	if len(like) > 0 {
+		if err = s.GetContent(c, likeSubject.Type, likeList, ids, wids, mids); err != nil {
+			log.Error("s.GetContent( %d, %v, %v, %v, %v) error(%v)", likeSubject.Type, likeList, ids, mids, wids, err)
+		}
+	}
+	return
+}
+
+// archiveWithTag get archives and tags.
+func (s *Service) archiveWithTag(c context.Context, aids []int64, likes map[int64]*model.Like) (err error) {
+	var (
+		archives       *arcmdl.ArcsReply
+		arcErr, tagErr error
+		tags           map[int64][]*tagmdl.Tag
+		ip             = metadata.String(c, metadata.RemoteIP)
+	)
+	group, errCtx := errgroup.WithContext(c)
+	group.Go(func() error {
+		if archives, arcErr = s.arcClient.Arcs(errCtx, &arcmdl.ArcsRequest{Aids: aids}); err != nil {
+			log.Error("s.arcClient.Arcs(%v, %s) error(%v)", aids, ip, err)
+			return arcErr
+		}
+		return nil
+	})
+	group.Go(func() error {
+		arg := &tagmdl.ArgResTags{Oids: aids, Type: _tagArcType, RealIP: ip}
+		if tags, tagErr = s.tagRPC.ResTags(errCtx, arg); tagErr != nil {
+			log.Error("ResTags接口错误 s.tag.ResTag(%+v) error(%v)", arg, tagErr)
+			return tagErr
+		}
+		return nil
+	})
+	if err = group.Wait(); err != nil {
+		return
+	}
+	for _, val := range likes {
+		if val.Wid != 0 {
+			tem := make(map[string]interface{}, 2)
+			if arch, ok := archives.Arcs[val.Wid]; ok && arch.IsNormal() {
+				tem["archives"] = arch
+			}
+			if tag, ok := tags[val.Wid]; ok {
+				temps := make([]string, 0, len(tag))
+				for _, val := range tag {
+					temps = append(temps, val.Name)
+				}
+				tem["tags"] = temps
+			}
+			val.Object = tem
+		}
+	}
+	return
+}
+
+// accountAndContent get likecontent and accountinfo .
+func (s *Service) accountAndContent(c context.Context, ids []int64, mids []int64, likes map[int64]*model.Like) (err error) {
+	var (
+		contents map[int64]*model.LikeContent
+		accRly   *acccli.CardsReply
+	)
+	if contents, err = s.dao.GetLikeContent(c, ids); err != nil {
+		log.Error(" s.dao.GetLikeContent(%v) error(%v)", ids, err)
+		return
+	}
+	if accRly, err = s.accClient.Cards3(c, &acccli.MidsReq{Mids: mids}); err != nil {
+		log.Error("s.AccountsInfo(%v) error(%v)", mids, err)
+		return
+	}
+	for _, val := range likes {
+		temp := make(map[string]interface{}, 2)
+		if cont, ok := contents[val.ID]; ok {
+			temp["content"] = cont
+		}
+		if val.Mid != 0 && accRly != nil {
+			if acct, ok := accRly.Cards[val.Mid]; ok {
+				temp["owner"] = map[string]interface{}{
+					"mid":   acct.Mid,
+					"name":  acct.Name,
+					"face":  acct.Face,
+					"sex":   acct.Sex,
+					"level": acct.Level,
+				}
+			}
+		}
+		val.Object = temp
+	}
+	return
+}
+
+// articles .
+func (s *Service) articles(c context.Context, wids []int64, likes map[int64]*model.Like) (err error) {
+	var artiRes map[int64]*artmdl.Meta
+	if artiRes, err = s.artRPC.ArticleMetas(c, &artmdl.ArgAids{Aids: wids}); err != nil {
+		log.Error("s.ArticleMetas(%v) error(%v)", wids, err)
+		return
+	}
+	for _, val := range likes {
+		if val.Wid != 0 {
+			if v, ok := artiRes[val.Wid]; ok {
+				val.Object = map[string]interface{}{
+					"article": v,
+				}
+			}
+		}
+	}
+	return
+}
+
+// musicsAndAct .
+func (s *Service) musicsAndAct(c context.Context, wids, mids []int64, likes map[int64]*model.Like) (err error) {
+	var (
+		musics *model.MusicRes
+		accRly *acccli.CardsReply
+		ip     = metadata.String(c, metadata.RemoteIP)
+	)
+	if musics, err = s.dao.Musics(c, wids, ip); err != nil {
+		log.Error("s.dao.Musics(%v) error(%+v)", wids, err)
+		return
+	}
+	if accRly, err = s.accClient.Cards3(c, &acccli.MidsReq{Mids: mids}); err != nil {
+		log.Error("s.AccountsInfo(%v) error(%v)", mids, err)
+		return
+	}
+	for _, val := range likes {
+		temp := make(map[string]interface{}, 2)
+		if v, ok := musics.Data[val.Wid]; ok {
+			temp["music"] = v
+		}
+		if val.Mid != 0 && accRly != nil {
+			if acct, ok := accRly.Cards[val.Mid]; ok {
+				temp["owner"] = map[string]interface{}{
+					"mid":   acct.Mid,
+					"name":  acct.Name,
+					"face":  acct.Face,
+					"sex":   acct.Sex,
+					"level": acct.Level,
+				}
+			}
+		}
+		val.Object = temp
+	}
+	return
+}
+
+// GetContent get act_subjet extensions .
+func (s *Service) GetContent(c context.Context, likeSubType int, likes map[int64]*model.Like, ids []int64, wids []int64, mids []int64) (err error) {
+	switch likeSubType {
+	case model.PICTURE, model.PICTURELIKE, model.DRAWYOO, model.DRAWYOOLIKE, model.TEXT, model.TEXTLIKE, model.QUESTION:
+		err = s.accountAndContent(c, ids, mids, likes)
+	case model.VIDEO, model.VIDEOLIKE, model.ONLINEVOTE, model.VIDEO2, model.PHONEVIDEO, model.SMALLVIDEO:
+		err = s.archiveWithTag(c, wids, likes)
+	case model.ARTICLE:
+		err = s.articles(c, wids, likes)
+	case model.MUSIC:
+		err = s.musicsAndAct(c, wids, mids, likes)
+	default:
+		err = ecode.RequestErr
+	}
+	return
+}
+
+// ItemUp .
+func (s *Service) ItemUp(c context.Context, sid, wid int64, state int) (likeList *model.Like, err error) {
+	var likeSubject *model.ActSubject
+	if likeSubject, err = s.dao.ActSubject(c, sid); err != nil {
+		log.Error("s.GetLikesSubjectByID(%d) error(%v)", sid, err)
+		return
+	}
+	likeList = new(model.Like)
+	if err = s.DB.Where("sid =?", likeSubject.ID).Where("wid = ?", wid).Last(likeList).Error; err != nil && err != gorm.ErrRecordNotFound {
+		log.Error("s.DB.Model(model.Like{}).Where(sid =? %d).Where(wid = ?, %d).Last(),error(%v)", likeSubject.ID, wid, err)
+		return
+	}
+	if likeList.ID == 0 {
+		err = nil
+		return
+	}
+	likeList.State = state
+	likeList.Mtime = xtime.Time(time.Now().Unix())
+	if err = s.DB.Model(&model.Like{}).Where("id =?", likeList.ID).Update(map[string]interface{}{"state": state, "mtime": likeList.Mtime.Time().Format("2006-01-02 15:04:05")}).Error; err != nil {
+		log.Error("s.DB.Model(&model.Like{}).Where(id =?, %d).Update() error(%v) ", likeList.ID, err)
+	}
+	return
+}
+
+// ItemAdd .
+func (s *Service) ItemAdd(c context.Context, args *model.AddLikes) (likeList *model.Like, err error) {
+	var (
+		likeSubject *model.ActSubject
+		ip          = metadata.String(c, metadata.RemoteIP)
+	)
+	if likeSubject, err = s.dao.ActSubject(c, args.Sid); err != nil {
+		log.Error(" s.GetLikesSubjectByID(%d) error(%v) ", args.Sid, err)
+		return
+	}
+	//怀疑原代码这里是个bug？？ todo
+	if args.Type != likeSubject.Type {
+		err = errors.New("ItemAdd params liketype error")
+		return
+	}
+	likeList = new(model.Like)
+	if err = s.DB.Where("sid =?", likeSubject.ID).Where("wid = ?", args.Wid).Last(likeList).Error; err != nil && err != gorm.ErrRecordNotFound {
+		log.Error("s.DB.Model(model.Like{}).Where(sid =?, %d).Where(wid = ?, %d).Last() error(%v)", likeSubject.ID, args.Wid, err)
+		return
+	}
+	if err == gorm.ErrRecordNotFound {
+		addLike := &model.Like{
+			Type:  args.Type,
+			Wid:   args.Wid,
+			Sid:   likeSubject.ID,
+			Mid:   args.Mid,
+			State: args.State,
+		}
+		ipv6 := net.ParseIP(ip)
+		if ipv6 == nil {
+			ipv6 = []byte{}
+		}
+		addLikeContent := &model.LikeContent{
+			Plat:    args.Plat,
+			Device:  args.Device,
+			Message: "no",
+			Image:   "no",
+			IPv6:    ipv6,
+		}
+		tx := s.DB.Begin()
+		if err = tx.Create(addLike).Error; err != nil {
+			log.Error("db.Model(&model.Like{}).Create(%v) error(%v)", addLike, err)
+			tx.Rollback()
+			return
+		}
+		addLikeContent.ID = addLike.ID
+		if err = tx.Create(addLikeContent).Error; err != nil {
+			log.Error("db.Model(&model.LikeContent{}).Create(%v) error(%v)\n", addLikeContent, err)
+			tx.Rollback()
+			return
+		}
+		tx.Commit()
+		likeList = addLike
+	} else {
+		likeList.State = args.State
+		likeList.Mtime = xtime.Time(time.Now().Unix())
+		if err = s.DB.Model(&model.Like{}).Where("id =?", likeList.ID).Update(map[string]interface{}{"state": args.State, "mtime": likeList.Mtime.Time().Format("2006-01-02 15:04:05")}).Error; err != nil {
+			log.Error("s.DB.Model(&model.Like{}).Where(id =?, %d).Update() error(%v) ", likeList.ID, err)
+		}
+	}
+	return
+
+}
+
+// AddPicContent .
+func (s *Service) AddPicContent(c context.Context, args *model.AddPic) (likeID int64, err error) {
+	var (
+		likeSubject *model.ActSubject
+		ip          = metadata.String(c, metadata.RemoteIP)
+	)
+	if likeSubject, err = s.dao.ActSubject(c, args.Sid); err != nil {
+		log.Error(" s.GetLikesSubjectByID(%d) error(%v) ", args.Sid, err)
+		return
+	}
+	likes := &model.Like{
+		Sid:   likeSubject.ID,
+		Wid:   args.Wid,
+		Type:  args.Type,
+		Mid:   args.Mid,
+		State: _pending,
+	}
+	ipv6 := net.ParseIP(ip)
+	if ipv6 == nil {
+		ipv6 = []byte{}
+	}
+	likeContent := &model.LikeContent{
+		IPv6:    ipv6,
+		Plat:    args.Plat,
+		Device:  args.Device,
+		Message: args.Message,
+		Link:    args.Link,
+		Image:   args.Image, //只支持传image串（需要支持传文件）todo
+	}
+	tx := s.DB.Begin()
+	if err = tx.Create(likes).Error; err != nil {
+		log.Error("db.Model(&model.Like{}).Create(%v) error(%v)", likes, err)
+		tx.Rollback()
+		return
+	}
+	likeContent.ID = likes.ID
+	if err = tx.Create(likeContent).Error; err != nil {
+		log.Error("db.Model(&model.LikeContent{}).Create(%v) error(%v)\n", likeContent, err)
+		tx.Rollback()
+		return
+	}
+	tx.Commit()
+	likeID = likes.ID // need to update todo
+	return
+}
+
+// BatchLikes .
+func (s *Service) BatchLikes(c context.Context, args *model.BatchLike) (err error) {
+	var (
+		likes   []*model.Like
+		likeMap map[int64]*model.Like
+		addWid  []int64
+		ipv6    = net.ParseIP(metadata.String(c, metadata.RemoteIP))
+	)
+	if ipv6 == nil {
+		ipv6 = []byte{}
+	}
+	if err = s.DB.Where(fmt.Sprintf("sid = ? and wid in (%s)", xstr.JoinInts(args.Wid)), args.Sid).Find(&likes).Error; err != nil && err != gorm.ErrRecordNotFound {
+		log.Error("s.DB.Where(%d,%v) error(%v)", args.Sid, args.Wid, err)
+		return
+	}
+	if err == gorm.ErrRecordNotFound {
+		addWid = args.Wid
+	} else {
+		likeMap = make(map[int64]*model.Like, len(likes))
+		for _, v := range likes {
+			likeMap[v.Wid] = v
+		}
+		addWid = make([]int64, 0, len(args.Wid))
+		for _, v := range args.Wid {
+			if _, ok := likeMap[v]; !ok {
+				addWid = append(addWid, v)
+			}
+		}
+	}
+	if len(addWid) == 0 {
+		return
+	}
+	item := &model.Like{
+		Sid:   args.Sid,
+		Mid:   args.Mid,
+		Type:  args.Type,
+		State: _pending,
+	}
+	if err = s.dao.BatchLike(c, item, addWid, ipv6); err != nil {
+		log.Error("s.dao.BatchLike(%v) error(%+v)", addWid, err)
+	}
+	return
+}
+
+// VideoAdd .
+func (s *Service) VideoAdd(c context.Context, args *model.AddLikes) (likeList *model.Like, err error) {
+	var (
+		likeSubject *model.ActSubject
+		ip          = metadata.String(c, metadata.RemoteIP)
+	)
+	if likeSubject, err = s.dao.ActSubject(c, args.Sid); err != nil {
+		log.Error("s.dao.ActSubject(%d) error(%v) ", args.Sid, err)
+		return
+	}
+	if likeSubject.Type != model.VIDEO && likeSubject.Type != model.VIDEOLIKE && likeSubject.Type != model.VIDEO2 {
+		err = errors.New("VideoAdd params liketype error")
+		return
+	}
+	likeList = new(model.Like)
+	if err = s.DB.Where("sid =?", likeSubject.ID).Where("wid = ?", args.Wid).Last(likeList).Error; err != nil && err != gorm.ErrRecordNotFound {
+		log.Error("s.DB.Model(&model.Like{}).Where(sid =?, %d).Where(wid = ?, %d).Last() error(%v)", likeSubject.ID, args.Wid, err)
+		return
+	}
+	if err == gorm.ErrRecordNotFound {
+		addLike := &model.Like{
+			Type:  args.Type,
+			Wid:   args.Wid,
+			Sid:   likeSubject.ID,
+			Mid:   args.Mid,
+			State: _approved,
+		}
+		ipv6 := net.ParseIP(ip)
+		if ipv6 == nil {
+			ipv6 = []byte{}
+		}
+		addLikeContent := &model.LikeContent{
+			IPv6:    ipv6,
+			Plat:    args.Plat,
+			Device:  args.Device,
+			Message: "no",
+			Image:   "no",
+		}
+		tx := s.DB.Begin()
+		if err = tx.Create(addLike).Error; err != nil {
+			log.Error("db.Model(&model.Like{}).Create(%v) error(%v)", addLike, err)
+			tx.Rollback()
+			return
+		}
+		addLikeContent.ID = addLike.ID
+		if err = tx.Create(addLikeContent).Error; err != nil {
+			log.Error("tx.Model(&model.LikeContent{}).Create(%v) error(%v)", addLikeContent, err)
+			tx.Rollback()
+			return
+		}
+		tx.Commit()
+		likeList = addLike
+	} else {
+		likeList.State = _approved
+		likeList.Mtime = xtime.Time(time.Now().Unix())
+		if err = s.DB.Model(&model.Like{}).Where("id =?", likeList.ID).Update(map[string]interface{}{"state": _approved, "mtime": likeList.Mtime.Time().Format("2006-01-02 15:04:05")}).Error; err != nil {
+			log.Error("ls.DB.Model(&model.Like{}).Where(id =?, %d).Update() error(%v) ", likeList.ID, err)
+		}
+	}
+	return
+}
+
+// UpLikesState .
+func (s *Service) UpLikesState(c context.Context, IDs []int64, state int, reply string, username string) (err error) {
+	if err = s.DB.Model(&model.Like{}).Where("id in (?)", xstr.JoinInts(IDs)).Update(map[string]interface{}{"state": state}).Error; err != nil {
+		log.Info("s.DB.Model(&model.Like{}).Where(id = ?,%d).Update() error(%v)", IDs, err)
+		return
+	}
+	if reply != "" {
+		s.DB.Model(&model.LikeContent{}).Where("id in (?)", xstr.JoinInts(IDs)).Update(map[string]interface{}{"reply": reply})
+	}
+	if state != 0 {
+		for _, v := range IDs {
+			likeLog := &model.ActLikeLog{
+				Lid:   v,
+				User:  username,
+				State: int64(state),
+			}
+			s.DB.Create(likeLog)
+		}
+	}
+	return
+}
+
+// UpLike .
+func (s *Service) UpLike(c context.Context, args *model.UpLike, username string) (res int64, err error) {
+	likes := map[string]interface{}{
+		"Type":     args.Type,
+		"Mid":      args.Mid,
+		"Wid":      args.Wid,
+		"State":    args.State,
+		"StickTop": args.StickTop,
+	}
+	if err = s.DB.Model(model.Like{}).Where("id = ?", args.Lid).Update(likes).Error; err != nil {
+		log.Error("s.DB.Model(model.Like{}).Where(id = ?, %d).Update() error(%v)", args.Lid, err)
+		return
+	}
+	likeContent := map[string]interface{}{
+		"Message": args.Message,
+		"Reply":   args.Reply,
+		"Link":    args.Link,
+		"Image":   args.Image,
+	}
+	if err = s.DB.Model(model.LikeContent{}).Where("id = ?", args.Lid).Update(likeContent).Error; err != nil {
+		log.Error("s.DB.Model(model.LikeContent{}).Where(id = ?,%d).Update() error(%v)", args.Lid, err)
+		return
+	}
+	if args.State != 0 {
+		likeLog := &model.ActLikeLog{
+			Lid:   args.Lid,
+			User:  username,
+			State: int64(args.State),
+		}
+		s.DB.Create(likeLog)
+	}
+	res = args.Lid
+	return
+}
+
+// AddLike .
+func (s *Service) AddLike(c context.Context, args *model.AddLikes) (likesRes *model.Like, err error) {
+	switch args.DealType {
+	case "itemUp":
+		likesRes, err = s.ItemUp(c, args.Sid, args.Wid, args.State)
+	case "itemAdd":
+		likesRes, err = s.ItemAdd(c, args)
+	case "videoAdd":
+		likesRes, err = s.VideoAdd(c, args)
+	default:
+		err = errors.New("type error")
+	}
+	return
+}
+
+// UpWid .
+func (s *Service) UpWid(c context.Context, args *model.UpWid) (err error) {
+	var (
+		subject *model.ActSubject
+	)
+	if subject, err = s.dao.ActSubject(c, args.Sid); err != nil {
+		return
+	}
+	like := map[string]interface{}{
+		"state": args.State,
+		"mtime": xtime.Time(time.Now().Unix()),
+	}
+	if err := s.DB.Model(&model.Like{}).Where("sid = ? and wid = ?", subject.ID, args.Wid).Update(like).Limit(1).Error; err != nil {
+		log.Error("actSrv.DB.Where(sid = %d and wid = %d).Update().Limit(1) error(%v)", subject.ID, args.Wid, err)
+	}
+	return
+}

app/admin/main/activity/service/likes_test.go

@@ -0,0 +1,53 @@
+package service
+
+import (
+	"context"
+	"fmt"
+	"go-common/app/admin/main/activity/model"
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestService_LikesByLid(t *testing.T) {
+	Convey("like get items", t, WithService(func(s *Service) {
+		res, err := s.LikesList(context.Background(), &model.LikesParam{Sid: 10256, PageSize: 10, Page: 1, Mid: 155551800, States: []int{0, 1}})
+		So(err, ShouldBeEmpty)
+		for _, v := range res.Likes {
+			fmt.Printf("%+v", v)
+		}
+	}))
+}
+
+func TestService_Likes(t *testing.T) {
+	Convey("like get items", t, WithService(func(s *Service) {
+		res, err := s.Likes(context.Background(), 10256, []int64{1185, 1256})
+		So(err, ShouldBeEmpty)
+		for _, v := range res {
+			fmt.Printf("%+v", v)
+		}
+	}))
+}
+
+func TestService_UpLike(t *testing.T) {
+	Convey("like get items", t, WithService(func(s *Service) {
+		res, err := s.AddLike(context.Background(), &model.AddLikes{DealType: "videoAdd", Sid: 10206, Wid: 10210488, Mid: 88895364, Device: 11, Plat: 12, State: 1, Type: 12})
+		So(err, ShouldBeEmpty)
+		fmt.Printf("%+v", res)
+	}))
+}
+
+func TestService_UpLikeContents(t *testing.T) {
+	Convey("like get items", t, WithService(func(s *Service) {
+		res, err := s.UpLike(context.Background(), &model.UpLike{Lid: 13557, Type: 13, State: 1, Message: "ii", Reply: "nono", Image: "jj", Link: "like", Mid: 12345, Wid: 12367, StickTop: 1}, "ly")
+		So(err, ShouldBeEmpty)
+		fmt.Printf("%+v", res)
+	}))
+}
+
+func TestService_BatchLikes(t *testing.T) {
+	Convey("like get items", t, WithService(func(s *Service) {
+		err := s.BatchLikes(context.Background(), &model.BatchLike{Sid: 10299, Type: 13, Mid: 12345, Wid: []int64{1, 4, 5, 6, 7}})
+		So(err, ShouldBeEmpty)
+	}))
+}

app/admin/main/activity/service/service.go

@@ -0,0 +1,56 @@
+package service
+
+import (
+	"context"
+	"go-common/app/admin/main/activity/conf"
+	"go-common/app/admin/main/activity/dao"
+	tagrpc "go-common/app/interface/main/tag/rpc/client"
+	artrpc "go-common/app/interface/openplatform/article/rpc/client"
+	acccli "go-common/app/service/main/account/api"
+	arcclient "go-common/app/service/main/archive/api"
+
+	"github.com/jinzhu/gorm"
+)
+
+// Service biz service def.
+type Service struct {
+	c         *conf.Config
+	dao       *dao.Dao
+	DB        *gorm.DB
+	accClient acccli.AccountClient
+	tagRPC    *tagrpc.Service
+	artRPC    *artrpc.Service
+	arcClient arcclient.ArchiveClient
+}
+
+// New new a Service and return.
+func New(c *conf.Config) (s *Service) {
+	s = &Service{
+		c:      c,
+		dao:    dao.New(c),
+		tagRPC: tagrpc.New2(c.TagRPC),
+		artRPC: artrpc.New(c.ArticlrRPC),
+	}
+	s.DB = s.dao.DB
+	var err error
+	if s.arcClient, err = arcclient.NewClient(c.ArcClient); err != nil {
+		panic(err)
+	}
+	if s.accClient, err = acccli.NewClient(c.AccClient); err != nil {
+		panic(err)
+	}
+	return s
+}
+
+// Ping check dao health.
+func (s *Service) Ping(c context.Context) (err error) {
+	return s.dao.Ping(c)
+}
+
+// Wait wait all closed.
+func (s *Service) Wait() {}
+
+// Close close all dao.
+func (s *Service) Close() {
+	s.dao.Close()
+}

app/admin/main/activity/service/service_test.go

@@ -0,0 +1,36 @@
+package service
+
+import (
+	"flag"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"go-common/app/admin/main/activity/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var svr *Service
+
+func init() {
+	dir, _ := filepath.Abs("../cmd/activity-admin-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() {
+		Reset(func() {})
+		f(svr)
+	}
+}
+
+func Test_Service(t *testing.T) {
+	Convey("service test", t, WithService(func(s *Service) {
+		s.Wait()
+		s.Close()
+	}))
+}

app/admin/main/activity/service/subject.go

@@ -0,0 +1,307 @@
+package service
+
+import (
+	"context"
+	"time"
+
+	"go-common/app/admin/main/activity/model"
+	articlemodel "go-common/app/interface/openplatform/article/model"
+	"go-common/library/log"
+	"go-common/library/net/metadata"
+
+	"github.com/jinzhu/gorm"
+)
+
+// GetArticleMetas from rpc .
+func (s *Service) GetArticleMetas(c context.Context, aids []int64) (res map[int64]*articlemodel.Meta, err error) {
+	if res, err = s.artRPC.ArticleMetas(c, &articlemodel.ArgAids{Aids: aids}); err != nil {
+		log.Error("s.ArticleMetas(%v) error(%v)", aids, err)
+	}
+	return
+}
+
+// SubjectList get subject list .
+func (s *Service) SubjectList(c context.Context, listParams *model.ListSub) (listRes *model.SubListRes, err error) {
+	var (
+		count int64
+		list  []*model.ActSubject
+	)
+	db := s.DB
+	if listParams.Keyword != "" {
+		names := listParams.Keyword + "%"
+		db = db.Where("`id` = ? or `name` like ? or `author` like ?", listParams.Keyword, names, names)
+	}
+	if listParams.Sctime != 0 {
+		parseScime := time.Unix(listParams.Sctime, 0)
+		db = db.Where("ctime >= ?", parseScime.Format("2006-01-02 15:04:05"))
+	}
+	if listParams.Ectime != 0 {
+		parseEcime := time.Unix(listParams.Ectime, 0)
+		db = db.Where("etime <= ?", parseEcime.Format("2006-01-02 15:04:05"))
+	}
+	if len(listParams.States) > 0 {
+		db = db.Where("state in (?)", listParams.States)
+	}
+	if len(listParams.Types) > 0 {
+		db = db.Where("type in (?)", listParams.Types)
+	}
+	if err = db.Offset((listParams.Page - 1) * listParams.PageSize).Limit(listParams.PageSize).Order("id desc").Find(&list).Error; err != nil && err != gorm.ErrRecordNotFound {
+		log.Error(" db.Model(&model.ActSubject{}).Find() args(%v) error(%v)", listParams, err)
+		return
+	}
+	if err = db.Model(&model.ActSubject{}).Count(&count).Error; err != nil {
+		log.Error("db.Model(&model.ActSubject{}).Count() args(%v) error(%v)", listParams, err)
+		return
+	}
+	listRes = &model.SubListRes{
+		List: list,
+		Page: &model.PageRes{
+			Num:   listParams.Page,
+			Size:  listParams.PageSize,
+			Total: count,
+		},
+	}
+	return
+}
+
+// VideoList .
+func (s *Service) VideoList(c context.Context) (res []*model.ActSubjectResult, err error) {
+	var (
+		types    = []int{1, 4}
+		list     []*model.ActSubject
+		likeList []*model.Like
+	)
+	db := s.DB
+	if err = db.Where("state = ?", 1).Where("type in (?)", types).Find(&list).Error; err != nil && err != gorm.ErrRecordNotFound {
+		log.Error("db.Model(&model.ActSubject{}).Where(state = ?, 1).Where(type in (?), %v).Find() error(%v)", types, err)
+		return
+	}
+	listCount := len(list)
+	if listCount == 0 {
+		return
+	}
+	sids := make([]int64, 0, listCount)
+	for _, value := range list {
+		sids = append(sids, value.ID)
+	}
+	if err = db.Where("sid in (?)", sids).Where("wid > ?", 0).Find(&likeList).Error; err != nil && err != gorm.ErrRecordNotFound {
+		log.Error("db.Model(&model.Like{}).Where(sid in (?), %v).Find() error(%v)", sids, err)
+		return
+	}
+	hashList := make(map[int64][]int64)
+	for _, value := range likeList {
+		hashList[value.Sid] = append(hashList[value.Sid], value.Wid)
+	}
+	res = make([]*model.ActSubjectResult, 0, len(list))
+	for _, value := range list {
+		rs := &model.ActSubjectResult{
+			ActSubject: value,
+		}
+		if v, ok := hashList[value.ID]; ok {
+			rs.Aids = v
+		}
+		res = append(res, rs)
+	}
+	return
+}
+
+// AddActSubject .
+func (s *Service) AddActSubject(c context.Context, params *model.AddList) (res int64, err error) {
+	if params.ScreenSet != 2 {
+		params.ScreenSet = 1
+	}
+	protect := &model.ActSubjectProtocol{
+		Protocol:  params.Protocol,
+		Types:     params.Types,
+		Pubtime:   params.Pubtime,
+		Deltime:   params.Deltime,
+		Editime:   params.Editime,
+		Tags:      params.Tags,
+		Hot:       params.Hot,
+		BgmID:     params.BgmID,
+		Oids:      params.Oids,
+		ScreenSet: params.ScreenSet,
+		PasterID:  params.PasterID,
+	}
+	actTime := &model.ActTimeConfig{
+		Interval: params.Interval,
+		Tlimit:   params.Tlimit,
+		Ltime:    params.Ltime,
+	}
+	if params.Tags != "" {
+		if err = s.dao.AddTags(c, params.Tags, metadata.String(c, metadata.RemoteIP)); err != nil {
+			log.Error("s.AddTags(%s,) error(%v)", params.Tags, err)
+			return
+		}
+	}
+	actSub := &model.ActSubject{
+		Oid:        params.ActSubject.Oid,
+		Type:       params.ActSubject.Type,
+		State:      params.ActSubject.State,
+		Level:      params.ActSubject.Level,
+		Flag:       params.ActSubject.Flag,
+		Rank:       params.ActSubject.Rank,
+		Stime:      params.ActSubject.Stime,
+		Etime:      params.ActSubject.Etime,
+		Lstime:     params.ActSubject.Lstime,
+		Letime:     params.ActSubject.Letime,
+		Uetime:     params.ActSubject.Uetime,
+		Ustime:     params.ActSubject.Ustime,
+		Name:       params.ActSubject.Name,
+		Author:     params.ActSubject.Author,
+		ActURL:     params.ActSubject.ActURL,
+		Cover:      params.ActSubject.Cover,
+		Dic:        params.ActSubject.Dic,
+		H5Cover:    params.ActSubject.H5Cover,
+		LikeLimit:  params.ActSubject.LikeLimit,
+		AndroidURL: params.ActSubject.AndroidURL,
+		IosURL:     params.ActSubject.IosURL,
+	}
+	if err = s.DB.Create(actSub).Error; err != nil {
+		log.Error("s.DB.Create(%v) error(%v)", actSub, err)
+		return
+	}
+	protect.Sid = actSub.ID
+	if err = s.DB.Create(protect).Error; err != nil {
+		log.Error("s.DB.Create(%v) error(%v)", protect, err)
+		return
+	}
+	if params.Type == model.ONLINEVOTE {
+		actTime.Sid = actSub.ID
+		if err = s.DB.Create(actTime).Error; err != nil {
+			log.Error("s.DB.Create(%v) error(%v)", actTime, err)
+			return
+		}
+	}
+	res = actSub.ID
+	return
+}
+
+// UpActSubject .
+func (s *Service) UpActSubject(c context.Context, params *model.AddList, sid int64) (res int64, err error) {
+	if params.ScreenSet != 2 {
+		params.ScreenSet = 1
+	}
+	onlineData := &model.ActTimeConfig{
+		Interval: params.Interval,
+		Tlimit:   params.Tlimit,
+		Ltime:    params.Ltime,
+	}
+	actSubject := new(model.ActSubject)
+	if err = s.DB.Where("id = ?", sid).Last(actSubject).Error; err != nil {
+		log.Error("s.DB.Where(id = ?, %d).Last(%v) error(%v)", sid, actSubject, err)
+		return
+	}
+	data := map[string]interface{}{
+		"Oid":        params.Oid,
+		"Type":       params.Type,
+		"State":      params.State,
+		"Level":      params.Level,
+		"Flag":       params.Flag,
+		"Rank":       params.Rank,
+		"Stime":      params.Stime,
+		"Etime":      params.Etime,
+		"Lstime":     params.Lstime,
+		"Uetime":     params.Uetime,
+		"Ustime":     params.Ustime,
+		"Name":       params.Name,
+		"Author":     params.Author,
+		"ActURL":     params.ActURL,
+		"Cover":      params.Cover,
+		"Dic":        params.Dic,
+		"H5Cover":    params.H5Cover,
+		"LikeLimit":  params.LikeLimit,
+		"AndroidURL": params.AndroidURL,
+		"IosURL":     params.IosURL,
+	}
+	if err = s.DB.Model(&model.ActSubject{}).Where("id = ?", sid).Update(data).Error; err != nil {
+		log.Error("s.DB.Model(&model.ActSubject{}).Where(id = ?, %d).Update(%v) error(%v)", sid, data, err)
+		return
+	}
+	item := new(model.ActSubjectProtocol)
+	if err = s.DB.Where("sid = ? ", sid).Last(item).Error; err != nil && err != gorm.ErrRecordNotFound {
+		log.Error("s.DB.Where(sid = ? , %d).Last(%v) error(%v)", sid, item, err)
+		return
+	}
+	//item有值
+	if item.ID > 0 {
+		if params.Tags != "" {
+			if item.Tags != params.Tags {
+				if err = s.dao.AddTags(c, params.Tags, metadata.String(c, metadata.RemoteIP)); err != nil {
+					log.Error("s.AddTags(%s) error(%v)", params.Tags, err)
+					return
+				}
+			}
+		}
+		upProtectData := map[string]interface{}{
+			"Protocol":  params.Protocol,
+			"Types":     params.Types,
+			"Pubtime":   params.Pubtime,
+			"Deltime":   params.Deltime,
+			"Editime":   params.Editime,
+			"Hot":       params.Hot,
+			"BgmID":     params.BgmID,
+			"Oids":      params.Oids,
+			"ScreenSet": params.ScreenSet,
+			"PasterID":  params.PasterID,
+			"Tags":      params.Tags,
+		}
+		if err = s.DB.Model(&model.ActSubjectProtocol{}).Where("id = ?", item.ID).Update(upProtectData).Error; err != nil {
+			log.Error("s.DB.Model(&model.ActSubjectProtocol{}).Where(id = ?, %d).Update(%v) error(%v)", item.ID, upProtectData, err)
+			return
+		}
+	} else {
+		protectDtata := &model.ActSubjectProtocol{
+			Protocol:  params.Protocol,
+			Types:     params.Types,
+			Pubtime:   params.Pubtime,
+			Deltime:   params.Deltime,
+			Editime:   params.Editime,
+			Hot:       params.Hot,
+			BgmID:     params.BgmID,
+			Oids:      params.Oids,
+			ScreenSet: params.ScreenSet,
+			PasterID:  params.PasterID,
+			Sid:       sid,
+		}
+		if err = s.DB.Create(protectDtata).Error; err != nil {
+			log.Error("s.DB.Create(%v) error(%v)", protectDtata, err)
+			return
+		}
+	}
+	if actSubject.Type == model.ONLINEVOTE {
+		onlineData.Sid = sid
+		output := new(model.ActTimeConfig)
+		if err = s.DB.Where("sid = ?", sid).Last(output).Error; err != nil && err != gorm.ErrRecordNotFound {
+			log.Error("s.DB.Where(sid = ?, %d).Last(%v) error(%v)", sid, output, err)
+			return
+		}
+		if output.ID > 0 {
+			if err = s.DB.Model(&model.ActTimeConfig{}).Where("id = ?", output.ID).Update(onlineData).Error; err != nil {
+				log.Error("s.DB.Model(&model.ActTimeConfig{}).Where(id = ?, %d).Update(%v) error(%v)", output.ID, onlineData, err)
+				return
+			}
+		}
+
+	}
+	res = sid
+	return
+}
+
+// SubProtocol .
+func (s *Service) SubProtocol(c context.Context, sid int64) (res *model.ActSubjectProtocol, err error) {
+	res = &model.ActSubjectProtocol{}
+	if err = s.DB.Where("sid = ?", sid).First(res).Error; err != nil && err != gorm.ErrRecordNotFound {
+		log.Error("s.DB.Where(sid = %d ) error(%v)", sid, err)
+	}
+	return
+}
+
+// TimeConf .
+func (s *Service) TimeConf(c context.Context, sid int64) (res *model.ActTimeConfig, err error) {
+	res = new(model.ActTimeConfig)
+	if err = s.DB.Where("sid = ?", sid).First(res).Error; err != nil && err != gorm.ErrRecordNotFound {
+		log.Error("actSrv.DB.Where(sid = ?, %d) error(%v)", sid, err)
+	}
+	return
+}

app/admin/main/activity/service/subject_test.go

@@ -0,0 +1,166 @@
+package service
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	"go-common/app/admin/main/activity/model"
+
+	xtime "go-common/library/time"
+
+	"time"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestService_SubjectList(t *testing.T) {
+	Convey("service test", t, WithService(func(s *Service) {
+		p := &model.ListSub{
+			Page:     1,
+			PageSize: 15,
+			Keyword:  "layang123",
+			States:   []int{1},
+			Types:    []int{18},
+			Sctime:   1534835169,
+			Ectime:   1546272001,
+		}
+		list, err := s.SubjectList(context.Background(), p)
+		So(err, ShouldBeNil)
+		for _, v := range list.List {
+			fmt.Printf("%+v", v)
+		}
+	}))
+}
+
+func TestService_VideoList(t *testing.T) {
+	Convey("service test", t, WithService(func(s *Service) {
+		list, err := s.VideoList(context.Background())
+		So(err, ShouldBeNil)
+		for _, v := range list {
+			fmt.Printf("%+v  %+v", v.ActSubject, v.Aids)
+		}
+	}))
+}
+
+func TestService_AddActSubject(t *testing.T) {
+	Convey("service test", t, WithService(func(s *Service) {
+		p := &model.AddList{
+			ActSubject: model.ActSubject{
+				Oid:        11,
+				Type:       9,
+				State:      1,
+				Level:      5,
+				Rank:       100,
+				Stime:      xtime.Time(time.Now().Unix()),
+				Etime:      xtime.Time(time.Now().Unix()),
+				Ctime:      xtime.Time(time.Now().Unix()),
+				Mtime:      xtime.Time(time.Now().Unix()),
+				Lstime:     xtime.Time(time.Now().Unix()),
+				Letime:     xtime.Time(time.Now().Unix()),
+				Uetime:     xtime.Time(time.Now().Unix()),
+				Ustime:     xtime.Time(time.Now().Unix()),
+				Name:       "test one",
+				Author:     "layang",
+				ActURL:     "http://www.baidu.com/",
+				Cover:      "cover",
+				Flag:       128,
+				Dic:        "dif",
+				H5Cover:    "H5Cover",
+				LikeLimit:  5,
+				AndroidURL: "AndroidURL",
+				IosURL:     "IosURL",
+			},
+			Protocol:  "Protocol",
+			Types:     "1,2,3",
+			Pubtime:   xtime.Time(time.Now().Unix()),
+			Deltime:   xtime.Time(time.Now().Unix()),
+			Editime:   xtime.Time(time.Now().Unix()),
+			Tags:      "由三",
+			Interval:  1,
+			Tlimit:    123,
+			Ltime:     124,
+			Hot:       1,
+			BgmID:     3,
+			PasterID:  4,
+			Oids:      "5,7,8",
+			ScreenSet: 1,
+		}
+		res, err := s.AddActSubject(context.Background(), p)
+		So(err, ShouldBeNil)
+		fmt.Printf("%d", res)
+	}))
+}
+
+func TestService_UpActSubject(t *testing.T) {
+	Convey("service test", t, WithService(func(s *Service) {
+		p := &model.AddList{
+			ActSubject: model.ActSubject{
+				Oid:        12,
+				Type:       9,
+				State:      0,
+				Level:      6,
+				Rank:       101,
+				Stime:      xtime.Time(time.Now().Unix()),
+				Etime:      xtime.Time(time.Now().Unix()),
+				Ctime:      xtime.Time(time.Now().Unix()),
+				Mtime:      xtime.Time(time.Now().Unix()),
+				Lstime:     xtime.Time(time.Now().Unix()),
+				Letime:     xtime.Time(time.Now().Unix()),
+				Uetime:     xtime.Time(time.Now().Unix()),
+				Ustime:     xtime.Time(time.Now().Unix()),
+				Name:       "test two",
+				Author:     "layang2",
+				ActURL:     "http://www.baidu.com/2",
+				Cover:      "cover2",
+				Flag:       129,
+				Dic:        "dif2",
+				H5Cover:    "H5Cover2",
+				LikeLimit:  6,
+				AndroidURL: "AndroidURL2",
+				IosURL:     "IosURL2",
+			},
+			Protocol:  "Protocol2",
+			Types:     "1,2,3,4",
+			Pubtime:   xtime.Time(time.Now().Unix()),
+			Deltime:   xtime.Time(time.Now().Unix()),
+			Editime:   xtime.Time(time.Now().Unix()),
+			Tags:      "由三2",
+			Interval:  2,
+			Tlimit:    124,
+			Ltime:     125,
+			Hot:       0,
+			BgmID:     4,
+			PasterID:  8,
+			Oids:      "5,7,8.9",
+			ScreenSet: 2,
+		}
+		res, err := s.UpActSubject(context.Background(), p, 10298)
+		So(err, ShouldBeNil)
+		fmt.Printf("%+v", res)
+	}))
+}
+
+func TestService_SubProtocol(t *testing.T) {
+	Convey("sub protovol ", t, WithService(func(s *Service) {
+		list, err := s.SubProtocol(context.Background(), 10256)
+		So(err, ShouldBeNil)
+		fmt.Printf("%+v", list)
+	}))
+}
+
+func TestService_TimeConf(t *testing.T) {
+	Convey("sub TimeConf ", t, WithService(func(s *Service) {
+		list, err := s.TimeConf(context.Background(), 10298)
+		So(err, ShouldBeNil)
+		fmt.Printf("%+v", list)
+	}))
+}
+
+func TestService_GetArticleMetas(t *testing.T) {
+	Convey("sub TimeConf ", t, WithService(func(s *Service) {
+		list, err := s.GetArticleMetas(context.Background(), []int64{1412})
+		So(err, ShouldBeNil)
+		fmt.Printf("%+v", list)
+	}))
+}