Create & Init Project...

app/interface/main/creative/dao/template/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 = [
+        "dao.go",
+        "memcache.go",
+        "template.go",
+    ],
+    importpath = "go-common/app/interface/main/creative/dao/template",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/creative/conf:go_default_library",
+        "//app/interface/main/creative/model/template:go_default_library",
+        "//library/cache/memcache:go_default_library",
+        "//library/database/sql: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"],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "dao_test.go",
+        "memcache_test.go",
+        "template_test.go",
+    ],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/creative/conf:go_default_library",
+        "//app/interface/main/creative/model/template:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)

app/interface/main/creative/dao/template/dao.go

@@ -0,0 +1,89 @@
+package template
+
+import (
+	"context"
+	"go-common/app/interface/main/creative/conf"
+	"go-common/library/cache/memcache"
+	"go-common/library/database/sql"
+	"go-common/library/log"
+	"time"
+)
+
+// Dao is archive dao.
+type Dao struct {
+	// config
+	c *conf.Config
+	// db
+	db *sql.DB
+	// insert
+	addTplStmt *sql.Stmt
+	// update
+	upTplStmt  *sql.Stmt
+	delTplStmt *sql.Stmt
+	// select
+	getTplStmt      *sql.Stmt
+	getMutilTplStmt *sql.Stmt
+	getCntStmt      *sql.Stmt
+	// mc
+	mc       *memcache.Pool
+	mcExpire int32
+	// chan
+	tplch chan func()
+}
+
+// New init api url
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		c:  c,
+		db: sql.NewMySQL(c.DB.Creative),
+		// memcache
+		mc:       memcache.NewPool(c.Memcache.Archive.Config),
+		mcExpire: int32(time.Duration(c.Memcache.Archive.TplExpire) / time.Second),
+		// chan
+		tplch: make(chan func(), 1024),
+	}
+	// insert
+	d.addTplStmt = d.db.Prepared(_addTplSQL)
+	// update
+	d.upTplStmt = d.db.Prepared(_upTplSQL)
+	d.delTplStmt = d.db.Prepared(_delTplSQL)
+	// select
+	d.getTplStmt = d.db.Prepared(_getTplSQL)
+	d.getMutilTplStmt = d.db.Prepared(_getMutilTplSQL)
+	d.getCntStmt = d.db.Prepared(_getCntSQL)
+	go d.cacheproc()
+	return
+}
+
+// Ping db
+func (d *Dao) Ping(c context.Context) (err error) {
+	if err = d.db.Ping(c); err != nil {
+		return
+	}
+	return d.db.Ping(c)
+}
+
+// Close db
+func (d *Dao) Close() (err error) {
+	if d.db != nil {
+		d.db.Close()
+	}
+	return d.db.Close()
+}
+
+// addCache add to chan for cache
+func (d *Dao) addCache(f func()) {
+	select {
+	case d.tplch <- f:
+	default:
+		log.Warn("template cacheproc chan full")
+	}
+}
+
+// cacheproc is a routine for execute closure.
+func (d *Dao) cacheproc() {
+	for {
+		f := <-d.tplch
+		f()
+	}
+}

app/interface/main/creative/dao/template/dao_test.go

@@ -0,0 +1,35 @@
+package template
+
+import (
+	"flag"
+	"go-common/app/interface/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")
+		flag.Set("conf_token", "96b6a6c10bb311e894c14a552f48fef8")
+		flag.Set("tree_id", "2305")
+		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.toml")
+	}
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	d = New(conf.Conf)
+	m.Run()
+	os.Exit(0)
+}

app/interface/main/creative/dao/template/memcache.go

@@ -0,0 +1,67 @@
+package template
+
+import (
+	"context"
+	"go-common/app/interface/main/creative/model/template"
+	"go-common/library/cache/memcache"
+	"go-common/library/log"
+	"strconv"
+)
+
+const (
+	_prefix = "tpl_"
+)
+
+func keyTpl(mid int64) string {
+	return _prefix + strconv.FormatInt(mid, 10)
+}
+
+// tplCache get tpl cache.
+func (d *Dao) tplCache(c context.Context, mid int64) (tps []*template.Template, err error) {
+	var (
+		conn = d.mc.Get(c)
+		r    *memcache.Item
+	)
+	defer conn.Close()
+	// get cache
+	r, err = conn.Get(keyTpl(mid))
+	if err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+		} else {
+			log.Error("memcache conn.Get2(%d) error(%v)", mid, err)
+		}
+		return
+	}
+	tps = []*template.Template{}
+	if err = conn.Scan(r, &tps); err != nil {
+		log.Error("tplCache json.Unmarshal(%s) error(%v)", r.Value, err)
+		tps = nil
+	}
+	return
+}
+
+// addTplCache add tpl cache.
+func (d *Dao) addTplCache(c context.Context, mid int64, tps []*template.Template) (err error) {
+	var (
+		key = keyTpl(mid)
+	)
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	if err = conn.Set(&memcache.Item{Key: key, Object: tps, Flags: memcache.FlagJSON, Expiration: d.mcExpire}); err != nil {
+		log.Error("tplCache memcache.Set(%v) error(%v)", key, err)
+	}
+
+	return
+}
+
+// delTplCache del tpl cache.
+func (d *Dao) delTplCache(c context.Context, mid int64) (err error) {
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	// del cache
+	if err = conn.Delete(keyTpl(mid)); err == memcache.ErrNotFound {
+		err = nil
+	}
+	return
+}

app/interface/main/creative/dao/template/memcache_test.go

@@ -0,0 +1,62 @@
+package template
+
+import (
+	"context"
+	"go-common/app/interface/main/creative/model/template"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestTemplatekeyTpl(t *testing.T) {
+	var (
+		mid = int64(2089809)
+	)
+	convey.Convey("keyTpl", t, func(ctx convey.C) {
+		p1 := keyTpl(mid)
+		ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+			ctx.So(p1, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestTemplatetplCache(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(2089809)
+	)
+	convey.Convey("tplCache", t, func(ctx convey.C) {
+		tps, err := d.tplCache(c, mid)
+		ctx.Convey("Then err should be nil.tps should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(tps, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestTemplateaddTplCache(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(2089809)
+		tps = []*template.Template{}
+	)
+	convey.Convey("addTplCache", t, func(ctx convey.C) {
+		err := d.addTplCache(c, mid, tps)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestTemplatedelTplCache(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(2089809)
+	)
+	convey.Convey("delTplCache", t, func(ctx convey.C) {
+		err := d.delTplCache(c, mid)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}

app/interface/main/creative/dao/template/template.go

@@ -0,0 +1,136 @@
+package template
+
+import (
+	"context"
+
+	"go-common/app/interface/main/creative/model/template"
+	"go-common/library/database/sql"
+	"go-common/library/log"
+)
+
+const (
+	// insert
+	_addTplSQL = "INSERT INTO archive_templates (mid,name,title,typeid,tag,copyright,content,state,ctime,mtime) VALUES (?,?,?,?,?,?,?,?,?,?)"
+	// update
+	_upTplSQL  = "UPDATE archive_templates SET name=?,title=?,typeid=?,tag=?,copyright=?,content=?,mtime=? WHERE id=? AND mid=?"
+	_delTplSQL = "UPDATE archive_templates SET state=?,mtime=? WHERE id=? AND mid=?"
+	// select
+	_getTplSQL      = "SELECT id,name,title,typeid,tag,copyright,content,state,ctime,mtime FROM archive_templates WHERE id=? AND mid=?"
+	_getMutilTplSQL = "SELECT id,name,title,typeid,tag,copyright,content FROM archive_templates WHERE mid=? AND state=0 ORDER BY ctime DESC"
+	_getCntSQL      = "SELECT count(id) FROM archive_templates WHERE mid = ? AND state = 0"
+)
+
+// templates get all Template from db.
+func (d *Dao) templates(c context.Context, mid int64) (tps []*template.Template, err error) {
+	tps = make([]*template.Template, 0)
+	rows, err := d.getMutilTplStmt.Query(c, mid)
+	if err != nil {
+		log.Error("mysqlDB.Query error(%v)", err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		t := &template.Template{}
+		if err = rows.Scan(&t.ID, &t.Name, &t.Title, &t.TypeID, &t.Tag, &t.Copyright, &t.Content); err != nil {
+			log.Error("row.Scan error(%v)", err)
+			return
+		}
+		tps = append(tps, t)
+	}
+	return
+}
+
+// Template get single template.
+func (d *Dao) Template(c context.Context, id, mid int64) (t *template.Template, err error) {
+	row := d.getTplStmt.QueryRow(c, id, mid)
+	t = &template.Template{}
+	if err = row.Scan(&t.ID, &t.Name, &t.Title, &t.TypeID, &t.Tag, &t.Copyright, &t.Content, &t.State, &t.CTime, &t.MTime); err != nil {
+		if err == sql.ErrNoRows {
+			t = nil
+			err = nil
+		} else {
+			log.Error("row.Scan error(%v)", err)
+		}
+	}
+	return
+}
+
+// Templates get all Template
+func (d *Dao) Templates(c context.Context, mid int64) (tps []*template.Template, err error) {
+	// try cache
+	if tps, _ = d.tplCache(c, mid); tps != nil {
+		return
+	}
+	// from db
+	if tps, err = d.templates(c, mid); tps != nil {
+		d.addCache(func() {
+			d.addTplCache(context.TODO(), mid, tps)
+		})
+	}
+	return
+}
+
+// AddTemplate add Template
+func (d *Dao) AddTemplate(c context.Context, mid int64, tp *template.Template) (id int64, err error) {
+	res, err := d.addTplStmt.Exec(c, mid, tp.Name, tp.Title, tp.TypeID, tp.Tag, tp.Copyright, tp.Content, tp.State, tp.CTime, tp.MTime)
+	if err != nil {
+		log.Error("d.AddTemplate.Exec(%+v) error(%v)", tp, err)
+		return
+	}
+	if id, err = res.LastInsertId(); err != nil {
+		log.Error("res.LastInsertId(%d) error(%v)", id, err)
+		return
+	}
+	d.addCache(func() {
+		d.delTplCache(context.TODO(), mid)
+	})
+	return
+}
+
+// UpTemplate update Template
+func (d *Dao) UpTemplate(c context.Context, mid int64, tp *template.Template) (rows int64, err error) {
+	res, err := d.upTplStmt.Exec(c, tp.Name, tp.Title, tp.TypeID, tp.Tag, tp.Copyright, tp.Content, tp.MTime, tp.ID, mid)
+	if err != nil {
+		log.Error("d.upTplStmt.Exec(%d, %d) error(%v)", mid, tp.ID, err)
+		return
+	}
+	if rows, err = res.RowsAffected(); err != nil {
+		log.Error("res.RowsAffected rows(%d) error(%v)", rows, err)
+		return
+	}
+	d.addCache(func() {
+		d.delTplCache(context.TODO(), mid)
+	})
+	return
+}
+
+// DelTemplate delete Template
+func (d *Dao) DelTemplate(c context.Context, mid int64, tp *template.Template) (rows int64, err error) {
+	res, err := d.delTplStmt.Exec(c, tp.State, tp.MTime, tp.ID, mid)
+	if err != nil {
+		log.Error("d.delTplStmt.Exec(%d ) error(%v)", mid, err)
+		return
+	}
+	if rows, err = res.RowsAffected(); err != nil {
+		log.Error("res.RowsAffected rows(%d) error(%v)", rows, err)
+		return
+	}
+	d.addCache(func() {
+		d.delTplCache(context.TODO(), mid)
+	})
+	return
+}
+
+// Count count all state Template
+func (d *Dao) Count(c context.Context, mid int64) (count int64, err error) {
+	row := d.getCntStmt.QueryRow(c, mid)
+	if err = row.Scan(&count); err != nil {
+		if err == sql.ErrNoRows {
+			err = nil
+			count = 0
+		} else {
+			log.Error("row.Scan error(%v)", err)
+		}
+	}
+	return
+}

app/interface/main/creative/dao/template/template_test.go

@@ -0,0 +1,111 @@
+package template
+
+import (
+	"context"
+	"go-common/app/interface/main/creative/model/template"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestTemplatetemplates(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(2089809)
+	)
+	convey.Convey("templates", t, func(ctx convey.C) {
+		tps, err := d.templates(c, mid)
+		ctx.Convey("Then err should be nil.tps should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(tps, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestTemplateTemplate(t *testing.T) {
+	var (
+		c   = context.TODO()
+		id  = int64(1)
+		mid = int64(2089809)
+	)
+	convey.Convey("Template", t, func(ctx convey.C) {
+		no, err := d.Template(c, id, mid)
+		ctx.Convey("Then err should be nil.no should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(no, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestTemplateTemplates(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(2089809)
+	)
+	convey.Convey("Templates", t, func(ctx convey.C) {
+		tps, err := d.Templates(c, mid)
+		ctx.Convey("Then err should be nil.tps should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(tps, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestTemplateAddTemplate(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(2089809)
+		tp  = &template.Template{}
+	)
+	convey.Convey("AddTemplate", t, func(ctx convey.C) {
+		id, err := d.AddTemplate(c, mid, tp)
+		ctx.Convey("Then err should be nil.id should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(id, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestTemplateUpTemplate(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(2089809)
+		tp  = &template.Template{}
+	)
+	convey.Convey("UpTemplate", t, func(ctx convey.C) {
+		rows, err := d.UpTemplate(c, mid, tp)
+		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 TestTemplateDelTemplate(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(2089809)
+		tp  = &template.Template{}
+	)
+	convey.Convey("DelTemplate", t, func(ctx convey.C) {
+		rows, err := d.DelTemplate(c, mid, tp)
+		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 TestTemplateCount(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(2089809)
+	)
+	convey.Convey("Count", t, func(ctx convey.C) {
+		count, err := d.Count(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)
+		})
+	})
+}