Create & Init Project...

app/job/main/creative/dao/academy/BUILD

@@ -0,0 +1,53 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "academy.go",
+        "dao.go",
+    ],
+    importpath = "go-common/app/job/main/creative/dao/academy",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/job/main/creative/conf:go_default_library",
+        "//app/job/main/creative/model:go_default_library",
+        "//library/database/sql:go_default_library",
+        "//library/log: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 = [
+        "academy_test.go",
+        "dao_test.go",
+    ],
+    embed = [":go_default_library"],
+    tags = ["automanaged"],
+    deps = [
+        "//app/job/main/creative/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)

app/job/main/creative/dao/academy/academy.go

@@ -0,0 +1,49 @@
+package academy
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"go-common/app/job/main/creative/model"
+
+	"go-common/library/log"
+	"go-common/library/xstr"
+)
+
+const (
+	// select
+	_getArcsSQL = "SELECT id,oid,business FROM academy_archive WHERE state=? AND business=? AND id > ? order by id ASC limit ?"
+)
+
+//Archives get limit achives.
+func (d *Dao) Archives(c context.Context, id int64, bs, limit int) (res []*model.OArchive, err error) {
+	rows, err := d.db.Query(c, _getArcsSQL, 0, bs, id, limit)
+	res = make([]*model.OArchive, 0)
+	for rows.Next() {
+		a := &model.OArchive{}
+		if err = rows.Scan(&a.ID, &a.OID, &a.Business); err != nil {
+			log.Error("rows.Scan error(%v)", err)
+			return
+		}
+		res = append(res, a)
+	}
+	return
+}
+
+//UPHotByAIDs update hot by aids.
+func (d *Dao) UPHotByAIDs(c context.Context, hots map[int64]int64) error {
+	var oids []int64
+	sql := "UPDATE academy_archive SET hot = CASE oid "
+	for oid, hot := range hots {
+		sql += fmt.Sprintf("WHEN %d THEN %d ", oid, hot)
+		oids = append(oids, oid)
+	}
+	sql += fmt.Sprintf("END, mtime=? WHERE oid IN (%s)", xstr.JoinInts(oids))
+	_, err := d.db.Exec(c, sql, time.Now())
+	if err != nil {
+		log.Error("d.db.Exec sql(%s) error(%v)", sql, err)
+	}
+	log.Info("d.db.Exec sql(%s) hots(%+v) error(%v)", sql, hots, err)
+	return err
+}

app/job/main/creative/dao/academy/academy_test.go

@@ -0,0 +1,42 @@
+package academy
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestAcademyArchives(t *testing.T) {
+	convey.Convey("Archives", t, func(ctx convey.C) {
+		var (
+			c     = context.Background()
+			id    = int64(10110127)
+			bs    = int(1)
+			limit = int(10)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			_, err := d.Archives(c, id, bs, limit)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldEqual, err)
+			})
+		})
+	})
+}
+
+func TestAcademyUPHotByAIDs(t *testing.T) {
+	convey.Convey("UPHotByAIDs", t, func(ctx convey.C) {
+		var (
+			c    = context.Background()
+			hots = map[int64]int64{
+				10110127: 11,
+			}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.UPHotByAIDs(c, hots)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldEqual, err)
+			})
+		})
+	})
+}

app/job/main/creative/dao/academy/dao.go

@@ -0,0 +1,34 @@
+package academy
+
+import (
+	"context"
+	"go-common/app/job/main/creative/conf"
+	"go-common/library/database/sql"
+)
+
+// Dao is creative dao.
+type Dao struct {
+	// config
+	c *conf.Config
+	// db
+	db *sql.DB
+}
+
+// New init api url
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		c:  c,
+		db: sql.NewMySQL(c.DB.Creative),
+	}
+	return
+}
+
+// Ping creativeDb
+func (d *Dao) Ping(c context.Context) (err error) {
+	return d.db.Ping(c)
+}
+
+// Close creativeDb
+func (d *Dao) Close() (err error) {
+	return d.db.Close()
+}

app/job/main/creative/dao/academy/dao_test.go

@@ -0,0 +1,34 @@
+package academy
+
+import (
+	"flag"
+	"go-common/app/job/main/creative/conf"
+	"os"
+	"testing"
+)
+
+var (
+	d *Dao
+)
+
+func TestMain(m *testing.M) {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.archive.creative-job")
+		flag.Set("conf_token", "43943fda0bb311e8865c66d44b23cda7")
+		flag.Set("tree_id", "16037")
+		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/creative-job.toml")
+	}
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	d = New(conf.Conf)
+	os.Exit(m.Run())
+}

app/job/main/creative/dao/archive/BUILD

@@ -0,0 +1,60 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "dao_test.go",
+        "rpc_test.go",
+    ],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/job/main/creative/conf:go_default_library",
+        "//vendor/github.com/go-sql-driver/mysql:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "dao.go",
+        "rpc.go",
+    ],
+    importpath = "go-common/app/job/main/creative/dao/archive",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/openplatform/article/model:go_default_library",
+        "//app/interface/openplatform/article/rpc/client:go_default_library",
+        "//app/job/main/creative/conf:go_default_library",
+        "//app/job/main/creative/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",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster: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/job/main/creative/dao/archive/dao.go

@@ -0,0 +1,77 @@
+package archive
+
+import (
+	"context"
+	"net/url"
+	"strconv"
+
+	article "go-common/app/interface/openplatform/article/rpc/client"
+	"go-common/app/job/main/creative/conf"
+	"go-common/app/job/main/creative/model"
+	archive "go-common/app/service/main/archive/api/gorpc"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	httpx "go-common/library/net/http/blademaster"
+)
+
+// Dao is archive dao.
+type Dao struct {
+	// config
+	c *conf.Config
+	// rpc
+	arc *archive.Service2
+	art *article.Service
+	// http client
+	client  *httpx.Client
+	viewURL string
+}
+
+// New init api url
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		c:   c,
+		arc: archive.New2(c.ArchiveRPC),
+		art: article.New(c.ArticleRPC),
+		// http client
+		client:  httpx.NewClient(c.HTTPClient.Normal),
+		viewURL: c.Host.Videoup + "/videoup/view",
+	}
+	return
+}
+
+// Ping fn
+func (d *Dao) Ping(c context.Context) (err error) {
+	return
+}
+
+// Close fn
+func (d *Dao) Close() (err error) {
+	return
+}
+
+// View get archive
+func (d *Dao) View(c context.Context, mid, aid int64) (av *model.ArcVideo, err error) {
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("aid", strconv.FormatInt(aid, 10))
+	var res struct {
+		Code int             `json:"code"`
+		Data *model.ArcVideo `json:"data"`
+	}
+	if err = d.client.Get(c, d.viewURL, "", params, &res); err != nil {
+		log.Error("archive.view url(%s) mid(%d) error(%v)", d.viewURL+"?"+params.Encode(), mid, err)
+		err = ecode.CreativeArchiveAPIErr
+		return
+	}
+	if res.Code != 0 {
+		log.Error("archive.view url(%s) mid(%d) res(%v)", d.viewURL+"?"+params.Encode(), mid, res)
+		err = ecode.Int(res.Code)
+		return
+	}
+	if res.Data.Archive == nil {
+		log.Error("archive.view url(%s) mid(%d) res(%v)", d.viewURL+"?"+params.Encode(), mid, res)
+		return
+	}
+	av = res.Data
+	return
+}

app/job/main/creative/dao/archive/dao_test.go

@@ -0,0 +1,55 @@
+package archive
+
+import (
+	"context"
+	"flag"
+	"os"
+	"testing"
+
+	"go-common/app/job/main/creative/conf"
+
+	_ "github.com/go-sql-driver/mysql"
+	"github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func TestMain(m *testing.M) {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.archive.creative-job")
+		flag.Set("conf_token", "43943fda0bb311e8865c66d44b23cda7")
+		flag.Set("tree_id", "16037")
+		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/creative-job.toml")
+	}
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	d = New(conf.Conf)
+	os.Exit(m.Run())
+}
+
+func Test_UpCount(t *testing.T) {
+	var (
+		err error
+		c   = context.TODO()
+		mid = int64(123)
+	)
+	convey.Convey("UpCount", t, func(ctx convey.C) {
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				_, err = d.UpCount(c, mid)
+				ctx.So(err, convey.ShouldEqual, err)
+			})
+		})
+	})
+}

app/job/main/creative/dao/archive/rpc.go

@@ -0,0 +1,65 @@
+package archive
+
+import (
+	"context"
+	"strconv"
+
+	"go-common/app/interface/openplatform/article/model"
+	"go-common/app/service/main/archive/api"
+	"go-common/app/service/main/archive/model/archive"
+
+	"go-common/library/ecode"
+	"go-common/library/log"
+)
+
+// UpCount get archives count.
+func (d *Dao) UpCount(c context.Context, mid int64) (count int, err error) {
+	var arg = &archive.ArgUpCount2{Mid: mid}
+	if count, err = d.arc.UpCount2(c, arg); err != nil {
+		log.Error("rpc UpCount2 (%v) error(%v)", mid, err)
+		err = ecode.CreativeArcServiceErr
+	}
+	return
+}
+
+// Archives get archive list.
+func (d *Dao) Archives(c context.Context, aids []int64) (a map[int64]*api.Arc, err error) {
+	var arg = &archive.ArgAids2{Aids: aids, RealIP: ""}
+	if a, err = d.arc.Archives3(c, arg); err != nil {
+		log.Error("d.arc.Archive3 aids(%v+)|error(%v)", aids, err)
+		err = ecode.CreativeArcServiceErr
+	}
+	return
+}
+
+// Archive get archive info.
+func (d *Dao) Archive(c context.Context, aid int64) (a *api.Arc, err error) {
+	var arg = &archive.ArgAid2{Aid: aid, RealIP: ""}
+	if a, err = d.arc.Archive3(c, arg); err != nil {
+		log.Error("d.arc.Archive3 aid(%d)|error(%v)", aid, err)
+		err = ecode.CreativeArcServiceErr
+	}
+	return
+}
+
+// Stats get archives stat.
+func (d *Dao) Stats(c context.Context, aids []int64) (a map[int64]*api.Stat, err error) {
+	var arg = &archive.ArgAids2{Aids: aids, RealIP: ""}
+	if a, err = d.arc.Stats3(c, arg); err != nil {
+		log.Error("rpc Stats (%v) error(%v)", aids, err)
+		err = ecode.CreativeArcServiceErr
+	}
+	return
+}
+
+// ArticleMetas batch get articles by aids.
+func (d *Dao) ArticleMetas(c context.Context, aids []int64) (res map[int64]*model.Meta, err error) {
+	arg := &model.ArgAids{Aids: aids, RealIP: ""}
+	if res, err = d.art.ArticleMetas(c, arg); err != nil {
+		log.Error("d.art.ArticleMetas aids(%+v)|error(%v)", arg, err)
+		if _, er := strconv.ParseInt(err.Error(), 10, 64); er != nil {
+			err = ecode.CreativeArticleRPCErr
+		}
+	}
+	return
+}

app/job/main/creative/dao/archive/rpc_test.go

@@ -0,0 +1,83 @@
+package archive
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestArchiveUpCount(t *testing.T) {
+	convey.Convey("UpCount", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			mid = int64(1)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			_, err := d.UpCount(c, mid)
+			ctx.Convey("Then err should be nil.count should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldEqual, err)
+			})
+		})
+	})
+}
+
+func TestArchiveArchives(t *testing.T) {
+	convey.Convey("Archives", t, func(ctx convey.C) {
+		var (
+			c    = context.Background()
+			aids = []int64{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			_, err := d.Archives(c, aids)
+			ctx.Convey("Then err should be nil.a should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldEqual, err)
+			})
+		})
+	})
+}
+
+func TestArchiveArchive(t *testing.T) {
+	convey.Convey("Archive", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			aid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			_, err := d.Archive(c, aid)
+			ctx.Convey("Then err should be nil.a should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldEqual, err)
+			})
+		})
+	})
+}
+
+func TestArchiveStats(t *testing.T) {
+	convey.Convey("Stats", t, func(ctx convey.C) {
+		var (
+			c    = context.Background()
+			aids = []int64{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			_, err := d.Stats(c, aids)
+			ctx.Convey("Then err should be nil.a should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldEqual, err)
+			})
+		})
+	})
+}
+
+func TestArchiveArticleMetas(t *testing.T) {
+	convey.Convey("ArticleMetas", t, func(ctx convey.C) {
+		var (
+			c    = context.Background()
+			aids = []int64{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			_, err := d.ArticleMetas(c, aids)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldEqual, err)
+			})
+		})
+	})
+}

app/job/main/creative/dao/monitor/BUILD

@@ -0,0 +1,47 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["dao_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/job/main/creative/conf:go_default_library",
+        "//vendor/github.com/go-sql-driver/mysql:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["dao.go"],
+    importpath = "go-common/app/job/main/creative/dao/monitor",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/job/main/creative/conf:go_default_library",
+        "//app/job/main/creative/model:go_default_library",
+        "//library/log:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/job/main/creative/dao/monitor/dao.go

@@ -0,0 +1,120 @@
+package monitor
+
+import (
+	"bytes"
+	"context"
+	"crypto/md5"
+	"encoding/json"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+	"strconv"
+	"time"
+
+	"go-common/app/job/main/creative/conf"
+	"go-common/app/job/main/creative/model"
+	"go-common/library/log"
+)
+
+const (
+	_uri      = "/api/v1/message/add"
+	_method   = "POST"
+	_fileType = "application/json"
+)
+
+// Dao is message dao.
+type Dao struct {
+	c      *conf.Config
+	client *http.Client
+	url    string
+}
+
+// New new a message dao.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		c: c,
+		client: &http.Client{
+			Timeout: time.Duration(time.Second * 1),
+		},
+		url: c.Monitor.Host + _uri,
+	}
+	return
+}
+
+// Send send exception message to owner.
+func (d *Dao) Send(c context.Context, username, msg string) (err error) {
+	params := url.Values{}
+	now := time.Now().Unix()
+	params.Set("username", username)
+	params.Set("content", msg)
+	params.Set("title", "test")
+	params.Set("url", "")
+	params.Set("type", "wechat")
+	params.Set("token", d.c.Monitor.AppToken)
+	params.Set("timestamp", strconv.FormatInt(now, 10))
+	bap := &model.BAP{
+		UserName:  params.Get("username"),
+		Content:   params.Get("content"),
+		Title:     params.Get("title"),
+		URL:       params.Get("url"),
+		Ty:        params.Get("type"),
+		Token:     params.Get("token"),
+		TimeStamp: now,
+		Signature: d.getSign(params),
+	}
+	jsonStr, err := json.Marshal(bap)
+	if err != nil {
+		log.Error("monitor json.Marshal error (%v)", err)
+		return
+	}
+	req, err := http.NewRequest(_method, d.url, bytes.NewBuffer(jsonStr))
+	if err != nil {
+		log.Error("monitor http.NewRequest error (%v)", err)
+		return
+	}
+	req.Header.Add("Content-Type", _fileType)
+	// timeout
+	ctx, cancel := context.WithTimeout(c, 800*time.Millisecond)
+	req = req.WithContext(ctx)
+	defer cancel()
+	response, err := d.client.Do(req)
+	if err != nil {
+		log.Error("monitor  d.client.Post error(%v)", err)
+		return
+	}
+	defer response.Body.Close()
+	if response.StatusCode != http.StatusOK {
+		log.Error("monitor http.StatusCode nq http.StatusOK (%d) | url(%s)", response.StatusCode, d.url)
+		return
+	}
+	body, err := ioutil.ReadAll(response.Body)
+	if err != nil {
+		log.Error("monitor ioutil.ReadAll error(%v)", err)
+		return
+	}
+	var result struct {
+		Status int    `json:"status"`
+		Msg    string `json:"msg"`
+	}
+	if err = json.Unmarshal(body, &result); err != nil {
+		log.Error("monitor json.Unmarshal status(%d) error(%v)", result.Status, err)
+	}
+	if result.Status != 0 {
+		log.Error("monitor get status(%d) msg(%s)", result.Status, result.Msg)
+	}
+	return
+}
+
+func (d *Dao) getSign(params url.Values) (sign string) {
+	for k, v := range params {
+		if len(v) == 0 {
+			params.Del(k)
+		}
+	}
+	h := md5.New()
+	io.WriteString(h, params.Encode()+d.c.Monitor.AppSecret)
+	sign = fmt.Sprintf("%x", h.Sum(nil))
+	return
+}

app/job/main/creative/dao/monitor/dao_test.go

@@ -0,0 +1,55 @@
+package monitor
+
+import (
+	"context"
+	"flag"
+	"os"
+	"testing"
+
+	"go-common/app/job/main/creative/conf"
+
+	_ "github.com/go-sql-driver/mysql"
+	"github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func TestMain(m *testing.M) {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.archive.creative-job")
+		flag.Set("conf_token", "43943fda0bb311e8865c66d44b23cda7")
+		flag.Set("tree_id", "16037")
+		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/creative-job.toml")
+	}
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	d = New(conf.Conf)
+	os.Exit(m.Run())
+}
+
+func Test_Monitor(t *testing.T) {
+	var (
+		err      error
+		c        = context.TODO()
+		username = "test"
+	)
+	convey.Convey("monitor", t, func(ctx convey.C) {
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				err = d.Send(c, username, "creative-job test")
+				ctx.So(err, convey.ShouldEqual, err)
+			})
+		})
+	})
+}

app/job/main/creative/dao/newcomer/BUILD

@@ -0,0 +1,57 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "api.go",
+        "dao.go",
+        "db.go",
+    ],
+    importpath = "go-common/app/job/main/creative/dao/newcomer",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/creative/api:go_default_library",
+        "//app/job/main/creative/conf:go_default_library",
+        "//app/job/main/creative/model:go_default_library",
+        "//library/database/sql:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster: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 = [
+        "api_test.go",
+        "dao_test.go",
+        "db_test.go",
+    ],
+    embed = [":go_default_library"],
+    tags = ["automanaged"],
+    deps = [
+        "//app/job/main/creative/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)

app/job/main/creative/dao/newcomer/api.go

@@ -0,0 +1,45 @@
+package newcomer
+
+import (
+	"context"
+	"errors"
+	"net/url"
+
+	"go-common/library/log"
+	"go-common/library/xstr"
+)
+
+// SendNotify send msg notify user
+func (d *Dao) SendNotify(c context.Context, mids []int64, mc, title, context string) (err error) {
+	var (
+		params = url.Values{}
+		res    struct {
+			Code int    `json:"code"`
+			Msg  string `json:"msg"`
+			Data *struct {
+				TotalCount   int     `json:"total_count"`
+				ErrorCount   int     `json:"error_count"`
+				ErrorMidList []int64 `json:"error_mid_list"`
+			} `json:"data"`
+		}
+	)
+	params.Set("mc", mc)                        //消息码，用于识别消息类别
+	params.Set("data_type", "4")                //消息类型：1、回复我的 2、@我 3、收到的爱 4、业务通知 5、系统公告
+	params.Set("title", title)                  //消息标题
+	params.Set("context", context)              //消息实体内容
+	params.Set("mid_list", xstr.JoinInts(mids)) //用于接收该消息的用户mid列表，不超过1000个(半角逗号分割)
+
+	log.Info("SendNotify params(%+v)|msgURI(%s)", params.Encode(), d.msgURI)
+	if err = d.httpClient.Post(c, d.msgURI, "", params, &res); err != nil {
+		log.Error("d.httpClient.Post(%s,%v,%d)", d.msgURI, params, err)
+		return
+	}
+	if res.Code != 0 {
+		err = errors.New("code != 0")
+		log.Error("d.httpClient.Post(%s,%v,%v,%d)", d.msgURI, params, err, res.Code)
+	}
+	if res.Data != nil {
+		log.Info("SendNotify log total_count(%d) error_count(%d) error_mid_list(%v)", res.Data.TotalCount, res.Data.ErrorCount, res.Data.ErrorMidList)
+	}
+	return
+}

app/job/main/creative/dao/newcomer/api_test.go

@@ -0,0 +1,26 @@
+package newcomer
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestNewcomerSendNotify(t *testing.T) {
+	convey.Convey("Msg", t, func(ctx convey.C) {
+		var (
+			c       = context.Background()
+			mids    = []int64{27515405}
+			mc      = "1_17_2"
+			title   = "creative"
+			context = "sssss"
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			err := d.SendNotify(c, mids, mc, title, context)
+			ctx.Convey("Then err should be nil.msg should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldEqual, err)
+			})
+		})
+	})
+}

app/job/main/creative/dao/newcomer/dao.go

@@ -0,0 +1,55 @@
+package newcomer
+
+import (
+	"context"
+
+	grpc "go-common/app/interface/main/creative/api"
+	"go-common/app/job/main/creative/conf"
+	"go-common/library/database/sql"
+	httpx "go-common/library/net/http/blademaster"
+)
+
+// Dao is search dao.
+type Dao struct {
+	c *conf.Config
+	//db
+	db *sql.DB
+	//grpc
+	grpcClient grpc.CreativeClient
+	// http
+	httpClient *httpx.Client
+	msgURI     string
+}
+
+// New new a search dao.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		c:          c,
+		db:         sql.NewMySQL(c.DB.Creative),
+		httpClient: httpx.NewClient(c.HTTPClient.Slow),
+		msgURI:     c.Host.Message + "/api/notify/send.user.notify.do", //发送用户通知消息接口
+	}
+
+	var err error
+	if d.grpcClient, err = grpc.NewClient(c.CreativeGRPClient); err != nil {
+		panic(err)
+	}
+	return d
+}
+
+// CheckTaskState call grpc client.
+func (d *Dao) CheckTaskState(c context.Context, MID, TaskID int64) (*grpc.TaskReply, error) {
+	return d.grpcClient.CheckTaskState(c, &grpc.TaskRequest{Mid: MID, TaskId: TaskID})
+}
+
+// Ping ping grpc.
+func (d *Dao) Ping(c context.Context) (err error) {
+	d.grpcClient.Ping(c, nil)
+	return
+}
+
+// Close close grpc.
+func (d *Dao) Close(c context.Context) (err error) {
+	d.grpcClient.Close(c, nil)
+	return
+}

app/job/main/creative/dao/newcomer/dao_test.go

@@ -0,0 +1,34 @@
+package newcomer
+
+import (
+	"flag"
+	"go-common/app/job/main/creative/conf"
+	"os"
+	"testing"
+)
+
+var (
+	d *Dao
+)
+
+func TestMain(m *testing.M) {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.archive.creative-job")
+		flag.Set("conf_token", "43943fda0bb311e8865c66d44b23cda7")
+		flag.Set("tree_id", "16037")
+		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/creative-job.toml")
+	}
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	d = New(conf.Conf)
+	os.Exit(m.Run())
+}

app/job/main/creative/dao/newcomer/db.go

@@ -0,0 +1,230 @@
+package newcomer
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"go-common/app/job/main/creative/model"
+	"go-common/library/log"
+)
+
+//UserTasks get user unfinish  task.
+func (d *Dao) UserTasks(c context.Context, index string, id int64, limit int) (res []*model.UserTask, err error) {
+	_getUserTaskSQL := "SELECT id, mid, task_id, task_group_id, task_type, state, task_bind_time, ctime, mtime FROM newcomers_task_user_%s WHERE state=-1 AND id > ? order by id asc limit ?"
+
+	rows, err := d.db.Query(c, fmt.Sprintf(_getUserTaskSQL, index), id, limit)
+	if err != nil {
+		log.Error("UserTasks d.db.Query error(%v)", err)
+		return
+	}
+	defer rows.Close()
+	res = make([]*model.UserTask, 0)
+	for rows.Next() {
+		r := &model.UserTask{}
+		if err = rows.Scan(&r.ID, &r.MID, &r.TaskID, &r.TaskGroupID, &r.TaskType, &r.State, &r.TaskBindTime, &r.CTime, &r.MTime); err != nil {
+			log.Error("UserTasks rows.Scan error(%v)", err)
+			return
+		}
+		res = append(res, r)
+	}
+	return
+}
+
+// getTableName by mid%100
+func getTableName(mid int64) string {
+	return fmt.Sprintf("%02d", mid%100)
+}
+
+// UpUserTask update user task finish state
+func (d *Dao) UpUserTask(c context.Context, mid, tid int64) (int64, error) {
+	_upUserTaskSQL := "UPDATE newcomers_task_user_%s SET state=? WHERE mid=? AND task_id=?"
+
+	res, err := d.db.Exec(c, fmt.Sprintf(_upUserTaskSQL, getTableName(mid)), 0, mid, tid)
+	if err != nil {
+		log.Error("RewardActivate d.db.Exec mid(%d) id(%d) error(%v)", mid, tid, err)
+		return 0, err
+	}
+	return res.RowsAffected()
+}
+
+//UserTasksByMIDAndState get user unfinish task by mid & state.
+func (d *Dao) UserTasksByMIDAndState(c context.Context, mid int64, state int) (res []*model.UserTask, err error) {
+	_getUserTaskByMIDSQL := "SELECT id, mid, task_id, task_group_id, task_type, state, ctime, mtime FROM newcomers_task_user_%s WHERE mid=? AND state=?"
+
+	rows, err := d.db.Query(c, fmt.Sprintf(_getUserTaskByMIDSQL, getTableName(mid)), mid, state)
+	if err != nil {
+		log.Error("UserTasksByMIDAndState d.db.Query error(%v)", err)
+		return
+	}
+	defer rows.Close()
+	res = make([]*model.UserTask, 0)
+	for rows.Next() {
+		r := &model.UserTask{}
+		if err = rows.Scan(&r.ID, &r.MID, &r.TaskID, &r.TaskGroupID, &r.TaskType, &r.State, &r.CTime, &r.MTime); err != nil {
+			log.Error("UserTasksByMIDAndState rows.Scan error(%v)", err)
+			return
+		}
+		res = append(res, r)
+	}
+	return
+}
+
+//Tasks get all task.
+func (d *Dao) Tasks(c context.Context) (res []*model.Task, err error) {
+	_getTaskSQL := "SELECT id, group_id, type, state, target_type, target_value, title, `desc`, comment, ctime, mtime FROM newcomers_task WHERE state=0"
+
+	rows, err := d.db.Query(c, _getTaskSQL)
+	if err != nil {
+		log.Error("Tasks d.db.Query error(%v)", err)
+		return
+	}
+	defer rows.Close()
+
+	res = make([]*model.Task, 0)
+	for rows.Next() {
+		r := &model.Task{}
+		if err = rows.Scan(&r.ID, &r.GroupID, &r.Type, &r.State, &r.TargetType, &r.TargetValue, &r.Title, &r.Desc, &r.Comment, &r.CTime, &r.MTime); err != nil {
+			log.Error("Tasks rows.Scan error(%v)", err)
+			return
+		}
+		res = append(res, r)
+	}
+	return
+}
+
+// TaskByTID get task by task_id
+func (d *Dao) TaskByTID(c context.Context, mid int64, tid int64) (res *model.Task, err error) {
+	_getOneTaskSQL := fmt.Sprintf("SELECT task_id,task_group_id,task_type,state FROM newcomers_task_user_%s WHERE mid=? AND task_id=?", getTableName(mid))
+
+	row := d.db.QueryRow(c, _getOneTaskSQL, mid, tid)
+	res = &model.Task{}
+	if err = row.Scan(&res.ID, &res.GroupID, &res.Type, &res.State); err != nil {
+		log.Error("TaskByTID ow.Scan error(%v)", err)
+		return
+	}
+
+	return
+}
+
+// CheckTaskComplete check task complete state
+func (d *Dao) CheckTaskComplete(c context.Context, mid int64, tid int64) bool {
+	task, err := d.TaskByTID(c, mid, tid)
+	if err != nil || task == nil {
+		return false
+	}
+	if task.State == 0 {
+		return true
+	}
+	return false
+}
+
+//UserTasksNotify get unfinish task send notify to user.
+func (d *Dao) UserTasksNotify(c context.Context, index string, id int64, start, end string, limit int) (res []*model.UserTask, err error) {
+	_getUserTaskSQL := "SELECT id, mid, task_id, task_group_id, task_type, state, ctime, mtime FROM newcomers_task_user_%s WHERE state=-1 AND task_type=1 AND id>? AND ctime >= ? AND ctime <= ? order by id asc limit ?"
+
+	rows, err := d.db.Query(c, fmt.Sprintf(_getUserTaskSQL, index), id, start, end, limit)
+	if err != nil {
+		log.Error("UserTasks d.db.Query error(%v)", err)
+		return
+	}
+	defer rows.Close()
+	res = make([]*model.UserTask, 0)
+	for rows.Next() {
+		r := &model.UserTask{}
+		if err = rows.Scan(&r.ID, &r.MID, &r.TaskID, &r.TaskGroupID, &r.TaskType, &r.State, &r.CTime, &r.MTime); err != nil {
+			log.Error("UserTasks rows.Scan error(%v)", err)
+			return
+		}
+		res = append(res, r)
+	}
+	return
+}
+
+//UserTasksByMID get user unfinish task by mid.
+func (d *Dao) UserTasksByMID(c context.Context, mid int64) (res []*model.UserTask, err error) {
+	_getUserTaskByMIDSQL := "SELECT id, mid, task_id, task_group_id, task_type, state, ctime, mtime FROM newcomers_task_user_%s WHERE mid=?"
+
+	rows, err := d.db.Query(c, fmt.Sprintf(_getUserTaskByMIDSQL, getTableName(mid)), mid)
+	if err != nil {
+		log.Error("UserTasksByMID d.db.Query error(%v)", err)
+		return
+	}
+	defer rows.Close()
+	res = make([]*model.UserTask, 0)
+	for rows.Next() {
+		r := &model.UserTask{}
+		if err = rows.Scan(&r.ID, &r.MID, &r.TaskID, &r.TaskGroupID, &r.TaskType, &r.State, &r.CTime, &r.MTime); err != nil {
+			log.Error("UserTasksByMID rows.Scan error(%v)", err)
+			return
+		}
+		res = append(res, r)
+	}
+	return
+}
+
+// AllGiftRewards get all GiftRewards for cache
+func (d *Dao) AllGiftRewards(c context.Context) (res map[int8][]*model.GiftReward, err error) {
+	_getAllGiftRewardSQL := "SELECT task_type,reward_id,state,comment,ctime,mtime FROM newcomers_gift_reward WHERE state=0"
+
+	rows, err := d.db.Query(c, _getAllGiftRewardSQL)
+	if err != nil {
+		log.Error("AllGiftRewards d.db.Query error(%v)", err)
+		return
+	}
+	defer rows.Close()
+	res = make(map[int8][]*model.GiftReward)
+	for rows.Next() {
+		t := &model.GiftReward{}
+		if err = rows.Scan(&t.TaskType, &t.RewardID, &t.State, &t.Comment, &t.CTime, &t.MTime); err != nil {
+			log.Error("AllGiftRewards rows.Scan error(%v)", err)
+			return
+		}
+		res[t.TaskType] = append(res[t.TaskType], t)
+	}
+	return
+}
+
+// GiftRewardCount get received gift reward count
+func (d *Dao) GiftRewardCount(c context.Context, mid int64) (res int, err error) {
+	sqlStr := "SELECT count(DISTINCT task_gift_id) FROM newcomers_reward_receive WHERE NOT task_gift_id=0 AND mid=?"
+	row := d.db.QueryRow(c, sqlStr, mid)
+	err = row.Scan(&res)
+	if err != nil {
+		log.Error("GiftRewardCount d.db.QueryRow error(%v)", err)
+	}
+	return
+}
+
+// BaseRewardCount get received base reward count
+func (d *Dao) BaseRewardCount(c context.Context, mid int64) (res int, err error) {
+	sqlStr := "SELECT count(DISTINCT task_group_id) FROM newcomers_reward_receive WHERE NOT task_group_id=0 AND mid=?"
+	row := d.db.QueryRow(c, sqlStr, mid)
+	err = row.Scan(&res)
+	if err != nil {
+		log.Error("BaseRewardCount d.db.QueryRow error(%v)", err)
+	}
+	return
+}
+
+//CheckTasksForRewardNotify get finish task send notify to user.
+func (d *Dao) CheckTasksForRewardNotify(c context.Context, index string, id int64, startMtime, endMtime time.Time, limit int) (res []*model.UserTask, err error) {
+	_getUserTaskSQL := "SELECT id, mid, task_id, task_group_id, task_type, state, ctime, mtime FROM newcomers_task_user_%s WHERE state=0 AND id>? AND mtime>=? AND mtime<=? order by id asc limit ?"
+
+	rows, err := d.db.Query(c, fmt.Sprintf(_getUserTaskSQL, index), id, startMtime.Format("2006-01-02 15:04:05"), endMtime.Format("2006-01-02 15:04:05"), limit)
+	if err != nil {
+		log.Error("UserTasks d.db.Query error(%v)", err)
+		return
+	}
+	defer rows.Close()
+	res = make([]*model.UserTask, 0)
+	for rows.Next() {
+		r := &model.UserTask{}
+		if err = rows.Scan(&r.ID, &r.MID, &r.TaskID, &r.TaskGroupID, &r.TaskType, &r.State, &r.CTime, &r.MTime); err != nil {
+			log.Error("UserTasks rows.Scan error(%v)", err)
+			return
+		}
+		res = append(res, r)
+	}
+	return
+}

app/job/main/creative/dao/newcomer/db_test.go

@@ -0,0 +1,200 @@
+package newcomer
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestNewcomerUserTasks(t *testing.T) {
+	convey.Convey("UserTasks", t, func(ctx convey.C) {
+		var (
+			c     = context.Background()
+			index = ""
+			id    = int64(0)
+			limit = int(100)
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			_, err := d.UserTasks(c, index, id, limit)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldEqual, err)
+			})
+		})
+	})
+}
+
+func TestNewcomergetTableName(t *testing.T) {
+	convey.Convey("getTableName", t, func(ctx convey.C) {
+		var (
+			mid = int64(27515405)
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			p1 := getTableName(mid)
+			ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(p1, convey.ShouldEqual, p1)
+			})
+		})
+	})
+}
+
+func TestNewcomerUpUserTask(t *testing.T) {
+	convey.Convey("UpUserTask", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			mid = int64(27515405)
+			tid = int64(1)
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			_, err := d.UpUserTask(c, mid, tid)
+			ctx.Convey("Then err should be nil.p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldEqual, err)
+			})
+		})
+	})
+}
+
+func TestNewcomerUserTasksByMID(t *testing.T) {
+	convey.Convey("UserTasksByMID", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			mid = int64(27515405)
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			_, err := d.UserTasksByMID(c, mid)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldEqual, err)
+			})
+		})
+	})
+}
+
+func TestNewcomerTaskByTID(t *testing.T) {
+	convey.Convey("TaskByTID", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			mid = int64(27515405)
+			tid = int64(1)
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			_, err := d.TaskByTID(c, mid, tid)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldEqual, err)
+			})
+		})
+	})
+}
+func TestNewcomerTasks(t *testing.T) {
+	convey.Convey("Tasks", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			_, err := d.Tasks(c)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldEqual, err)
+			})
+		})
+	})
+}
+
+func TestNewcomerCheckTaskComplete(t *testing.T) {
+	convey.Convey("CheckTaskComplete", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			mid = int64(27515405)
+			tid = int64(1)
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			res := d.CheckTaskComplete(c, mid, tid)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(res, convey.ShouldEqual, res)
+			})
+		})
+	})
+}
+
+func TestNewcomerUserTasksNotify(t *testing.T) {
+	convey.Convey("UserTasksNotify", t, func(ctx convey.C) {
+		var (
+			c     = context.Background()
+			id    = int64(0)
+			index = "1"
+			start = time.Now().Format("2006-01-02 15:04:05")
+			end   = time.Now().Format("2006-01-02 15:04:05")
+			limit = 100
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			_, err := d.UserTasksNotify(c, index, id, start, end, limit)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldEqual, err)
+			})
+		})
+	})
+}
+
+func TestNewcomerGiftRewardCount(t *testing.T) {
+	convey.Convey("GiftRewardCount", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			mid = int64(27515405)
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			_, err := d.GiftRewardCount(c, mid)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldEqual, err)
+			})
+		})
+	})
+}
+
+func TestNewcomerBaseRewardCount(t *testing.T) {
+	convey.Convey("BaseRewardCount", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			mid = int64(27515405)
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			_, err := d.BaseRewardCount(c, mid)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldEqual, err)
+			})
+		})
+	})
+}
+
+func TestNewcomerCheckTasksForRewardNotify(t *testing.T) {
+	convey.Convey("CheckTasksForRewardNotify", t, func(ctx convey.C) {
+		var (
+			c     = context.Background()
+			id    = int64(0)
+			index = "1"
+			start = time.Now()
+			end   = time.Now()
+			limit = 100
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			_, err := d.CheckTasksForRewardNotify(c, index, id, start, end, limit)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldEqual, err)
+			})
+		})
+	})
+}
+
+func TestNewcomerUserTasksByMIDAndState(t *testing.T) {
+	convey.Convey("UserTasksByMIDAndState", t, func(ctx convey.C) {
+		var (
+			c     = context.Background()
+			mid   = int64(27515405)
+			state = 0
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			_, err := d.UserTasksByMIDAndState(c, mid, state)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldEqual, err)
+			})
+		})
+	})
+}

app/job/main/creative/dao/weeklyhonor/BUILD

@@ -0,0 +1,79 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "dao.go",
+        "hbase.go",
+        "httpclient.go",
+        "infoc.go",
+        "monkey.go",
+        "mysql.go",
+        "rpc.go",
+    ],
+    importpath = "go-common/app/job/main/creative/dao/weeklyhonor",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/admin/main/up/util/hbaseutil:go_default_library",
+        "//app/interface/main/creative/model/weeklyhonor:go_default_library",
+        "//app/job/main/creative/conf:go_default_library",
+        "//app/service/main/archive/api/gorpc:go_default_library",
+        "//app/service/main/archive/model/archive:go_default_library",
+        "//app/service/main/up/api/v1:go_default_library",
+        "//library/database/hbase.v2:go_default_library",
+        "//library/database/sql:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/log/infoc:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/xstr:go_default_library",
+        "//vendor/github.com/bouk/monkey:go_default_library",
+        "//vendor/github.com/tsuna/gohbase/hrpc: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 = [
+        "dao_test.go",
+        "hbase_test.go",
+        "httpclient_test.go",
+        "infoc_test.go",
+        "mysql_test.go",
+        "rpc_test.go",
+    ],
+    embed = [":go_default_library"],
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/creative/model/weeklyhonor:go_default_library",
+        "//app/job/main/creative/conf:go_default_library",
+        "//app/service/main/up/api/v1:go_default_library",
+        "//library/database/hbase.v2:go_default_library",
+        "//vendor/github.com/bouk/monkey:go_default_library",
+        "//vendor/github.com/golang/mock/gomock:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+        "//vendor/github.com/tsuna/gohbase/hrpc:go_default_library",
+        "//vendor/gopkg.in/h2non/gock.v1:go_default_library",
+    ],
+)

app/job/main/creative/dao/weeklyhonor/dao.go

@@ -0,0 +1,63 @@
+package weeklyhonor
+
+import (
+	"context"
+	"time"
+
+	"go-common/app/job/main/creative/conf"
+	arcrpc "go-common/app/service/main/archive/api/gorpc"
+	upgrpc "go-common/app/service/main/up/api/v1"
+	"go-common/library/database/hbase.v2"
+	"go-common/library/database/sql"
+	binfoc "go-common/library/log/infoc"
+	bm "go-common/library/net/http/blademaster"
+)
+
+// Dao is creative dao.
+type Dao struct {
+	// config
+	c *conf.Config
+	// db
+	db *sql.DB
+	// httpClient
+	httpClient *bm.Client
+	// hbase
+	hbase        *hbase.Client
+	hbaseTimeOut time.Duration
+	// rpc
+	arc   *arcrpc.Service2
+	infoc *binfoc.Infoc
+	// grpc
+	upClient upgrpc.UpClient
+}
+
+// New init api url
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		c:          c,
+		db:         sql.NewMySQL(c.DB.Creative),
+		httpClient: bm.NewClient(c.HTTPClient.Normal),
+		// hbase
+		hbase:        hbase.NewClient(c.HBaseOld.Config),
+		hbaseTimeOut: time.Duration(time.Millisecond * 200),
+		arc:          arcrpc.New2(c.ArchiveRPC),
+		infoc:        binfoc.New(c.WeeklyHonorInfoc),
+	}
+	var err error
+	d.upClient, err = upgrpc.NewClient(c.UpGRPCClient)
+	if err != nil {
+		panic(err)
+	}
+	return
+}
+
+// Ping creativeDb
+func (d *Dao) Ping(c context.Context) (err error) {
+	return d.pingMySQL(c)
+}
+
+// Close creativeDb
+func (d *Dao) Close() (err error) {
+	_ = d.infoc.Close()
+	return d.db.Close()
+}

app/job/main/creative/dao/weeklyhonor/dao_test.go

@@ -0,0 +1,54 @@
+package weeklyhonor
+
+import (
+	"flag"
+	"os"
+	"strings"
+	"testing"
+
+	"go-common/app/job/main/creative/conf"
+
+	"github.com/golang/mock/gomock"
+	"gopkg.in/h2non/gock.v1"
+)
+
+var (
+	d *Dao
+)
+
+func TestMain(m *testing.M) {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.archive.creative-job")
+		flag.Set("conf_token", "43943fda0bb311e8865c66d44b23cda7")
+		flag.Set("tree_id", "16037")
+		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/creative-job.toml")
+	}
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	d = New(conf.Conf)
+	os.Exit(m.Run())
+}
+
+func httpMock(method, url string) *gock.Request {
+	r := gock.New(url)
+	r.Method = strings.ToUpper(method)
+	d.httpClient.SetTransport(gock.DefaultTransport)
+	return r
+}
+
+func WithMock(t *testing.T, f func(controller *gomock.Controller)) func() {
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+	return func() {
+		f(ctrl)
+	}
+}

app/job/main/creative/dao/weeklyhonor/hbase.go

@@ -0,0 +1,63 @@
+package weeklyhonor
+
+import (
+	"context"
+	"strconv"
+
+	"go-common/app/admin/main/up/util/hbaseutil"
+	model "go-common/app/interface/main/creative/model/weeklyhonor"
+	"go-common/library/ecode"
+	"go-common/library/log"
+
+	"github.com/tsuna/gohbase/hrpc"
+)
+
+// reverse for string.
+func reverseString(s string) string {
+	rs := []rune(s)
+	l := len(rs)
+	for f, t := 0, l-1; f < t; f, t = f+1, t-1 {
+		rs[f], rs[t] = rs[t], rs[f]
+	}
+	ns := string(rs)
+	if l < 10 {
+		for i := 0; i < 10-l; i++ {
+			ns = ns + "0"
+		}
+	}
+	return ns
+}
+
+func honorRowKey(id int64, date string) string {
+	idStr := strconv.FormatInt(id, 10)
+	s := reverseString(idStr) + date
+	return s
+}
+
+// HonorStat get up honor.
+func (d *Dao) HonorStat(c context.Context, mid int64, date string) (stat *model.HonorStat, err error) {
+	var (
+		result      *hrpc.Result
+		ctx, cancel = context.WithTimeout(c, d.hbaseTimeOut)
+		tableName   = "up_honorary_weekly"
+		key         = honorRowKey(mid, date)
+	)
+	defer cancel()
+	if result, err = d.hbase.GetStr(ctx, tableName, key); err != nil {
+		log.Error("HonorStat d.hbase.GetStr tableName(%s) mid(%d) key(%v) error(%v)", tableName, mid, key, err)
+		err = ecode.CreativeDataErr
+		return
+	}
+	if result == nil {
+		return
+	}
+	stat = new(model.HonorStat)
+	parser := hbaseutil.Parser{}
+	err = parser.Parse(result.Cells, &stat)
+	if err != nil {
+		log.Error("failed to parse hbase cells,tableName(%s) mid(%d) key(%v) stat(%+v) err(%v)", tableName, mid, key, stat, err)
+		return
+	}
+	log.Info("HonorStat d.hbase.GetStr tableName(%s) mid(%d) key(%v) stat(%+v)", tableName, mid, key, stat)
+	return
+}

app/job/main/creative/dao/weeklyhonor/hbase_test.go

@@ -0,0 +1,130 @@
+package weeklyhonor
+
+import (
+	"bytes"
+	"context"
+	"encoding/binary"
+	"reflect"
+	"testing"
+
+	"go-common/library/database/hbase.v2"
+
+	"github.com/bouk/monkey"
+	"github.com/smartystreets/goconvey/convey"
+	"github.com/tsuna/gohbase/hrpc"
+)
+
+func TestWeeklyhonorreverseString(t *testing.T) {
+	convey.Convey("reverseString", t, func(ctx convey.C) {
+		var (
+			s = ""
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			p1 := reverseString(s)
+			ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(p1, convey.ShouldEqual, p1)
+			})
+		})
+	})
+}
+
+func TestWeeklyhonorhonorRowKey(t *testing.T) {
+	convey.Convey("honorRowKey", t, func(ctx convey.C) {
+		var (
+			id   = int64(0)
+			date = ""
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			p1 := honorRowKey(id, date)
+			ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(p1, convey.ShouldEqual, p1)
+			})
+		})
+	})
+}
+
+func TestWeeklyhonorHonorStat(t *testing.T) {
+	var (
+		c          = context.Background()
+		mid        = int64(0)
+		date       = "20181112"
+		val1 int32 = 500
+		val2 int32 = -2
+		cs         = getMockCells(val1, val2)
+	)
+	guard := monkey.PatchInstanceMethod(reflect.TypeOf(d.hbase), "GetStr", func(_ *hbase.Client, _ context.Context, _, _ string, _ ...func(hrpc.Call) error) (*hrpc.Result, error) {
+		res := &hrpc.Result{
+			Cells: cs,
+		}
+		return res, nil
+	})
+	defer guard.Unpatch()
+	convey.Convey("honorStat", t, func() {
+		stat, err := d.HonorStat(c, mid, date)
+		convey.So(err, convey.ShouldBeNil)
+		convey.So(stat, convey.ShouldNotBeNil)
+		convey.So(stat.Play, convey.ShouldEqual, val1)
+		convey.So(stat.PlayInc, convey.ShouldEqual, val1)
+		convey.So(stat.Rank0, convey.ShouldEqual, val1)
+		convey.So(stat.FansInc, convey.ShouldEqual, val2)
+	})
+}
+
+func getMockCells(v1, v2 int32) []*hrpc.Cell {
+	s1 := make([]byte, 0)
+	buf1 := bytes.NewBuffer(s1)
+	s2 := make([]byte, 0)
+	buf2 := bytes.NewBuffer(s2)
+
+	binary.Write(buf1, binary.BigEndian, v1)
+	binary.Write(buf2, binary.BigEndian, v2)
+	cells := []*hrpc.Cell{
+		{
+			Qualifier: []byte("play"),
+			Value:     buf1.Bytes(),
+			Family:    []byte("f"),
+		},
+		{
+			Qualifier: []byte("play_last_w"),
+			Value:     buf1.Bytes(),
+			Family:    []byte("f"),
+		},
+		{
+			Qualifier: []byte("play_inc"),
+			Value:     buf1.Bytes(),
+			Family:    []byte("f"),
+		},
+		{
+			Qualifier: []byte("fans_inc"),
+			Value:     buf2.Bytes(),
+			Family:    []byte("f"),
+		},
+		{
+			Qualifier: []byte("rank168"),
+			Value:     buf1.Bytes(),
+			Family:    []byte("r"),
+		},
+		{
+			Qualifier: []byte("rank0"),
+			Value:     buf1.Bytes(),
+			Family:    []byte("r"),
+		},
+		{
+			Qualifier: []byte("rank1"),
+			Value:     buf1.Bytes(),
+			Family:    []byte("r"),
+		},
+		{
+			Qualifier: []byte("rank3"),
+			Value:     buf1.Bytes(),
+			Family:    []byte("r"),
+		},
+		{
+			Qualifier: []byte("rank4"),
+			Value:     buf1.Bytes(),
+			Family:    []byte("r"),
+		},
+	}
+
+	return cells
+}

app/job/main/creative/dao/weeklyhonor/httpclient.go

@@ -0,0 +1,110 @@
+package weeklyhonor
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net/url"
+	"time"
+
+	"go-common/library/log"
+	"go-common/library/xstr"
+)
+
+const (
+	_title          = "叮！你有一份荣誉周报待查收！"
+	_newYearTitle   = "嘭~~~啪！你有一份荣誉周报待查收！"
+	_content        = "这周的成就已达成，快进来瞅瞅吧～ #{周报传送门}{\"https://member.bilibili.com/studio/annyroal/upper-honor-weekly/my\"}"
+	_newYearContent = "这周的成就已达成，元气满满过新年～ #{周报传送门}{\"https://member.bilibili.com/studio/annyroal/upper-honor-weekly/my\"}"
+	_notifyDataType = "4" // 消息类型：1、回复我的2、@我3、收到的爱4、业务通知
+	_notifyURL      = "/api/notify/send.user.notify.do"
+	_notifyMC       = "1_17_1"
+	_upMidsURL      = "/x/internal/uper/list_up"
+)
+
+type newYear struct {
+	start, end time.Time
+}
+
+var (
+	ny = newYear{
+		start: time.Date(2019, 2, 3, 0, 0, 0, 0, time.Local),
+		end:   time.Date(2019, 2, 24, 0, 0, 0, 0, time.Local),
+	}
+)
+
+type msgReply struct {
+	Code int   `json:"code"`
+	Data *data `json:"data"`
+}
+
+type data struct {
+	TotalCount   int     `json:"total_count"`
+	ErrorCount   int     `json:"error_count"`
+	ErrorMidList []int64 `json:"error_mid_list"`
+}
+
+// SendNotify 发送站内信
+func (d *Dao) SendNotify(c context.Context, mids []int64) (errMids []int64, err error) {
+	title, content := getTitleAndContent()
+	res := msgReply{}
+	params := url.Values{}
+	params.Set("mc", _notifyMC)
+	params.Set("title", title)
+	params.Set("data_type", _notifyDataType)
+	params.Set("context", content)
+	params.Set("mid_list", xstr.JoinInts(mids))
+	notifyURI := d.c.Host.Message + _notifyURL
+	if err = d.httpClient.Post(c, notifyURI, "", params, &res); err != nil {
+		log.Error("d.httpClient.Post(%s,%v,%d)", notifyURI, params, err)
+		return
+	}
+	if res.Code != 0 {
+		err = errors.New("code != 0")
+		log.Error("d.httpClient.Post(%s,%v,%v,%d)", notifyURI, params, err, res.Code)
+	}
+	if res.Data != nil {
+		errMids = res.Data.ErrorMidList
+		log.Info("SendNotify log total_count(%d) error_count(%d) error_mid_list(%v)", res.Data.TotalCount, res.Data.ErrorCount, res.Data.ErrorMidList)
+	}
+	return
+}
+
+func getTitleAndContent() (string, string) {
+	now := time.Now()
+	if now.After(ny.end) || now.Before(ny.start) {
+		return _title, _content
+	}
+	return _newYearTitle, _newYearContent
+}
+
+// Deprecated: use UpActivesList instead.
+func (d *Dao) UpMids(c context.Context, size int, lastid int64, activeOnly bool) (mids []int64, newid int64, err error) {
+	res := &struct {
+		Code int `json:"code"`
+		Data *struct {
+			Result []int64 `json:"result"`
+			LastID int64   `json:"last_id"`
+		} `json:"data"`
+	}{}
+	params := url.Values{}
+	params.Set("size", fmt.Sprintf("%d", size))
+	params.Set("last_id", fmt.Sprintf("%d", lastid))
+	if activeOnly {
+		// filter by having archive within 180 days
+		params.Set("activity", "1,2,3")
+	}
+	midsURI := d.c.Host.API + _upMidsURL
+	if err = d.httpClient.Get(c, midsURI, "", params, &res); err != nil {
+		log.Error("d.httpClient.Get(%s,%v,%d)", midsURI+"?"+params.Encode(), params, err)
+		return
+	}
+	if res.Code != 0 {
+		err = errors.New("code != 0")
+		log.Error("d.httpClient.Get(%s,%v,%v,%d)", midsURI, params, err, res.Code)
+	}
+	if res != nil && res.Data != nil {
+		return res.Data.Result, res.Data.LastID, nil
+	}
+	return
+}

app/job/main/creative/dao/weeklyhonor/httpclient_test.go

@@ -0,0 +1,45 @@
+package weeklyhonor
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+	"gopkg.in/h2non/gock.v1"
+)
+
+func TestWeeklyhonorSendNotify(t *testing.T) {
+	convey.Convey("SendNotify", t, func(ctx convey.C) {
+		var (
+			c    = context.Background()
+			mids = []int64{11}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			defer gock.Off()
+			httpMock("POST", d.c.Host.Message+_notifyURL).Reply(200).JSON(`{"code":0,"data":{}}`)
+			_, err := d.SendNotify(c, mids)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldEqual, err)
+			})
+		})
+	})
+}
+
+func TestWeeklyhonorUpMids(t *testing.T) {
+	convey.Convey("UpMids", t, func(ctx convey.C) {
+		var (
+			c          = context.Background()
+			size       = int(0)
+			lastid     = int64(0)
+			activeOnly bool
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			mids, newid, err := d.UpMids(c, size, lastid, activeOnly)
+			ctx.Convey("Then err should be nil.mids,newid should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(newid, convey.ShouldNotBeNil)
+				ctx.So(mids, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}

app/job/main/creative/dao/weeklyhonor/infoc.go

@@ -0,0 +1,21 @@
+package weeklyhonor
+
+import (
+	"context"
+	"go-common/library/log"
+	"time"
+)
+
+// HonorInfoc log honor msg send status
+func (d *Dao) HonorInfoc(c context.Context, mid int64, success int32) (err error) {
+	ctime := time.Now().Format("20060102 15:04:05")
+	i := map[string]interface{}{
+		"mid":     mid,
+		"ctime":   ctime,
+		"exc":     "",
+		"success": success,
+	}
+	log.Warn("infocproc create infoc(%v)", i)
+	err = d.infoc.Info(mid, ctime, "", success)
+	return
+}

app/job/main/creative/dao/weeklyhonor/infoc_test.go

@@ -0,0 +1,24 @@
+package weeklyhonor
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestWeeklyhonorHonorInfoc(t *testing.T) {
+	convey.Convey("HonorInfoc", t, func(ctx convey.C) {
+		var (
+			c       = context.Background()
+			mid     = int64(0)
+			success = int32(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.HonorInfoc(c, mid, success)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}

app/job/main/creative/dao/weeklyhonor/monkey.go

@@ -0,0 +1,52 @@
+package weeklyhonor
+
+import (
+	"context"
+	model "go-common/app/interface/main/creative/model/weeklyhonor"
+	upgrpc "go-common/app/service/main/up/api/v1"
+	"reflect"
+
+	"github.com/bouk/monkey"
+)
+
+//MockHonorStat is
+func (d *Dao) MockHonorStat(stat *model.HonorStat, err error) (guard *monkey.PatchGuard) {
+	return monkey.PatchInstanceMethod(reflect.TypeOf(d), "HonorStat", func(_ *Dao, _ context.Context, _ int64, _ string) (*model.HonorStat, error) {
+		return stat, err
+	})
+}
+
+//MockSendNotify is
+func (d *Dao) MockSendNotify(err error) (guard *monkey.PatchGuard) {
+	return monkey.PatchInstanceMethod(reflect.TypeOf(d), "SendNotify", func(_ *Dao, _ context.Context, _ []int64) error {
+		return err
+	})
+}
+
+//MockLatestHonorLogs is
+func (d *Dao) MockLatestHonorLogs(hls []*model.HonorLog, err error) (guard *monkey.PatchGuard) {
+	return monkey.PatchInstanceMethod(reflect.TypeOf(d), "LatestHonorLogs", func(_ *Dao, _ context.Context, _ []int64) ([]*model.HonorLog, error) {
+		return hls, err
+	})
+}
+
+//MockClickCounts is
+func (d *Dao) MockClickCounts(res map[int64]int32, err error) (guard *monkey.PatchGuard) {
+	return monkey.PatchInstanceMethod(reflect.TypeOf(d), "ClickCounts", func(_ *Dao, _ context.Context, _ []int64) (map[int64]int32, error) {
+		return res, err
+	})
+}
+
+//MockUpCount is
+func (d *Dao) MockUpCount(count int, err error) (guard *monkey.PatchGuard) {
+	return monkey.PatchInstanceMethod(reflect.TypeOf(d), "UpCount", func(_ *Dao, _ context.Context, _ int64) (int, error) {
+		return count, err
+	})
+}
+
+//MockUpActivesList is
+func (d *Dao) MockUpActivesList(upActives []*upgrpc.UpActivity, newid int64, err error) (guard *monkey.PatchGuard) {
+	return monkey.PatchInstanceMethod(reflect.TypeOf(d), "UpActivesList", func(_ *Dao, _ context.Context, _ int64, _ int) ([]*upgrpc.UpActivity, int64, error) {
+		return upActives, newid, err
+	})
+}

app/job/main/creative/dao/weeklyhonor/mysql.go

@@ -0,0 +1,107 @@
+package weeklyhonor
+
+import (
+	"context"
+	"fmt"
+
+	model "go-common/app/interface/main/creative/model/weeklyhonor"
+	"go-common/library/log"
+	"go-common/library/xstr"
+)
+
+const (
+	_honorLogsSQL       = `SELECT id,mid,hid,count,ctime,mtime FROM weeklyhonor WHERE mid=?`
+	_honorLatestLogsSQL = `SELECT id,mid,hid,mtime FROM weeklyhonor WHERE mid in (%s) and mtime >= ?`
+	_honorClicksSQL     = `SELECT mid,count FROM weeklyhonor_click WHERE mid in (%s) and mtime >= ?`
+	_upsertCountSQL     = `INSERT INTO weeklyhonor (mid,hid,count) VALUES (?,?,?) ON DUPLICATE KEY UPDATE count=count+1`
+)
+
+// pingMySQL check mysql connection.
+func (d *Dao) pingMySQL(c context.Context) error {
+	return d.db.Ping(c)
+}
+
+// HonorLogs .
+func (d *Dao) HonorLogs(c context.Context, mid int64) (hls map[int]*model.HonorLog, err error) {
+	rows, err := d.db.Query(c, _honorLogsSQL, mid)
+	if err != nil {
+		log.Error("d.db.Query(%s,%d) error(%v)", _honorLogsSQL, mid, err)
+		return
+	}
+	defer rows.Close()
+	hls = make(map[int]*model.HonorLog)
+	for rows.Next() {
+		h := new(model.HonorLog)
+		if err = rows.Scan(&h.ID, &h.MID, &h.HID, &h.Count, &h.CTime, &h.MTime); err != nil {
+			log.Error("rows.Scan error(%v)", err)
+			return
+		}
+		hls[h.HID] = h
+	}
+	err = rows.Err()
+	return
+}
+
+// LatestHonorLogs list latest honor logs by mids
+func (d *Dao) LatestHonorLogs(c context.Context, mids []int64) (hls []*model.HonorLog, err error) {
+	latestSun := model.LatestSunday()
+	midsStr := xstr.JoinInts(mids)
+	if midsStr == "" {
+		return
+	}
+	sql := fmt.Sprintf(_honorLatestLogsSQL, midsStr)
+	rows, err := d.db.Query(c, sql, latestSun)
+	if err != nil {
+		log.Error("d.db.Query(%s,%q,%v) error(%v)", _honorLatestLogsSQL, mids, latestSun, err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		h := new(model.HonorLog)
+		if err = rows.Scan(&h.ID, &h.MID, &h.HID, &h.MTime); err != nil {
+			log.Error("rows.Scan error(%v)", err)
+			return
+		}
+		hls = append(hls, h)
+	}
+	err = rows.Err()
+	return
+}
+
+// UpsertCount .
+func (d *Dao) UpsertCount(c context.Context, mid int64, hid int) (affected int64, err error) {
+	res, err := d.db.Exec(c, _upsertCountSQL, mid, hid, 1)
+	if err != nil {
+		log.Error("d.db.Exec(%s,%d,%d,%d) error(%v)", _upsertCountSQL, mid, hid, 1, err)
+		return
+	}
+	return res.RowsAffected()
+}
+
+// ClickCounts  honor click count map
+func (d *Dao) ClickCounts(c context.Context, mids []int64) (res map[int64]int32, err error) {
+	res = make(map[int64]int32)
+	twoWeekAgo := model.LatestSunday().AddDate(0, 0, -14)
+	midsStr := xstr.JoinInts(mids)
+	if midsStr == "" {
+		return
+	}
+	sql := fmt.Sprintf(_honorClicksSQL, midsStr)
+	rows, err := d.db.Query(c, sql, twoWeekAgo)
+	if err != nil {
+		log.Error("d.db.Query(%s,%v) error(%v)", sql, twoWeekAgo, err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		var mid, count int64
+		if err = rows.Scan(&mid, &count); err != nil {
+			log.Error("rows.Scan error(%v)", err)
+			return
+		}
+		if count > 0 {
+			res[mid] = int32(count)
+		}
+	}
+	return
+}

app/job/main/creative/dao/weeklyhonor/mysql_test.go

@@ -0,0 +1,85 @@
+package weeklyhonor
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestWeeklyhonorpingMySQL(t *testing.T) {
+	convey.Convey("pingMySQL", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			err := d.pingMySQL(c)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestWeeklyhonorHonorLogs(t *testing.T) {
+	convey.Convey("HonorLogs", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			mid = int64(2)
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			_, err := d.HonorLogs(c, mid)
+			ctx.Convey("Then err should be nil.hls should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestWeeklyhonorLatestHonorLogs(t *testing.T) {
+	convey.Convey("LatestHonorLogs", t, func(ctx convey.C) {
+		var (
+			c    = context.Background()
+			mids = []int64{1}
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			_, err := d.LatestHonorLogs(c, mids)
+			ctx.Convey("Then err should be nil.hls should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestWeeklyhonorUpsertCount(t *testing.T) {
+	convey.Convey("UpsertCount", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			mid = int64(0)
+			hid = int(0)
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			affected, err := d.UpsertCount(c, mid, hid)
+			ctx.Convey("Then err should be nil.affected should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(affected, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestWeeklyhonorClickCounts(t *testing.T) {
+	convey.Convey("ClickCounts", t, func(ctx convey.C) {
+		var (
+			c    = context.Background()
+			mids = []int64{1}
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			res, err := d.ClickCounts(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/job/main/creative/dao/weeklyhonor/rpc.go

@@ -0,0 +1,53 @@
+package weeklyhonor
+
+import (
+	"context"
+
+	"go-common/app/service/main/archive/model/archive"
+	upgrpc "go-common/app/service/main/up/api/v1"
+	"go-common/library/ecode"
+	"go-common/library/log"
+)
+
+const fromWeeklyHonor = 1
+
+// UpCount get archives count.
+func (d *Dao) UpCount(c context.Context, mid int64) (count int, err error) {
+	var arg = &archive.ArgUpCount2{Mid: mid}
+	if count, err = d.arc.UpCount2(c, arg); err != nil {
+		log.Error("rpc UpCount2 (%v) error(%v)", mid, err)
+		err = ecode.CreativeArcServiceErr
+	}
+	return
+}
+
+// UpActivesList list up-actives
+func (d *Dao) UpActivesList(c context.Context, lastID int64, ps int) (upActives []*upgrpc.UpActivity, newid int64, err error) {
+	upListReq := upgrpc.UpListByLastIDReq{
+		LastID: lastID,
+		Ps:     ps,
+	}
+	reply, err := d.upClient.UpInfoActivitys(c, &upListReq)
+	if err != nil {
+		log.Error("failed to list up&active info,err(%v)", err)
+		return
+	}
+	newid = reply.GetLastID()
+	upActives = reply.GetUpActivitys()
+	return
+}
+
+// GetUpSwitch get up switch state
+func (d *Dao) GetUpSwitch(c context.Context, mid int64) (state uint8, err error) {
+	req := upgrpc.UpSwitchReq{
+		Mid:  mid,
+		From: fromWeeklyHonor,
+	}
+	reply, err := d.upClient.UpSwitch(c, &req)
+	if err != nil {
+		log.Error("d.upClient.UpSwitch req(%+v),err(%v)", req, err)
+		return
+	}
+	state = reply.GetState()
+	return
+}

app/job/main/creative/dao/weeklyhonor/rpc_test.go

@@ -0,0 +1,96 @@
+package weeklyhonor
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	whmdl "go-common/app/interface/main/creative/model/weeklyhonor"
+	upgrpc "go-common/app/service/main/up/api/v1"
+
+	"github.com/golang/mock/gomock"
+	"github.com/smartystreets/goconvey/convey"
+)
+
+var c = context.Background()
+
+func TestWeeklyhonorUpCount(t *testing.T) {
+	convey.Convey("UpCount", t, func(ctx convey.C) {
+		var (
+			mid = int64(1627855)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			count, err := d.UpCount(c, mid)
+			ctx.Convey("Then err should be nil.count should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(count, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestWeeklyhonorUpActiveLists(t *testing.T) {
+	convey.Convey("UpActivesList", t, func(ctx convey.C) {
+		ctx.Convey("When everything gose positive", WithMock(t, func(mockCtrl *gomock.Controller) {
+			// mock
+			mockUpClient := upgrpc.NewMockUpClient(mockCtrl)
+			d.upClient = mockUpClient
+			mockReq := upgrpc.UpListByLastIDReq{
+				LastID: 0,
+				Ps:     100,
+			}
+			mockReply := upgrpc.UpActivityListReply{
+				UpActivitys: []*upgrpc.UpActivity{
+					{Mid: 1},
+					{Activity: 2},
+				},
+				LastID: 1,
+			}
+			mockUpClient.EXPECT().UpInfoActivitys(gomock.Any(), &mockReq).Return(&mockReply, nil)
+			// test
+			upActives, newId, err := d.UpActivesList(c, 0, 100)
+			ctx.Convey("Then err should be nil.count should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(upActives[0], convey.ShouldEqual, mockReply.UpActivitys[0])
+				ctx.So(newId, convey.ShouldEqual, mockReply.LastID)
+			})
+		}))
+	})
+}
+
+func TestWeeklyhonorGetUpSwitch(t *testing.T) {
+	convey.Convey("GetUpSwitch", t, WithMock(t, func(mockCtrl *gomock.Controller) {
+		var (
+			c   = context.Background()
+			mid = int64(75379101)
+		)
+		convey.Convey("When everything gose positive", func(ctx convey.C) {
+			mockUpClient := upgrpc.NewMockUpClient(mockCtrl)
+			d.upClient = mockUpClient
+			mockReq := upgrpc.UpSwitchReq{
+				Mid:  mid,
+				From: fromWeeklyHonor,
+			}
+			mockState := whmdl.HonorUnSub
+			mockUpClient.EXPECT().UpSwitch(gomock.Any(), &mockReq).Return(&upgrpc.UpSwitchReply{State: mockState}, nil)
+			state, err := d.GetUpSwitch(c, mid)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(state, convey.ShouldEqual, mockState)
+			})
+		})
+		convey.Convey("When return err", func(ctx convey.C) {
+			mockUpClient := upgrpc.NewMockUpClient(mockCtrl)
+			d.upClient = mockUpClient
+			mockReq := upgrpc.UpSwitchReq{
+				Mid:  mid,
+				From: fromWeeklyHonor,
+			}
+			mockUpClient.EXPECT().UpSwitch(gomock.Any(), &mockReq).Return(nil, fmt.Errorf("mock err"))
+			_, err := d.GetUpSwitch(c, mid)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldNotBeNil)
+			})
+		})
+	}))
+}