Create & Init Project...

app/service/main/up/dao/card/BUILD

@@ -0,0 +1,65 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "card.go",
+        "dao.go",
+        "rpc.go",
+        "up_base.go",
+    ],
+    importpath = "go-common/app/service/main/up/dao/card",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/service/main/archive/api:go_default_library",
+        "//app/service/main/up/conf:go_default_library",
+        "//app/service/main/up/dao:go_default_library",
+        "//app/service/main/up/dao/global:go_default_library",
+        "//app/service/main/up/model:go_default_library",
+        "//library/database/sql:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/sync/errgroup:go_default_library",
+        "//library/xstr:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "card_test.go",
+        "dao_test.go",
+        "rpc_test.go",
+        "up_base_test.go",
+    ],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/service/main/up/conf:go_default_library",
+        "//app/service/main/up/dao:go_default_library",
+        "//app/service/main/up/dao/global:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)

app/service/main/up/dao/card/card.go

@@ -0,0 +1,282 @@
+package card
+
+import (
+	"context"
+	"fmt"
+	"go-common/app/service/main/up/model"
+	"go-common/library/database/sql"
+	"go-common/library/log"
+	"go-common/library/xstr"
+)
+
+const (
+	_UpInfoBaseColumn = `mid, name_cn, name_en, name_alias, signature, content, nationality, 
+nation, gender, blood_type, constellation, height, weight, birth_place, birth_date, occupation, 
+tags, masterpieces, school, location, interests, platform, platform_account`
+	_countUpSQL             = "SELECT count(distinct mid) FROM card_up"
+	_listUpMidSQL           = "SELECT mid FROM card_up order BY mtime DESC"
+	_listUpInfoSQL          = "SELECT " + _UpInfoBaseColumn + " FROM card_up limit ? offset ?"
+	_getUpInfoByMidSQL      = "SELECT " + _UpInfoBaseColumn + " FROM card_up WHERE mid=?"
+	_listUpVideoIDSQL       = "SELECT avid FROM card_up_video WHERE mid=? ORDER BY id DESC"
+	_listUpImageSQL         = "SELECT url, height, width FROM card_up_image WHERE mid=? ORDER BY id DESC"
+	_listUpAccountSQL       = "SELECT url, title, picture, abstract FROM card_up_account WHERE mid = ?"
+	_listUpInfoByMidsSQL    = "SELECT " + _UpInfoBaseColumn + " FROM card_up WHERE mid IN (%s)"
+	_listUpVideoIDByMidsSQL = "SELECT mid, avid FROM card_up_video WHERE mid IN (%s) ORDER BY id DESC"
+	_listUpImageByMidsSQL   = "SELECT mid, url, height, width FROM card_up_image WHERE mid IN (%s) ORDER BY id DESC"
+	_listUpAccountByMidsSQL = "SELECT mid, url, title, picture, abstract FROM card_up_account WHERE mid IN (%s)"
+)
+
+// CountUpCard count up num
+func (d *Dao) CountUpCard(ctx context.Context) (total int, err error) {
+	row := d.db.QueryRow(ctx, _countUpSQL)
+	err = row.Scan(&total)
+	if err != nil {
+		log.Error("CountUpCard row.Scan error(%v)", err)
+	}
+	return
+}
+
+// ListUpInfo page list up mids
+func (d *Dao) ListUpInfo(ctx context.Context, offset uint, size uint) (infos []*model.UpCardInfo, err error) {
+	rows, err := d.db.Query(ctx, _listUpInfoSQL, size, offset)
+	if err != nil {
+		log.Error("ListUpInfo d.db.Query error(%v)", err)
+		return
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		info := &model.UpCardInfo{}
+		err = rows.Scan(&info.MID,
+			&info.NameCN, &info.NameEN, &info.NameAlias,
+			&info.Signature,
+			&info.Content, &info.Nationality, &info.Nation,
+			&info.Gender, &info.BloodType, &info.Constellation,
+			&info.Height, &info.Weight, &info.BirthPlace,
+			&info.BirthDate, &info.Occupation, &info.Tags,
+			&info.Masterpieces, &info.School, &info.Location,
+			&info.Interests, &info.Platform, &info.PlatformAccount)
+		if err != nil {
+			log.Error("ListUpInfo rows.Scan error(%v)", err)
+			return
+		}
+		infos = append(infos, info)
+	}
+
+	return
+}
+
+// MidUpInfoMap get <mid, UpInfo> map by mids
+func (d *Dao) MidUpInfoMap(ctx context.Context, mids []int64) (midUpInfoMap map[int64]*model.UpCardInfo, err error) {
+	midUpInfoMap = make(map[int64]*model.UpCardInfo)
+	rows, err := d.db.Query(ctx, fmt.Sprintf(_listUpInfoByMidsSQL, xstr.JoinInts(mids)))
+	if err != nil {
+		log.Error("MidUpInfoMap d.db.Query error(%v)", err)
+		return
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		info := &model.UpCardInfo{}
+		err = rows.Scan(&info.MID,
+			&info.NameCN, &info.NameEN, &info.NameAlias,
+			&info.Signature,
+			&info.Content, &info.Nationality, &info.Nation,
+			&info.Gender, &info.BloodType, &info.Constellation,
+			&info.Height, &info.Weight, &info.BirthPlace,
+			&info.BirthDate, &info.Occupation, &info.Tags,
+			&info.Masterpieces, &info.School, &info.Location,
+			&info.Interests, &info.Platform, &info.PlatformAccount)
+		if err != nil {
+			log.Error("MidUpInfoMap rows.Scan error(%v)", err)
+			return
+		}
+		midUpInfoMap[info.MID] = info
+	}
+
+	return
+}
+
+// MidAccountsMap get <mid, Accounts> map by mids
+func (d *Dao) MidAccountsMap(ctx context.Context, mids []int64) (midAccountsMap map[int64][]*model.UpCardAccount, err error) {
+	midAccountsMap = make(map[int64][]*model.UpCardAccount)
+	rows, err := d.db.Query(ctx, fmt.Sprintf(_listUpAccountByMidsSQL, xstr.JoinInts(mids)))
+	if err != nil {
+		log.Error("MidAccountsMap d.db.Query error(%v)", err)
+		return
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		var mid int64
+		account := new(model.UpCardAccount)
+		err = rows.Scan(&mid, &account.URL, &account.Title, &account.Picture, &account.Desc)
+		if err != nil {
+			log.Error("MidAccountsMap row.Scan error(%v)", err)
+			return
+		}
+		midAccountsMap[mid] = append(midAccountsMap[mid], account)
+	}
+
+	return
+}
+
+// MidImagesMap get <mid, Images> map by mids
+func (d *Dao) MidImagesMap(ctx context.Context, mids []int64) (midImagesMap map[int64][]*model.UpCardImage, err error) {
+	midImagesMap = make(map[int64][]*model.UpCardImage)
+	rows, err := d.db.Query(ctx, fmt.Sprintf(_listUpImageByMidsSQL, xstr.JoinInts(mids)))
+	if err != nil {
+		log.Error("MidImagesMap d.db.Query error(%v)", err)
+		return
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		var mid int64
+		image := new(model.UpCardImage)
+		err = rows.Scan(&mid, &image.URL, &image.Height, &image.Width)
+		if err != nil {
+			log.Error("MidImagesMap row.Scan error(%v)", err)
+			return
+		}
+		midImagesMap[mid] = append(midImagesMap[mid], image)
+	}
+
+	return
+}
+
+// MidAvidsMap get <mid, Avids> map by mids
+func (d *Dao) MidAvidsMap(ctx context.Context, mids []int64) (midAvidsMap map[int64][]int64, err error) {
+	midAvidsMap = make(map[int64][]int64)
+	rows, err := d.db.Query(ctx, fmt.Sprintf(_listUpVideoIDByMidsSQL, xstr.JoinInts(mids)))
+	if err != nil {
+		log.Error("MidAvidsMap d.db.Query error(%v)", err)
+		return
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		var mid int64
+		var avid int64
+		err = rows.Scan(&mid, &avid)
+		if err != nil {
+			log.Error("MidAvidsMap row.Scan error(%v)", err)
+			return
+		}
+		midAvidsMap[mid] = append(midAvidsMap[mid], avid)
+	}
+
+	return
+}
+
+// ListUpMID list up mids
+func (d *Dao) ListUpMID(ctx context.Context) (mids []int64, err error) {
+	rows, err := d.db.Query(ctx, _listUpMidSQL)
+	if err != nil {
+		log.Error("ListCardBase d.db.Query error(%v)", err)
+		return
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		var mid int64
+		err = rows.Scan(&mid)
+		if err != nil {
+			log.Error("ListCardBase row.Scan error(%v)", err)
+			return
+		}
+		mids = append(mids, mid)
+	}
+
+	return
+}
+
+// GetUpInfo get up info by mid
+func (d *Dao) GetUpInfo(ctx context.Context, mid int64) (card *model.UpCardInfo, err error) {
+	row := d.db.QueryRow(ctx, _getUpInfoByMidSQL, mid)
+	card = &model.UpCardInfo{}
+	if err = row.Scan(&card.MID,
+		&card.NameCN, &card.NameEN, &card.NameAlias,
+		&card.Signature,
+		&card.Content, &card.Nationality, &card.Nation,
+		&card.Gender, &card.BloodType, &card.Constellation,
+		&card.Height, &card.Weight, &card.BirthPlace,
+		&card.BirthDate, &card.Occupation, &card.Tags,
+		&card.Masterpieces, &card.School, &card.Location,
+		&card.Interests, &card.Platform, &card.PlatformAccount); err != nil {
+		if err == sql.ErrNoRows {
+			card = nil
+			err = nil
+		} else {
+			log.Error("GetUpCard row.Scan error(%v)", err)
+			return
+		}
+	}
+	return
+}
+
+// ListUpAccount list up accounts by mid
+func (d *Dao) ListUpAccount(ctx context.Context, mid int64) (accounts []*model.UpCardAccount, err error) {
+	rows, err := d.db.Query(ctx, _listUpAccountSQL, mid)
+	if err != nil {
+		log.Error("listUpAccount d.db.Query error(%v)", err)
+		return
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		account := new(model.UpCardAccount)
+		err = rows.Scan(&account.URL, &account.Title, &account.Picture, &account.Desc)
+		if err != nil {
+			log.Error("listUpAccount row.Scan error(%v)", err)
+			return
+		}
+		accounts = append(accounts, account)
+	}
+
+	return
+}
+
+// ListUpImage list up images by mid
+func (d *Dao) ListUpImage(ctx context.Context, mid int64) (images []*model.UpCardImage, err error) {
+	rows, err := d.db.Query(ctx, _listUpImageSQL, mid)
+	if err != nil {
+		log.Error("listUpImage d.db.Query error(%v)", err)
+		return
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		image := new(model.UpCardImage)
+		err = rows.Scan(&image.URL, &image.Height, &image.Width)
+		if err != nil {
+			log.Error("listUpImage row.Scan error(%v)", err)
+			return
+		}
+		images = append(images, image)
+	}
+
+	return
+}
+
+// ListAVID list avids by mid
+func (d *Dao) ListAVID(ctx context.Context, mid int64) (avids []int64, err error) {
+	rows, err := d.db.Query(ctx, _listUpVideoIDSQL, mid)
+	if err != nil {
+		log.Error("listUpVideo d.db.Query error(%v)", err)
+		return
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		var avid int64
+		err = rows.Scan(&avid)
+		if err != nil {
+			log.Error("listUpVideo row.Scan error(%v)", err)
+			return
+		}
+		avids = append(avids, avid)
+	}
+
+	return
+}

app/service/main/up/dao/card/card_test.go

@@ -0,0 +1,148 @@
+package card
+
+import (
+	"context"
+	"github.com/smartystreets/goconvey/convey"
+	"testing"
+)
+
+func TestCountUpCard(t *testing.T) {
+	var c = context.Background()
+	convey.Convey("CountUpCard", t, func(ctx convey.C) {
+		total, err := d.CountUpCard(c)
+		ctx.Convey("Then err should be nil.total should not be nil", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(total, convey.ShouldNotBeNil)
+		})
+	})
+}
+func TestPageListUpInfo(t *testing.T) {
+	var (
+		c      = context.Background()
+		offset = uint(1)
+		size   = uint(1)
+	)
+	convey.Convey("ListUpInfo", t, func(ctx convey.C) {
+		infos, err := d.ListUpInfo(c, offset, size)
+		ctx.Convey("Then err should be nil.infos should not be nil", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(infos, convey.ShouldNotBeNil)
+		})
+	})
+}
+func TestListUpMID(t *testing.T) {
+	var c = context.Background()
+	convey.Convey("ListUpMID", t, func(ctx convey.C) {
+		mids, err := d.ListUpMID(c)
+		ctx.Convey("Then err should be nil.mids should not be nil", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(mids, convey.ShouldNotBeNil)
+		})
+	})
+}
+func TestGetUpInfo(t *testing.T) {
+	var (
+		c   = context.Background()
+		mid = int64(1532165)
+	)
+	convey.Convey("GetUpInfo", t, func(ctx convey.C) {
+		upInfo, err := d.GetUpInfo(c, mid)
+		ctx.Convey("Then err should be nil.upInfo should not be nil", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(upInfo, convey.ShouldNotBeNil)
+		})
+	})
+}
+func TestListUpAccount(t *testing.T) {
+	var (
+		c   = context.Background()
+		mid = int64(1532165)
+	)
+	convey.Convey("ListUpAccount", t, func(ctx convey.C) {
+		accounts, err := d.ListUpAccount(c, mid)
+		ctx.Convey("Then err should be nil.accounts should not be nil", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(accounts, convey.ShouldNotBeNil)
+		})
+	})
+}
+func TestListUpImage(t *testing.T) {
+	var (
+		c   = context.Background()
+		mid = int64(1532165)
+	)
+	convey.Convey("ListUpImage", t, func(ctx convey.C) {
+		images, err := d.ListUpImage(c, mid)
+		ctx.Convey("Then err should be nil.images should not be nil", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(images, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestListAVID(t *testing.T) {
+	var (
+		c   = context.Background()
+		mid = int64(1532165)
+	)
+	convey.Convey("ListAVID", t, func(ctx convey.C) {
+		avids, err := d.ListAVID(c, mid)
+		ctx.Convey("Then err should be nil.avids should not be nil", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(avids, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestMidUpInfoMap(t *testing.T) {
+	var (
+		c    = context.Background()
+		mids = []int64{1532165}
+	)
+	convey.Convey("MidUpInfoMap", t, func(ctx convey.C) {
+		res, err := d.MidUpInfoMap(c, mids)
+		ctx.Convey("Then err should be nil.res should not be nil", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(res, convey.ShouldNotBeNil)
+		})
+	})
+}
+func TestMidAccountsMap(t *testing.T) {
+	var (
+		c    = context.Background()
+		mids = []int64{1532165}
+	)
+	convey.Convey("MidAccountsMap", t, func(ctx convey.C) {
+		res, err := d.MidAccountsMap(c, mids)
+		ctx.Convey("Then err should be nil.res should not be nil", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(res, convey.ShouldNotBeNil)
+		})
+	})
+}
+func TestMidImagesMap(t *testing.T) {
+	var (
+		c    = context.Background()
+		mids = []int64{1532165}
+	)
+	convey.Convey("MidImagesMap", t, func(ctx convey.C) {
+		res, err := d.MidImagesMap(c, mids)
+		ctx.Convey("Then err should be nil.res should not be nil", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(res, convey.ShouldNotBeNil)
+		})
+	})
+}
+func TestMidAvidsMap(t *testing.T) {
+	var (
+		c    = context.Background()
+		mids = []int64{1532165}
+	)
+	convey.Convey("MidAvidsMap", t, func(ctx convey.C) {
+		res, err := d.MidAvidsMap(c, mids)
+		ctx.Convey("Then err should be nil.res should not be nil", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(res, convey.ShouldNotBeNil)
+		})
+	})
+}

app/service/main/up/dao/card/dao.go

@@ -0,0 +1,36 @@
+package card
+
+import (
+	"context"
+
+	"go-common/app/service/main/up/conf"
+	"go-common/app/service/main/up/dao/global"
+	"go-common/library/database/sql"
+)
+
+// Dao is redis dao.
+type Dao struct {
+	c  *conf.Config
+	db *sql.DB
+}
+
+// New fn
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		c:  c,
+		db: global.GetUpCrmDB(),
+	}
+	return d
+}
+
+// Close fn
+func (d *Dao) Close() {
+	if d.db != nil {
+		d.db.Close()
+	}
+}
+
+// Ping ping cpdb
+func (d *Dao) Ping(c context.Context) (err error) {
+	return d.db.Ping(c)
+}

app/service/main/up/dao/card/dao_test.go

@@ -0,0 +1,42 @@
+package card
+
+import (
+	"flag"
+	"os"
+	"testing"
+
+	"go-common/app/service/main/up/conf"
+	"go-common/app/service/main/up/dao"
+	"go-common/app/service/main/up/dao/global"
+)
+
+var (
+	d *Dao
+)
+
+func TestMain(m *testing.M) {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", dao.AppID)
+		flag.Set("conf_token", dao.UatToken)
+		flag.Set("tree_id", dao.TreeID)
+		flag.Set("conf_version", "docker-1")
+		flag.Set("deploy_env", "uat")
+		flag.Set("conf_host", "config.bilibili.co")
+		flag.Set("conf_path", "/tmp")
+		flag.Set("region", "sh")
+		flag.Set("zone", "sh001")
+	} else {
+		flag.Set("conf", "../../cmd/up-service.toml")
+	}
+	if os.Getenv("UT_LOCAL_TEST") != "" {
+		flag.Set("conf", "../../cmd/up-service.toml")
+	}
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	global.Init(conf.Conf)
+	d = New(conf.Conf)
+	m.Run()
+	os.Exit(0)
+}

app/service/main/up/dao/card/rpc.go

@@ -0,0 +1,97 @@
+package card
+
+import (
+	"context"
+	"fmt"
+	"sync"
+
+	arcgrpc "go-common/app/service/main/archive/api"
+	"go-common/app/service/main/up/dao"
+	"go-common/app/service/main/up/dao/global"
+	"go-common/app/service/main/up/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	"go-common/library/sync/errgroup"
+)
+
+const _avURL = "http://www.bilibili.com/video/av%d"
+
+//ListVideoArchive list videos by avids
+func (d *Dao) ListVideoArchive(ctx context.Context, avids []int64) (videos []*model.UpCardVideo, err error) {
+
+	archives, err := d.listArchives(ctx, avids)
+	if err != nil {
+		log.Error("d.listArchives error(%v) arg(%v)", err, avids)
+		err = ecode.CreativeArcServiceErr
+		return
+	}
+	for avid, data := range archives {
+		video := transfer(avid, data)
+		videos = append(videos, video)
+	}
+
+	return
+}
+
+//AvidVideoMap get <avid, video> map by avids
+func (d *Dao) AvidVideoMap(ctx context.Context, avids []int64) (avidVideoMap map[int64]*model.UpCardVideo, err error) {
+	avidVideoMap = make(map[int64]*model.UpCardVideo)
+	archives, err := d.listArchives(ctx, avids)
+	if err != nil {
+		log.Error("d.listArchives error(%v) arg(%v)", err, avids)
+		err = ecode.CreativeArcServiceErr
+		return
+	}
+
+	for avid, data := range archives {
+		video := transfer(avid, data)
+		avidVideoMap[avid] = video
+	}
+	return
+}
+
+func (d *Dao) listArchives(ctx context.Context, avids []int64) (archives map[int64]*arcgrpc.Arc, err error) {
+	archives = make(map[int64]*arcgrpc.Arc)
+
+	var (
+		g errgroup.Group
+		m sync.Mutex
+	)
+
+	dao.Split(0, len(avids), 300, func(start int, end int) {
+		g.Go(func() (err error) {
+			var (
+				arg = &arcgrpc.ArcsRequest{
+					Aids: avids[start:end],
+				}
+				res *arcgrpc.ArcsReply
+			)
+			if res, err = global.GetArcClient().Arcs(ctx, arg); err != nil {
+				log.Error("d.acc.Archives3 arg(%v) error(%v)", arg, err)
+				err = nil
+			} else {
+				for k, v := range res.Arcs {
+					m.Lock()
+					archives[k] = v
+					m.Unlock()
+				}
+			}
+			return
+		})
+	})
+
+	if err = g.Wait(); err != nil {
+		log.Error("g.Wait() error(%v)", err)
+	}
+	return
+}
+
+func transfer(avid int64, archive *arcgrpc.Arc) (video *model.UpCardVideo) {
+	return &model.UpCardVideo{
+		URL:      fmt.Sprintf(_avURL, avid),
+		Title:    archive.Title,
+		Picture:  archive.Pic,
+		Duration: archive.Duration,
+		CTime:    archive.Ctime,
+	}
+}

app/service/main/up/dao/card/rpc_test.go

@@ -0,0 +1,35 @@
+package card
+
+import (
+	"context"
+	"github.com/smartystreets/goconvey/convey"
+	"testing"
+)
+
+func TestListVideoArchive(t *testing.T) {
+	var (
+		c     = context.TODO()
+		avids = []int64{31908629}
+	)
+	convey.Convey("Info", t, func(ctx convey.C) {
+		videos, err := d.ListVideoArchive(c, avids)
+		ctx.Convey("Then err should be nil.videos should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(videos, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestAvidVideoMap(t *testing.T) {
+	var (
+		c     = context.TODO()
+		avids = []int64{31908629}
+	)
+	convey.Convey("Info", t, func(ctx convey.C) {
+		avidVideoMap, err := d.AvidVideoMap(c, avids)
+		ctx.Convey("Then err should be nil.midVideosMap should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(avidVideoMap, convey.ShouldNotBeNil)
+		})
+	})
+}

app/service/main/up/dao/card/up_base.go

@@ -0,0 +1,34 @@
+package card
+
+import (
+	"context"
+	"fmt"
+	"go-common/library/log"
+)
+
+const _listUpBaseSQL = "SELECT id, mid FROM up_base_info WHERE id > ? AND business_type = 1 %s LIMIT ?"
+
+// ListUpBase list <id, mid> k-v pairs
+func (d *Dao) ListUpBase(c context.Context, size int, lastID int64, where string) (idMids map[int64]int64, err error) {
+	idMids = make(map[int64]int64)
+	rows, err := d.db.Query(c, fmt.Sprintf(_listUpBaseSQL, where), lastID, size)
+	if err != nil {
+		log.Error("ListUpBase d.db.Query error(%v)", err)
+		return
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		var mid int64
+		var id int64
+
+		err = rows.Scan(&id, &mid)
+		if err != nil {
+			log.Error("ListUpBase rows.Scan error(%v)", err)
+			return
+		}
+		idMids[id] = mid
+	}
+
+	return
+}

app/service/main/up/dao/card/up_base_test.go

@@ -0,0 +1,26 @@
+package card
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestCardListUpBase(t *testing.T) {
+	convey.Convey("ListUpBase", t, func(ctx convey.C) {
+		var (
+			c      = context.Background()
+			size   = int(3)
+			lastID = int64(1)
+			where  = "AND activity = 1"
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			idMids, err := d.ListUpBase(c, size, lastID, where)
+			ctx.Convey("Then err should be nil.idMids should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(idMids, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}