Create & Init Project...

app/interface/main/app-interface/service/space/BUILD

@@ -0,0 +1,91 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "contribute_test.go",
+        "service_test.go",
+        "space_test.go",
+    ],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//app/interface/main/app-interface/model:go_default_library",
+        "//app/interface/main/app-interface/model/space:go_default_library",
+        "//app/service/main/account/model:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "contribute.go",
+        "service.go",
+        "space.go",
+    ],
+    importpath = "go-common/app/interface/main/app-interface/service/space",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//app/interface/main/app-interface/dao/account:go_default_library",
+        "//app/interface/main/app-interface/dao/archive:go_default_library",
+        "//app/interface/main/app-interface/dao/article:go_default_library",
+        "//app/interface/main/app-interface/dao/audio:go_default_library",
+        "//app/interface/main/app-interface/dao/bangumi:go_default_library",
+        "//app/interface/main/app-interface/dao/bplus:go_default_library",
+        "//app/interface/main/app-interface/dao/coin:go_default_library",
+        "//app/interface/main/app-interface/dao/community:go_default_library",
+        "//app/interface/main/app-interface/dao/elec:go_default_library",
+        "//app/interface/main/app-interface/dao/favorite:go_default_library",
+        "//app/interface/main/app-interface/dao/live:go_default_library",
+        "//app/interface/main/app-interface/dao/member:go_default_library",
+        "//app/interface/main/app-interface/dao/pay:go_default_library",
+        "//app/interface/main/app-interface/dao/relation:go_default_library",
+        "//app/interface/main/app-interface/dao/search:go_default_library",
+        "//app/interface/main/app-interface/dao/shop:go_default_library",
+        "//app/interface/main/app-interface/dao/space:go_default_library",
+        "//app/interface/main/app-interface/dao/tag:go_default_library",
+        "//app/interface/main/app-interface/dao/thumbup:go_default_library",
+        "//app/interface/main/app-interface/model:go_default_library",
+        "//app/interface/main/app-interface/model/audio:go_default_library",
+        "//app/interface/main/app-interface/model/bangumi:go_default_library",
+        "//app/interface/main/app-interface/model/bplus:go_default_library",
+        "//app/interface/main/app-interface/model/community:go_default_library",
+        "//app/interface/main/app-interface/model/favorite:go_default_library",
+        "//app/interface/main/app-interface/model/shop:go_default_library",
+        "//app/interface/main/app-interface/model/space:go_default_library",
+        "//app/interface/openplatform/article/model:go_default_library",
+        "//app/service/main/account/model:go_default_library",
+        "//app/service/main/archive/api:go_default_library",
+        "//app/service/main/thumbup/model:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/sync/errgroup:go_default_library",
+        "//library/time:go_default_library",
+        "//vendor/github.com/pkg/errors: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/app-interface/service/space/contribute.go

@@ -0,0 +1,482 @@
+package space
+
+import (
+	"context"
+	"sort"
+	"time"
+
+	"go-common/app/interface/main/app-interface/model"
+	"go-common/app/interface/main/app-interface/model/audio"
+	"go-common/app/interface/main/app-interface/model/bplus"
+	"go-common/app/interface/main/app-interface/model/space"
+	article "go-common/app/interface/openplatform/article/model"
+	"go-common/app/service/main/archive/api"
+	"go-common/library/log"
+	"go-common/library/sync/errgroup"
+	xtime "go-common/library/time"
+)
+
+const (
+	_androidAudio = 516009
+	_iosAudio     = 6160
+)
+
+// Contribute func
+func (s *Service) Contribute(c context.Context, plat int8, build int, vmid int64, pn, ps int, now time.Time) (res *space.Contributes, err error) {
+	var (
+		attrs *space.Attrs
+		items []*space.Item
+	)
+	if pn == 1 {
+		var (
+			ctime  xtime.Time
+			cached bool
+		)
+		size := ps
+		if items, err = s.bplusDao.RangeContributeCache(c, vmid, pn, ps); err != nil {
+			log.Error("%+v", err)
+		} else if len(items) != 0 {
+			ctime = items[0].CTime
+		} else {
+			size = 100
+			cached = true
+		}
+		if res, err = s.firstContribute(c, vmid, size, now); err != nil {
+			log.Error("%+v", err)
+			err = nil
+		}
+		if res != nil && len(res.Items) != 0 {
+			if res.Items[0].CTime > ctime {
+				if err = s.bplusDao.NotifyContribute(c, vmid, nil, ctime); err != nil {
+					log.Error("%+v", err)
+					err = nil
+				}
+			}
+			if cached {
+				ris := res.Items
+				s.addCache(func() {
+					s.bplusDao.AddContributeCache(context.Background(), vmid, nil, ris)
+				})
+			}
+			if len(items) == 0 {
+				ris := make([]*space.Item, 0, ps)
+				for _, item := range res.Items {
+					item.FormatKey()
+					switch item.Goto {
+					case model.GotoAudio:
+						if (plat == model.PlatAndroid && build > _androidAudio) || (plat == model.PlatIPhone && build > _iosAudio) || plat == model.PlatAndroidB {
+							ris = append(ris, item)
+						}
+					default:
+						ris = append(ris, item)
+					}
+					if len(ris) == ps {
+						break
+					}
+				}
+				res.Items = ris
+				return
+			}
+		}
+	} else {
+		if items, err = s.bplusDao.RangeContributeCache(c, vmid, pn, ps); err != nil {
+			return
+		}
+	}
+	if len(items) != 0 {
+		if attrs, err = s.bplusDao.AttrCache(c, vmid); err != nil {
+			log.Error("%+v", err)
+		}
+		// merge res
+		if res, err = s.dealContribute(c, plat, build, vmid, attrs, items, now); err != nil {
+			log.Error("%+v", err)
+		}
+	}
+	if res == nil {
+		res = &space.Contributes{Tab: &space.Tab{}, Items: []*space.Item{}, Links: &space.Links{}}
+	}
+	return
+}
+
+// Contribution func
+func (s *Service) Contribution(c context.Context, plat int8, build int, vmid int64, cursor *model.Cursor, now time.Time) (res *space.Contributes, err error) {
+	var (
+		attrs *space.Attrs
+		items []*space.Item
+	)
+	if cursor.Latest() {
+		var (
+			ctime  xtime.Time
+			cached bool
+		)
+		size := cursor.Size
+		if items, err = s.bplusDao.RangeContributeCache(c, vmid, 1, 1); err != nil {
+			log.Error("%+v", err)
+		} else if len(items) != 0 {
+			ctime = items[0].CTime
+		} else {
+			size = 100
+			cached = true
+		}
+		if res, err = s.firstContribute(c, vmid, size, now); err != nil {
+			log.Error("%+v", err)
+		}
+		if res != nil && len(res.Items) != 0 {
+			if cached {
+				ris := res.Items
+				s.addCache(func() {
+					s.bplusDao.AddContributeCache(context.Background(), vmid, nil, ris)
+				})
+			}
+			if res.Items[0].CTime > ctime {
+				if len(items) != 0 {
+					if attrs, err = s.bplusDao.AttrCache(c, vmid); err != nil {
+						log.Error("%+v", err)
+					}
+				}
+				if err = s.bplusDao.NotifyContribute(c, vmid, attrs, ctime); err != nil {
+					log.Error("%+v", err)
+					err = nil
+				}
+			}
+			ris := make([]*space.Item, 0, cursor.Size)
+			for _, item := range res.Items {
+				item.FormatKey()
+				ris = append(ris, item)
+				if len(ris) == cursor.Size {
+					break
+				}
+			}
+			if len(ris) != 0 {
+				res.Items = ris
+				res.Links.Link(0, int64(ris[len(ris)-1].Member))
+			}
+			return
+		}
+	}
+	if items, err = s.bplusDao.RangeContributionCache(c, vmid, cursor); err != nil {
+		return
+	}
+	if len(items) != 0 {
+		if attrs, err = s.bplusDao.AttrCache(c, vmid); err != nil {
+			log.Error("%+v", err)
+		}
+		// merge res
+		if res, err = s.dealContribute(c, plat, build, vmid, attrs, items, now); err != nil {
+			log.Error("%+v", err)
+		}
+	}
+	if res == nil {
+		res = &space.Contributes{Tab: &space.Tab{}, Items: []*space.Item{}, Links: &space.Links{}}
+	}
+	return
+}
+
+func (s *Service) firstContribute(c context.Context, vmid int64, size int, now time.Time) (res *space.Contributes, err error) {
+	res = &space.Contributes{Tab: &space.Tab{}, Items: []*space.Item{}, Links: &space.Links{}}
+	g, ctx := errgroup.WithContext(c)
+	var arcItem, artItem, clipItem, albumItem, audioItem, items []*space.Item
+	g.Go(func() (err error) {
+		var arcs []*api.Arc
+		if arcs, err = s.arcDao.UpArcs3(ctx, vmid, 1, size); err != nil {
+			log.Error("s.arcDao.UpArcs3(%d,%d,%d) error(%v)", vmid, 1, size, err)
+			err = nil
+			return
+		}
+		if len(arcs) != 0 {
+			arcItem = make([]*space.Item, 0, len(arcs))
+			for _, v := range arcs {
+				if v.IsNormal() {
+					si := &space.Item{}
+					si.FromArc3(v)
+					arcItem = append(arcItem, si)
+				}
+			}
+		}
+		return
+	})
+	g.Go(func() (err error) {
+		var arts []*article.Meta
+		if arts, _, err = s.artDao.UpArticles(ctx, vmid, 1, size); err != nil {
+			log.Error("s.artDao.UpArticles(%d,%d,%d) error(%v)", vmid, 1, size, err)
+			err = nil
+			return
+		}
+		if len(arts) != 0 {
+			artItem = make([]*space.Item, 0, len(arts))
+			for _, v := range arts {
+				if v.AttrVal(article.AttrBitNoDistribute) {
+					continue
+				}
+				si := &space.Item{}
+				si.FromArticle(v)
+				artItem = append(artItem, si)
+			}
+		}
+		return
+	})
+	g.Go(func() (err error) {
+		var clips []*bplus.Clip
+		if clips, _, err = s.bplusDao.AllClip(c, vmid, size); err != nil {
+			log.Error("s.bplusDao.AllClip(%d,%d) error(%v)", vmid, size, err)
+			err = nil
+			return
+		}
+		if len(clips) != 0 {
+			clipItem = make([]*space.Item, 0, len(clips))
+			for _, v := range clips {
+				si := &space.Item{}
+				si.FromClip(v)
+				clipItem = append(clipItem, si)
+			}
+		}
+		return
+	})
+	g.Go(func() (err error) {
+		var album []*bplus.Album
+		if album, _, err = s.bplusDao.AllAlbum(c, vmid, size); err != nil {
+			log.Error("s.bplusDao.AllAlbum(%d,%d) error(%v)", vmid, size, err)
+			err = nil
+			return
+		}
+		if len(album) != 0 {
+			albumItem = make([]*space.Item, 0, len(album))
+			for _, v := range album {
+				si := &space.Item{}
+				si.FromAlbum(v)
+				albumItem = append(albumItem, si)
+			}
+		}
+		return
+	})
+	g.Go(func() (err error) {
+		var audio []*audio.Audio
+		if audio, err = s.audioDao.AllAudio(c, vmid); err != nil {
+			log.Error("s.audioDao.AllAudio(%d) error(%v)", vmid, err)
+			err = nil
+			return
+		}
+		if len(audio) != 0 {
+			audioItem = make([]*space.Item, 0, len(audio))
+			for _, v := range audio {
+				si := &space.Item{}
+				si.FromAudio(v)
+				audioItem = append(audioItem, si)
+			}
+		}
+		return
+	})
+	if err = g.Wait(); err != nil {
+		log.Error("Contribute errgroup.WithContext error(%v)", err)
+	}
+	items = make([]*space.Item, 0, len(arcItem)+len(artItem)+len(clipItem)+len(albumItem)+len(audioItem))
+	if len(arcItem) != 0 {
+		res.Tab.Archive = true
+		items = append(items, arcItem...)
+	}
+	if len(artItem) != 0 {
+		res.Tab.Article = true
+		items = append(items, artItem...)
+	}
+	if len(clipItem) != 0 {
+		res.Tab.Clip = true
+		items = append(items, clipItem...)
+	}
+	if len(albumItem) != 0 {
+		res.Tab.Album = true
+		items = append(items, albumItem...)
+	}
+	if len(audioItem) != 0 {
+		res.Tab.Audios = true
+		items = append(items, audioItem...)
+	}
+	sort.Sort(space.Items(items))
+	res.Items = items
+	return
+}
+
+func (s *Service) dealContribute(c context.Context, plat int8, build int, vmid int64, attrs *space.Attrs, items []*space.Item, now time.Time) (res *space.Contributes, err error) {
+	res = &space.Contributes{Tab: &space.Tab{}, Items: []*space.Item{}, Links: &space.Links{}}
+	var aids, cvids, clids, alids, auids []int64
+	if attrs == nil {
+		attrs = &space.Attrs{}
+	} else if !((plat == model.PlatAndroid && build > _androidAudio) || (plat == model.PlatIPhone && build > _iosAudio) || plat == model.PlatAndroidB) {
+		attrs.Audio = false
+	}
+	for _, item := range items {
+		if item.ID == 0 {
+			continue
+		}
+		switch item.Goto {
+		case model.GotoAv:
+			aids = append(aids, item.ID)
+		case model.GotoArticle:
+			cvids = append(cvids, item.ID)
+		case model.GotoClip:
+			clids = append(clids, item.ID)
+		case model.GotoAlbum:
+			alids = append(alids, item.ID)
+		case model.GotoAudio:
+			if (plat == model.PlatAndroid && build > _androidAudio) || (plat == model.PlatIPhone && build > _iosAudio) || plat == model.PlatAndroidB {
+				auids = append(auids, item.ID)
+			}
+		}
+	}
+	var (
+		am  map[int64]*api.Arc
+		atm map[int64]*article.Meta
+		clm map[int64]*bplus.Clip
+		alm map[int64]*bplus.Album
+		aum map[int64]*audio.Audio
+	)
+	g, ctx := errgroup.WithContext(c)
+	if len(aids) != 0 {
+		g.Go(func() (err error) {
+			if am, err = s.arcDao.Archives2(ctx, aids); err != nil {
+				log.Error("s.arcDao.Archives(%v) error(%v)", aids, err)
+				err = nil
+			}
+			return
+		})
+	}
+	if len(cvids) != 0 {
+		g.Go(func() (err error) {
+			if atm, err = s.artDao.Articles(ctx, cvids); err != nil {
+				log.Error("s.artDao.Articles(%v) error(%v)", cvids, err)
+				err = nil
+			}
+			return
+		})
+	}
+	if len(clids) != 0 {
+		g.Go(func() (err error) {
+			if clm, err = s.bplusDao.ClipDetail(ctx, clids); err != nil {
+				log.Error("s.bplusDao.ClipDetail(%v) error(%v)", clids, err)
+				err = nil
+			}
+			return
+		})
+	}
+	if len(alids) != 0 {
+		g.Go(func() (err error) {
+			if alm, err = s.bplusDao.AlbumDetail(ctx, vmid, alids); err != nil {
+				log.Error("s.bplusDao.AlbumDetail(%v) error(%v)", alids, err)
+				err = nil
+			}
+			return
+		})
+	}
+	if len(auids) != 0 {
+		g.Go(func() (err error) {
+			if aum, err = s.audioDao.AudioDetail(c, auids); err != nil {
+				log.Error("s.audioDao.AudioDetail(%v) error(%v)", auids, err)
+				err = nil
+			}
+			return
+		})
+	}
+	if err = g.Wait(); err != nil {
+		log.Error("Contribute errgroup.WithContext error(%v)", err)
+		return
+	}
+	if len(am) != 0 || attrs.Archive {
+		res.Tab.Archive = true
+	}
+	if len(atm) != 0 || attrs.Article {
+		res.Tab.Article = true
+	}
+	if len(clm) != 0 || attrs.Clip {
+		res.Tab.Clip = true
+	}
+	if len(alm) != 0 || attrs.Album {
+		res.Tab.Album = true
+	}
+	if len(aum) != 0 || attrs.Audio {
+		res.Tab.Audios = true
+	}
+	ris := make([]*space.Item, 0, len(items))
+	for _, item := range items {
+		ri := &space.Item{}
+		switch item.Goto {
+		case model.GotoAv:
+			if a, ok := am[item.ID]; ok && a.IsNormal() {
+				ri.FromArc3(a)
+			}
+		case model.GotoArticle:
+			if at, ok := atm[item.ID]; ok {
+				ri.FromArticle(at)
+			}
+		case model.GotoClip:
+			if cl, ok := clm[item.ID]; ok {
+				ri.FromClip(cl)
+			}
+		case model.GotoAlbum:
+			if al, ok := alm[item.ID]; ok {
+				ri.FromAlbum(al)
+			}
+		case model.GotoAudio:
+			if au, ok := aum[item.ID]; ok {
+				ri.FromAudio(au)
+			}
+		}
+		if ri.Goto != "" {
+			ri.FormatKey()
+			ris = append(ris, ri)
+		}
+	}
+	res.Items = ris
+	res.Links.Link(int64(items[0].Member), int64(items[len(items)-1].Member))
+	return
+}
+
+// Clip func
+func (s *Service) Clip(c context.Context, vmid int64, pos, size int) (res *space.ClipList) {
+	var (
+		clips []*bplus.Clip
+		err   error
+	)
+	res = &space.ClipList{Item: []*space.Item{}}
+	if clips, res.More, res.Offset, err = s.bplusDao.Clips(c, vmid, pos, size); err != nil {
+		log.Error("%+v", err)
+		return
+	}
+	if len(clips) > 0 {
+		res.Item = make([]*space.Item, 0, len(clips))
+		for _, v := range clips {
+			si := &space.Item{}
+			si.FromClip(v)
+			res.Item = append(res.Item, si)
+		}
+	}
+	return
+}
+
+// Album func
+func (s *Service) Album(c context.Context, vmid int64, pos, size int) (res *space.AlbumList) {
+	var (
+		albums []*bplus.Album
+		err    error
+	)
+	res = &space.AlbumList{Item: []*space.Item{}}
+	if albums, res.More, res.Offset, err = s.bplusDao.Albums(c, vmid, pos, size); err != nil {
+		log.Error("%+v", err)
+		return
+	}
+	if len(albums) > 0 {
+		res.Item = make([]*space.Item, 0, len(albums))
+		for _, v := range albums {
+			si := &space.Item{}
+			si.FromAlbum(v)
+			res.Item = append(res.Item, si)
+		}
+	}
+	return
+}
+
+// AddContribute func
+func (s *Service) AddContribute(c context.Context, vmid int64, attrs *space.Attrs, items []*space.Item) (err error) {
+	if err = s.bplusDao.AddContributeCache(c, vmid, attrs, items); err != nil {
+		log.Error("%+v", err)
+	}
+	return
+}

app/interface/main/app-interface/service/space/contribute_test.go

@@ -0,0 +1,211 @@
+package space
+
+import (
+	"context"
+	"reflect"
+	"testing"
+	"time"
+
+	"go-common/app/interface/main/app-interface/model"
+	"go-common/app/interface/main/app-interface/model/space"
+)
+
+func TestService_Contribute(t *testing.T) {
+	type args struct {
+		c     context.Context
+		plat  int8
+		build int
+		vmid  int64
+		pn    int
+		ps    int
+		now   time.Time
+	}
+	tests := []struct {
+		name    string
+		s       *Service
+		args    args
+		wantRes *space.Contributes
+		wantErr bool
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gotRes, err := tt.s.Contribute(tt.args.c, tt.args.plat, tt.args.build, tt.args.vmid, tt.args.pn, tt.args.ps, tt.args.now)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Service.Contribute() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(gotRes, tt.wantRes) {
+				t.Errorf("Service.Contribute() = %v, want %v", gotRes, tt.wantRes)
+			}
+		})
+	}
+}
+
+func TestService_Contribution(t *testing.T) {
+	type args struct {
+		c      context.Context
+		plat   int8
+		build  int
+		vmid   int64
+		cursor *model.Cursor
+		now    time.Time
+	}
+	tests := []struct {
+		name    string
+		s       *Service
+		args    args
+		wantRes *space.Contributes
+		wantErr bool
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gotRes, err := tt.s.Contribution(tt.args.c, tt.args.plat, tt.args.build, tt.args.vmid, tt.args.cursor, tt.args.now)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Service.Contribution() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(gotRes, tt.wantRes) {
+				t.Errorf("Service.Contribution() = %v, want %v", gotRes, tt.wantRes)
+			}
+		})
+	}
+}
+
+func TestService_firstContribute(t *testing.T) {
+	type args struct {
+		c    context.Context
+		vmid int64
+		size int
+		now  time.Time
+	}
+	tests := []struct {
+		name    string
+		s       *Service
+		args    args
+		wantRes *space.Contributes
+		wantErr bool
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gotRes, err := tt.s.firstContribute(tt.args.c, tt.args.vmid, tt.args.size, tt.args.now)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Service.firstContribute() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(gotRes, tt.wantRes) {
+				t.Errorf("Service.firstContribute() = %v, want %v", gotRes, tt.wantRes)
+			}
+		})
+	}
+}
+
+func TestService_dealContribute(t *testing.T) {
+	type args struct {
+		c     context.Context
+		plat  int8
+		build int
+		vmid  int64
+		attrs *space.Attrs
+		items []*space.Item
+		now   time.Time
+	}
+	tests := []struct {
+		name    string
+		s       *Service
+		args    args
+		wantRes *space.Contributes
+		wantErr bool
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gotRes, err := tt.s.dealContribute(tt.args.c, tt.args.plat, tt.args.build, tt.args.vmid, tt.args.attrs, tt.args.items, tt.args.now)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Service.dealContribute() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(gotRes, tt.wantRes) {
+				t.Errorf("Service.dealContribute() = %v, want %v", gotRes, tt.wantRes)
+			}
+		})
+	}
+}
+
+func TestService_Clip(t *testing.T) {
+	type args struct {
+		c    context.Context
+		vmid int64
+		pos  int
+		size int
+	}
+	tests := []struct {
+		name    string
+		s       *Service
+		args    args
+		wantRes *space.ClipList
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if gotRes := tt.s.Clip(tt.args.c, tt.args.vmid, tt.args.pos, tt.args.size); !reflect.DeepEqual(gotRes, tt.wantRes) {
+				t.Errorf("Service.Clip() = %v, want %v", gotRes, tt.wantRes)
+			}
+		})
+	}
+}
+
+func TestService_Album(t *testing.T) {
+	type args struct {
+		c    context.Context
+		vmid int64
+		pos  int
+		size int
+	}
+	tests := []struct {
+		name    string
+		s       *Service
+		args    args
+		wantRes *space.AlbumList
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if gotRes := tt.s.Album(tt.args.c, tt.args.vmid, tt.args.pos, tt.args.size); !reflect.DeepEqual(gotRes, tt.wantRes) {
+				t.Errorf("Service.Album() = %v, want %v", gotRes, tt.wantRes)
+			}
+		})
+	}
+}
+
+func TestService_AddContribute(t *testing.T) {
+	type args struct {
+		c     context.Context
+		vmid  int64
+		attrs *space.Attrs
+		items []*space.Item
+	}
+	tests := []struct {
+		name    string
+		s       *Service
+		args    args
+		wantErr bool
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if err := tt.s.AddContribute(tt.args.c, tt.args.vmid, tt.args.attrs, tt.args.items); (err != nil) != tt.wantErr {
+				t.Errorf("Service.AddContribute() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}

app/interface/main/app-interface/service/space/service.go

@@ -0,0 +1,138 @@
+package space
+
+import (
+	"context"
+	"runtime"
+	"time"
+
+	"go-common/app/interface/main/app-interface/conf"
+	accdao "go-common/app/interface/main/app-interface/dao/account"
+	arcdao "go-common/app/interface/main/app-interface/dao/archive"
+	artdao "go-common/app/interface/main/app-interface/dao/article"
+	audiodao "go-common/app/interface/main/app-interface/dao/audio"
+	bgmdao "go-common/app/interface/main/app-interface/dao/bangumi"
+	bplusdao "go-common/app/interface/main/app-interface/dao/bplus"
+	coindao "go-common/app/interface/main/app-interface/dao/coin"
+	commdao "go-common/app/interface/main/app-interface/dao/community"
+	elecdao "go-common/app/interface/main/app-interface/dao/elec"
+	favdao "go-common/app/interface/main/app-interface/dao/favorite"
+	livedao "go-common/app/interface/main/app-interface/dao/live"
+	memberdao "go-common/app/interface/main/app-interface/dao/member"
+	paydao "go-common/app/interface/main/app-interface/dao/pay"
+	reldao "go-common/app/interface/main/app-interface/dao/relation"
+	srchdao "go-common/app/interface/main/app-interface/dao/search"
+	shopdao "go-common/app/interface/main/app-interface/dao/shop"
+	spcdao "go-common/app/interface/main/app-interface/dao/space"
+	tagdao "go-common/app/interface/main/app-interface/dao/tag"
+	thumbupdao "go-common/app/interface/main/app-interface/dao/thumbup"
+	"go-common/library/log"
+)
+
+// Service is space service
+type Service struct {
+	c          *conf.Config
+	arcDao     *arcdao.Dao
+	spcDao     *spcdao.Dao
+	accDao     *accdao.Dao
+	coinDao    *coindao.Dao
+	commDao    *commdao.Dao
+	srchDao    *srchdao.Dao
+	favDao     *favdao.Dao
+	bgmDao     *bgmdao.Dao
+	tagDao     *tagdao.Dao
+	liveDao    *livedao.Dao
+	elecDao    *elecdao.Dao
+	artDao     *artdao.Dao
+	audioDao   *audiodao.Dao
+	relDao     *reldao.Dao
+	bplusDao   *bplusdao.Dao
+	shopDao    *shopdao.Dao
+	thumbupDao *thumbupdao.Dao
+	payDao     *paydao.Dao
+	memberDao  *memberdao.Dao
+	// chan
+	mCh       chan func()
+	tick      time.Duration
+	BlackList map[int64]struct{}
+}
+
+// New new space
+func New(c *conf.Config) (s *Service) {
+	s = &Service{
+		c:          c,
+		arcDao:     arcdao.New(c),
+		spcDao:     spcdao.New(c),
+		accDao:     accdao.New(c),
+		coinDao:    coindao.New(c),
+		commDao:    commdao.New(c),
+		srchDao:    srchdao.New(c),
+		favDao:     favdao.New(c),
+		bgmDao:     bgmdao.New(c),
+		tagDao:     tagdao.New(c),
+		liveDao:    livedao.New(c),
+		elecDao:    elecdao.New(c),
+		artDao:     artdao.New(c),
+		audioDao:   audiodao.New(c),
+		relDao:     reldao.New(c),
+		bplusDao:   bplusdao.New(c),
+		shopDao:    shopdao.New(c),
+		thumbupDao: thumbupdao.New(c),
+		payDao:     paydao.New(c),
+		memberDao:  memberdao.New(c),
+		// mc proc
+		mCh:       make(chan func(), 1024),
+		tick:      time.Duration(c.Tick),
+		BlackList: make(map[int64]struct{}),
+	}
+	// video db
+	for i := 0; i < runtime.NumCPU(); i++ {
+		go s.cacheproc()
+	}
+	if c != nil && c.Space != nil {
+		for _, mid := range c.Space.ForbidMid {
+			s.BlackList[mid] = struct{}{}
+		}
+	}
+	s.loadBlacklist()
+	go s.blacklistproc()
+	return
+}
+
+// addCache add archive to mc or redis
+func (s *Service) addCache(f func()) {
+	select {
+	case s.mCh <- f:
+	default:
+		log.Warn("cacheproc chan full")
+	}
+}
+
+// cacheproc write memcache and stat redis use goroutine
+func (s *Service) cacheproc() {
+	for {
+		f := <-s.mCh
+		f()
+	}
+}
+
+// Ping check server ok
+func (s *Service) Ping(c context.Context) (err error) {
+	return
+}
+
+// loadBlacklist
+func (s *Service) loadBlacklist() {
+	list, err := s.spcDao.Blacklist(context.Background())
+	if err != nil {
+		log.Error("%+v", err)
+		return
+	}
+	s.BlackList = list
+}
+
+func (s *Service) blacklistproc() {
+	for {
+		time.Sleep(s.tick)
+		s.loadBlacklist()
+	}
+}

app/interface/main/app-interface/service/space/service_test.go

@@ -0,0 +1,82 @@
+package space
+
+import (
+	"context"
+	"reflect"
+	"testing"
+
+	"go-common/app/interface/main/app-interface/conf"
+)
+
+func TestNew(t *testing.T) {
+	type args struct {
+		c *conf.Config
+	}
+	tests := []struct {
+		name  string
+		args  args
+		wantS *Service
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if gotS := New(tt.args.c); !reflect.DeepEqual(gotS, tt.wantS) {
+				t.Errorf("New() = %v, want %v", gotS, tt.wantS)
+			}
+		})
+	}
+}
+
+func TestService_addCache(t *testing.T) {
+	type args struct {
+		f func()
+	}
+	tests := []struct {
+		name string
+		s    *Service
+		args args
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tt.s.addCache(tt.args.f)
+		})
+	}
+}
+
+func TestService_cacheproc(t *testing.T) {
+	tests := []struct {
+		name string
+		s    *Service
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tt.s.cacheproc()
+		})
+	}
+}
+
+func TestService_Ping(t *testing.T) {
+	type args struct {
+		c context.Context
+	}
+	tests := []struct {
+		name    string
+		s       *Service
+		args    args
+		wantErr bool
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if err := tt.s.Ping(tt.args.c); (err != nil) != tt.wantErr {
+				t.Errorf("Service.Ping() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}

app/interface/main/app-interface/service/space/space.go

@@ -0,0 +1,679 @@
+package space
+
+import (
+	"context"
+	"strconv"
+	"time"
+
+	"go-common/app/interface/main/app-interface/model"
+	"go-common/app/interface/main/app-interface/model/audio"
+	"go-common/app/interface/main/app-interface/model/bangumi"
+	"go-common/app/interface/main/app-interface/model/bplus"
+	"go-common/app/interface/main/app-interface/model/community"
+	"go-common/app/interface/main/app-interface/model/favorite"
+	"go-common/app/interface/main/app-interface/model/shop"
+	"go-common/app/interface/main/app-interface/model/space"
+	article "go-common/app/interface/openplatform/article/model"
+	account "go-common/app/service/main/account/model"
+	"go-common/app/service/main/archive/api"
+	thumbup "go-common/app/service/main/thumbup/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	"go-common/library/sync/errgroup"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_shopName     = "的店铺"
+	_businessLike = "archive"
+)
+
+// Space aggregation space data.
+func (s *Service) Space(c context.Context, mid, vmid int64, plat int8, build int, pn, ps int, platform, device, mobiApp, name string, now time.Time) (sp *space.Space, err error) {
+	if _, ok := s.BlackList[vmid]; ok {
+		err = ecode.NothingFound
+		return
+	}
+	sp = &space.Space{}
+	// get card
+	card, err := s.card(c, vmid, name)
+	if err != nil {
+		if ecode.String(errors.Cause(err).Error()) == ecode.UserNotExist || vmid < 1 {
+			err = ecode.NothingFound
+			return
+		}
+		sp.Card = &space.Card{Mid: strconv.FormatInt(vmid, 10)}
+		log.Error("%+v", err)
+	} else if card == nil {
+		log.Warn("space mid(%d) vmid(%d) name(%s) plat(%s) device(%s) card is nil", mid, vmid, name, platform, device)
+		err = ecode.NothingFound
+		return
+	} else {
+		if card.Mid == "" {
+			err = ecode.NothingFound
+			return
+		}
+		if vmid > 0 && card.Mid != strconv.FormatInt(vmid, 10) {
+			err = ecode.NothingFound
+			return
+		}
+		if vmid < 1 {
+			if vmid, _ = strconv.ParseInt(card.Mid, 10, 64); vmid < 1 {
+				err = ecode.NothingFound
+				return
+			}
+		}
+		sp.Card = card
+		// ignore some card field
+		sp.Card.Rank = ""
+		sp.Card.DisplayRank = ""
+		sp.Card.Regtime = 0
+		sp.Card.Spacesta = 0
+		sp.Card.Birthday = ""
+		sp.Card.Place = ""
+		sp.Card.Article = 0
+		sp.Card.Friend = 0
+		sp.Card.Attentions = nil
+		sp.Card.Pendant.Pid = 0
+		sp.Card.Pendant.Image = ""
+		sp.Card.Pendant.Expire = 0
+		sp.Card.Nameplate.Nid = 0
+		sp.Card.Nameplate.Name = ""
+		sp.Card.Nameplate.Image = ""
+		sp.Card.Nameplate.ImageSmall = ""
+		sp.Card.Nameplate.Level = ""
+		sp.Card.Nameplate.Condition = ""
+	}
+	// space
+	g, ctx := errgroup.WithContext(c)
+	g.Go(func() error {
+		sp.Space, _ = s.spcDao.SpaceMob(ctx, mid, vmid, platform, device)
+		return nil
+	})
+	g.Go(func() error {
+		sp.Card.FansGroup, _ = s.bplusDao.GroupsCount(ctx, mid, vmid)
+		return nil
+	})
+	g.Go(func() (err error) {
+		cardm, err := s.audioDao.Card(ctx, vmid)
+		if err != nil {
+			log.Error("%+v", err)
+			err = nil
+			return
+		}
+		if card, ok := cardm[vmid]; ok && card.Type == 1 && card.Status == 1 {
+			sp.Card.Audio = 1
+		}
+		return
+	})
+	if vmid == mid {
+		g.Go(func() (err error) {
+			if sp.Card.FansUnread, err = s.relDao.FollowersUnread(ctx, vmid); err != nil {
+				log.Error("%+v", err)
+				err = nil
+			}
+			return
+		})
+	}
+	g.Go(func() (err error) {
+		cert, err := s.audioDao.UpperCert(ctx, vmid)
+		if err != nil {
+			log.Error("%+v", err)
+			err = nil
+			return
+		}
+		if cert == nil || cert.Cert == nil || cert.Cert.Type == -1 || cert.Cert.Desc == "" {
+			return
+		}
+		if sp.Card.OfficialVerify.Type == -1 {
+			sp.Card.OfficialVerify.Type = int8(cert.Cert.Type)
+		}
+		if sp.Card.OfficialVerify.Desc != "" {
+			sp.Card.OfficialVerify.Desc = sp.Card.OfficialVerify.Desc + "、" + cert.Cert.Desc
+		} else {
+			sp.Card.OfficialVerify.Desc = cert.Cert.Desc
+		}
+		return
+	})
+	// iOS蓝版 强行去除充电模块
+	if model.IsIPhone(plat) && (build >= 7000 && build <= 8000) {
+		sp.Elec = nil
+	} else {
+		// elec rank
+		g.Go(func() (err error) {
+			info, err := s.elecDao.Info(ctx, vmid, mid)
+			if err != nil {
+				log.Error("%+v", err)
+				err = nil
+				return
+			}
+			if info != nil {
+				info.Show = true
+				sp.Elec = info
+			}
+			return
+		})
+	}
+	g.Go(func() error {
+		rel, _ := s.accDao.RichRelations3(ctx, mid, vmid)
+		// -999:无关系, -1:我已经拉黑该用户, 0:我悄悄关注了该用户, 1:我公开关注了该用户
+		// 1- 悄悄关注 2 关注  6-好友 128-拉黑
+		if rel == 1 {
+			sp.Relation = 0
+		} else if rel == 2 || rel == 6 {
+			sp.Relation = 1
+		} else if rel >= 128 {
+			sp.Relation = -1
+		} else {
+			sp.Relation = -999
+		}
+		return nil
+	})
+	g.Go(func() (err error) {
+		if sp.Medal, err = s.liveDao.MedalStatus(ctx, vmid); err != nil {
+			log.Error("%+v", err)
+			err = nil
+		}
+		return
+	})
+	// g.Go(func() (err error) {
+	// 	if sp.Attention, err = s.relDao.Attention(ctx, mid, vmid); err != nil {
+	// 		log.Error("%+v", err)
+	// 		err = nil
+	// 	}
+	// 	return
+	// })
+	g.Go(func() (err error) {
+		if sp.Live, err = s.liveDao.Live(ctx, vmid, platform); err != nil {
+			log.Error("%+v", err)
+			err = nil
+		}
+		return
+	})
+	sp.Tab = &space.Tab{}
+	// up archives
+	g.Go(func() error {
+		sp.Archive = s.UpArcs(ctx, vmid, pn, ps, now)
+		if sp.Archive != nil && len(sp.Archive.Item) > 0 {
+			sp.Tab.Archive = true
+		}
+		return nil
+	})
+	g.Go(func() (err error) {
+		if sp.Tab.Dynamic, err = s.bplusDao.Dynamic(ctx, vmid); err != nil {
+			log.Error("%+v", err)
+			err = nil
+		}
+		return
+	})
+	g.Go(func() error {
+		sp.Article = s.UpArticles(ctx, vmid, 0, 3)
+		if sp.Article != nil && len(sp.Article.Item) != 0 {
+			sp.Tab.Article = true
+		}
+		return nil
+	})
+	g.Go(func() error {
+		sp.Clip = s.upClips(ctx, vmid)
+		if sp.Clip != nil && len(sp.Clip.Item) != 0 {
+			sp.Tab.Clip = true
+		}
+		return nil
+	})
+	g.Go(func() error {
+		sp.Album = s.upAlbums(ctx, vmid)
+		if sp.Album != nil && len(sp.Album.Item) != 0 {
+			sp.Tab.Album = true
+		}
+		return nil
+	})
+	g.Go(func() error {
+		sp.Audios = s.audios(ctx, vmid, 1, 3)
+		if sp.Audios != nil && len(sp.Audios.Item) != 0 {
+			sp.Tab.Audios = true
+		}
+		return nil
+	})
+	g.Go(func() (err error) {
+		var info *shop.Info
+		if info, err = s.shopDao.Info(ctx, vmid, mobiApp, device, build); err != nil {
+			log.Error("%+v", err)
+			err = nil
+			return
+		}
+		if info != nil && info.Shop != nil && info.Shop.Status == 2 {
+			sp.Tab.Shop = true
+			sp.Shop = &space.Shop{ID: info.Shop.ID, Name: info.Shop.Name + _shopName}
+		}
+		return
+	})
+	if sp.Setting, err = s.spcDao.Setting(c, vmid); err != nil {
+		log.Error("%+v", err)
+		err = nil
+	}
+	if sp.Setting == nil {
+		err = g.Wait()
+		return
+	}
+	g.Go(func() error {
+		sp.Favourite = s.favFolders(ctx, mid, vmid, sp.Setting, plat, build, mobiApp)
+		if sp.Favourite != nil && len(sp.Favourite.Item) != 0 {
+			sp.Tab.Favorite = true
+		}
+		return nil
+	})
+	g.Go(func() error {
+		sp.Season = s.Bangumi(ctx, mid, vmid, sp.Setting, pn, ps)
+		if sp.Season != nil && len(sp.Season.Item) != 0 {
+			sp.Tab.Bangumi = true
+		}
+		return nil
+	})
+	g.Go(func() error {
+		sp.CoinArc = s.CoinArcs(ctx, mid, vmid, sp.Setting, pn, ps)
+		if sp.CoinArc != nil && len(sp.CoinArc.Item) != 0 {
+			sp.Tab.Coin = true
+		}
+		return nil
+	})
+	g.Go(func() error {
+		sp.LikeArc = s.LikeArcs(ctx, mid, vmid, sp.Setting, pn, ps)
+		if sp.LikeArc != nil && len(sp.LikeArc.Item) != 0 {
+			sp.Tab.Like = true
+		}
+		return nil
+	})
+	err = g.Wait()
+	return
+}
+
+// UpArcs get upload archive .
+func (s *Service) UpArcs(c context.Context, uid int64, pn, ps int, now time.Time) (res *space.ArcList) {
+	var (
+		arcs []*api.Arc
+		err  error
+	)
+	res = &space.ArcList{Item: []*space.ArcItem{}}
+	if res.Count, err = s.arcDao.UpCount2(c, uid); err != nil {
+		log.Error("%+v", err)
+	}
+	if arcs, err = s.arcDao.UpArcs3(c, uid, pn, ps); err != nil {
+		log.Error("%+v", err)
+		return
+	}
+	if len(arcs) != 0 {
+		res.Item = make([]*space.ArcItem, 0, len(arcs))
+		for _, v := range arcs {
+			si := &space.ArcItem{}
+			si.FromArc(v)
+			res.Item = append(res.Item, si)
+		}
+	}
+	return
+}
+
+// UpArticles get article.
+func (s *Service) UpArticles(c context.Context, uid int64, pn, ps int) (res *space.ArticleList) {
+	res = &space.ArticleList{Item: []*space.ArticleItem{}, Lists: []*article.List{}}
+	g, ctx := errgroup.WithContext(c)
+	g.Go(func() (err error) {
+		var ams []*article.Meta
+		if ams, res.Count, err = s.artDao.UpArticles(ctx, uid, pn, ps); err != nil {
+			return err
+		}
+		if len(ams) != 0 {
+			res.Item = make([]*space.ArticleItem, 0, len(ams))
+			for _, v := range ams {
+				if v.AttrVal(article.AttrBitNoDistribute) {
+					continue
+				}
+				si := &space.ArticleItem{}
+				si.FromArticle(v)
+				res.Item = append(res.Item, si)
+			}
+		}
+		return err
+	})
+	g.Go(func() (err error) {
+		var lists []*article.List
+		lists, res.ListsCount, err = s.artDao.UpLists(c, uid)
+		if err != nil {
+			return err
+		}
+		if len(lists) > 0 {
+			res.Lists = lists
+		}
+		return err
+	})
+	if err := g.Wait(); err != nil {
+		log.Error("%+v", err)
+	}
+	return
+}
+
+// favFolders get favorite folders
+func (s *Service) favFolders(c context.Context, mid, vmid int64, setting *space.Setting, plat int8, build int, mobiApp string) (res *space.FavList) {
+	const (
+		_oldAndroidBuild = 427100
+		_oldIOSBuild     = 3910
+	)
+	var (
+		fs  []*favorite.Folder
+		err error
+	)
+	res = &space.FavList{Item: []*favorite.Folder{}}
+	if mid != vmid {
+		if setting == nil {
+			setting, err = s.spcDao.Setting(c, vmid)
+			if err != nil {
+				log.Error("%+v", err)
+				return
+			}
+		}
+		if setting.FavVideo != 1 {
+			return
+		}
+	}
+	var mediaList bool
+	// 双端版本号限制，符合此条件显示为“默认收藏夹”：
+	// iPhone <5.36.1(8300) 或iPhone>5.36.1(8300)
+	// Android <5360001或Android>5361000
+	// 双端版本号限制，符合此条件显示为“默认播单”：
+	// iPhone=5.36.1(8300)
+	// 5360001 <=Android <=5361000
+	if (plat == model.PlatIPhone && build == 8300) || (plat == model.PlatAndroid && build >= 5360001 && build <= 5361000) {
+		mediaList = true
+	}
+	if fs, err = s.favDao.Folders(c, mid, vmid, mobiApp, build, mediaList); err != nil {
+		log.Error("%+v", err)
+		return
+	}
+	for _, v := range fs {
+		if ((plat == model.PlatAndroid || plat == model.PlatAndroidG) && build <= _oldAndroidBuild) || ((plat == model.PlatIPhone || plat == model.PlatIPhoneI) && build <= _oldIOSBuild) {
+			v.Videos = v.Cover
+			v.Cover = nil
+		}
+	}
+	res.Item = fs
+	res.Count = len(fs)
+	return
+}
+
+// Bangumi get concern season
+func (s *Service) Bangumi(c context.Context, mid, vmid int64, setting *space.Setting, pn, ps int) (res *space.BangumiList) {
+	var (
+		seasons []*bangumi.Season
+		err     error
+	)
+	res = &space.BangumiList{Item: []*space.BangumiItem{}}
+	if mid != vmid {
+		if setting == nil {
+			setting, err = s.spcDao.Setting(c, vmid)
+			if err != nil {
+				log.Error("%+v", err)
+				return
+			}
+		}
+		if setting.Bangumi != 1 {
+			return
+		}
+	}
+	if seasons, res.Count, err = s.bgmDao.Concern(c, mid, vmid, pn, ps); err != nil {
+		log.Error("%+v", err)
+		return
+	}
+	if len(seasons) != 0 {
+		res.Item = make([]*space.BangumiItem, 0, len(seasons))
+		for _, v := range seasons {
+			si := &space.BangumiItem{}
+			si.FromSeason(v)
+			res.Item = append(res.Item, si)
+		}
+	}
+	return
+}
+
+// Community get community
+func (s *Service) Community(c context.Context, uid int64, pn, ps int, ak, platform string) (res *space.CommuList) {
+	var (
+		comm []*community.Community
+		err  error
+	)
+	res = &space.CommuList{Item: []*space.CommItem{}}
+	if comm, res.Count, err = s.commDao.Community(c, uid, ak, platform, pn, ps); err != nil {
+		log.Error("%+v", err)
+		return
+	}
+	if len(comm) != 0 {
+		res.Item = make([]*space.CommItem, 0, len(comm))
+		for _, v := range comm {
+			si := &space.CommItem{}
+			si.FromCommunity(v)
+			res.Item = append(res.Item, si)
+		}
+	}
+	return
+}
+
+// CoinArcs get coin archives.
+func (s *Service) CoinArcs(c context.Context, mid, vmid int64, setting *space.Setting, pn, ps int) (res *space.ArcList) {
+	var (
+		coins []*api.Arc
+		err   error
+	)
+	res = &space.ArcList{Item: []*space.ArcItem{}}
+	if mid != vmid {
+		if setting == nil {
+			setting, err = s.spcDao.Setting(c, vmid)
+			if err != nil {
+				log.Error("%+v", err)
+				return
+			}
+		}
+		if setting.CoinsVideo != 1 {
+			return
+		}
+	}
+	if coins, res.Count, err = s.coinDao.CoinList(c, vmid, pn, ps); err != nil {
+		log.Error("%+v", err)
+		return
+	}
+	if len(coins) != 0 {
+		res.Item = make([]*space.ArcItem, 0, len(coins))
+		for _, v := range coins {
+			si := &space.ArcItem{}
+			si.FromCoinArc(v)
+			res.Item = append(res.Item, si)
+		}
+	}
+	return
+}
+
+// LikeArcs get like archives.
+func (s *Service) LikeArcs(c context.Context, mid, vmid int64, setting *space.Setting, pn, ps int) (res *space.ArcList) {
+	var (
+		likes []*thumbup.ItemLikeRecord
+		err   error
+	)
+	res = &space.ArcList{Item: []*space.ArcItem{}}
+	if mid != vmid {
+		if setting == nil {
+			setting, err = s.spcDao.Setting(c, vmid)
+			if err != nil {
+				log.Error("%+v", err)
+				return
+			}
+		}
+		if setting.LikesVideo != 1 {
+			return
+		}
+	}
+	if likes, res.Count, err = s.thumbupDao.UserTotalLike(c, vmid, _businessLike, pn, ps); err != nil {
+		log.Error("%+v", err)
+		return
+	}
+	if len(likes) != 0 {
+		aids := make([]int64, 0, len(likes))
+		for _, v := range likes {
+			aids = append(aids, v.MessageID)
+		}
+		var as map[int64]*api.Arc
+		if as, err = s.arcDao.Archives2(c, aids); err != nil {
+			log.Error("%+v", err)
+			return
+		}
+		if len(as) == 0 {
+			return
+		}
+		res.Item = make([]*space.ArcItem, 0, len(as))
+		for _, v := range likes {
+			if a, ok := as[v.MessageID]; ok {
+				si := &space.ArcItem{}
+				si.FromLikeArc(a)
+				res.Item = append(res.Item, si)
+			}
+		}
+	}
+	return
+}
+
+func (s *Service) upClips(c context.Context, uid int64) (res *space.ClipList) {
+	var (
+		clips []*bplus.Clip
+		err   error
+	)
+	res = &space.ClipList{Item: []*space.Item{}}
+	if clips, res.Count, err = s.bplusDao.AllClip(c, uid, 200); err != nil {
+		log.Error("%+v", err)
+		return
+	}
+	if len(clips) != 0 {
+		res.Item = make([]*space.Item, 0, len(clips))
+		for k, v := range clips {
+			si := &space.Item{}
+			si.FromClip(v)
+			res.Item = append(res.Item, si)
+			if k == 1 {
+				break
+			}
+		}
+	}
+	return
+}
+
+func (s *Service) upAlbums(c context.Context, uid int64) (res *space.AlbumList) {
+	var (
+		album []*bplus.Album
+		err   error
+	)
+	res = &space.AlbumList{Item: []*space.Item{}}
+	if album, res.Count, err = s.bplusDao.AllAlbum(c, uid, 6); err != nil {
+		log.Error("%+v", err)
+		return
+	}
+	if len(album) != 0 {
+		res.Item = make([]*space.Item, 0, len(album))
+		for k, v := range album {
+			si := &space.Item{}
+			si.FromAlbum(v)
+			res.Item = append(res.Item, si)
+			if k == 5 {
+				break
+			}
+		}
+	}
+	return
+}
+
+// card get card by mid, vmid or name.
+func (s *Service) card(c context.Context, vmid int64, name string) (scard *space.Card, err error) {
+	scard = &space.Card{}
+	var profile *account.ProfileStat
+	if vmid > 0 {
+		profile, err = s.accDao.Profile3(c, vmid)
+	} else if name != "" {
+		profile, err = s.accDao.ProfileByName3(c, name)
+	}
+	if err != nil {
+		err = errors.Wrapf(err, "%v,%v", vmid, name)
+		return
+	}
+	scard.Mid = strconv.FormatInt(profile.Mid, 10)
+	scard.Name = profile.Name
+	// scard.Approve =
+	scard.Sex = profile.Sex
+	scard.Rank = strconv.FormatInt(int64(profile.Rank), 10)
+	scard.Face = profile.Face
+	scard.DisplayRank = strconv.FormatInt(int64(profile.Rank), 10)
+	// scard.Regtime =
+	if profile.Silence == 1 {
+		scard.Spacesta = -2
+	}
+	// scard.Birthday =
+	// scard.Place =
+	scard.Description = profile.Official.Desc
+	scard.Article = 0
+	scard.Attentions = []int64{}
+	scard.Fans = int(profile.Follower)
+	// scard.Friend = profile.Following
+	scard.Attention = int(profile.Following)
+	scard.Sign = profile.Sign
+	scard.LevelInfo.Cur = profile.Level
+	scard.LevelInfo.Min = profile.LevelExp.Min
+	scard.LevelInfo.NowExp = profile.LevelExp.NowExp
+	scard.LevelInfo.NextExp = profile.LevelExp.NextExp
+	if profile.LevelExp.NextExp == -1 {
+		scard.LevelInfo.NextExp = "--"
+	}
+	scard.Pendant.Pid = profile.Pendant.Pid
+	scard.Pendant.Name = profile.Pendant.Name
+	scard.Pendant.Image = profile.Pendant.Image
+	scard.Pendant.Expire = profile.Pendant.Expire
+	scard.OfficialVerify.Role = profile.Official.Role
+	scard.OfficialVerify.Title = profile.Official.Title
+	if profile.Official.Role == 0 {
+		scard.OfficialVerify.Type = -1
+	} else {
+		if profile.Official.Role <= 2 {
+			scard.OfficialVerify.Type = 0
+		} else {
+			scard.OfficialVerify.Type = 1
+		}
+		scard.OfficialVerify.Desc = profile.Official.Title
+	}
+	scard.Vip.Type = int(profile.Vip.Type)
+	scard.Vip.VipStatus = int(profile.Vip.Status)
+	scard.Vip.DueDate = profile.Vip.DueDate
+	// scard.FansGroup =
+	// scard.Audio =
+	// scard.FansUnread =
+	return
+}
+
+// audios
+func (s *Service) audios(c context.Context, mid int64, pn, ps int) (res *space.AudioList) {
+	var (
+		audios []*audio.Audio
+		err    error
+	)
+	res = &space.AudioList{Item: []*space.AudioItem{}}
+	if audios, res.Count, err = s.audioDao.Audios(c, mid, pn, ps); err != nil {
+		log.Error("%+v", err)
+		return
+	}
+	if len(audios) != 0 {
+		res.Item = make([]*space.AudioItem, 0, len(audios))
+		for _, v := range audios {
+			si := &space.AudioItem{}
+			si.FromAudio(v)
+			res.Item = append(res.Item, si)
+		}
+	}
+	return
+}
+
+// Report func
+func (s *Service) Report(c context.Context, mid int64, reason, ak string) (err error) {
+	return s.spcDao.Report(c, mid, reason, ak)
+}

app/interface/main/app-interface/service/space/space_test.go

@@ -0,0 +1,341 @@
+package space
+
+import (
+	"context"
+	"reflect"
+	"testing"
+	"time"
+
+	"go-common/app/interface/main/app-interface/model/space"
+	account "go-common/app/service/main/account/model"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestService_Space(t *testing.T) {
+	type args struct {
+		c        context.Context
+		mid      int64
+		vmid     int64
+		plat     int8
+		build    int
+		pn       int
+		ps       int
+		platform string
+		device   string
+		mobiApp  string
+		name     string
+		now      time.Time
+	}
+	tests := []struct {
+		name    string
+		s       *Service
+		args    args
+		wantSp  *space.Space
+		wantErr error
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		Convey(tt.name, t, func(t *testing.T) {
+			gotSp, err := tt.s.Space(tt.args.c, tt.args.mid, tt.args.vmid, tt.args.plat, tt.args.build, tt.args.pn, tt.args.ps, tt.args.platform, tt.args.device, tt.args.mobiApp, tt.args.name, tt.args.now)
+			So(err, ShouldEqual, tt.wantErr)
+			So(gotSp, ShouldNotResemble, tt.wantSp)
+		})
+	}
+}
+
+func TestService_UpArcs(t *testing.T) {
+	type args struct {
+		c   context.Context
+		uid int64
+		pn  int
+		ps  int
+		now time.Time
+	}
+	tests := []struct {
+		name    string
+		s       *Service
+		args    args
+		wantRes *space.ArcList
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if gotRes := tt.s.UpArcs(tt.args.c, tt.args.uid, tt.args.pn, tt.args.ps, tt.args.now); !reflect.DeepEqual(gotRes, tt.wantRes) {
+				t.Errorf("Service.UpArcs() = %v, want %v", gotRes, tt.wantRes)
+			}
+		})
+	}
+}
+
+func TestService_UpArticles(t *testing.T) {
+	type args struct {
+		c   context.Context
+		uid int64
+		pn  int
+		ps  int
+	}
+	tests := []struct {
+		name    string
+		s       *Service
+		args    args
+		wantRes *space.ArticleList
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if gotRes := tt.s.UpArticles(tt.args.c, tt.args.uid, tt.args.pn, tt.args.ps); !reflect.DeepEqual(gotRes, tt.wantRes) {
+				t.Errorf("Service.UpArticles() = %v, want %v", gotRes, tt.wantRes)
+			}
+		})
+	}
+}
+
+func TestService_favFolders(t *testing.T) {
+	type args struct {
+		c       context.Context
+		mid     int64
+		uid     int64
+		plat    int8
+		build   int
+		mobiApp string
+	}
+	tests := []struct {
+		name    string
+		s       *Service
+		args    args
+		wantRes *space.FavList
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if gotRes := tt.s.favFolders(tt.args.c, tt.args.mid, tt.args.uid, nil, tt.args.plat, tt.args.build, tt.args.mobiApp); !reflect.DeepEqual(gotRes, tt.wantRes) {
+				t.Errorf("Service.favFolders() = %v, want %v", gotRes, tt.wantRes)
+			}
+		})
+	}
+}
+
+func TestService_Bangumi(t *testing.T) {
+	type args struct {
+		c   context.Context
+		mid int64
+		uid int64
+		pn  int
+		ps  int
+	}
+	tests := []struct {
+		name    string
+		s       *Service
+		args    args
+		wantRes *space.BangumiList
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if gotRes := tt.s.Bangumi(tt.args.c, tt.args.mid, tt.args.uid, nil, tt.args.pn, tt.args.ps); !reflect.DeepEqual(gotRes, tt.wantRes) {
+				t.Errorf("Service.Bangumi() = %v, want %v", gotRes, tt.wantRes)
+			}
+		})
+	}
+}
+
+func TestService_Community(t *testing.T) {
+	type args struct {
+		c        context.Context
+		uid      int64
+		pn       int
+		ps       int
+		ak       string
+		platform string
+	}
+	tests := []struct {
+		name    string
+		s       *Service
+		args    args
+		wantRes *space.CommuList
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if gotRes := tt.s.Community(tt.args.c, tt.args.uid, tt.args.pn, tt.args.ps, tt.args.ak, tt.args.platform); !reflect.DeepEqual(gotRes, tt.wantRes) {
+				t.Errorf("Service.Community() = %v, want %v", gotRes, tt.wantRes)
+			}
+		})
+	}
+}
+
+func TestService_CoinArcs(t *testing.T) {
+	type args struct {
+		c   context.Context
+		uid int64
+		pn  int
+		ps  int
+	}
+	tests := []struct {
+		name    string
+		s       *Service
+		args    args
+		wantRes *space.ArcList
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if gotRes := tt.s.CoinArcs(tt.args.c, 0, tt.args.uid, nil, tt.args.pn, tt.args.ps); !reflect.DeepEqual(gotRes, tt.wantRes) {
+				t.Errorf("Service.CoinArcs() = %v, want %v", gotRes, tt.wantRes)
+			}
+		})
+	}
+}
+
+func TestService_LikeArcs(t *testing.T) {
+	type args struct {
+		c   context.Context
+		uid int64
+		pn  int
+		ps  int
+	}
+	tests := []struct {
+		name    string
+		s       *Service
+		args    args
+		wantRes *space.ArcList
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if gotRes := tt.s.LikeArcs(tt.args.c, 0, tt.args.uid, nil, tt.args.pn, tt.args.ps); !reflect.DeepEqual(gotRes, tt.wantRes) {
+				t.Errorf("Service.LikeArcs() = %v, want %v", gotRes, tt.wantRes)
+			}
+		})
+	}
+}
+
+func TestService_upClips(t *testing.T) {
+	type args struct {
+		c   context.Context
+		uid int64
+	}
+	tests := []struct {
+		name    string
+		s       *Service
+		args    args
+		wantRes *space.ClipList
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if gotRes := tt.s.upClips(tt.args.c, tt.args.uid); !reflect.DeepEqual(gotRes, tt.wantRes) {
+				t.Errorf("Service.upClips() = %v, want %v", gotRes, tt.wantRes)
+			}
+		})
+	}
+}
+
+func TestService_upAlbums(t *testing.T) {
+	type args struct {
+		c   context.Context
+		uid int64
+	}
+	tests := []struct {
+		name    string
+		s       *Service
+		args    args
+		wantRes *space.AlbumList
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if gotRes := tt.s.upAlbums(tt.args.c, tt.args.uid); !reflect.DeepEqual(gotRes, tt.wantRes) {
+				t.Errorf("Service.upAlbums() = %v, want %v", gotRes, tt.wantRes)
+			}
+		})
+	}
+}
+
+func TestService_card(t *testing.T) {
+	type args struct {
+		c    context.Context
+		vmid int64
+		name string
+	}
+	tests := []struct {
+		name     string
+		s        *Service
+		args     args
+		wantCard *account.Card
+		wantErr  bool
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gotCard, err := tt.s.card(tt.args.c, tt.args.vmid, tt.args.name)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Service.card() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(gotCard, tt.wantCard) {
+				t.Errorf("Service.card() = %v, want %v", gotCard, tt.wantCard)
+			}
+		})
+	}
+}
+
+func TestService_audios(t *testing.T) {
+	type args struct {
+		c   context.Context
+		mid int64
+		pn  int
+		ps  int
+	}
+	tests := []struct {
+		name    string
+		s       *Service
+		args    args
+		wantRes *space.AudioList
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if gotRes := tt.s.audios(tt.args.c, tt.args.mid, tt.args.pn, tt.args.ps); !reflect.DeepEqual(gotRes, tt.wantRes) {
+				t.Errorf("Service.audios() = %v, want %v", gotRes, tt.wantRes)
+			}
+		})
+	}
+}
+
+func TestService_Report(t *testing.T) {
+	type args struct {
+		c      context.Context
+		mid    int64
+		reason string
+		ak     string
+	}
+	tests := []struct {
+		name    string
+		s       *Service
+		args    args
+		wantErr bool
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if err := tt.s.Report(tt.args.c, tt.args.mid, tt.args.reason, tt.args.ak); (err != nil) != tt.wantErr {
+				t.Errorf("Service.Report() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}