Create & Init Project...

app/job/main/mcn/dao/BUILD

@@ -0,0 +1,66 @@
+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",
+        "email.go",
+        "mcn.go",
+        "memcache.go",
+        "recommend.go",
+    ],
+    importpath = "go-common/app/job/main/mcn/dao",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/job/main/mcn/conf:go_default_library",
+        "//app/job/main/mcn/model:go_default_library",
+        "//library/cache/memcache:go_default_library",
+        "//library/database/sql:go_default_library",
+        "//library/log:go_default_library",
+        "//library/time:go_default_library",
+        "//library/xstr:go_default_library",
+        "//vendor/github.com/pkg/errors:go_default_library",
+        "//vendor/gopkg.in/gomail.v2: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",
+        "email_test.go",
+        "mcn_test.go",
+        "memcache_test.go",
+        "recommend_test.go",
+    ],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/job/main/mcn/conf:go_default_library",
+        "//app/job/main/mcn/model:go_default_library",
+        "//library/time:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)

app/job/main/mcn/dao/dao.go

@@ -0,0 +1,47 @@
+package dao
+
+import (
+	"context"
+	"crypto/tls"
+
+	"go-common/app/job/main/mcn/conf"
+	"go-common/library/cache/memcache"
+	xsql "go-common/library/database/sql"
+
+	gomail "gopkg.in/gomail.v2"
+)
+
+// Dao dao
+type Dao struct {
+	c     *conf.Config
+	mc    *memcache.Pool
+	db    *xsql.DB
+	email *gomail.Dialer
+}
+
+// New init mysql db
+func New(c *conf.Config) (dao *Dao) {
+	dao = &Dao{
+		c:  c,
+		mc: memcache.NewPool(c.Memcache),
+		db: xsql.NewMySQL(c.MySQL),
+		// mail
+		email: gomail.NewDialer(c.MailConf.Host, c.MailConf.Port, c.MailConf.Username, c.MailConf.Password),
+	}
+	dao.email.TLSConfig = &tls.Config{
+		InsecureSkipVerify: true,
+	}
+	return
+}
+
+// Close close the resource.
+func (d *Dao) Close() {
+	d.mc.Close()
+	d.db.Close()
+}
+
+// Ping dao ping
+func (d *Dao) Ping(c context.Context) error {
+	// TODO: if you need use mc,redis, please add
+	return d.db.Ping(c)
+}

app/job/main/mcn/dao/dao_test.go

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

app/job/main/mcn/dao/email.go

@@ -0,0 +1,40 @@
+package dao
+
+import (
+	"os"
+
+	"go-common/app/job/main/mcn/conf"
+	"go-common/library/log"
+
+	"gopkg.in/gomail.v2"
+)
+
+// SendMail send the email.
+func (d *Dao) SendMail(body string, subject string, send []string) (err error) {
+	log.Info("send mail send:%v", send)
+	msg := gomail.NewMessage()
+	msg.SetHeader("From", conf.Conf.MailConf.Username)
+	msg.SetHeader("To", send...)
+	msg.SetHeader("Subject", subject)
+	msg.SetBody("text/html", body, gomail.SetPartEncoding(gomail.Base64))
+	if err = d.email.DialAndSend(msg); err != nil {
+		log.Error("s.email.DialAndSend error(%v)", err)
+		return
+	}
+	return
+}
+
+// SendMailAttach send the email.
+func (d *Dao) SendMailAttach(filename string, subject string, send []string) (err error) {
+	msg := gomail.NewMessage()
+	msg.SetHeader("From", conf.Conf.MailConf.Username)
+	msg.SetHeader("To", send...)
+	msg.SetHeader("Subject", subject)
+	msg.Attach(filename)
+	if err = d.email.DialAndSend(msg); err != nil {
+		log.Error("s.email.DialAndSend error(%v)", err)
+		return
+	}
+	err = os.Remove(filename)
+	return
+}

app/job/main/mcn/dao/email_test.go

@@ -0,0 +1,39 @@
+package dao
+
+import (
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaoSendMail(t *testing.T) {
+	convey.Convey("SendMail", t, func(ctx convey.C) {
+		var (
+			body    = ""
+			subject = ""
+			send    = []string{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.SendMail(body, subject, send)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoSendMailAttach(t *testing.T) {
+	convey.Convey("SendMailAttach", t, func(ctx convey.C) {
+		var (
+			filename = ""
+			subject  = ""
+			send     = []string{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.SendMailAttach(filename, subject, send)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}

app/job/main/mcn/dao/mcn.go

@@ -0,0 +1,318 @@
+package dao
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"time"
+
+	"go-common/app/job/main/mcn/model"
+	xsql "go-common/library/database/sql"
+	xtime "go-common/library/time"
+	"go-common/library/xstr"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_upMcnSignStateOPSQL       = "UPDATE mcn_sign SET state = ? WHERE id = ?"
+	_upMcnUpStateOPSQL         = "UPDATE mcn_up SET state = ?, state_change_time = ? WHERE id = ?"
+	_upMcnSignPayExpOPSQL      = "UPDATE mcn_sign SET pay_expire_state = 2 WHERE id = ?"
+	_upMcnSignEmailStateSQL    = "UPDATE mcn_sign SET email_state = 2 WHERE id IN (%s)"
+	_upMcnSignPayEmailStateSQL = "UPDATE mcn_sign_pay SET email_state = 2 WHERE id IN (%s)"
+	_inMcnDataSummarySQL       = "INSERT mcn_data_summary(mcn_mid,sign_id,up_count,fans_count_accumulate,generate_date,data_type) VALUES (?,?,?,?,?,1)"
+	_selMcnSignsSQL            = `SELECT id,begin_date,end_date,state FROM mcn_sign`
+	_selMcnUpsSQL              = `SELECT id,begin_date,end_date,state FROM mcn_up LIMIT ?,?`
+	_selMcnSignPayWarnsSQL     = `SELECT p.sign_id,p.due_date,p.pay_value FROM mcn_sign_pay p INNER JOIN mcn_sign s ON p.sign_id = s.id WHERE p.state = 0 AND 
+	s.state = 10 AND s.end_date >= ? AND s.begin_date <= p.due_date AND p.due_date <= s.end_date AND date_sub(p.due_date,interval 7 day) <= ?`
+	_selMcnSignMidsSQL  = "SELECT id,mcn_mid FROM mcn_sign WHERE state = 10"
+	_selMcnUPCountSQL   = "SELECT sign_id,count(up_mid) as count FROM mcn_up WHERE sign_id IN (%s) AND state = 10 GROUP BY sign_id"
+	_selMcnUPMidsSQL    = "SELECT sign_id,up_mid FROM mcn_up WHERE sign_id IN (%s) AND state = 10"
+	_selCrmUpMidsSumSQL = "SELECT SUM(fans_count) as count FROM up_base_info WHERE mid IN (%s)"
+	_selMcnSignPayDues  = `SELECT p.id, p.mcn_mid, p.sign_id, p.due_date, p.pay_value FROM mcn_sign_pay p LEFT JOIN mcn_sign s ON p.sign_id = s.id 
+	WHERE p.due_date <= ? AND p.email_state = 1 AND p.state = 0 AND s.state = 10 AND s.end_date >= ?`
+	_selMcnSignDues = "SELECT id, mcn_mid, begin_date, end_date FROM mcn_sign WHERE end_date <= ? and end_date >= ? and email_state = 1"
+)
+
+// UpMcnSignStateOP .
+func (d *Dao) UpMcnSignStateOP(c context.Context, signID int64, state int8) (rows int64, err error) {
+	var res sql.Result
+	if res, err = d.db.Exec(c, _upMcnSignStateOPSQL, state, signID); err != nil {
+		return rows, err
+	}
+	return res.RowsAffected()
+}
+
+// UpMcnUpStateOP .
+func (d *Dao) UpMcnUpStateOP(c context.Context, signUpID int64, state int8) (rows int64, err error) {
+	var res sql.Result
+	if res, err = d.db.Exec(c, _upMcnUpStateOPSQL, state, time.Now(), signUpID); err != nil {
+		return rows, err
+	}
+	return res.RowsAffected()
+}
+
+// UpMcnSignPayExpOP .
+func (d *Dao) UpMcnSignPayExpOP(c context.Context, signPayID int64) (rows int64, err error) {
+	var res sql.Result
+	if res, err = d.db.Exec(c, _upMcnSignPayExpOPSQL, signPayID); err != nil {
+		return rows, err
+	}
+	return res.RowsAffected()
+}
+
+// UpMcnSignPayEmailState .
+func (d *Dao) UpMcnSignPayEmailState(c context.Context, ids []int64) (rows int64, err error) {
+	var res sql.Result
+	if res, err = d.db.Exec(c, fmt.Sprintf(_upMcnSignPayEmailStateSQL, xstr.JoinInts(ids))); err != nil {
+		return rows, err
+	}
+	return res.RowsAffected()
+}
+
+// UpMcnSignEmailState .
+func (d *Dao) UpMcnSignEmailState(c context.Context, ids []int64) (rows int64, err error) {
+	var res sql.Result
+	if res, err = d.db.Exec(c, fmt.Sprintf(_upMcnSignEmailStateSQL, xstr.JoinInts(ids))); err != nil {
+		return rows, err
+	}
+	return res.RowsAffected()
+}
+
+// AddMcnDataSummary .
+func (d *Dao) AddMcnDataSummary(c context.Context, mcnMid, signID, upCount, fansCountAccumulate int64, genDate xtime.Time) (err error) {
+	_, err = d.db.Exec(c, _inMcnDataSummarySQL, mcnMid, signID, upCount, fansCountAccumulate, genDate)
+	return
+}
+
+// McnSigns .
+func (d *Dao) McnSigns(c context.Context) (mss []*model.MCNSignInfo, err error) {
+	var rows *xsql.Rows
+	if rows, err = d.db.Query(c, _selMcnSignsSQL); err != nil {
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		ms := new(model.MCNSignInfo)
+		if err = rows.Scan(&ms.SignID, &ms.BeginDate, &ms.EndDate, &ms.State); err != nil {
+			if err == xsql.ErrNoRows {
+				err = nil
+				return
+			}
+			return
+		}
+		mss = append(mss, ms)
+	}
+	err = rows.Err()
+	return
+}
+
+// McnUps .
+func (d *Dao) McnUps(c context.Context, offset, limit int64) (ups []*model.MCNUPInfo, err error) {
+	var rows *xsql.Rows
+	if rows, err = d.db.Query(c, _selMcnUpsSQL, offset, limit); err != nil {
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		up := new(model.MCNUPInfo)
+		if err = rows.Scan(&up.SignUpID, &up.BeginDate, &up.EndDate, &up.State); err != nil {
+			if err == xsql.ErrNoRows {
+				err = nil
+				return
+			}
+			return
+		}
+		ups = append(ups, up)
+	}
+	err = rows.Err()
+	return
+}
+
+// McnSignPayWarns .
+func (d *Dao) McnSignPayWarns(c context.Context) (sps []*model.SignPayInfo, err error) {
+	var (
+		rows     *xsql.Rows
+		now      time.Time
+		template = time.Now().Format(model.TimeFormatDay)
+	)
+	if now, err = time.ParseInLocation(model.TimeFormatDay, template, time.Local); err != nil {
+		err = errors.Errorf("time.ParseInLocation(%s) error(%+v)", template, err)
+		return
+	}
+	if rows, err = d.db.Query(c, _selMcnSignPayWarnsSQL, now, now); err != nil {
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		sp := new(model.SignPayInfo)
+		if err = rows.Scan(&sp.SignID, &sp.DueDate, &sp.PayValue); err != nil {
+			if err == xsql.ErrNoRows {
+				err = nil
+				return
+			}
+			return
+		}
+		sps = append(sps, sp)
+	}
+	err = rows.Err()
+	return
+}
+
+// McnSignMids .
+func (d *Dao) McnSignMids(c context.Context) (msid map[int64]int64, sids []int64, err error) {
+	var rows *xsql.Rows
+	if rows, err = d.db.Query(c, _selMcnSignMidsSQL); err != nil {
+		return
+	}
+	defer rows.Close()
+	msid = make(map[int64]int64)
+	for rows.Next() {
+		var signID, mcnMid int64
+		if err = rows.Scan(&signID, &mcnMid); err != nil {
+			if err == xsql.ErrNoRows {
+				err = nil
+				return
+			}
+			return
+		}
+		msid[signID] = mcnMid
+		sids = append(sids, signID)
+	}
+	err = rows.Err()
+	return
+}
+
+// McnUPCount .
+func (d *Dao) McnUPCount(c context.Context, signIDs []int64) (mmc map[int64]int64, err error) {
+	var rows *xsql.Rows
+	if rows, err = d.db.Query(c, fmt.Sprintf(_selMcnUPCountSQL, xstr.JoinInts(signIDs))); err != nil {
+		return
+	}
+	defer rows.Close()
+	mmc = make(map[int64]int64)
+	for rows.Next() {
+		var signID, count int64
+		if err = rows.Scan(&signID, &count); err != nil {
+			if err == xsql.ErrNoRows {
+				err = nil
+				return
+			}
+			return
+		}
+		mmc[signID] = count
+	}
+	err = rows.Err()
+	return
+}
+
+// McnUPMids .
+func (d *Dao) McnUPMids(c context.Context, signIDs []int64) (mup map[int64][]int64, err error) {
+	var rows *xsql.Rows
+	if rows, err = d.db.Query(c, fmt.Sprintf(_selMcnUPMidsSQL, xstr.JoinInts(signIDs))); err != nil {
+		return
+	}
+	defer rows.Close()
+	mup = make(map[int64][]int64)
+	for rows.Next() {
+		var signID, upMid int64
+		if err = rows.Scan(&signID, &upMid); err != nil {
+			if err == xsql.ErrNoRows {
+				err = nil
+				return
+			}
+			return
+		}
+		mup[signID] = append(mup[signID], upMid)
+	}
+	err = rows.Err()
+	return
+}
+
+// CrmUpMidsSum .
+func (d *Dao) CrmUpMidsSum(c context.Context, upMids []int64) (count int64, err error) {
+	row := d.db.QueryRow(c, fmt.Sprintf(_selCrmUpMidsSumSQL, xstr.JoinInts(upMids)))
+	var countNull sql.NullInt64
+	if err = row.Scan(&countNull); err != nil {
+		if err == sql.ErrNoRows {
+			err = nil
+			return
+		}
+	}
+	count = countNull.Int64
+	return
+}
+
+// McnSignPayDues .
+func (d *Dao) McnSignPayDues(c context.Context) (sps []*model.SignPayInfo, err error) {
+	var (
+		rows     *xsql.Rows
+		now, future   time.Time
+		nowDate        = time.Now()
+		date     = nowDate.AddDate(0, 0, 7)
+		template = date.Format(model.TimeFormatDay)
+		nowTemplate    = nowDate.Format(model.TimeFormatDay)
+	)
+	if now, err = time.ParseInLocation(model.TimeFormatDay, nowTemplate, time.Local); err != nil {
+		err = errors.Errorf("time.ParseInLocation(%s) now error(%+v)", nowTemplate, err)
+		return
+	}
+	if future, err = time.ParseInLocation(model.TimeFormatDay, template, time.Local); err != nil {
+		err = errors.Errorf("time.ParseInLocation(%s) error(%+v)", template, err)
+		return
+	}
+	if rows, err = d.db.Query(c, _selMcnSignPayDues, future, now); err != nil {
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		sp := new(model.SignPayInfo)
+		if err = rows.Scan(&sp.SignPayID, &sp.McnMid, &sp.SignID, &sp.DueDate, &sp.PayValue); err != nil {
+			if err == xsql.ErrNoRows {
+				err = nil
+				return
+			}
+			return
+		}
+		sps = append(sps, sp)
+	}
+	err = rows.Err()
+	return
+}
+
+// McnSignDues .
+func (d *Dao) McnSignDues(c context.Context) (mss []*model.MCNSignInfo, err error) {
+	var (
+		rows           *xsql.Rows
+		now, future    time.Time
+		nowDate        = time.Now()
+		nowTemplate    = nowDate.Format(model.TimeFormatDay)
+		futureDate     = nowDate.AddDate(0, 0, 30)
+		futureTemplate = futureDate.Format(model.TimeFormatDay)
+	)
+	if now, err = time.ParseInLocation(model.TimeFormatDay, nowTemplate, time.Local); err != nil {
+		err = errors.Errorf("time.ParseInLocation(%s) now error(%+v)", nowTemplate, err)
+		return
+	}
+	if future, err = time.ParseInLocation(model.TimeFormatDay, futureTemplate, time.Local); err != nil {
+		err = errors.Errorf("time.ParseInLocation(%s) future error(%+v)", futureTemplate, err)
+		return
+	}
+	if rows, err = d.db.Query(c, _selMcnSignDues, future, now); err != nil {
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		ms := new(model.MCNSignInfo)
+		if err = rows.Scan(&ms.SignID, &ms.McnMid, &ms.BeginDate, &ms.EndDate); err != nil {
+			if err == xsql.ErrNoRows {
+				err = nil
+				return
+			}
+			return
+		}
+		mss = append(mss, ms)
+	}
+	err = rows.Err()
+	return
+}

app/job/main/mcn/dao/mcn_test.go

@@ -0,0 +1,194 @@
+package dao
+
+import (
+	"context"
+	"testing"
+
+	xtime "go-common/library/time"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaoUpMcnSignStateOP(t *testing.T) {
+	convey.Convey("UpMcnSignStateOP", t, func(ctx convey.C) {
+		var (
+			c      = context.Background()
+			signID = int64(0)
+			state  = int8(0)
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			rows, err := d.UpMcnSignStateOP(c, signID, state)
+			ctx.Convey("Then err should be nil.rows should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(rows, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoUpMcnUpStateOP(t *testing.T) {
+	convey.Convey("UpMcnUpStateOP", t, func(ctx convey.C) {
+		var (
+			c        = context.Background()
+			signUpID = int64(0)
+			state    = int8(0)
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			rows, err := d.UpMcnUpStateOP(c, signUpID, state)
+			ctx.Convey("Then err should be nil.rows should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(rows, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoUpMcnSignPayExpOP(t *testing.T) {
+	convey.Convey("UpMcnSignPayExpOP", t, func(ctx convey.C) {
+		var (
+			c         = context.Background()
+			signPayID = int64(0)
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			rows, err := d.UpMcnSignPayExpOP(c, signPayID)
+			ctx.Convey("Then err should be nil.rows should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(rows, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoAddMcnDataSummary(t *testing.T) {
+	convey.Convey("AddMcnDataSummary", t, func(ctx convey.C) {
+		var (
+			c                   = context.Background()
+			mcnMid              = int64(0)
+			signID              = int64(1)
+			upCount             = int64(0)
+			fansCountAccumulate = int64(0)
+			genDate             xtime.Time
+		)
+		var _, err = d.db.Exec(c, "delete from mcn_data_summary where sign_id=? and generate_date='1970-01-01'", signID)
+		if err != nil {
+			t.Logf("err=%v", err)
+		}
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			err := d.AddMcnDataSummary(c, mcnMid, signID, upCount, fansCountAccumulate, genDate)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoMcnSigns(t *testing.T) {
+	convey.Convey("McnSigns", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			mss, err := d.McnSigns(c)
+			ctx.Convey("Then err should be nil.mss should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(mss, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoMcnUps(t *testing.T) {
+	convey.Convey("McnUps", t, func(ctx convey.C) {
+		var (
+			c      = context.Background()
+			offset = int64(0)
+			limit  = int64(1)
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			ups, err := d.McnUps(c, offset, limit)
+			ctx.Convey("Then err should be nil.ups should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(len(ups), convey.ShouldBeGreaterThanOrEqualTo,0)
+			})
+		})
+	})
+}
+
+func TestDaoMcnSignPays(t *testing.T) {
+	convey.Convey("McnSignPays", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			sps, err := d.McnSignPayWarns(c)
+			ctx.Convey("Then err should be nil.sps should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(len(sps), convey.ShouldBeGreaterThanOrEqualTo, 0)
+			})
+		})
+	})
+}
+
+func TestDaoMcnSignMids(t *testing.T) {
+	convey.Convey("McnSignMids", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			msid, sids, err := d.McnSignMids(c)
+			ctx.Convey("Then err should be nil.msid,sids should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(sids, convey.ShouldNotBeNil)
+				ctx.So(msid, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoMcnUPCount(t *testing.T) {
+	convey.Convey("McnUPCount", t, func(ctx convey.C) {
+		var (
+			c       = context.Background()
+			signIDs = []int64{0}
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			mmc, err := d.McnUPCount(c, signIDs)
+			ctx.Convey("Then err should be nil.mmc should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(mmc, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoMcnUPMids(t *testing.T) {
+	convey.Convey("McnUPMids", t, func(ctx convey.C) {
+		var (
+			c       = context.Background()
+			signIDs = []int64{0}
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			mup, err := d.McnUPMids(c, signIDs)
+			ctx.Convey("Then err should be nil.mup should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(mup, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoCrmUpMidsSum(t *testing.T) {
+	convey.Convey("CrmUpMidsSum", t, func(ctx convey.C) {
+		var (
+			c      = context.Background()
+			upMids = []int64{0}
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			count, err := d.CrmUpMidsSum(c, upMids)
+			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)
+			})
+		})
+	})
+}

app/job/main/mcn/dao/memcache.go

@@ -0,0 +1,32 @@
+package dao
+
+import (
+	"context"
+	"strconv"
+
+	gmc "go-common/library/cache/memcache"
+	"go-common/library/log"
+)
+
+const (
+	_mcnSign = "mcn_s_"
+)
+
+// user mcn sign key.
+func mcnSignKey(mcnMid int64) string {
+	return _mcnSign + strconv.FormatInt(mcnMid, 10)
+}
+
+// DelMcnSignCache del mcn sign cache info.
+func (d *Dao) DelMcnSignCache(c context.Context, mcnMid int64) (err error) {
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	if err = conn.Delete(mcnSignKey(mcnMid)); err != nil {
+		if err == gmc.ErrNotFound {
+			err = nil
+			return
+		}
+		log.Error("conn.Delete(%d) error(%v)", mcnMid, err)
+	}
+	return
+}

app/job/main/mcn/dao/memcache_test.go

@@ -0,0 +1,37 @@
+package dao
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaomcnSignKey(t *testing.T) {
+	convey.Convey("mcnSignKey", t, func(ctx convey.C) {
+		var (
+			mcnMid = int64(0)
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			p1 := mcnSignKey(mcnMid)
+			ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(p1, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoDelMcnSignCache(t *testing.T) {
+	convey.Convey("DelMcnSignCache", t, func(ctx convey.C) {
+		var (
+			c      = context.Background()
+			mcnMid = int64(0)
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			err := d.DelMcnSignCache(c, mcnMid)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}

app/job/main/mcn/dao/recommend.go

@@ -0,0 +1,68 @@
+package dao
+
+import (
+	"context"
+	"database/sql"
+	"time"
+
+	"go-common/app/job/main/mcn/model"
+	xsql "go-common/library/database/sql"
+)
+
+const (
+	_inMcnUpRecommendPoolSQL = `INSERT INTO mcn_up_recommend_pool (up_mid, fans_count, fans_count_increase_month, archive_count, play_count_accumulate, play_count_average, active_tid, last_archive_time, generate_time) VALUES (?,?,?,?,?,?,?,?,?) 
+ON DUPLICATE KEY UPDATE fans_count=?, fans_count_increase_month=?, archive_count=?, play_count_accumulate=?, play_count_average=?, active_tid=?, last_archive_time=?, generate_time=?`
+	_delMcnUpRecommendPoolSQL    = "UPDATE mcn_up_recommend_pool SET state = 100  WHERE generate_time < ? AND state IN (1,2) AND source = 1"
+	_delMcnUpRecommendSourceSQL  = "DELETE FROM mcn_up_recommend_source WHERE id = ?"
+	_selMcnUpRecommendSourcesSQL = "SELECT id,up_mid,fans_count,fans_count_increase_month,archive_count,play_count_accumulate,play_count_average,active_tid,last_archive_time,ctime,mtime FROM mcn_up_recommend_source LIMIT ?"
+)
+
+// AddMcnUpRecommend .
+func (d *Dao) AddMcnUpRecommend(c context.Context, arg *model.McnUpRecommendPool) (rows int64, err error) {
+	var res sql.Result
+	if res, err = d.db.Exec(c, _inMcnUpRecommendPoolSQL, arg.UpMid, arg.FansCount, arg.FansCountIncreaseMonth, arg.ArchiveCount, arg.PlayCountAccumulate, arg.PlayCountAverage, arg.ActiveTid, arg.LastArchiveTime, arg.GenerateTime,
+		arg.FansCount, arg.FansCountIncreaseMonth, arg.ArchiveCount, arg.PlayCountAccumulate, arg.PlayCountAverage, arg.ActiveTid, arg.LastArchiveTime, arg.GenerateTime); err != nil {
+		return rows, err
+	}
+	return res.RowsAffected()
+}
+
+// DelMcnUpRecommendPool .
+func (d *Dao) DelMcnUpRecommendPool(c context.Context) (rows int64, err error) {
+	var res sql.Result
+	if res, err = d.db.Exec(c, _delMcnUpRecommendPoolSQL, time.Now().AddDate(0, 0, -3)); err != nil {
+		return rows, err
+	}
+	return res.RowsAffected()
+}
+
+// DelMcnUpRecommendSource .
+func (d *Dao) DelMcnUpRecommendSource(c context.Context, id int64) (rows int64, err error) {
+	var res sql.Result
+	if res, err = d.db.Exec(c, _delMcnUpRecommendSourceSQL, id); err != nil {
+		return rows, err
+	}
+	return res.RowsAffected()
+}
+
+// McnUpRecommendSources .
+func (d *Dao) McnUpRecommendSources(c context.Context, limit int) (rps []*model.McnUpRecommendPool, err error) {
+	var rows *xsql.Rows
+	if rows, err = d.db.Query(c, _selMcnUpRecommendSourcesSQL, limit); err != nil {
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		rp := new(model.McnUpRecommendPool)
+		if err = rows.Scan(&rp.ID, &rp.UpMid, &rp.FansCount, &rp.FansCountIncreaseMonth, &rp.ArchiveCount, &rp.PlayCountAccumulate, &rp.PlayCountAverage, &rp.ActiveTid, &rp.LastArchiveTime, &rp.Ctime, &rp.Mtime); err != nil {
+			if err == xsql.ErrNoRows {
+				err = nil
+				return
+			}
+			return
+		}
+		rps = append(rps, rp)
+	}
+	err = rows.Err()
+	return
+}

app/job/main/mcn/dao/recommend_test.go

@@ -0,0 +1,73 @@
+package dao
+
+import (
+	"context"
+	"testing"
+
+	"go-common/app/job/main/mcn/model"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaoAddMcnUpRecommend(t *testing.T) {
+	convey.Convey("AddMcnUpRecommend", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			arg = &model.McnUpRecommendPool{}
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			rows, err := d.AddMcnUpRecommend(c, arg)
+			ctx.Convey("Then err should be nil.rows should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(rows, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoDelMcnUpRecommendPool(t *testing.T) {
+	convey.Convey("DelMcnUpRecommendPool", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			rows, err := d.DelMcnUpRecommendPool(c)
+			ctx.Convey("Then err should be nil.rows should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(rows, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoDelMcnUpRecommendSource(t *testing.T) {
+	convey.Convey("DelMcnUpRecommendSource", t, func(ctx convey.C) {
+		var (
+			c  = context.Background()
+			id = int64(0)
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			rows, err := d.DelMcnUpRecommendSource(c, id)
+			ctx.Convey("Then err should be nil.rows should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(rows, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoMcnUpRecommendSources(t *testing.T) {
+	convey.Convey("McnUpRecommendSources", t, func(ctx convey.C) {
+		var (
+			c     = context.Background()
+			limit = 100
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			rps, err := d.McnUpRecommendSources(c, limit)
+			ctx.Convey("Then err should be nil.rps should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(len(rps), convey.ShouldBeGreaterThanOrEqualTo, 0)
+			})
+		})
+	})
+}