Create & Init Project...

app/interface/main/favorite/service/BUILD

@@ -0,0 +1,69 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "rpc_test.go",
+        "service_test.go",
+        "topic_test.go",
+    ],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/favorite/conf:go_default_library",
+        "//library/ecode:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "rpc.go",
+        "service.go",
+        "topic.go",
+        "video.go",
+    ],
+    importpath = "go-common/app/interface/main/favorite/service",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/favorite/conf:go_default_library",
+        "//app/interface/main/favorite/dao/music:go_default_library",
+        "//app/interface/main/favorite/dao/topic:go_default_library",
+        "//app/interface/main/favorite/dao/video:go_default_library",
+        "//app/interface/main/favorite/model: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",
+        "//app/service/main/favorite/api: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/stat/prom:go_default_library",
+        "//library/sync/pipeline/fanout:go_default_library",
+        "//library/time: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/favorite/service/rpc.go

@@ -0,0 +1,198 @@
+package service
+
+import (
+	"context"
+
+	"go-common/app/service/main/archive/api"
+	arcmdl "go-common/app/service/main/archive/model/archive"
+	favpb "go-common/app/service/main/favorite/api"
+	favmdl "go-common/app/service/main/favorite/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	"go-common/library/time"
+)
+
+// ArcRPC find archive by rpc
+func (s *Service) ArcRPC(c context.Context, aid int64) (a *api.Arc, err error) {
+	argAid := &arcmdl.ArgAid2{
+		Aid: aid,
+	}
+	if a, err = s.arcRPC.Archive3(c, argAid); err != nil {
+		log.Error("s.arcRPC.Archive3(%v), error(%v)", argAid, err)
+	}
+	if !a.IsNormal() {
+		err = ecode.ArchiveNotExist
+	}
+	return
+}
+
+// ArcsRPC find archives by rpc
+func (s *Service) ArcsRPC(c context.Context, aids []int64) (as map[int64]*api.Arc, err error) {
+	if len(aids) == 0 {
+		return
+	}
+	argAids := &arcmdl.ArgAids2{
+		Aids: aids,
+	}
+	if as, err = s.arcRPC.Archives3(c, argAids); err != nil {
+		log.Error("s.arcRPC.Archives3(%v, archives), err(%v)", argAids, err)
+	}
+	return
+}
+
+// AddFavRPC add favorite .
+func (s *Service) AddFavRPC(c context.Context, typ int8, mid, aid, fid int64) (err error) {
+	arg := &favpb.AddFavReq{Tp: int32(typ), Mid: mid, Oid: aid, Fid: fid}
+	_, err = s.favClient.AddFav(c, arg)
+	if err != nil {
+		log.Error("s.favClient.AddFav(%+v) error(%v)", arg, err)
+	}
+	return
+}
+
+// DelFavRPC del favorite .
+func (s *Service) DelFavRPC(c context.Context, typ int8, mid, aid, fid int64) (err error) {
+	arg := &favpb.DelFavReq{Tp: int32(typ), Mid: mid, Oid: aid, Fid: fid}
+	if _, err = s.favClient.DelFav(c, arg); err != nil {
+		log.Error("s.favClient.DelFavRPC(%+v) error(%v)", arg, err)
+	}
+	return
+}
+
+// FavoritesRPC favorites list.
+func (s *Service) FavoritesRPC(c context.Context, typ int8, mid, vmid, fid int64, tid int, keyword, order string, pn, ps int) (favs *favmdl.Favorites, err error) {
+	arg := &favpb.FavoritesReq{Tp: int32(typ), Mid: mid, Uid: vmid, Fid: fid, Tid: int32(tid), Keyword: keyword, Order: order, Pn: int32(pn), Ps: int32(ps)}
+	var reply *favpb.FavoritesReply
+	if reply, err = s.favClient.Favorites(c, arg); err != nil {
+		log.Error("s.favClient.Favorites(%+v) error(%v)", arg, err)
+		return
+	}
+	favs = &favmdl.Favorites{}
+	favs.Page.Count = int(reply.Res.Page.Count)
+	favs.Page.Num = int(reply.Res.Page.Num)
+	favs.Page.Size = int(reply.Res.Page.Size_)
+	for _, data := range reply.Res.List {
+		favs.List = append(favs.List, &favmdl.Favorite{
+			ID:    data.Id,
+			Oid:   data.Oid,
+			Mid:   data.Mid,
+			Fid:   data.Fid,
+			Type:  int8(data.Type),
+			State: int8(data.State),
+			CTime: time.Time(data.Ctime),
+			MTime: time.Time(data.Mtime),
+		})
+	}
+	return
+}
+
+// IsFavByFidRPC return user whether favored
+func (s *Service) IsFavByFidRPC(c context.Context, typ int8, mid, aid int64, fid int64) (res bool, err error) {
+	arg := &favpb.IsFavoredByFidReq{Type: int32(typ), Mid: mid, Oid: aid, Fid: fid}
+	var reply *favpb.IsFavoredReply
+	if reply, err = s.favClient.IsFavoredByFid(c, arg); err != nil {
+		log.Error("s.favClient.IsFavoredByFid(%+v) error(%v)", arg, err)
+		return
+	}
+	res = reply.Faved
+	return
+}
+
+// IsFavRPC return user whether favored
+func (s *Service) IsFavRPC(c context.Context, typ int8, mid, aid int64) (res bool, err error) {
+	arg := &favpb.IsFavoredReq{Typ: int32(typ), Mid: mid, Oid: aid}
+	var reply *favpb.IsFavoredReply
+	if reply, err = s.favClient.IsFavored(c, arg); err != nil {
+		log.Error("s.favClient.IsFavored(%+v) error(%v)", arg, err)
+		return
+	}
+	res = reply.Faved
+	return
+}
+
+// InDefaultRPC return aid whether in default fodler.
+func (s *Service) InDefaultRPC(c context.Context, typ int8, mid, aid int64) (res bool, err error) {
+	arg := &favpb.InDefaultFolderReq{Typ: int32(typ), Mid: mid, Oid: aid}
+	var reply *favpb.InDefaultFolderReply
+	if reply, err = s.favClient.InDefault(c, arg); err != nil {
+		log.Error("s.favClient.IsFavored(%+v) error(%v)", arg, err)
+		return
+	}
+	res = reply.IsIn
+	return
+}
+
+// IsFavsRPC return user's oids whether favored
+func (s *Service) IsFavsRPC(c context.Context, typ int8, mid int64, aids []int64) (res map[int64]bool, err error) {
+	arg := &favpb.IsFavoredsReq{Typ: int32(typ), Mid: mid, Oids: aids}
+	var reply *favpb.IsFavoredsReply
+	if reply, err = s.favClient.IsFavoreds(c, arg); err != nil {
+		log.Error("s.favClient.IsFavoreds(%+v) error(%v)", arg, err)
+		return
+	}
+	res = reply.Faveds
+	return
+}
+
+// AllFoldersRPC user's folders list.
+func (s *Service) AllFoldersRPC(c context.Context, typ int8, mid, vmid, oid int64, ip string) (fs []*favmdl.Folder, err error) {
+	arg := &favpb.UserFoldersReq{Typ: int32(typ), Mid: mid, Vmid: vmid, Oid: oid}
+	var reply *favpb.UserFoldersReply
+	if reply, err = s.favClient.UserFolders(c, arg); err != nil {
+		log.Error("s.favClient.UserFolders(%+v) error(%v)", arg, err)
+		return
+	}
+	fs = reply.GetRes()
+	return
+}
+
+// FolderRPC user's folder .
+func (s *Service) FolderRPC(c context.Context, typ int8, fid, mid, vmid int64) (f *favmdl.Folder, err error) {
+	arg := &favpb.UserFolderReq{Typ: int32(typ), Mid: mid, Vmid: vmid, Fid: fid}
+	var reply *favpb.UserFolderReply
+	if reply, err = s.favClient.UserFolder(c, arg); err != nil {
+		log.Error("s.favClient.UserFolder(%+v) error(%v)", arg, err)
+		return
+	}
+	f = reply.GetRes()
+	return
+}
+
+// TlistsRPC archive type list.
+func (s *Service) TlistsRPC(c context.Context, typ int8, mid, vmid, fid int64) (ps []*favmdl.Partition, err error) {
+	arg := &favpb.TlistsReq{Tp: int32(typ), Mid: mid, Uid: vmid, Fid: fid}
+	var reply *favpb.TlistsReply
+	if reply, err = s.favClient.Tlists(c, arg); err != nil {
+		log.Error("s.favClient.Tlists(%+v) error(%v)", arg, err)
+		return
+	}
+	ps = make([]*favmdl.Partition, 0)
+	for _, v := range reply.Res {
+		ps = append(ps, &favmdl.Partition{
+			Tid:   int(v.Tid),
+			Name:  v.Name,
+			Count: int(v.Count),
+		})
+	}
+	return
+}
+
+// RecentsRPC recent favs .
+func (s *Service) RecentsRPC(c context.Context, typ int8, mid int64, size int) (aids []int64, err error) {
+	arg := &favpb.RecentFavsReq{Tp: int32(typ), Mid: mid, Size_: int32(size)}
+	var reply *favpb.RecentFavsReply
+	if reply, err = s.favClient.RecentFavs(c, arg); err != nil {
+		log.Error("s.favClient.RecentFavs(%+v) error(%v)", arg, err)
+		return
+	}
+	aids = reply.GetRes()
+	return
+}
+
+// TypesRPC find all archives's type by rpc
+func (s *Service) TypesRPC(c context.Context) (ats map[int16]*arcmdl.ArcType, err error) {
+	if ats, err = s.arcRPC.Types2(c); err != nil {
+		log.Error("s.arcRPC.Types2(), error(%v)", err)
+	}
+	return
+}

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

@@ -0,0 +1,21 @@
+package service
+
+import (
+	"context"
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func Test_ArcsRPC(t *testing.T) {
+	Convey("ArcsRPC", t, func() {
+		var (
+			aids = []int64{123, 345}
+		)
+		res, err := s.ArcsRPC(context.TODO(), aids)
+		t.Logf("res:%+v", res)
+		t.Logf("err:%+v", err)
+		So(res, ShouldNotBeNil)
+		So(err, ShouldBeNil)
+	})
+}

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

@@ -0,0 +1,70 @@
+package service
+
+import (
+	"context"
+
+	"go-common/app/interface/main/favorite/conf"
+	musicDao "go-common/app/interface/main/favorite/dao/music"
+	topicDao "go-common/app/interface/main/favorite/dao/topic"
+	videoDao "go-common/app/interface/main/favorite/dao/video"
+	arcrpc "go-common/app/service/main/archive/api/gorpc"
+	favpb "go-common/app/service/main/favorite/api"
+	"go-common/library/log"
+	"go-common/library/stat/prom"
+	"go-common/library/sync/pipeline/fanout"
+)
+
+// Service define fav service
+type Service struct {
+	conf *conf.Config
+	// dao
+	videoDao *videoDao.Dao
+	topicDao *topicDao.Dao
+	musicDao *musicDao.Dao
+	// cache chan
+	cache *fanout.Fanout
+	// prom
+	prom *prom.Prom
+	// rpc
+	favClient favpb.FavoriteClient
+	arcRPC    *arcrpc.Service2
+}
+
+// New return fav service
+func New(c *conf.Config) (s *Service) {
+	s = &Service{
+		conf: c,
+		// dao
+		videoDao: videoDao.New(c),
+		topicDao: topicDao.New(c),
+		musicDao: musicDao.New(c),
+		// cache
+		cache: fanout.New("cache"),
+		// prom
+		prom: prom.New().WithTimer("fav_add_video", []string{"method"}),
+		// rpc
+		arcRPC: arcrpc.New2(c.RPCClient2.Archive),
+	}
+	favClient, err := favpb.New(c.RPCClient2.FavClient)
+	if err != nil {
+		panic(err)
+	}
+	s.favClient = favClient
+	return
+}
+
+// Ping check service health
+func (s *Service) Ping(c context.Context) (err error) {
+	return s.videoDao.Ping(c)
+}
+
+// Close close service
+func (s *Service) Close() {
+	s.videoDao.Close()
+}
+
+// PromError stat and log.
+func (s *Service) PromError(name string, format string, args ...interface{}) {
+	prom.BusinessErrCount.Incr(name)
+	log.Error(format, args...)
+}

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

@@ -0,0 +1,22 @@
+package service
+
+import (
+	"flag"
+	"fmt"
+	"path/filepath"
+
+	"go-common/app/interface/main/favorite/conf"
+)
+
+var (
+	s *Service
+)
+
+func init() {
+	dir, _ := filepath.Abs("../cmd/favorite-test.toml")
+	flag.Set("conf", dir)
+	if err := conf.Init(); err != nil {
+		fmt.Printf("conf.Init() error(%v)", err)
+	}
+	s = New(conf.Conf)
+}

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

@@ -0,0 +1,82 @@
+package service
+
+import (
+	"context"
+
+	"go-common/app/interface/main/favorite/model"
+	favmdl "go-common/app/service/main/favorite/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+)
+
+var _emptyTopics = []*model.Topic{}
+
+// AddFavTopic add fav topic
+func (s *Service) AddFavTopic(c context.Context, mid, tpID int64, ck, ak string) (err error) {
+	tpIDs := []int64{tpID}
+	tps, err := s.topicDao.TopicMap(c, tpIDs, false, nil)
+	if err != nil {
+		log.Error("s.topic.Get(%v)", err)
+		return
+	}
+	if len(tps) == 0 {
+		err = ecode.TopicNotExist
+		return
+	}
+	if err = s.AddFavRPC(c, favmdl.TypeTopic, mid, tpID, 0); err != nil {
+		log.Error(" s.AddFavRPC(%d,%d) error(%v)", mid, tpID, err)
+	}
+	return
+}
+
+// DelFavTopic del fav topic
+func (s *Service) DelFavTopic(c context.Context, mid, tpID int64) (err error) {
+	if err = s.DelFavRPC(c, favmdl.TypeTopic, mid, tpID, 0); err != nil {
+		log.Error("s.DelFavRPC(%d,%d) error(%v)", mid, tpID, err)
+	}
+	return
+}
+
+// IsTopicFavoured topic is favoured.
+func (s *Service) IsTopicFavoured(c context.Context, mid, tpID int64) (faved bool, err error) {
+	typ := favmdl.TypeTopic
+	if faved, err = s.IsFavRPC(c, typ, mid, tpID); err != nil {
+		log.Error("s.IsFavRPC(%d,%d,%d) error(%v)", typ, mid, tpID, err)
+	}
+	return
+}
+
+// FavTopics get fav topics
+func (s *Service) FavTopics(c context.Context, mid int64, pn, ps int, appInfo *model.AppInfo) (res *model.TopicList, err error) {
+	res = &model.TopicList{}
+	res.PageNum = pn
+	res.PageSize = ps
+	typ := favmdl.TypeTopic
+	favs, err := s.FavoritesRPC(c, typ, mid, mid, 0, 0, "", "", pn, ps)
+	if err != nil {
+		log.Error("s.Favorites(%d,%d,%d,%d,%d,%d,%s) error(%v)", typ, mid, 0, pn, ps, err)
+		return
+	}
+	res.Total = int64(favs.Page.Count)
+	var oids []int64
+	for _, fav := range favs.List {
+		oids = append(oids, fav.Oid)
+	}
+	if res.Total == 0 {
+		res.List = _emptyTopics
+		return
+	}
+	topics, err := s.topicDao.TopicMap(c, oids, false, appInfo)
+	if err != nil {
+		log.Error("s.topic.MuliGet error(%v)", err)
+		return
+	}
+	for _, fav := range favs.List {
+		if topic, ok := topics[fav.Oid]; ok {
+			topic.FavAt = fav.MTime
+			topic.MID = mid
+			res.List = append(res.List, topic)
+		}
+	}
+	return
+}

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

@@ -0,0 +1,61 @@
+package service
+
+import (
+	"context"
+	"go-common/library/ecode"
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func Test_FavTopics(t *testing.T) {
+	Convey("FavTopics", t, func() {
+		var (
+			mid int64 = 88888894
+			pn        = 1
+			ps        = 30
+		)
+		res, err := s.FavTopics(context.TODO(), mid, pn, ps, nil)
+		t.Logf("res:%v", res)
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeNil)
+	})
+}
+
+func Test_IsTopicFavoured(t *testing.T) {
+	Convey("IsTopicFavoured", t, func() {
+		var (
+			mid  int64 = 88888894
+			tpID int64 = 3456
+		)
+		res, err := s.IsTopicFavoured(context.TODO(), mid, tpID)
+		t.Logf("res:%v", res)
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeNil)
+	})
+}
+
+func Test_AddFavTopic(t *testing.T) {
+	Convey("AddFavTopic", t, func() {
+		var (
+			mid    int64 = 88888894
+			tpID   int64 = 3456
+			ck, ak string
+		)
+		err := s.AddFavTopic(context.TODO(), mid, tpID, ck, ak)
+		t.Logf("err:%v", err)
+		So(err, ShouldEqual, ecode.FavTopicExist)
+	})
+}
+
+func Test_DelFavTopic(t *testing.T) {
+	Convey("DelFavTopic", t, func() {
+		var (
+			mid  int64 = 88888894
+			tpID int64 = 3457
+		)
+		err := s.DelFavTopic(context.TODO(), mid, tpID)
+		t.Logf("err:%v", err)
+		So(err, ShouldEqual, ecode.FavVideoAlreadyDel)
+	})
+}

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

@@ -0,0 +1,606 @@
+package service
+
+import (
+	"context"
+	"html/template"
+	"math"
+
+	musicmdl "go-common/app/interface/main/favorite/model"
+	"go-common/app/service/main/archive/api"
+	pb "go-common/app/service/main/favorite/api"
+	"go-common/app/service/main/favorite/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	"go-common/library/net/metadata"
+)
+
+var (
+	_emptyArchives     = []*model.FavArchive{}
+	_emptyVideoFolders = []*model.VideoFolder{}
+)
+
+// newCovers get three cover of each fid
+func (s *Service) newCovers(c context.Context, mid int64, recents map[int64][]*model.Resource) (fcvs map[int64][]*model.Cover, err error) {
+	var (
+		fids, misFids []int64
+	)
+	for fid := range recents {
+		fids = append(fids, fid)
+	}
+	if fcvs, misFids, err = s.videoDao.NewCoversCache(c, mid, fids); err != nil {
+		log.Error("s.videoDao.NewCoversCache(fids %v) err(%v)", fids, err)
+		return
+	}
+	// get miss cover from db
+	if len(misFids) > 0 {
+		var (
+			allAids []int64
+			allMids []int64
+			as      map[int64]*api.Arc
+			ms      map[int64]*musicmdl.Music
+		)
+		for _, fid := range misFids {
+			if resources, ok := recents[fid]; ok {
+				for _, res := range resources {
+					if int8(res.Typ) == model.TypeVideo {
+						allAids = append(allAids, res.Oid)
+					} else {
+						allMids = append(allMids, res.Oid)
+					}
+				}
+			}
+		}
+		if len(allAids) > 0 {
+			if as, err = s.arcsRPC(c, allAids); err != nil {
+				log.Error("s.arcsRPC(aids %v),err(%v)", allAids, err)
+				return
+			}
+		}
+		if len(allMids) > 0 {
+			if ms, err = s.musicDao.MusicMap(c, allMids); err != nil {
+				log.Error("s.musicMap(allMids %v),err(%v)", allMids, err)
+				return
+			}
+		}
+		// set miss fid's cover
+		for _, misFid := range misFids {
+			fid := misFid
+			cvs := make([]*model.Cover, 0)
+			for _, res := range recents[fid] {
+				cv := &model.Cover{}
+				cv.Aid = res.Oid
+				cv.Type = res.Typ
+				if int8(res.Typ) == model.TypeVideo {
+					if arc, ok := as[res.Oid]; ok {
+						if !arc.IsNormal() {
+							continue
+						}
+						cv.Pic = arc.Pic
+						cvs = append(cvs, cv)
+					}
+				} else {
+					if music, ok := ms[res.Oid]; ok {
+						cv.Pic = music.Cover
+						cvs = append(cvs, cv)
+					}
+				}
+			}
+			if err := s.videoDao.SetNewCoverCache(c, mid, fid, cvs); err != nil {
+				log.Error("s.videoDao.SetNewCoverCache(%d,%d,%v) error(%v)", mid, fid, cvs, err)
+			}
+			fcvs[fid] = cvs
+		}
+	}
+	return
+}
+
+func (s *Service) arcsRPC(c context.Context, aids []int64) (arcsMap map[int64]*api.Arc, err error) {
+	var (
+		batch = s.conf.Fav.MaxPagesize
+		arcs  map[int64]*api.Arc
+	)
+	arcsMap = make(map[int64]*api.Arc, len(aids))
+	for len(aids) > 0 {
+		if len(aids) < batch {
+			batch = len(aids)
+		}
+		arcs, err = s.ArcsRPC(c, aids[:batch])
+		if err != nil {
+			log.Error("s.ArcsRPC(%v) error(%v)", aids[:batch], err)
+			return
+		}
+		for k, v := range arcs {
+			arcsMap[k] = v
+		}
+		aids = aids[batch:]
+	}
+	return
+}
+
+func (s *Service) normalArcs(c context.Context, aids []int64) (as []*api.Arc, err error) {
+	arcs, err := s.ArcsRPC(c, aids)
+	if err != nil {
+		log.Error("s.ArcsRPC(%v) error(%v)", aids, err)
+		return
+	}
+	as = make([]*api.Arc, 0, len(aids))
+	for _, v := range aids {
+		if a, ok := arcs[v]; ok {
+			as = append(as, a)
+		}
+	}
+	return
+}
+
+// FavVideo get fav videos from search or db
+func (s *Service) FavVideo(c context.Context, mid, vmid, uid, fid int64, keyword, order string, tid, pn, ps int) (sv *model.SearchArchive, err error) {
+	if order != "click" && order != "pubdate" {
+		order = model.SortMtime
+	}
+	if order == "pubdate" {
+		order = model.SortPubtime
+	}
+	sv = new(model.SearchArchive)
+	var favs *model.Favorites
+	if favs, err = s.FavoritesRPC(c, model.TypeVideo, mid, vmid, fid, tid, keyword, order, pn, ps); err != nil || favs == nil {
+		log.Error("s.FavoritesRPC(%d,%d,%d,%d,%d,%d) error(%v)", model.TypeVideo, mid, vmid, fid, pn, ps, err)
+		return
+	}
+	if len(favs.List) == 0 {
+		sv.Result = nil
+		sv.Archives = _emptyArchives
+		return
+	}
+	if err = s.newFillArchives(c, favs.List, sv); err != nil {
+		log.Error("s.newFillArchives error(%v)", err)
+	}
+	sv.Mid = uid
+	sv.Fid = fid
+	sv.Tid = tid
+	sv.Order = order
+	sv.Keyword = keyword
+	sv.PageCount = int(math.Ceil(float64(favs.Page.Count) / float64(s.conf.Fav.MaxPagesize)))
+	sv.PageSize = s.conf.Fav.MaxPagesize
+	sv.Total = favs.Page.Count
+	sv.NumPages = 0
+	sv.NumResults = 0
+	return
+}
+
+// TidList get video folder type names from search.
+func (s *Service) TidList(c context.Context, mid, vmid, uid, fid int64) (res []*model.Partition, err error) {
+	tidCounts, err := s.TlistsRPC(c, model.TypeVideo, mid, vmid, fid)
+	if err != nil {
+		log.Error("s.TlistsRPC(%d,%d,%d,%d) error(%v)", model.TypeVideo, mid, vmid, fid, err)
+		return
+	}
+	types, err := s.TypesRPC(c)
+	if err != nil {
+		log.Error("s.TypesRPC() error(%v)", err)
+		return
+	}
+	for _, t := range tidCounts {
+		if t.Tid == 0 {
+			continue
+		}
+		if v, ok := types[int16(t.Tid)]; ok {
+			t.Name = v.Name
+		}
+		res = append(res, t)
+	}
+	return
+}
+
+func (s *Service) archive(c context.Context, aid int64) (arc *api.Arc, err error) {
+	arc, err = s.ArcRPC(c, aid)
+	if err != nil {
+		log.Error("s.ArcRPC(%d), error(%v)", aid, err)
+	}
+	if !arc.IsNormal() {
+		err = ecode.ArchiveNotExist
+	}
+	return
+}
+
+// FavFolders get mid user's favorites.
+func (s *Service) FavFolders(c context.Context, mid, vmid, uid, aid int64, isSelf bool, mediaList bool, fromWeb bool) (res []*model.VideoFolder, err error) {
+	var fs []*model.Folder
+	typ := model.TypeVideo
+	ip := metadata.String(c, metadata.RemoteIP)
+	if fs, err = s.AllFoldersRPC(c, typ, mid, vmid, aid, ip); err != nil {
+		log.Error("s.AllFoldersRPC(%d,%d,%d,%d,%s) error(%v)", typ, mid, vmid, ip, err)
+		return
+	}
+	if len(fs) == 0 {
+		res = _emptyVideoFolders
+		return
+	}
+	faids := make(map[int64][]*model.Resource, len(fs))
+	for _, f := range fs {
+		faids[f.ID] = f.RecentRes
+	}
+	var covers map[int64][]*model.Cover
+	if covers, err = s.newCovers(c, uid, faids); err != nil {
+		log.Error("s.newCovers(%d,%v) error(%v)", uid, faids, err)
+		err = nil
+	}
+	//兼容老的缓存，后期下掉
+	for _, cover := range covers {
+		for _, co := range cover {
+			if co.Type == 0 {
+				co.Type = int32(model.TypeVideo)
+			}
+		}
+	}
+	for _, f := range fs {
+		maxCount := model.DefaultFolderLimit
+		if !f.IsDefault() {
+			maxCount = model.NormalFolderLimit
+		}
+		name := f.Name
+		if fromWeb { // web端html转义
+			name = template.HTMLEscapeString(name)
+		}
+		if mediaList {
+			if f.IsDefault() && name == "默认收藏夹" {
+				name = "默认播单"
+			}
+		}
+		cover := []*model.Cover{}
+		if mediaList {
+			if f.Cover != "" {
+				cover = []*model.Cover{{
+					Type: 0,
+					Pic:  f.Cover,
+				}}
+			} else {
+				cover = covers[f.ID]
+			}
+		} else {
+			for _, co := range covers[f.ID] {
+				if int8(co.Type) == model.TypeVideo {
+					cover = append(cover, co)
+				}
+			}
+		}
+		vf := &model.VideoFolder{
+			MediaId:  f.ID*100 + f.Mid%100,
+			Fid:      f.ID,
+			Mid:      f.Mid,
+			Name:     name,
+			MaxCount: maxCount,
+			CurCount: f.Count,
+			Favoured: f.Favored,
+			State:    int8(f.Attr & 3),
+			CTime:    f.CTime,
+			MTime:    f.MTime,
+			Cover:    cover,
+		}
+		res = append(res, vf)
+	}
+
+	return
+}
+
+// AddFavFolder add a new favorite folder
+func (s *Service) AddFavFolder(c context.Context, mid int64, name, cookie, accessKey string, state int32) (fid int64, err error) {
+	var reply *pb.AddFolderReply
+	reply, err = s.favClient.AddFolder(c, &pb.AddFolderReq{
+		Typ:       int32(model.TypeVideo),
+		Mid:       mid,
+		Name:      name,
+		Cookie:    cookie,
+		AccessKey: accessKey,
+		Public:    state,
+	})
+	if err != nil {
+		return
+	}
+	fid = reply.Fid
+	return
+}
+
+// UpFavName update favorite name.
+func (s *Service) UpFavName(c context.Context, mid, fid int64, name, cookie, accessKey string) (err error) {
+	_, err = s.favClient.UpFolderName(c, &pb.UpFolderNameReq{
+		Typ:       int32(model.TypeVideo),
+		Fid:       fid,
+		Mid:       mid,
+		Name:      name,
+		Cookie:    cookie,
+		AccessKey: accessKey,
+	})
+	return
+}
+
+// SetVideoFolderSort set folder sort.
+func (s *Service) SetVideoFolderSort(c context.Context, mid int64, fids []int64) (err error) {
+	_, err = s.favClient.SetFolderSort(c, &pb.SetFolderSortReq{
+		Typ:  int32(model.TypeVideo),
+		Mid:  mid,
+		Fids: fids,
+	})
+	return
+}
+
+// UpFavState update folder state.
+func (s *Service) UpFavState(c context.Context, mid, fid int64, public int32, cookie string, accessKey string) (err error) {
+	_, err = s.favClient.UpFolderAttr(c, &pb.UpFolderAttrReq{
+		Typ:    int32(model.TypeVideo),
+		Fid:    fid,
+		Mid:    mid,
+		Public: public,
+	})
+	return
+}
+
+// DelVideoFolder delete favFolder and push databus msg to del videos in folder.
+func (s *Service) DelVideoFolder(c context.Context, mid, fid int64) (err error) {
+	_, err = s.favClient.DelFolder(c, &pb.DelFolderReq{
+		Typ: int32(model.TypeVideo),
+		Mid: mid,
+		Fid: fid,
+	})
+	return
+}
+
+// RecentArcs return the newest archives in all folder.
+func (s *Service) RecentArcs(c context.Context, mid int64, pageNum, pageSize int) (sv *model.SearchArchive, err error) {
+	aids, err := s.RecentsRPC(c, model.TypeVideo, mid, pageSize)
+	if err != nil {
+		return
+	}
+	sv = new(model.SearchArchive)
+	if len(aids) == 0 {
+		sv.Result = nil
+		sv.Archives = _emptyArchives
+		return
+	}
+	archives, err := s.normalArcs(c, aids)
+	if err != nil {
+		log.Error("s.NormalArchives(%v) error(%v)", sv, err)
+		return
+	}
+	if err = s.fillArchives(c, sv); err != nil {
+		log.Error("s.RecentArcs err(%v)", err)
+	}
+	farchives := make([]*model.FavArchive, 0, len(archives))
+	for _, arc := range archives {
+		farchive := new(model.FavArchive)
+		farchive.Arc = arc
+		farchives = append(farchives, farchive)
+	}
+	sv.Result = nil
+	sv.Archives = farchives
+	sv.Mid = mid
+	sv.PageCount = sv.NumPages
+	sv.Total = sv.NumResults
+	sv.NumPages = 0
+	sv.NumResults = 0
+	return
+}
+
+func (s *Service) fillArchives(c context.Context, sv *model.SearchArchive) (err error) {
+	aids := make([]int64, 0, len(sv.Result))
+	searchArcs := make(map[int64]*model.SearchArchiveResult, len(sv.Result))
+	for _, v := range sv.Result {
+		aids = append(aids, v.ID)
+		searchArcs[v.ID] = &model.SearchArchiveResult{
+			FavTime: v.FavTime,
+			Title:   v.Title,
+			Play:    v.Play,
+		}
+	}
+	archives, err := s.normalArcs(c, aids)
+	if err != nil {
+		log.Error("s.NormalArchives(%v) error(%v)", sv, err)
+		return
+	}
+	farchives := make([]*model.FavArchive, 0, len(archives))
+	for _, arc := range archives {
+		var farchive = &model.FavArchive{}
+		farchive.Arc = arc
+		farchive.FavAt = searchArcs[arc.Aid].FavTime
+		farchive.HighlightTitle = searchArcs[arc.Aid].Title
+		farchive.PlayNum = searchArcs[arc.Aid].Play
+		farchives = append(farchives, farchive)
+	}
+	sv.Result = nil
+	sv.Archives = farchives
+	return
+}
+
+func (s *Service) newFillArchives(c context.Context, favorites []*model.Favorite, sv *model.SearchArchive) (err error) {
+	aids := make([]int64, 0, len(sv.Result))
+	favoriteArcs := make(map[int64]*model.Favorite, len(sv.Result))
+	for _, v := range favorites {
+		aids = append(aids, v.Oid)
+		favoriteArcs[v.Oid] = v
+	}
+	archives, err := s.normalArcs(c, aids)
+	if err != nil {
+		log.Error("s.normalArcs(%v) error(%v)", aids, err)
+		return
+	}
+	farchives := make([]*model.FavArchive, 0, len(archives))
+	for _, arc := range archives {
+		var farchive = &model.FavArchive{}
+		farchive.Arc = arc
+		farchive.FavAt = int64(favoriteArcs[arc.Aid].MTime)
+		farchive.HighlightTitle = arc.Title
+		farchives = append(farchives, farchive)
+	}
+	sv.Result = nil
+	sv.Archives = farchives
+	return
+}
+
+// AddArc add a archive into folder.
+func (s *Service) AddArc(c context.Context, mid, fid, aid int64, ck, ak string) (err error) {
+	if _, err = s.archive(c, aid); err != nil {
+		return
+	}
+	_, err = s.favClient.AddFav(c, &pb.AddFavReq{
+		Tp:  int32(model.TypeVideo),
+		Mid: mid,
+		Fid: fid,
+		Oid: aid,
+	})
+	if err != nil {
+		return
+	}
+	s.cache.Do(c, func(c context.Context) {
+		if err := s.videoDao.DelCoverCache(c, mid, fid); err != nil {
+			log.Error("s.videoDao.DelCoverCache(%d,%d) error(%v)", mid, fid, err)
+		}
+	})
+	return
+}
+
+// AddArcToFolders add a archive into multi folders.
+func (s *Service) AddArcToFolders(c context.Context, mid, aid int64, fids []int64, ck, ak string) (err error) {
+	if len(fids) == 0 {
+		err = s.AddArc(c, mid, 0, aid, ck, ak)
+	}
+	for _, fid := range fids {
+		err = s.AddArc(c, mid, fid, aid, ck, ak)
+	}
+	return
+}
+
+// DelArc delete a archive from favorite.
+func (s *Service) DelArc(c context.Context, mid, fid, aid int64) (err error) {
+	_, err = s.favClient.DelFav(c, &pb.DelFavReq{
+		Tp:  int32(model.TypeVideo),
+		Mid: mid,
+		Fid: fid,
+		Oid: aid,
+	})
+	if err != nil {
+		return
+	}
+	s.cache.Do(c, func(c context.Context) {
+		if err := s.videoDao.DelCoverCache(c, mid, fid); err != nil {
+			log.Error("s.videoDao.DelCoverCache(%d,%d) error(%v)", mid, fid, err)
+		}
+	})
+	return
+}
+
+// DelArcs delete some archives from favorite.
+func (s *Service) DelArcs(c context.Context, mid, fid int64, aids []int64) (err error) {
+	_, err = s.favClient.MultiDel(c, &pb.MultiDelReq{
+		Typ:  int32(model.TypeVideo),
+		Mid:  mid,
+		Fid:  fid,
+		Oids: aids,
+	})
+	if err != nil {
+		return
+	}
+	s.cache.Do(c, func(c context.Context) {
+		if err := s.videoDao.DelCoverCache(c, mid, fid); err != nil {
+			log.Error("s.videoDao.DelCoverCache(%d,%d) error(%v)", mid, fid, err)
+		}
+	})
+	return
+}
+
+// MoveArcs move archives from old favorite to new favorite
+func (s *Service) MoveArcs(c context.Context, mid, oldfid, newfid int64, aids []int64) (err error) {
+	if len(aids) == 0 || oldfid == newfid {
+		return
+	}
+	_, err = s.favClient.MoveFavs(c, &pb.MoveFavsReq{
+		Typ:    int32(model.TypeVideo),
+		Mid:    mid,
+		OldFid: oldfid,
+		NewFid: newfid,
+		Oids:   aids,
+	})
+	if err != nil {
+		return
+	}
+	s.cache.Do(c, func(c context.Context) {
+		if err := s.videoDao.DelCoverCache(c, mid, newfid); err != nil {
+			log.Error("s.videoDao.DelCoverCache(%d,%d) error(%v)", mid, newfid, err)
+		}
+		if err := s.videoDao.DelCoverCache(c, mid, oldfid); err != nil {
+			log.Error("s.videoDao.DelCoverCache(%d,%d) error(%v)", mid, oldfid, err)
+		}
+	})
+	return
+}
+
+// CopyArcs copy archives to other favorite.
+func (s *Service) CopyArcs(c context.Context, mid, oldmid, oldfid, newfid int64, aids []int64) (err error) {
+	if len(aids) == 0 || oldfid == newfid {
+		return
+	}
+	_, err = s.favClient.CopyFavs(c, &pb.CopyFavsReq{
+		Typ:    int32(model.TypeVideo),
+		OldMid: oldmid,
+		Mid:    mid,
+		OldFid: oldfid,
+		NewFid: newfid,
+		Oids:   aids,
+	})
+	if err != nil {
+		return
+	}
+	s.cache.Do(c, func(c context.Context) {
+		if err := s.videoDao.DelCoverCache(c, mid, newfid); err != nil {
+			log.Error("s.videoDao.DelCoverCache(%d,%d) error(%v)", mid, newfid, err)
+		}
+	})
+	return
+}
+
+// IsFaveds check if aids faved by user
+func (s *Service) IsFaveds(c context.Context, mid int64, aids []int64) (m map[int64]bool, err error) {
+	if m, err = s.IsFavsRPC(c, model.TypeVideo, mid, aids); err != nil {
+		log.Error("s.IsFavsRPC(%d,%d,%v) error(%v)", model.TypeVideo, mid, aids, err)
+	}
+	return
+}
+
+// IsFaved check if aid faved by user
+func (s *Service) IsFaved(c context.Context, mid, aid int64) (faved bool, count int, err error) {
+	if faved, err = s.IsFavRPC(c, model.TypeVideo, mid, aid); err != nil {
+		log.Error("s.IsFavsRPC(%d,%d,%d) error(%v)", model.TypeVideo, mid, aid, err)
+	}
+	count = 1
+	return
+}
+
+// InDef detemine aid whether or not archive in default folder.
+func (s *Service) InDef(c context.Context, mid, aid int64) (isin bool, err error) {
+	if isin, err = s.InDefaultRPC(c, model.TypeVideo, mid, aid); err != nil {
+		log.Error("s.InDefaultRPC(%d,%d,%d) error(%v)", model.TypeVideo, mid, aid, err)
+	}
+	return
+}
+
+// CleanState return this folder clean state.
+func (s *Service) CleanState(c context.Context, mid, fid int64) (cleanState int, err error) {
+	reply, err := s.favClient.CleanState(c, &pb.CleanStateReq{
+		Typ: int32(model.TypeVideo),
+		Mid: mid,
+		Fid: fid,
+	})
+	if err != nil {
+		return
+	}
+	cleanState = int(reply.CleanState)
+	return
+}
+
+// CleanInvalidArcs clean invalid archives.
+func (s *Service) CleanInvalidArcs(c context.Context, mid, fid int64) (err error) {
+	_, err = s.favClient.CleanInvalidFavs(c, &pb.CleanInvalidFavsReq{
+		Typ: int32(model.TypeVideo),
+		Mid: mid,
+		Fid: fid,
+	})
+	return
+}