Initial commit

app/admin/main/vip/dao/BUILD

@@ -0,0 +1,97 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "bfs_test.go",
+        "dao_test.go",
+        "dialog_test.go",
+        "jointly_test.go",
+        "memcache_test.go",
+        "month_test.go",
+        "mysql_test.go",
+        "order_test.go",
+        "panel_test.go",
+        "platform_test.go",
+        "privilege_test.go",
+        "push_test.go",
+        "resouce_test.go",
+        "send_test.go",
+        "tips_test.go",
+        "vip_test.go",
+        "welfare_test.go",
+    ],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/admin/main/vip/conf:go_default_library",
+        "//app/admin/main/vip/model:go_default_library",
+        "//library/database/sql:go_default_library",
+        "//library/log:go_default_library",
+        "//library/time:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+        "//vendor/gopkg.in/h2non/gock.v1:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "bfs.go",
+        "dao.go",
+        "dialog.go",
+        "jointly.go",
+        "memcache.go",
+        "month.go",
+        "mysql.go",
+        "order.go",
+        "panel.go",
+        "platform.go",
+        "privilege.go",
+        "push.go",
+        "resouce.go",
+        "send.go",
+        "tips.go",
+        "vip.go",
+        "welfare.go",
+    ],
+    importpath = "go-common/app/admin/main/vip/dao",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/admin/main/vip/conf:go_default_library",
+        "//app/admin/main/vip/model:go_default_library",
+        "//library/cache/memcache:go_default_library",
+        "//library/database/orm:go_default_library",
+        "//library/database/sql:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/stat/prom:go_default_library",
+        "//library/time:go_default_library",
+        "//vendor/github.com/google/uuid:go_default_library",
+        "//vendor/github.com/jinzhu/gorm:go_default_library",
+        "//vendor/github.com/pkg/errors:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/admin/main/vip/dao/bfs.go

@@ -0,0 +1,88 @@
+package dao
+
+import (
+	"bytes"
+	"context"
+	"crypto/hmac"
+	"crypto/sha1"
+	"encoding/base64"
+	"fmt"
+	"hash"
+	"net/http"
+	"strconv"
+	"time"
+
+	"go-common/app/admin/main/vip/conf"
+	"go-common/library/ecode"
+	"go-common/library/log"
+)
+
+// bfs info
+const (
+	_uploadURL = "/bfs/%s/%s"
+	_template  = "%s\n%s\n%s\n%d\n"
+	_method    = "PUT"
+	_bucket    = "vip"
+)
+
+// Upload upload picture or log file to bfs
+func (d *Dao) Upload(c context.Context, fileName string, fileType string, data []byte, bfs *conf.Bfs) (location string, err error) {
+	var (
+		req    *http.Request
+		resp   *http.Response
+		code   int
+		client = &http.Client{Timeout: time.Duration(bfs.Timeout) * time.Millisecond}
+		url    = fmt.Sprintf(bfs.Host+_uploadURL, _bucket, fileName)
+	)
+	// prepare the data of the file and init the request
+	buf := new(bytes.Buffer)
+	_, err = buf.Write(data)
+	if err != nil {
+		log.Error("Upload.buf.Write.error(%v)", err)
+		err = ecode.RequestErr
+		return
+	}
+	if req, err = http.NewRequest(_method, url, buf); err != nil {
+		log.Error("http.NewRequest() Upload(%v) error(%v)", url, err)
+		return
+	}
+	timing := time.Now().Unix()
+	// request setting
+	authorization := authorize(bfs.Key, bfs.Secret, _method, _bucket, fileName, timing)
+	req.Header.Set("Date", fmt.Sprint(timing))
+	req.Header.Set("Authorization", authorization)
+	req.Header.Set("Content-Type", fileType)
+	resp, err = client.Do(req)
+	// response treatment
+	if err != nil {
+		log.Error("Bfs client.Do(%s) error(%v)", url, err)
+		return
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		err = fmt.Errorf("Bfs status code error:%v", resp.StatusCode)
+		return
+	}
+	code, err = strconv.Atoi(resp.Header.Get("code"))
+	if err != nil || code != 200 {
+		err = fmt.Errorf("Bfs response code error:%v", code)
+		return
+	}
+	location = resp.Header.Get("Location")
+	return
+}
+
+// authorize returns authorization for upload file to bfs
+func authorize(key, secret, method, bucket, file string, expire int64) (authorization string) {
+	var (
+		content   string
+		mac       hash.Hash
+		signature string
+	)
+	content = fmt.Sprintf(_template, method, bucket, file, expire)
+	mac = hmac.New(sha1.New, []byte(secret))
+	mac.Write([]byte(content))
+	signature = base64.StdEncoding.EncodeToString(mac.Sum(nil))
+	authorization = fmt.Sprintf("%s:%s:%d", key, signature, expire)
+	return
+}

app/admin/main/vip/dao/bfs_test.go

@@ -0,0 +1,46 @@
+package dao
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaoUpload(t *testing.T) {
+	convey.Convey("Upload", t, func(ctx convey.C) {
+		var (
+			c        = context.Background()
+			fileName = "123"
+			fileType = "image/png"
+			data     = []byte("1231")
+			bfs      = d.c.Bfs
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			location, err := d.Upload(c, fileName, fileType, data, bfs)
+			ctx.Convey("Then err should be nil.location should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(location, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoauthorize(t *testing.T) {
+	convey.Convey("authorize", t, func(ctx convey.C) {
+		var (
+			key    = ""
+			secret = ""
+			method = ""
+			bucket = ""
+			file   = ""
+			expire = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			authorization := authorize(key, secret, method, bucket, file, expire)
+			ctx.Convey("Then authorization should not be nil.", func(ctx convey.C) {
+				ctx.So(authorization, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}

app/admin/main/vip/dao/dao.go

@@ -0,0 +1,65 @@
+package dao
+
+import (
+	"context"
+	"time"
+
+	"go-common/app/admin/main/vip/conf"
+	"go-common/library/cache/memcache"
+	"go-common/library/database/orm"
+	xsql "go-common/library/database/sql"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/stat/prom"
+
+	"github.com/jinzhu/gorm"
+)
+
+// Dao dao conf
+type Dao struct {
+	c        *conf.Config
+	db       *xsql.DB
+	vip      *gorm.DB
+	client   *bm.Client
+	mc       *memcache.Pool
+	mcExpire int32
+	errProm  *prom.Prom
+}
+
+// New init mysql db
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		c:        c,
+		db:       xsql.NewMySQL(c.MySQL),
+		vip:      orm.NewMySQL(c.ORM.Vip),
+		client:   bm.NewClient(c.HTTPClient),
+		mc:       memcache.NewPool(c.Memcache.Config),
+		mcExpire: int32(time.Duration(c.Memcache.Expire) / time.Second),
+		errProm:  prom.BusinessErrCount,
+	}
+	d.initORM()
+	return d
+}
+
+// Close close the resource.
+func (d *Dao) Close() (err error) {
+	return d.db.Close()
+}
+
+// Ping dao ping
+func (d *Dao) Ping(c context.Context) error {
+	return d.db.Ping(c)
+}
+
+// BeginTran start tx .
+func (d *Dao) BeginTran(c context.Context) (tx *xsql.Tx, err error) {
+	return d.db.Begin(c)
+}
+
+// BeginGormTran start gorm tx .
+func (d *Dao) BeginGormTran(c context.Context) (tx *gorm.DB) {
+	return d.vip.Begin()
+}
+
+func (d *Dao) initORM() {
+	d.vip.LogMode(true)
+}

app/admin/main/vip/dao/dao_test.go

@@ -0,0 +1,47 @@
+package dao
+
+import (
+	"flag"
+	"os"
+	"strings"
+	"testing"
+
+	"go-common/app/admin/main/vip/conf"
+
+	"gopkg.in/h2non/gock.v1"
+)
+
+var (
+	d *Dao
+)
+
+func TestMain(m *testing.M) {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.account.vip-admin")
+		flag.Set("conf_appid", "main.account.vip-admin")
+		flag.Set("conf_token", "12a1ee67d60cfb97ff79216e95ec5576")
+		flag.Set("tree_id", "20445")
+		flag.Set("conf_version", "docker-1")
+		flag.Set("deploy_env", "uat")
+		flag.Set("conf_env", "10")
+		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/vip-admin-test.toml")
+	}
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	d = New(conf.Conf)
+	d.client.SetTransport(gock.DefaultTransport)
+	os.Exit(m.Run())
+}
+
+func httpMock(method, url string) *gock.Request {
+	r := gock.New(url)
+	r.Method = strings.ToUpper(method)
+	return r
+}

app/admin/main/vip/dao/dialog.go

@@ -0,0 +1,106 @@
+package dao
+
+import (
+	"context"
+	"time"
+
+	"go-common/app/admin/main/vip/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+)
+
+const (
+	_vipConfDialog = "vip_conf_dialog"
+)
+
+// DialogAll .
+func (d *Dao) DialogAll(c context.Context, appID, platform int64, status string) (res []*model.ConfDialog, err error) {
+	db := d.vip.Table(_vipConfDialog)
+	if appID != 0 {
+		db = db.Where("app_id=?", appID)
+	}
+	if platform != 0 {
+		db = db.Where("platform=?", platform)
+	}
+	if len(status) > 0 {
+		curr := time.Now().Format("2006-01-02 15:04:05")
+		//padding：待生效，active：已经生效，inactive：已经失效
+		switch status {
+		case "padding":
+			db = db.Where("stage = true AND start_time>?", curr)
+		case "active":
+			db = db.Where("stage = true AND start_time<=? AND (end_time = '1970-01-01 08:00:00' OR end_time >?)", curr, curr)
+		case "inactive":
+			db = db.Where("stage = false OR (end_time > '1970-01-01 08:00:00' AND end_time < ?)", curr)
+		default:
+			log.Info("query all dialog.")
+		}
+	}
+	if err := db.Find(&res).Error; err != nil {
+		return nil, err
+	}
+	return
+}
+
+// DialogByID vip price config by id.
+func (d *Dao) DialogByID(c context.Context, id int64) (dlg *model.ConfDialog, err error) {
+	dlg = &model.ConfDialog{}
+	if err := d.vip.Table(_vipConfDialog).Where("id=?", id).First(dlg).Error; err != nil {
+		if err == ecode.NothingFound {
+			err = nil
+		}
+		return nil, err
+	}
+	return
+}
+
+// DialogBy vip price config by .
+func (d *Dao) DialogBy(c context.Context, appID, platform int64, id int64) (res []*model.ConfDialog, err error) {
+	if err := d.vip.Table(_vipConfDialog).Where("stage = true AND app_id=? AND platform=? AND id<>?", appID, platform, id).Find(&res).Error; err != nil {
+		return nil, err
+	}
+	return
+}
+
+// DialogSave .
+func (d *Dao) DialogSave(c context.Context, arg *model.ConfDialog) (eff int64, err error) {
+	db := d.vip.Table(_vipConfDialog).Save(arg)
+	if err = db.Error; err != nil {
+		return
+	}
+	eff = db.RowsAffected
+	return
+}
+
+// DialogEnable .
+func (d *Dao) DialogEnable(c context.Context, arg *model.ConfDialog) (eff int64, err error) {
+	stage := map[string]interface{}{
+		"stage":    arg.Stage,
+		"end_time": time.Now(),
+		"operator": arg.Operator,
+	}
+	db := d.vip.Table(_vipConfDialog).Where("id=?", arg.ID).Updates(stage)
+	if err = db.Error; err != nil {
+		return
+	}
+	eff = db.RowsAffected
+	return
+}
+
+// DialogDel delete vip price config by id.
+func (d *Dao) DialogDel(c context.Context, id int64) (eff int64, err error) {
+	db := d.vip.Table(_vipConfDialog).Where("id=?", id).Delete(&model.ConfDialog{})
+	if err = db.Error; err != nil {
+		return
+	}
+	eff = db.RowsAffected
+	return
+}
+
+// CountDialogByPlatID count dialog by platform id .
+func (d *Dao) CountDialogByPlatID(c context.Context, plat int64) (count int64, err error) {
+	if err := d.vip.Table(_vipConfDialog).Where("platform=?", plat).Count(&count).Error; err != nil {
+		return 0, err
+	}
+	return
+}

app/admin/main/vip/dao/dialog_test.go

@@ -0,0 +1,54 @@
+package dao
+
+import (
+	"context"
+	"fmt"
+	"testing"
+	"time"
+
+	"go-common/app/admin/main/vip/model"
+	xtime "go-common/library/time"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaoDialogSave(t *testing.T) {
+	curr := xtime.Time(time.Now().Unix())
+	convey.Convey("DialogSave", t, func() {
+		dlg := &model.ConfDialog{ID: 1, StartTime: curr, Operator: "tommy"}
+		eff, err := d.DialogSave(context.TODO(), dlg)
+		convey.So(err, convey.ShouldBeNil)
+		convey.So(eff, convey.ShouldNotBeNil)
+	})
+	convey.Convey("DialogByID", t, func() {
+		dlg, err := d.DialogByID(context.TODO(), 1)
+		convey.So(err, convey.ShouldBeNil)
+		convey.So(dlg, convey.ShouldNotBeNil)
+	})
+	convey.Convey("DialogEnable", t, func() {
+		dlg := &model.ConfDialog{ID: 1, Stage: false}
+		eff, err := d.DialogEnable(context.TODO(), dlg)
+		convey.So(err, convey.ShouldBeNil)
+		convey.So(eff, convey.ShouldNotBeNil)
+	})
+	convey.Convey("DialogEnable", t, func() {
+		dlg := &model.ConfDialog{ID: 1, Stage: true}
+		eff, err := d.DialogEnable(context.TODO(), dlg)
+		convey.So(err, convey.ShouldBeNil)
+		convey.So(eff, convey.ShouldNotBeNil)
+	})
+	convey.Convey("DialogAll", t, func() {
+		res, err := d.DialogAll(context.TODO(), 0, 0, "active")
+		convey.So(err, convey.ShouldBeNil)
+		convey.So(res, convey.ShouldNotBeNil)
+	})
+}
+
+func TestDaoCountDialogByPlatID(t *testing.T) {
+	convey.Convey("TestDaoCountDialogByPlatID", t, func() {
+		res, err := d.CountDialogByPlatID(context.TODO(), 1)
+		fmt.Println(res)
+		convey.So(err, convey.ShouldBeNil)
+		convey.So(res, convey.ShouldBeGreaterThanOrEqualTo, 0)
+	})
+}

app/admin/main/vip/dao/jointly.go

@@ -0,0 +1,90 @@
+package dao
+
+import (
+	"context"
+	xsql "database/sql"
+
+	"go-common/app/admin/main/vip/model"
+	"go-common/library/database/sql"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_jointlysWillEffectSQL = "SELECT id,title,content,operator,start_time,end_time,link,is_hot,ctime,mtime FROM vip_jointly WHERE start_time > ? AND deleted = 0 ORDER BY mtime DESC;"
+	_jointlysEffectSQL     = "SELECT id,title,content,operator,start_time,end_time,link,is_hot,ctime,mtime FROM vip_jointly WHERE start_time < ? AND end_time > ? AND deleted = 0 ORDER BY mtime DESC;"
+	_jointlysLoseEffectSQL = "SELECT id,title,content,operator,start_time,end_time,link,is_hot,ctime,mtime FROM vip_jointly WHERE end_time < ? AND deleted = 0 ORDER BY mtime DESC;"
+	_addjointlySQL         = "INSERT INTO vip_jointly(title,content,operator,start_time,end_time,link,is_hot)VALUES(?,?,?,?,?,?,?);"
+	_updateJointlySQL      = "UPDATE vip_jointly SET title = ?,content = ?,operator = ?,link = ?,is_hot = ?,start_time = ?,end_time = ? WHERE id = ?;"
+	_deleteJointlySQL      = "UPDATE vip_jointly SET deleted = 1 WHERE id = ?;"
+)
+
+// AddJointly add jointly.
+func (d *Dao) AddJointly(c context.Context, j *model.Jointly) (a int64, err error) {
+	var res xsql.Result
+	if res, err = d.db.Exec(c, _addjointlySQL, j.Title, j.Content, j.Operator, j.StartTime, j.EndTime, j.Link, j.IsHot); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	if a, err = res.RowsAffected(); err != nil {
+		err = errors.WithStack(err)
+	}
+	return
+}
+
+// JointlysByState jointly by state.
+func (d *Dao) JointlysByState(c context.Context, state int8, now int64) (res []*model.Jointly, err error) {
+	var rows *sql.Rows
+	switch state {
+	case model.WillEffect:
+		rows, err = d.db.Query(c, _jointlysWillEffectSQL, now)
+	case model.Effect:
+		rows, err = d.db.Query(c, _jointlysEffectSQL, now, now)
+	case model.LoseEffect:
+		rows, err = d.db.Query(c, _jointlysLoseEffectSQL, now)
+	default:
+		return
+	}
+	if err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		r := new(model.Jointly)
+		if err = rows.Scan(&r.ID, &r.Title, &r.Content, &r.Operator, &r.StartTime, &r.EndTime, &r.Link, &r.IsHot, &r.CTime, &r.MTime); err != nil {
+			err = errors.WithStack(err)
+			res = nil
+			return
+		}
+		res = append(res, r)
+	}
+	err = rows.Err()
+	return
+}
+
+// UpdateJointly update jointly.
+func (d *Dao) UpdateJointly(c context.Context, j *model.Jointly) (a int64, err error) {
+	var res xsql.Result
+	if res, err = d.db.Exec(c, _updateJointlySQL, j.Title, j.Content, j.Operator, j.Link, j.IsHot, j.StartTime, j.EndTime, j.ID); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	if a, err = res.RowsAffected(); err != nil {
+		err = errors.WithStack(err)
+	}
+	return
+}
+
+// DeleteJointly delete jointly.
+func (d *Dao) DeleteJointly(c context.Context, id int64) (a int64, err error) {
+	var res xsql.Result
+	if res, err = d.db.Exec(c, _deleteJointlySQL, id); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	if a, err = res.RowsAffected(); err != nil {
+		err = errors.WithStack(err)
+	}
+	return
+}

app/admin/main/vip/dao/jointly_test.go

@@ -0,0 +1,65 @@
+package dao
+
+import (
+	"context"
+	"fmt"
+	"math/rand"
+	"testing"
+	"time"
+
+	"go-common/app/admin/main/vip/model"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+// go test  -test.v -test.run TestDaoAddJointly
+func TestDaoAddJointly(t *testing.T) {
+	Convey("TestDaoAddJointly", t, func() {
+		a, err := d.AddJointly(context.TODO(), &model.Jointly{
+			Title:     "这条是有效的,并且不 hot",
+			Content:   "这叫副标题?",
+			Operator:  "admin",
+			StartTime: 1533202903,
+			EndTime:   1543202904,
+			Link:      fmt.Sprintf("https://t.cn/%d", rand.Int63()),
+			IsHot:     1,
+		})
+		So(err, ShouldBeNil)
+		So(a, ShouldEqual, 1)
+	})
+}
+
+// go test  -test.v -test.run TestDaoUpdateJointly
+func TestDaoUpdateJointly(t *testing.T) {
+	Convey("TestDaoUpdateJointly", t, func() {
+		a, err := d.UpdateJointly(context.TODO(), &model.Jointly{
+			Title:    "这条是有效的,并且no hot",
+			Content:  "这叫副标题??",
+			Operator: "admin2",
+			Link:     fmt.Sprintf("https://t.cn/%d", rand.Int63()),
+			IsHot:    0,
+			ID:       1,
+		})
+		So(err, ShouldBeNil)
+		So(a, ShouldEqual, 1)
+	})
+}
+
+// go test  -test.v -test.run TestDaoJointlysByState
+func TestDaoJointlysByState(t *testing.T) {
+	Convey("TestDaoJointlysByState", t, func() {
+		res, err := d.JointlysByState(context.TODO(), 1, time.Now().Unix())
+		t.Logf("count %+v", len(res))
+		So(err, ShouldBeNil)
+	})
+}
+
+// go test  -test.v -test.run TestDaoDeleteJointly
+func TestDaoDeleteJointly(t *testing.T) {
+	Convey("TestDaoDeleteJointly", t, func() {
+		res, err := d.DeleteJointly(context.TODO(), 1)
+		t.Logf("count %+v", res)
+		So(res, ShouldBeGreaterThanOrEqualTo, 0)
+		So(err, ShouldBeNil)
+	})
+}

app/admin/main/vip/dao/memcache.go

@@ -0,0 +1,93 @@
+package dao
+
+import (
+	"context"
+	"fmt"
+
+	gmc "go-common/library/cache/memcache"
+	"go-common/library/log"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_vipInfo = "big:%d"
+	_ui      = "ui:%s"
+)
+
+func userinfo(name string) string {
+	return fmt.Sprintf(_ui, name)
+}
+func vipInfoKey(mid int64) string {
+	return fmt.Sprintf(_vipInfo, mid)
+}
+
+// DelVipInfoCache delete vipinfo cache.
+func (d *Dao) DelVipInfoCache(c context.Context, mid int64) (err error) {
+	return d.delCache(c, vipInfoKey(mid))
+}
+
+func (d *Dao) delCache(c context.Context, key string) (err error) {
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	if err = conn.Delete(key); err != nil {
+		err = errors.WithStack(err)
+		d.errProm.Incr("conn_del")
+		return
+	}
+	return
+}
+
+// DelSelCode .
+func (d *Dao) DelSelCode(c context.Context, username string) (err error) {
+	return d.delCache(c, userinfo(username))
+}
+
+// SetSelCode .
+func (d *Dao) SetSelCode(c context.Context, username string, linkmap map[int64]int64) (err error) {
+	var (
+		key = userinfo(username)
+	)
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	item := &gmc.Item{Key: key, Object: linkmap, Expiration: d.mcExpire, Flags: gmc.FlagJSON}
+	if err = conn.Set(item); err != nil {
+		err = errors.Wrapf(err, "conn.Set(%s)", key)
+		d.errProm.Incr("set_selcode")
+	}
+	return
+}
+
+// GetSelCode .
+func (d *Dao) GetSelCode(c context.Context, username string) (linkmap map[int64]int64, err error) {
+	var (
+		key = userinfo(username)
+	)
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	item, err := conn.Get(key)
+	if err != nil {
+		if err == gmc.ErrNotFound {
+			err = nil
+			return
+		}
+		err = errors.Wrapf(err, "conn.Get(%s)", key)
+		d.errProm.Incr("vipinfo_mc")
+		return
+	}
+	linkmap = make(map[int64]int64)
+	if err = conn.Scan(item, &linkmap); err != nil {
+		err = errors.Wrapf(err, "conn.Scan(%s)", key)
+	}
+	return
+}
+
+// PingMC ping memcache.
+func (d *Dao) PingMC(c context.Context) (err error) {
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	if err = conn.Set(&gmc.Item{Key: "ping", Value: []byte{1}, Expiration: d.mcExpire}); err != nil {
+		log.Error("conn.Store(set, ping, 1) error(%v)", err)
+	}
+	return
+}

app/admin/main/vip/dao/memcache_test.go

@@ -0,0 +1,38 @@
+package dao
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestVipInfoKey(t *testing.T) {
+	convey.Convey("vipInfoKey", t, func() {
+		p1 := vipInfoKey(0)
+		convey.So(p1, convey.ShouldNotBeNil)
+	})
+}
+
+func TestDaoSetSelCode(t *testing.T) {
+	convey.Convey("SetSelCode", t, func() {
+		linkmap := map[int64]int64{1: 1}
+		err := d.SetSelCode(context.TODO(), "testSelCode", linkmap)
+		convey.So(err, convey.ShouldBeNil)
+	})
+	convey.Convey("GetSelCode", t, func() {
+		_, err := d.GetSelCode(context.TODO(), "testSelCode")
+		convey.So(err, convey.ShouldBeNil)
+	})
+	convey.Convey("DelSelCode", t, func() {
+		err := d.DelSelCode(context.TODO(), "testSelCode")
+		convey.So(err, convey.ShouldBeNil)
+	})
+}
+
+func TestDaoPingMC(t *testing.T) {
+	convey.Convey("PingMC", t, func() {
+		err := d.PingMC(context.TODO())
+		convey.So(err, convey.ShouldBeNil)
+	})
+}

app/admin/main/vip/dao/month.go

@@ -0,0 +1,120 @@
+package dao
+
+import (
+	"context"
+	xsql "database/sql"
+
+	"go-common/app/admin/main/vip/model"
+	"go-common/library/database/sql"
+
+	"github.com/pkg/errors"
+)
+
+// GetMonth .
+func (d *Dao) GetMonth(c context.Context, id int64) (m *model.VipMonth, err error) {
+	res := d.db.QueryRow(c, _getMonth, id)
+	m = new(model.VipMonth)
+	if err = res.Scan(&m.ID, &m.Month, &m.MonthType, &m.Operator, &m.Status, &m.Mtime); err != nil {
+		if err == sql.ErrNoRows {
+			err = nil
+			m = nil
+		} else {
+			err = errors.WithStack(err)
+		}
+	}
+	return
+}
+
+// MonthList get all month.
+func (d *Dao) MonthList(c context.Context) (res []*model.VipMonth, err error) {
+	var rows *sql.Rows
+	if rows, err = d.db.Query(c, _allMonth); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		r := &model.VipMonth{}
+		if err = rows.Scan(&r.ID, &r.Month, &r.MonthType, &r.Operator, &r.Status, &r.Mtime); err != nil {
+			err = errors.WithStack(err)
+			res = nil
+			return
+		}
+		res = append(res, r)
+	}
+	return
+}
+
+// MonthEdit .
+func (d *Dao) MonthEdit(c context.Context, id int64, status int8, op string) (eff int64, err error) {
+	var res xsql.Result
+	if res, err = d.db.Exec(c, _updateMonthStatus, status, op, id); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	if eff, err = res.RowsAffected(); err != nil {
+		err = errors.WithStack(err)
+	}
+	return
+}
+
+// GetPrice .
+func (d *Dao) GetPrice(c context.Context, id int64) (r *model.VipMonthPrice, err error) {
+	row := d.db.QueryRow(c, _monthPriceSQL, id)
+	r = new(model.VipMonthPrice)
+	if err = row.Scan(&r.ID, &r.MonthID, &r.MonthType, &r.Money, &r.Selected, &r.FirstDiscountMoney, &r.DiscountMoney, &r.StartTime, &r.EndTime, &r.Remark, &r.Operator); err != nil {
+		if err == sql.ErrNoRows {
+			err = nil
+			r = nil
+		} else {
+			err = errors.WithStack(err)
+		}
+	}
+	return
+}
+
+// PriceList .
+func (d *Dao) PriceList(c context.Context, mID int64) (res []*model.VipMonthPrice, err error) {
+	var rows *sql.Rows
+	if rows, err = d.db.Query(c, _allMonthPrice, mID); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		r := &model.VipMonthPrice{}
+		if err = rows.Scan(&r.ID, &r.MonthID, &r.MonthType, &r.Money, &r.Selected, &r.FirstDiscountMoney, &r.DiscountMoney, &r.StartTime, &r.EndTime, &r.Remark, &r.Operator); err != nil {
+			err = errors.WithStack(err)
+			res = nil
+			return
+		}
+		res = append(res, r)
+	}
+	return
+}
+
+// PriceAdd .
+func (d *Dao) PriceAdd(c context.Context, mp *model.VipMonthPrice) (eff int64, err error) {
+	var res xsql.Result
+	if res, err = d.db.Exec(c, _addMonthPrice, mp.MonthID, mp.MonthType, mp.Money, mp.FirstDiscountMoney, mp.DiscountMoney, mp.StartTime, mp.EndTime, mp.Remark, mp.Operator); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	if eff, err = res.RowsAffected(); err != nil {
+		err = errors.WithStack(err)
+	}
+	return
+}
+
+// PriceEdit .
+func (d *Dao) PriceEdit(c context.Context, mp *model.VipMonthPrice) (eff int64, err error) {
+	var res xsql.Result
+	if res, err = d.db.Exec(c, _editMonthPrice, mp.MonthType, mp.Money, mp.FirstDiscountMoney, mp.DiscountMoney, mp.StartTime, mp.EndTime, mp.Remark, mp.Operator, mp.ID); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	if eff, err = res.RowsAffected(); err != nil {
+		err = errors.WithStack(err)
+	}
+	return
+}

app/admin/main/vip/dao/month_test.go

@@ -0,0 +1,78 @@
+package dao
+
+import (
+	"context"
+	"testing"
+
+	"go-common/app/admin/main/vip/model"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	ctx = context.TODO()
+)
+
+func Test_GetMonth(t *testing.T) {
+	Convey("Test_GetMonth", t, func() {
+		res, err := d.GetMonth(context.Background(), 11)
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeNil)
+	})
+}
+func Test_MonthList(t *testing.T) {
+	Convey("Test_MonthList", t, func() {
+		res, err := d.MonthList(context.TODO())
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeEmpty)
+	})
+}
+
+func Test_MonthEdit(t *testing.T) {
+	var (
+		id     int64 = 31
+		status int8  = 1
+		op           = "test"
+	)
+	Convey("Test_MonthEdit", t, func() {
+		res, err := d.MonthEdit(context.Background(), id, status, op)
+		So(err, ShouldBeNil)
+		So(res, ShouldBeGreaterThanOrEqualTo, 0)
+	})
+}
+func Test_GetPrice(t *testing.T) {
+	var id int64 = 60
+	Convey("Test_GetPrice", t, func() {
+		res, err := d.GetPrice(context.Background(), id)
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeNil)
+	})
+}
+
+func Test_MonthPriceList(t *testing.T) {
+	Convey("Test_MonthPriceList", t, func() {
+		var (
+			err error
+			eff int64
+			res []*model.VipMonthPrice
+		)
+		ap := &model.VipMonthPrice{MonthID: 2, Money: 2.00}
+		eff, err = d.PriceAdd(ctx, ap)
+		So(err, ShouldBeNil)
+		So(eff, ShouldEqual, 1)
+		res, err = d.PriceList(context.TODO(), 2)
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeEmpty)
+	})
+}
+
+func Test_PriceEdit(t *testing.T) {
+	var (
+		vp = &model.VipMonthPrice{MonthID: 2, Money: 2.00}
+	)
+	Convey("Test_PriceEdit", t, func() {
+		res, err := d.PriceEdit(context.Background(), vp)
+		So(err, ShouldBeNil)
+		So(res, ShouldBeGreaterThanOrEqualTo, 0)
+	})
+}

app/admin/main/vip/dao/mysql.go

@@ -0,0 +1,539 @@
+package dao
+
+import (
+	"context"
+	xsql "database/sql"
+	"fmt"
+	"strconv"
+	"time"
+
+	"go-common/app/admin/main/vip/model"
+	"go-common/library/database/sql"
+	"go-common/library/log"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_SelPoolQueryCount = "SELECT COUNT(1) count from vip_resource_pool WHERE 1=1"
+	_SelBusinessByID   = "SELECT id,business_name,business_type,status,app_key,secret,contacts,contacts_number,ctime,mtime FROM vip_business_info WHERE id=?"
+
+	_SelBusinessByQuery = "SELECT id,business_name,business_type,status,app_key,secret,contacts,contacts_number,ctime,mtime FROM vip_business_info WHERE 1=1 "
+
+	_SelPoolByQuery    = "SELECT id,pool_name,business_id,reason,code_expire_time,start_time,end_time,contacts,contacts_number FROM vip_resource_pool WHERE 1=1"
+	_SelPoolByName     = "SELECT id,pool_name,business_id,reason,code_expire_time,start_time,end_time,contacts,contacts_number FROM vip_resource_pool WHERE pool_name = ?"
+	_SelPoolByID       = "SELECT id,pool_name,business_id,reason,code_expire_time,start_time,end_time,contacts,contacts_number FROM vip_resource_pool WHERE id=?"
+	_AddPool           = "INSERT INTO vip_resource_pool(pool_name,business_id,reason,code_expire_time,start_time,end_time,contacts,contacts_number) VALUES(?,?,?,?,?,?,?,?)"
+	_UpdatePool        = "UPDATE vip_resource_pool SET pool_name=?,business_id=?,reason=?,code_expire_time=?,start_time=?,end_time=?,contacts=?,contacts_number=? WHERE id = ?"
+	_SelBatchByPoolID  = "SELECT id,pool_id,unit,count,ver,start_time,end_time,surplus_count,code_use_count,direct_use_count FROM vip_resource_batch WHERE pool_id=?"
+	_SelBatchByID      = "SELECT id,pool_id,unit,count,ver,start_time,end_time,surplus_count,code_use_count,direct_use_count FROM vip_resource_batch WHERE id=?"
+	_AddBatch          = "INSERT INTO vip_resource_batch(pool_id,unit,count,ver,start_time,end_time,surplus_count,code_use_count,direct_use_count) VALUES(?,?,?,?,?,?,?,?,?)"
+	_UpdateBatch       = "UPDATE vip_resource_batch SET count = ?,ver=?,start_time=?,end_time=?,surplus_count=? WHERE id = ? AND ver=?"
+	_UseBatch          = "UPDATE vip_resource_batch SET ver=?,surplus_count = ?,direct_use_count=? WHERE id =? AND ver=?"
+	_allVersionSQL     = "SELECT `id`,`platform_id`,`version`,`tip`,`operator`,`link` FROM `vip_app_version`;"
+	_updateVersionSQL  = "UPDATE `vip_app_version` SET  %s WHERE `id` = ?;"
+	_businessInfosSQL  = "SELECT id,business_name,business_type,status,app_key,contacts,contacts_number,ctime,mtime FROM vip_business_info WHERE 1=1 "
+	_businessCountSQL  = "SELECT COUNT(1) FROM vip_business_info WHERE 1=1"
+	_addBusinessSQL    = "INSERT INTO `vip_business_info` (`business_name`,`business_type`,`status`,`app_key`,`secret`,`contacts`,`contacts_number`) VALUES (?,?,?,?,?,?,?);"
+	_updateBusinessSQL = "UPDATE `vip_business_info` SET `business_name` = ?,`business_type` = ?,`status` = ?,`app_key` = ?,`secret` = ?,`contacts` = ?,`contacts_number` = ? WHERE `id` = ?;"
+
+	_allMonth = "SELECT id,month,month_type,operator,status,mtime FROM vip_month WHERE deleted = 0"
+	_getMonth = "SELECT id,month,month_type,operator,status,mtime FROM vip_month WHERE id=?"
+
+	_updateMonthStatus = "UPDATE vip_month SET status=?,operator=? WHERE id=?"
+	_allMonthPrice     = "SELECT id,month_id,month_type,money,selected,first_discount_money,discount_money,start_time,end_time,remark,operator FROM vip_month_price WHERE month_id=?"
+	_monthPriceSQL     = "SELECT id,month_id,month_type,money,selected,first_discount_money,discount_money,start_time,end_time,remark,operator FROM vip_month_price WHERE id=?"
+	_addMonthPrice     = "INSERT INTO vip_month_price (month_id,month_type,money,first_discount_money,discount_money,start_time,end_time,remark,operator) VALUES (?,?,?,?,?,?,?,?,?)"
+	_editMonthPrice    = "UPDATE vip_month_price SET month_type=?,money=?,first_discount_money=?,discount_money=?,start_time=?,end_time=?,remark=?,operator=? WHERE id=?"
+
+	//resouce SQL
+	_addBatchCodeSQL       = "INSERT INTO vip_resource_batch_code(business_id,pool_id,status,batch_name,reason,unit,count,surplus_count,price,start_time,end_time,contacts,contacts_number,type,limit_day,max_count,operator) VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)"
+	_updateBatchCodeSQL    = "UPDATE vip_resource_batch_code SET status=?,batch_name=?,reason=?,price=?,contacts=?,contacts_number=?,type=?,limit_day=?,max_count=?,operator=? WHERE id=?"
+	_selBatchCodeIDSQL     = "SELECT id FROM vip_resource_batch_code WHERE  1=1"
+	_selBatchCodeSQL       = "SELECT id,business_id,pool_id,status,type,limit_day,max_count,batch_name,reason,unit,count,surplus_count,price,start_time,end_time,contacts,contacts_number,ctime FROM vip_resource_batch_code WHERE  1=1 "
+	_selBatchCodeByIDSQL   = "SELECT id,business_id,pool_id,status,type,limit_day,max_count,batch_name,reason,unit,count,surplus_count,price,start_time,end_time,contacts,contacts_number,ctime FROM vip_resource_batch_code WHERE  id = ?"
+	_selBatchCodeCountSQL  = "SELECT COUNT(1) FROM vip_resource_batch_code WHERE  1=1 "
+	_selBatchCodeByNameSQL = "SELECT id,business_id,pool_id,status,type,limit_day,max_count,batch_name,reason,unit,count,surplus_count,price,start_time,end_time,contacts,contacts_number,ctime FROM vip_resource_batch_code WHERE  batch_name = ?"
+	_selBatchCodesSQL      = "SELECT id,business_id,pool_id,status,type,limit_day,max_count,batch_name,reason,unit,count,surplus_count,price,start_time,end_time,contacts,contacts_number,ctime FROM vip_resource_batch_code WHERE  1=1 AND id in (%v)"
+
+	_batchAddCodeSQL = "INSERT INTO vip_resource_code(batch_code_id,status,code) VALUES"
+	_updateCodeSQL   = "UPDATE vip_resource_code SET status=? WHERE id = ?"
+	_selCodeSQL      = "SELECT id,batch_code_id,status,code,mid,use_time,ctime FROM vip_resource_code WHERE 1=1"
+	_selCodeByIDSQL  = "SELECT id,batch_code_id,status,code,mid,use_time,ctime FROM vip_resource_code WHERE id = ?"
+
+	//pushData
+	_selPushDataCountSQL = "SELECT COUNT(1) FROM vip_push_data WHERE 1=1 "
+	_selPushDataSQL      = "SELECT id,disable_type,`group_name`,title,content,push_total_count,pushed_count,progress_status,`status`,platform,link_type,link_url,error_code,expired_day_start,expired_day_end,effect_start_date,effect_end_date,push_start_time,push_end_time,operator FROM vip_push_data WHERE 1=1 "
+	_selPushDataByIDSQL  = "SELECT id,disable_type,`group_name`,title,content,push_total_count,pushed_count,progress_status,`status`,platform,link_type,link_url,error_code,expired_day_start,expired_day_end,effect_start_date,effect_end_date,push_start_time,push_end_time,operator FROM vip_push_data WHERE id=?"
+	_addPushDataSQL      = "INSERT INTO vip_push_data(`group_name`,title,content,push_total_count,pushed_count,progress_status,`status`,platform,link_type,link_url,expired_day_start,expired_day_end,effect_start_date,effect_end_date,push_start_time,push_end_time,operator) VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)"
+	_updatePushDataSQL   = "UPDATE vip_push_data SET  group_name=?,title=?,content=?,push_total_count=?,progress_status=?,platform=?,link_type=?,link_url=?,expired_day_start=?,expired_day_end=?,effect_start_date=?,effect_end_date=?,push_start_time=?,push_end_time=?,operator=? WHERE id=?"
+	_delPushDataSQL      = "DELETE FROM vip_push_data WHERE id = ?"
+	_disablePushDataSQL  = "UPDATE vip_push_data SET disable_type=1,progress_status=?,push_total_count=?,effect_end_date=? WHERE id=?"
+
+	//order
+	_vipOrderListSQL  = "SELECT id,order_no,app_id,platform,order_type,mid,to_mid,buy_months,money,refund_amount,status,pay_type,recharge_bp,third_trade_no,ver,payment_time,ctime,mtime,app_sub_id FROM vip_pay_order WHERE 1=1"
+	_vipOrderCountSQL = "SELECT COUNT(1) FROM vip_pay_order WHERE 1=1"
+	_vipOrderSQL      = "SELECT id,order_no,app_id,platform,order_type,mid,to_mid,buy_months,money,refund_amount,status,pay_type,recharge_bp,third_trade_no,ver,payment_time,ctime,mtime,app_sub_id FROM vip_pay_order WHERE order_no = ? "
+	_addOrderLogSQL   = "INSERT INTO vip_pay_order_log(order_no,refund_id,refund_amount,operator,mid,status) VALUES(?,?,?,?,?,?)"
+
+	_getUserChangeHistorySQL      = "SELECT id,mid,change_type,change_time,days,operator_id,relation_id,batch_id,remark,ctime,mtime FROM vip_user_change_history WHERE 1=1 "
+	_getUserChangeHistoryCountSQL = "SELECT COUNT(1) FROM `vip_user_change_history` WHERE 1=1 "
+	_defpn                        = 1
+	_defps                        = 20
+	_maxps                        = 100
+)
+
+func (d *Dao) joinPoolCondition(sql string, q *model.ResoucePoolBo, pn, ps int) string {
+	if len(q.PoolName) > 0 {
+		sql += " and pool_name like '%" + q.PoolName + "%'"
+	}
+	if q.BusinessID > 0 {
+		sql += " and business_id = " + strconv.Itoa(q.BusinessID)
+	}
+	if q.StartTime > 0 {
+		sql += " and start_time >= '" + q.StartTime.Time().Format("2006-01-02 15:04:05") + "'"
+	}
+	if q.EndTime > 0 {
+		sql += " and end_time <='" + q.EndTime.Time().Format("2006-01-02 15:04:05") + "'"
+	}
+	if q.ID > 0 || q.ID == -1 {
+		sql += " and id = " + strconv.Itoa(q.ID)
+	}
+	if pn > 0 {
+		if ps <= 0 {
+			ps = 20
+		}
+		offer := (q.PN - 1) * q.PS
+		sql += " limit " + strconv.Itoa(offer) + ", " + strconv.Itoa(q.PS)
+	}
+	return sql
+}
+
+func (d *Dao) joinHistoryCondition(sql string, u *model.UserChangeHistoryReq, iscount bool) string {
+	if u.Mid > 0 {
+		sql += " AND mid = " + fmt.Sprintf("%d", u.Mid)
+	}
+	if u.ChangeType > 0 {
+		sql += " AND change_type = " + fmt.Sprintf("%d", u.ChangeType)
+	}
+	if u.StartChangeTime > 0 {
+		stime := time.Unix(u.StartChangeTime, 0).Format("2006-01-02 15:04:05")
+		sql += " AND change_time >= '" + stime + "'"
+	}
+	if u.EndChangeTime > 0 {
+		etime := time.Unix(u.EndChangeTime, 0).Format("2006-01-02 15:04:05")
+		sql += " AND change_time <= '" + etime + "'"
+	}
+	if u.BatchID > 0 {
+		sql += " AND batch_id = " + fmt.Sprintf("%d", u.BatchID)
+	}
+	if len(u.RelationID) > 0 {
+		sql += " AND relation_id = " + fmt.Sprintf("'%v'", u.RelationID)
+	}
+	if iscount {
+		return sql
+	}
+	if u.Pn == 0 {
+		u.Pn = _defpn
+	}
+	if u.Ps == 0 {
+		u.Ps = _defps
+	}
+	offer := (u.Pn - 1) * u.Ps
+	sql += " ORDER BY id DESC LIMIT " + strconv.Itoa(offer) + ", " + strconv.Itoa(u.Ps)
+	return sql
+}
+
+// SelPoolByName sel pool by name
+func (d *Dao) SelPoolByName(c context.Context, name string) (r *model.VipResourcePool, err error) {
+	var row *sql.Row
+	if row = d.db.QueryRow(c, _SelPoolByName, name); err != nil {
+		log.Error("SelPoolByName db.query() error(%v)", err)
+		return
+	}
+	r = new(model.VipResourcePool)
+	if err = row.Scan(&r.ID, &r.PoolName, &r.BusinessID, &r.Reason, &r.CodeExpireTime, &r.StartTime, &r.EndTime, &r.Contacts, &r.ContactsNumber); err != nil {
+		if err == sql.ErrNoRows {
+			err = nil
+			r = nil
+		} else {
+			log.Error("row.Scan() error(%v)", err)
+		}
+		return
+	}
+	return
+}
+
+// SelCountPool sel count Pool
+func (d *Dao) SelCountPool(c context.Context, r *model.ResoucePoolBo) (count int, err error) {
+	var row *sql.Row
+	if row = d.db.QueryRow(c, d.joinPoolCondition(_SelPoolQueryCount, r, 0, 0)); err != nil {
+		log.Error("SelCountPool db.query() error(%v)", err)
+		return
+	}
+	if err = row.Scan(&count); err != nil {
+		log.Error("row.scan() error(%v)", err)
+		return
+	}
+	return
+}
+
+// SelPool sel pool by query condition
+func (d *Dao) SelPool(c context.Context, r *model.ResoucePoolBo, pn, ps int) (res []*model.VipResourcePool, err error) {
+
+	var rows *sql.Rows
+	if rows, err = d.db.Query(c, d.joinPoolCondition(_SelPoolByQuery, r, pn, ps)); err != nil {
+		log.Error("SelPool db.query() error(%v)", err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		r := new(model.VipResourcePool)
+		if err = rows.Scan(&r.ID, &r.PoolName, &r.BusinessID, &r.Reason, &r.CodeExpireTime, &r.StartTime, &r.EndTime, &r.Contacts, &r.ContactsNumber); err != nil {
+			log.Error("row.scan() error(%v)", err)
+			res = nil
+			return
+		}
+		res = append(res, r)
+
+	}
+	return
+}
+
+// SelPoolRow sel pool by id
+func (d *Dao) SelPoolRow(c context.Context, id int) (r *model.VipResourcePool, err error) {
+
+	var row *sql.Row
+	if row = d.db.QueryRow(c, _SelPoolByID, id); err != nil {
+		log.Error("SelPoolRow db.query() error(%v)", err)
+		return
+	}
+	r = new(model.VipResourcePool)
+	if err = row.Scan(&r.ID, &r.PoolName, &r.BusinessID, &r.Reason, &r.CodeExpireTime, &r.StartTime, &r.EndTime, &r.Contacts, &r.ContactsNumber); err != nil {
+		if err == sql.ErrNoRows {
+			err = nil
+			r = nil
+		} else {
+			log.Error("row.Scan() error(%v)", err)
+		}
+		return
+	}
+	return
+}
+
+// AddPool add pool
+func (d *Dao) AddPool(c context.Context, r *model.ResoucePoolBo) (a int64, err error) {
+	var res xsql.Result
+	if res, err = d.db.Exec(c, _AddPool, r.PoolName, r.BusinessID, r.Reason, r.CodeExpireTime, r.StartTime, r.EndTime, r.Contacts, r.ContactsNumber); err != nil {
+		log.Error("AddPool d.db.exec(%v) error(%v)", r, err)
+		return
+	}
+	if a, err = res.RowsAffected(); err != nil {
+		log.Error("AddPool RowsAffected() error(%v)", err)
+		return
+	}
+	return
+}
+
+// UpdatePool update pool
+func (d *Dao) UpdatePool(c context.Context, r *model.ResoucePoolBo) (a int64, err error) {
+	var res xsql.Result
+	if res, err = d.db.Exec(c, _UpdatePool, r.PoolName, r.BusinessID, r.Reason, r.CodeExpireTime, r.StartTime, r.EndTime, r.Contacts, r.ContactsNumber, r.ID); err != nil {
+		log.Error("UpdatePool d.db.exec(%v) error(%v)", r, err)
+		return
+	}
+	if a, err = res.RowsAffected(); err != nil {
+		log.Error("UpdatePool RowsAffected() error(%v)", err)
+		return
+	}
+	return
+}
+
+// SelBatchRow sel batch by id
+func (d *Dao) SelBatchRow(c context.Context, id int) (r *model.VipResourceBatch, err error) {
+	var row *sql.Row
+	if row = d.db.QueryRow(c, _SelBatchByID, id); err != nil {
+		log.Error("SelBatchRow db.query() error(%v)", err)
+		return
+	}
+	r = new(model.VipResourceBatch)
+	if err = row.Scan(&r.ID, &r.PoolID, &r.Unit, &r.Count, &r.Ver, &r.StartTime, &r.EndTime, &r.SurplusCount, &r.CodeUseCount, &r.DirectUseCount); err != nil {
+		if err == sql.ErrNoRows {
+			err = nil
+			r = nil
+		} else {
+			log.Error("row.Scan() error(%v)", err)
+		}
+		return
+	}
+	return
+}
+
+// SelBatchRows sel batch by poolID
+func (d *Dao) SelBatchRows(c context.Context, poolID int) (res []*model.VipResourceBatch, err error) {
+	var rows *sql.Rows
+	if rows, err = d.db.Query(c, _SelBatchByPoolID, poolID); err != nil {
+		log.Error("SelBatchRows db.query() error(%v)", err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		r := new(model.VipResourceBatch)
+		if err = rows.Scan(&r.ID, &r.PoolID, &r.Unit, &r.Count, &r.Ver, &r.StartTime, &r.EndTime, &r.SurplusCount, &r.CodeUseCount, &r.DirectUseCount); err != nil {
+			log.Error("row.scan() error(%v)", err)
+			res = nil
+			return
+		}
+		res = append(res, r)
+
+	}
+	return
+}
+
+// AddBatch add batch
+func (d *Dao) AddBatch(c context.Context, r *model.ResouceBatchBo) (a int64, err error) {
+	var res xsql.Result
+	if res, err = d.db.Exec(c, _AddBatch, r.PoolID, r.Unit, r.Count, 0, r.StartTime, r.EndTime, r.SurplusCount, r.CodeUseCount, r.DirectUseCount); err != nil {
+		log.Error("AddBatch d.db.exec(%v) error(%v)", r, err)
+		return
+	}
+	if a, err = res.RowsAffected(); err != nil {
+		log.Error("AddBatch RowsAffected() error(%v)", err)
+		return
+	}
+	return
+}
+
+// UpdateBatch update batch data
+func (d *Dao) UpdateBatch(c context.Context, r *model.VipResourceBatch, ver int) (a int64, err error) {
+	var res xsql.Result
+	if res, err = d.db.Exec(c, _UpdateBatch, r.Count, r.Ver, r.StartTime, r.EndTime, r.SurplusCount, r.ID, ver); err != nil {
+		log.Error("UpdateBatch d.db.exec(%v) error(%v)", r, err)
+		return
+	}
+	if a, err = res.RowsAffected(); err != nil {
+		log.Error("UpdateBatch RowsAffected() error(%v)", err)
+		return
+	}
+	return
+}
+
+// UseBatch use batch resouce
+func (d *Dao) UseBatch(tx *sql.Tx, r *model.VipResourceBatch, ver int) (a int64, err error) {
+	var res xsql.Result
+	if res, err = tx.Exec(_UseBatch, r.Ver, r.SurplusCount, r.DirectUseCount, r.ID, ver); err != nil {
+		log.Error("UseBatch d.db.exec(%v) error(%v)", r, err)
+		return
+	}
+	if a, err = res.RowsAffected(); err != nil {
+		log.Error("UseBatch RowsAffected() error(%v)", err)
+		return
+	}
+	return
+}
+
+// SelBusiness select businessInfo by id
+func (d *Dao) SelBusiness(c context.Context, id int) (r *model.VipBusinessInfo, err error) {
+	var row = d.db.QueryRow(c, _SelBusinessByID, id)
+	r = new(model.VipBusinessInfo)
+	if err = row.Scan(&r.ID, &r.BusinessName, &r.BusinessType, &r.Status, &r.AppKey, &r.Secret, &r.Contacts, &r.ContactsNumber, &r.Ctime, &r.Mtime); err != nil {
+		if err == sql.ErrNoRows {
+			err = nil
+			r = nil
+		} else {
+			log.Error("row.Scan() error(%v)", err)
+		}
+	}
+	return
+}
+
+// SelBusinessByQuery .
+func (d *Dao) SelBusinessByQuery(c context.Context, arg *model.QueryBusinessInfo) (r *model.VipBusinessInfo, err error) {
+	queryStr := ""
+	if len(arg.Name) > 0 {
+		queryStr += fmt.Sprintf(" AND business_name = '%v' ", arg.Name)
+	}
+	if len(arg.Appkey) > 0 {
+		queryStr += fmt.Sprintf(" AND app_key = '%v' ", arg.Appkey)
+	}
+	var row = d.db.QueryRow(c, _SelBusinessByQuery+queryStr)
+	r = new(model.VipBusinessInfo)
+	if err = row.Scan(&r.ID, &r.BusinessName, &r.BusinessType, &r.Status, &r.AppKey, &r.Secret, &r.Contacts, &r.ContactsNumber, &r.Ctime, &r.Mtime); err != nil {
+		if err == sql.ErrNoRows {
+			err = nil
+			r = nil
+		} else {
+			log.Error("row.Scan() error(%v)", err)
+		}
+	}
+	return
+}
+
+// AllVersion all version.
+func (d *Dao) AllVersion(c context.Context) (res []*model.VipAppVersion, err error) {
+	var rows *sql.Rows
+	if rows, err = d.db.Query(c, _allVersionSQL); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		r := new(model.VipAppVersion)
+		if err = rows.Scan(&r.ID, &r.PlatformID, &r.Version, &r.Tip, &r.Operator, &r.Link); err != nil {
+			err = errors.WithStack(err)
+			res = nil
+			return
+		}
+		res = append(res, r)
+	}
+	return
+}
+
+// UpdateVersion update version.
+func (d *Dao) UpdateVersion(c context.Context, v *model.VipAppVersion) (ret int64, err error) {
+	var (
+		sql string
+		res xsql.Result
+	)
+	if len(v.Version) > 0 {
+		sql += "`version` = '" + v.Version + "',"
+	}
+	if len(v.Tip) > 0 {
+		sql += "`tip` = '" + v.Tip + "',"
+	}
+	if len(v.Link) > 0 {
+		sql += "`link` = '" + v.Link + "',"
+	}
+	sql += "`operator` = '" + v.Operator + "'"
+	if res, err = d.db.Exec(c, fmt.Sprintf(_updateVersionSQL, sql), v.ID); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	if ret, err = res.RowsAffected(); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	return
+}
+
+// BussinessList business infos.
+func (d *Dao) BussinessList(c context.Context, pn, ps, status int) (res []*model.VipBusinessInfo, err error) {
+	var rows *sql.Rows
+	sqlStr := _businessInfosSQL
+	if status >= 0 {
+		sqlStr += fmt.Sprintf(" AND status=%v", status)
+	}
+	if pn <= 0 {
+		pn = _defpn
+	}
+	if pn <= 0 || pn > _maxps {
+		ps = _defps
+	}
+	sqlStr += fmt.Sprintf(" ORDER BY id DESC limit %v,%v", (pn-1)*ps, ps)
+	if rows, err = d.db.Query(c, sqlStr); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		r := new(model.VipBusinessInfo)
+		if err = rows.Scan(&r.ID, &r.BusinessName, &r.BusinessType, &r.Status, &r.AppKey,
+			&r.Contacts, &r.ContactsNumber, &r.Ctime, &r.Mtime); err != nil {
+			err = errors.WithStack(err)
+			res = nil
+			return
+		}
+		res = append(res, r)
+	}
+	return
+}
+
+// BussinessCount bussiness info count.
+func (d *Dao) BussinessCount(c context.Context, status int) (count int64, err error) {
+	var row *sql.Row
+	sqlstr := _businessCountSQL
+	if status >= 0 {
+		sqlstr += fmt.Sprintf(" AND status=%v", status)
+	}
+	if row = d.db.QueryRow(c, sqlstr); err != nil {
+		err = errors.WithStack(err)
+		d.errProm.Incr("query_db")
+		return
+	}
+	if err = row.Scan(&count); err != nil {
+		err = errors.WithStack(err)
+		d.errProm.Incr("row_scan_db")
+		return
+	}
+	return
+}
+
+// UpdateBusiness update business info.
+func (d *Dao) UpdateBusiness(c context.Context, r *model.VipBusinessInfo) (a int64, err error) {
+	var res xsql.Result
+	if res, err = d.db.Exec(c, _updateBusinessSQL, r.BusinessName, r.BusinessType, r.Status, r.AppKey, r.Secret, r.Contacts, r.ContactsNumber, r.ID); err != nil {
+		err = errors.WithStack(err)
+		d.errProm.Incr("exec_db")
+		return
+	}
+	if a, err = res.RowsAffected(); err != nil {
+		err = errors.WithStack(err)
+		d.errProm.Incr("rows_affected_db")
+		return
+	}
+	return
+}
+
+// AddBusiness add business info.
+func (d *Dao) AddBusiness(c context.Context, r *model.VipBusinessInfo) (a int64, err error) {
+	var res xsql.Result
+	if res, err = d.db.Exec(c, _addBusinessSQL, r.BusinessName, r.BusinessType, r.Status, r.AppKey, r.Secret, r.Contacts, r.ContactsNumber); err != nil {
+		err = errors.WithStack(err)
+		d.errProm.Incr("exec_db")
+		return
+	}
+	if a, err = res.RowsAffected(); err != nil {
+		err = errors.WithStack(err)
+		d.errProm.Incr("rows_affected_db")
+		return
+	}
+	return
+}
+
+// HistoryCount user change history.
+func (d *Dao) HistoryCount(c context.Context, u *model.UserChangeHistoryReq) (count int, err error) {
+	var row *sql.Row
+	if row = d.db.QueryRow(c, d.joinHistoryCondition(_getUserChangeHistoryCountSQL, u, true)); err != nil {
+		err = errors.WithStack(err)
+		d.errProm.Incr("query_db")
+		return
+	}
+	if err = row.Scan(&count); err != nil {
+		err = errors.WithStack(err)
+		d.errProm.Incr("row_scan_db")
+		return
+	}
+	return
+}
+
+// HistoryList history list.
+func (d *Dao) HistoryList(c context.Context, u *model.UserChangeHistoryReq) (res []*model.VipChangeHistory, err error) {
+	var rows *sql.Rows
+	if rows, err = d.db.Query(c, d.joinHistoryCondition(_getUserChangeHistorySQL, u, false)); err != nil {
+		err = errors.WithStack(err)
+		d.errProm.Incr("query_db")
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		r := new(model.VipChangeHistory)
+		if err = rows.Scan(&r.ID, &r.Mid, &r.ChangeType, &r.ChangeTime, &r.Days, &r.OperatorID, &r.RelationID, &r.BatchID, &r.Remark, &r.Ctime, &r.Mtime); err != nil {
+			err = errors.WithStack(err)
+			d.errProm.Incr("rows_scan_db")
+			res = nil
+			return
+		}
+		res = append(res, r)
+	}
+	return
+}

app/admin/main/vip/dao/mysql_test.go

@@ -0,0 +1,383 @@
+package dao
+
+import (
+	"context"
+	"fmt"
+	"go-common/app/admin/main/vip/model"
+	"testing"
+	"time"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaojoinPoolCondition(t *testing.T) {
+	convey.Convey("joinPoolCondition", t, func(ctx convey.C) {
+		var (
+			sqlStr = ""
+			q      = &model.ResoucePoolBo{}
+			pn     = int(0)
+			ps     = int(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			p1 := d.joinPoolCondition(sqlStr, q, pn, ps)
+			ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(p1, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaojoinHistoryCondition(t *testing.T) {
+	convey.Convey("joinHistoryCondition", t, func(ctx convey.C) {
+		var (
+			sql     = ""
+			u       = &model.UserChangeHistoryReq{}
+			iscount bool
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			p1 := d.joinHistoryCondition(sql, u, iscount)
+			ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(p1, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoSelPoolByName(t *testing.T) {
+	convey.Convey("SelPoolByName", t, func(ctx convey.C) {
+		var (
+			c    = context.Background()
+			name = ""
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			_, err := d.SelPoolByName(c, name)
+			ctx.Convey("Then err should be nil.r should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoSelCountPool(t *testing.T) {
+	convey.Convey("SelCountPool", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+			r = &model.ResoucePoolBo{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			count, err := d.SelCountPool(c, r)
+			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 TestDaoSelPool(t *testing.T) {
+	convey.Convey("SelPool", t, func(ctx convey.C) {
+		var (
+			c  = context.Background()
+			r  = &model.ResoucePoolBo{}
+			pn = int(0)
+			ps = int(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			res, err := d.SelPool(c, r, pn, ps)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(res, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoSelPoolRow(t *testing.T) {
+	convey.Convey("SelPoolRow", t, func(ctx convey.C) {
+		var (
+			c  = context.Background()
+			id = int(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			_, err := d.SelPoolRow(c, id)
+			ctx.Convey("Then err should be nil.r should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoAddPool(t *testing.T) {
+	convey.Convey("AddPool", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+			r = &model.ResoucePoolBo{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			a, err := d.AddPool(c, r)
+			ctx.Convey("Then err should be nil.a should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(a, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoUpdatePool(t *testing.T) {
+	convey.Convey("UpdatePool", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+			r = &model.ResoucePoolBo{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			a, err := d.UpdatePool(c, r)
+			ctx.Convey("Then err should be nil.a should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(a, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoSelBatchRow(t *testing.T) {
+	convey.Convey("SelBatchRow", t, func(ctx convey.C) {
+		var (
+			c  = context.Background()
+			id = int(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			_, err := d.SelBatchRow(c, id)
+			ctx.Convey("Then err should be nil.r should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoSelBatchRows(t *testing.T) {
+	convey.Convey("SelBatchRows", t, func(ctx convey.C) {
+		var (
+			c      = context.Background()
+			poolID = int(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			_, err := d.SelBatchRows(c, poolID)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoAddBatch(t *testing.T) {
+	convey.Convey("AddBatch", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+			r = &model.ResouceBatchBo{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			a, err := d.AddBatch(c, r)
+			ctx.Convey("Then err should be nil.a should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(a, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoUpdateBatch(t *testing.T) {
+	convey.Convey("UpdateBatch", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			r   = &model.VipResourceBatch{}
+			ver = int(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			a, err := d.UpdateBatch(c, r, ver)
+			ctx.Convey("Then err should be nil.a should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(a, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoUseBatch(t *testing.T) {
+	convey.Convey("UseBatch", t, func(ctx convey.C) {
+		var (
+			r   = &model.VipResourceBatch{}
+			ver = int(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			tx, err := d.BeginTran(context.Background())
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(tx, convey.ShouldNotBeNil)
+			a, err := d.UseBatch(tx, r, ver)
+			ctx.Convey("Then err should be nil.a should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(a, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoSelBusiness(t *testing.T) {
+	convey.Convey("SelBusiness", t, func(ctx convey.C) {
+		var (
+			c  = context.Background()
+			id = int(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			_, err := d.SelBusiness(c, id)
+			ctx.Convey("Then err should be nil.r should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoSelBusinessByQuery(t *testing.T) {
+	convey.Convey("SelBusinessByQuery", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			arg = &model.QueryBusinessInfo{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			r, err := d.SelBusinessByQuery(c, arg)
+			ctx.Convey("Then err should be nil.r should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(r, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoAllVersion(t *testing.T) {
+	convey.Convey("AllVersion", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			res, err := d.AllVersion(c)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(res, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoUpdateVersion(t *testing.T) {
+	convey.Convey("UpdateVersion", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+			v = &model.VipAppVersion{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			ret, err := d.UpdateVersion(c, v)
+			ctx.Convey("Then err should be nil.ret should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(ret, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoBussinessList(t *testing.T) {
+	convey.Convey("BussinessList", t, func(ctx convey.C) {
+		var (
+			c      = context.Background()
+			pn     = int(0)
+			ps     = int(0)
+			status = int(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			_, err := d.BussinessList(c, pn, ps, status)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoBussinessCount(t *testing.T) {
+	convey.Convey("BussinessCount", t, func(ctx convey.C) {
+		var (
+			c      = context.Background()
+			status = int(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			count, err := d.BussinessCount(c, status)
+			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 TestDaoUpdateBusiness(t *testing.T) {
+	convey.Convey("UpdateBusiness", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+			r = &model.VipBusinessInfo{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			a, err := d.UpdateBusiness(c, r)
+			ctx.Convey("Then err should be nil.a should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(a, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoAddBusiness(t *testing.T) {
+	convey.Convey("AddBusiness", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+			r = &model.VipBusinessInfo{
+				AppKey: fmt.Sprintf("a:%d", time.Now().Unix()),
+			}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			a, err := d.AddBusiness(c, r)
+			ctx.Convey("Then err should be nil.a should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(a, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoHistoryCount(t *testing.T) {
+	convey.Convey("HistoryCount", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+			u = &model.UserChangeHistoryReq{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			count, err := d.HistoryCount(c, u)
+			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 TestDaoHistoryList(t *testing.T) {
+	convey.Convey("HistoryList", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+			u = &model.UserChangeHistoryReq{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			res, err := d.HistoryList(c, u)
+			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/admin/main/vip/dao/order.go

@@ -0,0 +1,105 @@
+package dao
+
+import (
+	"context"
+	"fmt"
+
+	"go-common/app/admin/main/vip/model"
+	"go-common/library/database/sql"
+
+	"github.com/pkg/errors"
+)
+
+//OrderCount order count.
+func (d *Dao) OrderCount(c context.Context, arg *model.ArgPayOrder) (count int64, err error) {
+	if arg.Mid == 0 && len(arg.OrderNo) == 0 {
+		return
+	}
+	sqlStr := _vipOrderCountSQL
+	if arg.Mid > 0 {
+		sqlStr += fmt.Sprintf(" AND mid = %v", arg.Mid)
+	}
+	if len(arg.OrderNo) > 0 {
+		sqlStr += fmt.Sprintf(" AND order_no = '%v'", arg.OrderNo)
+	}
+	if arg.Status > 0 {
+		sqlStr += fmt.Sprintf(" AND status = %v", arg.Status)
+	}
+	var row = d.db.QueryRow(c, sqlStr)
+	if err = row.Scan(&count); err != nil {
+		err = errors.WithStack(err)
+		d.errProm.Incr("row_scan_db")
+		return
+	}
+	return
+}
+
+// OrderList order list.
+func (d *Dao) OrderList(c context.Context, arg *model.ArgPayOrder) (res []*model.PayOrder, err error) {
+	if arg.Mid == 0 && len(arg.OrderNo) == 0 {
+		return
+	}
+	sqlStr := _vipOrderListSQL
+	if arg.Mid > 0 {
+		sqlStr += fmt.Sprintf(" AND mid = %v", arg.Mid)
+	}
+	if len(arg.OrderNo) > 0 {
+		sqlStr += fmt.Sprintf(" AND order_no = '%v'", arg.OrderNo)
+	}
+	if arg.Status > 0 {
+		sqlStr += fmt.Sprintf(" AND status = %v", arg.Status)
+	}
+	if arg.PN < 0 {
+		arg.PN = _defpn
+	}
+	if arg.PS < 0 || arg.PS > 100 {
+		arg.PS = _defps
+	}
+	sqlStr += fmt.Sprintf(" ORDER BY ID DESC LIMIT %v,%v", (arg.PN-1)*arg.PS, arg.PS)
+	var rows *sql.Rows
+	if rows, err = d.db.Query(c, sqlStr); err != nil {
+		err = errors.WithStack(err)
+		d.errProm.Incr("query_db")
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		r := new(model.PayOrder)
+		if err = rows.Scan(&r.ID, &r.OrderNo, &r.AppID, &r.Platform, &r.OrderType, &r.Mid, &r.ToMid, &r.BuyMonths, &r.Money, &r.RefundAmount, &r.Status, &r.PayType, &r.RechargeBp,
+			&r.ThirdTradeNo, &r.Ver, &r.PaymentTime, &r.Ctime, &r.Mtime, &r.AppSubID); err != nil {
+			err = errors.WithStack(err)
+			d.errProm.Incr("row_scan_db")
+			res = nil
+			return
+		}
+		res = append(res, r)
+	}
+	err = rows.Err()
+	return
+}
+
+// SelOrder sel order by orderNo.
+func (d *Dao) SelOrder(c context.Context, orderNo string) (r *model.PayOrder, err error) {
+	row := d.db.QueryRow(c, _vipOrderSQL, orderNo)
+	r = new(model.PayOrder)
+	if err = row.Scan(&r.ID, &r.OrderNo, &r.AppID, &r.Platform, &r.OrderType, &r.Mid, &r.ToMid, &r.BuyMonths, &r.Money, &r.RefundAmount, &r.Status, &r.PayType, &r.RechargeBp,
+		&r.ThirdTradeNo, &r.Ver, &r.PaymentTime, &r.Ctime, &r.Mtime, &r.AppSubID); err != nil {
+		if err == sql.ErrNoRows {
+			err = nil
+			r = nil
+			return
+		}
+		err = errors.WithStack(err)
+		d.errProm.Incr("row_scan_db")
+	}
+	return
+}
+
+//AddPayOrderLog add order log.
+func (d *Dao) AddPayOrderLog(c context.Context, arg *model.PayOrderLog) (err error) {
+	if _, err = d.db.Exec(c, _addOrderLogSQL, arg.OrderNo, arg.RefundID, arg.RefundAmount, arg.Operator, arg.Mid, arg.Status); err != nil {
+		err = errors.WithStack(err)
+		d.errProm.Incr("db_exec")
+	}
+	return
+}

app/admin/main/vip/dao/order_test.go

@@ -0,0 +1,72 @@
+package dao
+
+import (
+	"context"
+	"go-common/app/admin/main/vip/model"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaoOrderCount(t *testing.T) {
+	convey.Convey("OrderCount", t, func(convCtx convey.C) {
+		var (
+			c   = context.Background()
+			arg = &model.ArgPayOrder{Mid: 1, OrderNo: "1"}
+		)
+		convCtx.Convey("When everything goes positive", func(convCtx convey.C) {
+			count, err := d.OrderCount(c, arg)
+			convCtx.Convey("Then err should be nil.count should not be nil.", func(convCtx convey.C) {
+				convCtx.So(err, convey.ShouldBeNil)
+				convCtx.So(count, convey.ShouldBeGreaterThanOrEqualTo, 0)
+			})
+		})
+	})
+}
+
+func TestDaoOrderList(t *testing.T) {
+	convey.Convey("OrderList", t, func(convCtx convey.C) {
+		var (
+			c   = context.Background()
+			arg = &model.ArgPayOrder{}
+		)
+		convCtx.Convey("When everything goes positive", func(convCtx convey.C) {
+			res, err := d.OrderList(c, arg)
+			convCtx.Convey("Then err should be nil.res should be nil.", func(convCtx convey.C) {
+				convCtx.So(err, convey.ShouldBeNil)
+				convCtx.So(res, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoSelOrder(t *testing.T) {
+	convey.Convey("SelOrder", t, func(convCtx convey.C) {
+		var (
+			c       = context.Background()
+			orderNo = "2016072617212166230921"
+		)
+		convCtx.Convey("When everything goes positive", func(convCtx convey.C) {
+			r, err := d.SelOrder(c, orderNo)
+			convCtx.Convey("Then err should be nil.r should not be nil.", func(convCtx convey.C) {
+				convCtx.So(err, convey.ShouldBeNil)
+				convCtx.So(r, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoAddPayOrderLog(t *testing.T) {
+	convey.Convey("AddPayOrderLog", t, func(convCtx convey.C) {
+		var (
+			c   = context.Background()
+			arg = &model.PayOrderLog{}
+		)
+		convCtx.Convey("When everything goes positive", func(convCtx convey.C) {
+			err := d.AddPayOrderLog(c, arg)
+			convCtx.Convey("Then err should be nil.", func(convCtx convey.C) {
+				convCtx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}

app/admin/main/vip/dao/panel.go

@@ -0,0 +1,267 @@
+package dao
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"time"
+
+	"go-common/app/admin/main/vip/model"
+	xsql "go-common/library/database/sql"
+	xtime "go-common/library/time"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_inVipPriceConfigSQL = "INSERT INTO vip_price_config_v2(platform,product_name,product_id,suit_type,month,sub_type,original_price,selected,remark,status,operator,oper_id,superscript,start_build,end_build) VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)"
+
+	_inVipDPriceConfigSQL          = "INSERT INTO vip_price_discount_config_v2(vpc_id,product_id,discount_price,stime,etime,remark,operator,oper_id,first_price) VALUES(?,?,?,?,?,?,?,?,?)"
+	_upVipPriceConfigIDSQL         = "UPDATE vip_price_config_v2 SET platform = ?, product_name = ?, product_id = ?, suit_type = ?, month = ?, sub_type = ?, original_price = ?, remark = ?, status = ?, operator = ?, oper_id = ?, selected = ?, superscript = ?, start_build = ?, end_build = ? WHERE id = ?"
+	_upVipDPriceConfigSQL          = "UPDATE vip_price_discount_config_v2 SET product_id = ?, discount_price = ?, stime = ?, etime =?, remark = ?, operator = ?, oper_id = ?,first_price = ?  WHERE id = ?"
+	_delVipPriceConfigIDSQL        = "DELETE FROM vip_price_config_v2 WHERE id = ?"
+	_delVipDPriceConfigIDSQL       = "DELETE FROM vip_price_discount_config_v2 WHERE id = ?"
+	_selVipPriceConfigUQCheckSQL   = "SELECT COUNT(*) FROM vip_price_config_v2 WHERE platform = ? AND month = ? AND sub_type = ? AND suit_type = ? %s;"
+	_selVipPriceConfigsSQL         = "SELECT id,platform,product_name,product_id,suit_type,month,sub_type,original_price,selected,remark,status,operator,oper_id,ctime,mtime,superscript,start_build,end_build FROM vip_price_config_v2 ORDER BY id DESC"
+	_selVipPriceConfigIDSQL        = "SELECT id,platform,product_name,product_id,suit_type,month,sub_type,original_price,selected,remark,status,operator,oper_id,ctime,mtime,superscript,start_build,end_build FROM vip_price_config_v2 WHERE id = ?"
+	_selVipDPriceConfigsSQL        = "SELECT id,vpc_id,product_id,discount_price,stime,etime,remark,operator,oper_id,ctime,mtime,first_price FROM vip_price_discount_config_v2 WHERE vpc_id = ? ORDER BY stime ASC"
+	_selVipDPriceConfigIDSQL       = "SELECT id,vpc_id,product_id,discount_price,stime,etime,remark,operator,oper_id,ctime,mtime,first_price FROM vip_price_discount_config_v2 WHERE id = ?"
+	_selVipDPriceConfigUQTimeSQL   = "SELECT id,vpc_id,product_id,discount_price,stime,etime,remark,ctime,mtime FROM vip_price_discount_config_v2 WHERE vpc_id = ? AND ((etime <> '1970-01-01 08:00:00' AND (etime >= ? OR etime >= ?) AND stime <= ?) OR (etime = '1970-01-01 08:00:00' AND stime <= ?))"
+	_selVipPriceDiscountConfigsSQL = "SELECT vpc_id,product_id,discount_price,stime,etime,remark,ctime,mtime FROM vip_price_discount_config_v2 WHERE stime <= ? AND ((etime > ? AND  etime <> '1970-01-01 08:00:00') OR (etime = '1970-01-01 08:00:00'))"
+	_selVipMaxPriceDiscountSQL     = "SELECT MAX(discount_price) FROM vip_price_discount_config_v2 WHERE vpc_id = ?"
+	_countVipPriceConfigByplatSQL  = "SELECT COUNT(*) FROM vip_price_config_v2 WHERE platform = ?"
+)
+
+// AddVipPriceConfig insert vip price config .
+func (d *Dao) AddVipPriceConfig(c context.Context, v *model.VipPriceConfig) (err error) {
+	if _, err = d.db.Exec(c, _inVipPriceConfigSQL, v.Plat, v.PdName, v.PdID, v.SuitType, v.Month, v.SubType, v.OPrice, v.Selected, v.Remark, v.Status, v.Operator, v.OpID, v.Superscript, v.StartBuild, v.EndBuild); err != nil {
+		err = errors.WithStack(err)
+	}
+	return
+}
+
+// AddVipDPriceConfig insert vip discount price config .
+func (d *Dao) AddVipDPriceConfig(c context.Context, v *model.VipDPriceConfig) (err error) {
+	if _, err = d.db.Exec(c, _inVipDPriceConfigSQL, v.ID, v.PdID, v.DPrice, v.STime, v.ETime, v.Remark, v.Operator, v.OpID, v.FirstPrice); err != nil {
+		err = errors.WithStack(err)
+	}
+	return
+}
+
+// UpVipPriceConfig update vip price config .
+func (d *Dao) UpVipPriceConfig(c context.Context, v *model.VipPriceConfig) (err error) {
+	if _, err = d.db.Exec(c, _upVipPriceConfigIDSQL, v.Plat, v.PdName, v.PdID, v.SuitType, v.Month, v.SubType, v.OPrice, v.Remark, v.Status, v.Operator, v.OpID, v.Selected, v.Superscript, v.StartBuild, v.EndBuild, v.ID); err != nil {
+		err = errors.WithStack(err)
+	}
+	return
+}
+
+// UpVipDPriceConfig update vip discount price config .
+func (d *Dao) UpVipDPriceConfig(c context.Context, v *model.VipDPriceConfig) (err error) {
+	if _, err = d.db.Exec(c, _upVipDPriceConfigSQL, v.PdID, v.DPrice, v.STime, v.ETime, v.Remark, v.Operator, v.OpID, v.FirstPrice, v.DisID); err != nil {
+		err = errors.WithStack(err)
+	}
+	return
+}
+
+// DelVipPriceConfig delete vip price config .
+func (d *Dao) DelVipPriceConfig(c context.Context, arg *model.ArgVipPriceID) (err error) {
+	if _, err = d.db.Exec(c, _delVipPriceConfigIDSQL, arg.ID); err != nil {
+		err = errors.WithStack(err)
+	}
+	return
+}
+
+// DelVipDPriceConfig delete vip discount price config .
+func (d *Dao) DelVipDPriceConfig(c context.Context, arg *model.ArgVipDPriceID) (err error) {
+	if _, err = d.db.Exec(c, _delVipDPriceConfigIDSQL, arg.DisID); err != nil {
+		err = errors.WithStack(err)
+	}
+	return
+}
+
+// VipPriceConfigUQCheck count vip price config unquie check.
+func (d *Dao) VipPriceConfigUQCheck(c context.Context, arg *model.ArgAddOrUpVipPrice) (count int64, err error) {
+	sqlPostfix := ""
+	if arg.EndBuild > 0 {
+		sqlPostfix += fmt.Sprintf(" AND (start_build<= %d )", arg.EndBuild)
+	}
+	if arg.StartBuild > 0 {
+		sqlPostfix += fmt.Sprintf(" AND (end_build >= %d OR end_build = 0 )", arg.StartBuild)
+	}
+	if arg.ID > 0 {
+		// for update
+		sqlPostfix += fmt.Sprintf(" AND id != %d ", arg.ID)
+	}
+	if err = d.db.QueryRow(c,
+		fmt.Sprintf(_selVipPriceConfigUQCheckSQL, sqlPostfix),
+		arg.Plat,
+		arg.Month,
+		arg.SubType,
+		arg.SuitType).Scan(&count); err != nil {
+		err = errors.WithStack(err)
+	}
+	return
+}
+
+// VipPriceConfigs vip price configs
+func (d *Dao) VipPriceConfigs(c context.Context) (vpcs []*model.VipPriceConfig, err error) {
+	var rows *xsql.Rows
+	if rows, err = d.db.Query(c, _selVipPriceConfigsSQL); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		vpc := new(model.VipPriceConfig)
+		if err = rows.Scan(&vpc.ID, &vpc.Plat, &vpc.PdName, &vpc.PdID, &vpc.SuitType, &vpc.Month, &vpc.SubType,
+			&vpc.OPrice, &vpc.Selected, &vpc.Remark, &vpc.Status, &vpc.Operator, &vpc.OpID, &vpc.CTime, &vpc.MTime,
+			&vpc.Superscript, &vpc.StartBuild, &vpc.EndBuild); err != nil {
+			if err == xsql.ErrNoRows {
+				err = nil
+				vpc = nil
+			} else {
+				err = errors.WithStack(err)
+			}
+			return
+		}
+		vpcs = append(vpcs, vpc)
+	}
+	return
+}
+
+// VipPriceConfigID vip price config by id
+func (d *Dao) VipPriceConfigID(c context.Context, arg *model.ArgVipPriceID) (vpc *model.VipPriceConfig, err error) {
+	row := d.db.QueryRow(c, _selVipPriceConfigIDSQL, arg.ID)
+	vpc = new(model.VipPriceConfig)
+	if err = row.Scan(&vpc.ID, &vpc.Plat, &vpc.PdName, &vpc.PdID, &vpc.SuitType, &vpc.Month, &vpc.SubType, &vpc.OPrice, &vpc.Selected,
+		&vpc.Remark, &vpc.Status, &vpc.Operator, &vpc.OpID, &vpc.CTime, &vpc.MTime, &vpc.Superscript, &vpc.StartBuild, &vpc.EndBuild); err != nil {
+		if err != sql.ErrNoRows {
+			err = errors.WithStack(err)
+			return
+		}
+		err = nil
+		vpc = nil
+	}
+	return
+}
+
+// VipDPriceConfigs vip discount price configs
+func (d *Dao) VipDPriceConfigs(c context.Context, arg *model.ArgVipPriceID) (res []*model.VipDPriceConfig, err error) {
+	var rows *xsql.Rows
+	if rows, err = d.db.Query(c, _selVipDPriceConfigsSQL, arg.ID); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		v := new(model.VipDPriceConfig)
+		if err = rows.Scan(&v.DisID, &v.ID, &v.PdID, &v.DPrice, &v.STime, &v.ETime, &v.Remark, &v.Operator, &v.OpID, &v.CTime, &v.MTime, &v.FirstPrice); err != nil {
+			if err == xsql.ErrNoRows {
+				err = nil
+				res = nil
+			} else {
+				err = errors.WithStack(err)
+			}
+			return
+		}
+		res = append(res, v)
+	}
+	return
+}
+
+// VipDPriceConfigID vip discount price config by id
+func (d *Dao) VipDPriceConfigID(c context.Context, arg *model.ArgVipDPriceID) (res *model.VipDPriceConfig, err error) {
+	row := d.db.QueryRow(c, _selVipDPriceConfigIDSQL, arg.DisID)
+	res = new(model.VipDPriceConfig)
+	if err = row.Scan(&res.DisID, &res.ID, &res.PdID, &res.DPrice, &res.STime, &res.ETime, &res.Remark, &res.Operator, &res.OpID, &res.CTime, &res.MTime, &res.FirstPrice); err != nil {
+		if err != xsql.ErrNoRows {
+			err = errors.WithStack(err)
+			return
+		}
+		err = nil
+		res = nil
+	}
+	return
+}
+
+// VipDPriceConfigUQTime count vip discount price config unquie check time.
+func (d *Dao) VipDPriceConfigUQTime(c context.Context, arg *model.ArgAddOrUpVipDPrice) (mvd map[int64]*model.VipDPriceConfig, err error) {
+	var (
+		rows  *xsql.Rows
+		etime = arg.ETime
+	)
+	if etime == 0 {
+		etime = xtime.Time(time.Now().AddDate(1000, 0, 0).Unix())
+	}
+	mvd = make(map[int64]*model.VipDPriceConfig)
+	if rows, err = d.db.Query(c, _selVipDPriceConfigUQTimeSQL, arg.ID, arg.STime, etime, etime, arg.STime); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		vdc := new(model.VipDPriceConfig)
+		if err = rows.Scan(&vdc.DisID, &vdc.ID, &vdc.PdID, &vdc.DPrice, &vdc.STime, &vdc.ETime, &vdc.Remark, &vdc.CTime, &vdc.MTime); err != nil {
+			if err != xsql.ErrNoRows {
+				err = errors.WithStack(err)
+				return
+			}
+			mvd = nil
+			err = nil
+			return
+		}
+		mvd[vdc.DisID] = vdc
+	}
+	err = rows.Err()
+	return
+}
+
+// VipPriceDiscountConfigs get vip price discount configs.
+func (d *Dao) VipPriceDiscountConfigs(c context.Context) (mvd map[int64]*model.VipDPriceConfig, err error) {
+	var (
+		rows *xsql.Rows
+		now  = time.Now()
+	)
+	mvd = make(map[int64]*model.VipDPriceConfig)
+	if rows, err = d.db.Query(c, _selVipPriceDiscountConfigsSQL, now, now); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		vdc := new(model.VipDPriceConfig)
+		if err = rows.Scan(&vdc.ID, &vdc.PdID, &vdc.DPrice, &vdc.STime, &vdc.ETime, &vdc.Remark, &vdc.CTime, &vdc.MTime); err != nil {
+			if err != xsql.ErrNoRows {
+				err = errors.WithStack(err)
+				return
+			}
+			mvd = nil
+			err = nil
+			return
+		}
+		mvd[vdc.ID] = vdc
+	}
+	err = rows.Err()
+	return
+}
+
+// VipMaxPriceDiscount max price discount.
+func (d *Dao) VipMaxPriceDiscount(c context.Context, arg *model.ArgAddOrUpVipPrice) (res float64, err error) {
+	var max sql.NullFloat64
+	row := d.db.QueryRow(c, _selVipMaxPriceDiscountSQL, arg.ID)
+	if err = row.Scan(&max); err != nil {
+		return
+	}
+	res = max.Float64
+	return
+}
+
+// CountVipPriceConfigByPlat count vip price config by platform id.
+func (d *Dao) CountVipPriceConfigByPlat(c context.Context, plat int64) (count int64, err error) {
+	row := d.db.QueryRow(c, _countVipPriceConfigByplatSQL, plat)
+	if err = row.Scan(&count); err != nil {
+		err = errors.WithStack(err)
+	}
+	return
+}

app/admin/main/vip/dao/panel_test.go

@@ -0,0 +1,273 @@
+package dao
+
+import (
+	"context"
+	"fmt"
+	"testing"
+	"time"
+
+	"go-common/app/admin/main/vip/model"
+	xtime "go-common/library/time"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaoAddVipPriceConfig(t *testing.T) {
+	Convey("Test_AddVipPriceConfig", t, func() {
+		v := &model.VipPriceConfig{
+			Plat:     1,
+			PdName:   "ddd",
+			PdID:     "sss",
+			SuitType: 1,
+			Month:    1,
+			SubType:  2,
+			OPrice:   1,
+			Selected: 1,
+			Remark:   "",
+			Status:   0,
+			Operator: "sss",
+			OpID:     1,
+		}
+		err := d.AddVipPriceConfig(context.TODO(), v)
+		So(err, ShouldBeNil)
+	})
+	Convey("Test_AddVipPriceConfig add build 200-300", t, func() {
+		v := &model.VipPriceConfig{
+			Plat:       10,
+			PdName:     "ddd",
+			PdID:       "sss",
+			SuitType:   1,
+			Month:      1,
+			SubType:    1,
+			OPrice:     1,
+			Selected:   1,
+			Remark:     "",
+			Status:     0,
+			Operator:   "sss",
+			OpID:       1,
+			StartBuild: 200,
+			EndBuild:   300,
+		}
+		err := d.AddVipPriceConfig(context.TODO(), v)
+		So(err, ShouldBeNil)
+	})
+	Convey("Test_AddVipPriceConfig add build 0-0", t, func() {
+		v := &model.VipPriceConfig{
+			Plat:       10,
+			PdName:     "ddd",
+			PdID:       "sss",
+			SuitType:   1,
+			Month:      1,
+			SubType:    1,
+			OPrice:     1,
+			Selected:   1,
+			Remark:     "",
+			Status:     0,
+			Operator:   "sss",
+			OpID:       1,
+			StartBuild: 200,
+			EndBuild:   300,
+		}
+		err := d.AddVipPriceConfig(context.TODO(), v)
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestDaoAddVipDPriceConfig(t *testing.T) {
+	Convey("Test_AddVipPriceConfig", t, func() {
+		v := &model.VipDPriceConfig{
+			DisID:    1,
+			ID:       1,
+			PdID:     "sss",
+			DPrice:   1,
+			STime:    xtime.Time(time.Now().Unix()),
+			Remark:   "",
+			Operator: "sss",
+			OpID:     1,
+		}
+		err := d.AddVipDPriceConfig(context.TODO(), v)
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestUpVipPriceConfig(t *testing.T) {
+	Convey("TestUpVipPriceConfig", t, func() {
+		err := d.UpVipPriceConfig(context.TODO(), &model.VipPriceConfig{
+			ID:         230,
+			Plat:       10,
+			PdName:     "ddd",
+			PdID:       "sss",
+			SuitType:   1,
+			Month:      1,
+			SubType:    1,
+			OPrice:     1,
+			Selected:   1,
+			Remark:     "",
+			Status:     0,
+			Operator:   "sss",
+			OpID:       1,
+			StartBuild: 250,
+			EndBuild:   300,
+		})
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestDaoUpVipPriceConfig(t *testing.T) {
+	Convey("Test_UpVipPriceConfig", t, func() {
+		v := &model.VipPriceConfig{
+			ID:       1,
+			Plat:     1,
+			PdName:   "ddd",
+			PdID:     "sss",
+			SuitType: 1,
+			Month:    1,
+			SubType:  2,
+			OPrice:   1,
+			Selected: 1,
+			Remark:   "",
+			Status:   0,
+			Operator: "sss",
+			OpID:     1,
+		}
+		err := d.AddVipPriceConfig(context.TODO(), v)
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestDaoUpVipDPriceConfig(t *testing.T) {
+	Convey("Test_UpVipDPriceConfig", t, func() {
+		v := &model.VipDPriceConfig{
+			DisID:    1,
+			ID:       1,
+			PdID:     "sss",
+			DPrice:   1,
+			STime:    xtime.Time(time.Now().Unix()),
+			Remark:   "",
+			Operator: "sss",
+			OpID:     1,
+		}
+		err := d.UpVipDPriceConfig(context.TODO(), v)
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestDaoDelVipPriceConfig(t *testing.T) {
+	Convey("Test_DelVipPriceConfig", t, func() {
+		err := d.DelVipPriceConfig(context.TODO(), &model.ArgVipPriceID{ID: 1})
+		So(err, ShouldBeNil)
+	})
+}
+func TestDaoDelVipDPriceConfig(t *testing.T) {
+	Convey("Test_DelVipDPriceConfig", t, func() {
+		err := d.DelVipDPriceConfig(context.TODO(), &model.ArgVipDPriceID{DisID: 1})
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestDaoVipPriceConfigUQCheck(t *testing.T) {
+	Convey("Test_VipPriceConfigUQCheck", t, func() {
+		res, err := d.VipPriceConfigUQCheck(context.TODO(), &model.ArgAddOrUpVipPrice{Plat: 1, Month: 1, SubType: 1, SuitType: 0})
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeNil)
+	})
+	Convey("Test_VipPriceConfigUQCheck count 0-0", t, func() {
+		count, err := d.VipPriceConfigUQCheck(context.TODO(), &model.ArgAddOrUpVipPrice{Plat: 10, Month: 1, SubType: 1, SuitType: 1})
+		fmt.Println("count:", count)
+		So(err, ShouldBeNil)
+		So(count, ShouldNotBeNil)
+	})
+	Convey("Test_VipPriceConfigUQCheck count 220-0", t, func() {
+		count, err := d.VipPriceConfigUQCheck(context.TODO(), &model.ArgAddOrUpVipPrice{Plat: 10, Month: 1, SubType: 1, SuitType: 1, StartBuild: 220, EndBuild: 0})
+		fmt.Println("count:", count)
+		So(err, ShouldBeNil)
+		So(count, ShouldNotBeNil)
+	})
+	Convey("Test_VipPriceConfigUQCheck count 120-180", t, func() {
+		count, err := d.VipPriceConfigUQCheck(context.TODO(), &model.ArgAddOrUpVipPrice{Plat: 10, Month: 1, SubType: 1, SuitType: 1, StartBuild: 120, EndBuild: 180})
+		fmt.Println("count:", count)
+		So(err, ShouldBeNil)
+		So(count, ShouldNotBeNil)
+	})
+	Convey("Test_VipPriceConfigUQCheck count 0-180", t, func() {
+		count, err := d.VipPriceConfigUQCheck(context.TODO(), &model.ArgAddOrUpVipPrice{Plat: 10, Month: 1, SubType: 1, SuitType: 1, StartBuild: 0, EndBuild: 180})
+		fmt.Println("count:", count)
+		So(err, ShouldBeNil)
+		So(count, ShouldNotBeNil)
+	})
+	Convey("Test_VipPriceConfigUQCheck count 0-600", t, func() {
+		count, err := d.VipPriceConfigUQCheck(context.TODO(), &model.ArgAddOrUpVipPrice{Plat: 10, Month: 1, SubType: 1, SuitType: 1, StartBuild: 0, EndBuild: 600})
+		fmt.Println("count:", count)
+		So(err, ShouldBeNil)
+		So(count, ShouldNotBeNil)
+	})
+}
+
+func TestDaoVipPriceConfigs(t *testing.T) {
+	Convey("Test_VipPriceConfigs", t, func() {
+		count, err := d.VipPriceConfigs(context.TODO())
+		So(err, ShouldBeNil)
+		So(count, ShouldNotBeEmpty)
+	})
+}
+
+func TestDaoVipPriceConfigID(t *testing.T) {
+	Convey("Test_VipPriceConfigID", t, func() {
+		ids, err := d.VipPriceConfigID(context.TODO(), &model.ArgVipPriceID{ID: 1})
+		So(err, ShouldBeNil)
+		So(ids, ShouldNotBeEmpty)
+	})
+}
+
+func TestDaoVipDPriceConfigs(t *testing.T) {
+	Convey("Test_VipDPriceConfigs", t, func() {
+		count, err := d.VipDPriceConfigs(context.TODO(), &model.ArgVipPriceID{ID: 1})
+		So(err, ShouldBeNil)
+		So(count, ShouldNotBeEmpty)
+	})
+}
+
+func TestDaoVipDPriceConfigID(t *testing.T) {
+	Convey("Test_VipDPriceConfigID", t, func() {
+		res, err := d.VipDPriceConfigID(context.TODO(), &model.ArgVipDPriceID{DisID: 1})
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestDaoVipDPriceConfigUQTime(t *testing.T) {
+	Convey("Test_VipDPriceConfigUQTime", t, func() {
+		arg := &model.ArgAddOrUpVipDPrice{
+			ID:    992,
+			STime: xtime.Time(time.Now().Unix()),
+			ETime: xtime.Time(time.Now().Unix()),
+		}
+		_, err := d.VipDPriceConfigUQTime(context.TODO(), arg)
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestDaoVipPriceDiscountConfigs(t *testing.T) {
+	Convey("Test_VipPriceDiscountConfigs", t, func() {
+		res, err := d.VipPriceDiscountConfigs(context.TODO())
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestDaoVipMaxPriceDiscount(t *testing.T) {
+	Convey("Test_VipMaxPriceDiscount", t, func() {
+		res, err := d.VipMaxPriceDiscount(context.TODO(), &model.ArgAddOrUpVipPrice{ID: 1})
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestDaoCountVipPriceConfigByPlat(t *testing.T) {
+	Convey("TestDaoCountVipPriceConfigByPlat", t, func() {
+		res, err := d.CountVipPriceConfigByPlat(context.TODO(), 1)
+		fmt.Println(res)
+		So(err, ShouldBeNil)
+		So(res, ShouldBeGreaterThanOrEqualTo, 0)
+	})
+}

app/admin/main/vip/dao/platform.go

@@ -0,0 +1,80 @@
+package dao
+
+import (
+	"context"
+
+	"go-common/app/admin/main/vip/model"
+	"go-common/library/ecode"
+)
+
+const (
+	_vipConfPlatform = "vip_platform_config"
+)
+
+// PlatformAll .
+func (d *Dao) PlatformAll(c context.Context, order string) (res []*model.ConfPlatform, err error) {
+	db := d.vip.Table(_vipConfPlatform)
+	if err := db.Where("is_del=0").Order("id " + order).Find(&res).Error; err != nil {
+		return nil, err
+	}
+	return
+}
+
+// PlatformByID vip platform config by id.
+func (d *Dao) PlatformByID(c context.Context, id int64) (re *model.ConfPlatform, err error) {
+	re = &model.ConfPlatform{}
+	if err := d.vip.Table(_vipConfPlatform).Where("id=?", id).First(re).Error; err != nil {
+		if err == ecode.NothingFound {
+			err = nil
+		}
+		return nil, err
+	}
+	return
+}
+
+// PlatformSave .
+func (d *Dao) PlatformSave(c context.Context, arg *model.ConfPlatform) (eff int64, err error) {
+	db := d.vip.Table(_vipConfPlatform).Omit("ctime").Save(arg)
+	if err = db.Error; err != nil {
+		return
+	}
+	eff = db.RowsAffected
+	return
+}
+
+// PlatformEnable .
+// func (d *Dao) PlatformEnable(c context.Context, arg *model.ConfPlatform) (eff int64, err error) {
+// 	isDel := map[string]interface{}{
+// 		"is_del":    arg.IsDel,
+// 		"operator": arg.Operator,
+// 	}
+// 	db := d.vip.Table(_vipConfPlatform).Where("id=?", arg.ID).Updates(isDel)
+// 	if err = db.Error; err != nil {
+// 		return
+// 	}
+// 	eff = db.RowsAffected
+// 	return
+// }
+
+// PlatformDel delete vip platform config by id.
+func (d *Dao) PlatformDel(c context.Context, id int64, operator string) (eff int64, err error) {
+	isDel := map[string]interface{}{
+		"is_del":   1,
+		"operator": operator,
+	}
+	db := d.vip.Table(_vipConfPlatform).Where("id=?", id).Updates(isDel)
+	if err = db.Error; err != nil {
+		return
+	}
+	eff = db.RowsAffected
+	return
+}
+
+// PlatformTypes .
+func (d *Dao) PlatformTypes(c context.Context) (res []*model.TypePlatform, err error) {
+	db := d.vip.Table(_vipConfPlatform)
+	if err := db.Select("id, platform_name").Where("is_del=0").Order("id").Find(&res).Error; err != nil {
+		return nil, err
+	}
+	return
+}

app/admin/main/vip/dao/platform_test.go

@@ -0,0 +1,66 @@
+package dao
+
+import (
+	"context"
+	"testing"
+
+	"go-common/app/admin/main/vip/model"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaoPlatformSuit(t *testing.T) {
+	convey.Convey("PlatformSuit", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			arg = &model.ConfPlatform{
+				ID:           1,
+				PlatformName: "android-ut",
+				Platform:     "android",
+				Device:       "phone",
+				MobiApp:      "android",
+				PanelType:    "normal",
+				Operator:     "test1",
+			}
+		)
+		ctx.Convey("clean data before", func(ctx convey.C) {
+			d.vip.Table(_vipConfPlatform).Where("platform_name=?", "android-ut").Delete(model.ConfPlatform{})
+		})
+		ctx.Convey("PlatformSave", func(ctx convey.C) {
+			eff, err := d.PlatformSave(c, arg)
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(eff, convey.ShouldNotBeNil)
+		})
+		ctx.Convey("PlatformByID", func(ctx convey.C) {
+			re, err := d.PlatformByID(c, arg.ID)
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(re, convey.ShouldNotBeNil)
+		})
+		ctx.Convey("PlatformAll", func(ctx convey.C) {
+			res, err := d.PlatformAll(c, "desc")
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(res, convey.ShouldNotBeNil)
+		})
+		ctx.Convey("PlatformDel", func(ctx convey.C) {
+			eff, err := d.PlatformDel(c, arg.ID, arg.Operator)
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(eff, convey.ShouldBeGreaterThanOrEqualTo, 0)
+		})
+		ctx.Convey("clean data", func(ctx convey.C) {
+			d.vip.Table(_vipConfPlatform).Where("platform_name=?", "android-ut").Delete(model.ConfPlatform{})
+		})
+	})
+}
+
+func TestDaoPlatformTypes(t *testing.T) {
+	convey.Convey("PlatformTypes", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			res, err := d.PlatformTypes(c)
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(res, convey.ShouldNotBeNil)
+		})
+	})
+}

app/admin/main/vip/dao/privilege.go

@@ -0,0 +1,144 @@
+package dao
+
+import (
+	"context"
+	xsql "database/sql"
+
+	"go-common/app/admin/main/vip/model"
+
+	"github.com/jinzhu/gorm"
+	"github.com/pkg/errors"
+)
+
+const (
+	_vipPrivileges          = "vip_privileges"
+	_vipPrivilegesResources = "vip_privileges_resources"
+	updateOrderSQL          = "UPDATE vip_privileges a, vip_privileges b SET a.order_num = b.order_num, b.order_num = a.order_num WHERE a.id = ? AND b.id = ?;"
+)
+
+// PrivilegeList query .
+func (d *Dao) PrivilegeList(c context.Context, langType int8) (res []*model.Privilege, err error) {
+	db := d.vip.Table(_vipPrivileges).Where("deleted=0 AND lang_type=?", langType).Order("order_num ASC")
+	if err := db.Find(&res).Error; err != nil {
+		return nil, err
+	}
+	return
+}
+
+// PrivilegeResourcesList query privilege resources .
+func (d *Dao) PrivilegeResourcesList(c context.Context) (res []*model.PrivilegeResources, err error) {
+	db := d.vip.Table(_vipPrivilegesResources)
+	if err := db.Find(&res).Error; err != nil {
+		return nil, err
+	}
+	return
+}
+
+// UpdateStatePrivilege update state privilege.
+func (d *Dao) UpdateStatePrivilege(c context.Context, p *model.Privilege) (a int64, err error) {
+	stage := map[string]interface{}{
+		"state": p.State,
+	}
+	db := d.vip.Table(_vipPrivileges).Where("id = ?", p.ID).Updates(stage)
+	if err = db.Error; err != nil {
+		return
+	}
+	a = db.RowsAffected
+	return
+}
+
+// DeletePrivilege dekete privilege.
+func (d *Dao) DeletePrivilege(c context.Context, id int64) (a int64, err error) {
+	stage := map[string]interface{}{
+		"deleted": 1,
+	}
+	db := d.vip.Table(_vipPrivileges).Where("id = ?", id).Updates(stage)
+	if err = db.Error; err != nil {
+		return
+	}
+	a = db.RowsAffected
+	return
+}
+
+// AddPrivilege add privilege.
+func (d *Dao) AddPrivilege(tx *gorm.DB, ps *model.Privilege) (id int64, err error) {
+	db := tx.Table(_vipPrivileges).Save(ps)
+	if err = db.Error; err != nil {
+		return
+	}
+	id = ps.ID
+	return
+}
+
+// MaxOrder max priivilege order.
+func (d *Dao) MaxOrder(c context.Context) (order int64, err error) {
+	p := new(model.Privilege)
+	db := d.vip.Table(_vipPrivileges).Order("order_num DESC").First(&p)
+	if err = db.Error; err != nil {
+		return
+	}
+	return p.Order, err
+}
+
+// AddPrivilegeResources add privilege resources.
+func (d *Dao) AddPrivilegeResources(tx *gorm.DB, p *model.PrivilegeResources) (a int64, err error) {
+	db := tx.Table(_vipPrivilegesResources).Save(p)
+	if err = db.Error; err != nil {
+		return
+	}
+	a = db.RowsAffected
+	return
+}
+
+// UpdatePrivilege update privilege .
+func (d *Dao) UpdatePrivilege(tx *gorm.DB, ps *model.Privilege) (a int64, err error) {
+	val := map[string]interface{}{
+		"privileges_name": ps.Name,
+		"title":           ps.Title,
+		"explains":        ps.Explain,
+		"privileges_type": ps.Type,
+		"operator":        ps.Operator,
+	}
+	if ps.IconURL != "" {
+		val["icon_url"] = ps.IconURL
+	}
+	if ps.IconGrayURL != "" {
+		val["icon_gray_url"] = ps.IconGrayURL
+	}
+	db := tx.Table(_vipPrivileges).Where("id = ?", ps.ID).Updates(val)
+	if err = db.Error; err != nil {
+		return
+	}
+	a = db.RowsAffected
+	return
+}
+
+// UpdatePrivilegeResources update privilege resources .
+func (d *Dao) UpdatePrivilegeResources(tx *gorm.DB, ps *model.PrivilegeResources) (aff int64, err error) {
+	stage := map[string]interface{}{
+		"link": ps.Link,
+	}
+	if ps.ImageURL != "" {
+		stage["image_url"] = ps.ImageURL
+	}
+	db := tx.Table(_vipPrivilegesResources).Where("pid = ? AND resources_type = ?", ps.PID, ps.Type).Updates(stage)
+	if err = db.Error; err != nil {
+		return
+	}
+	aff = db.RowsAffected
+	return
+}
+
+// UpdateOrder update privilege order.
+func (d *Dao) UpdateOrder(c context.Context, aid, bid int64) (a int64, err error) {
+	var res xsql.Result
+	if res, err = d.db.Exec(c, updateOrderSQL, aid, bid); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	if a, err = res.RowsAffected(); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	return
+}

app/admin/main/vip/dao/privilege_test.go

@@ -0,0 +1,156 @@
+package dao
+
+import (
+	"context"
+	"testing"
+
+	"go-common/app/admin/main/vip/model"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaoPrivilegeResourcesList(t *testing.T) {
+	convey.Convey("PrivilegeResourcesList", t, func() {
+		res, err := d.PrivilegeResourcesList(context.TODO())
+		convey.So(err, convey.ShouldBeNil)
+		convey.So(res, convey.ShouldNotBeNil)
+	})
+}
+
+// go test  -test.v -test.run TestDaoAddPrivilege
+func TestDaoAddPrivilege(t *testing.T) {
+	tx := d.BeginGormTran(context.Background())
+	p := &model.Privilege{
+		Name:        "超高清",
+		Title:       "超高清标题",
+		Explain:     "超高清描述描述超多字超多字超多字超多字超多字超多字超多字超多字超多字超多字超多字超多字超多字",
+		Type:        1,
+		Operator:    "admin",
+		State:       0,
+		Deleted:     0,
+		IconURL:     "https://activity.hdslb.com/blackboard/activity9757/static/img/title_screen.c529058.jpg",
+		IconGrayURL: "https://activity.hdslb.com/blackboard/activity9757/static/img/title_screen.c529058.jpg",
+		Order:       1,
+		LangType:    1,
+	}
+	convey.Convey("get max id", t, func() {
+		ep := new(model.Privilege)
+		db := d.vip.Table(_vipPrivileges).Order("order_num DESC").First(&ep)
+		convey.So(db.Error, convey.ShouldBeNil)
+		d.vip.Table(_vipPrivilegesResources).Where("pid > ?", ep.ID).Delete(model.PrivilegeResources{})
+		p.ID = ep.ID + 1
+	})
+	convey.Convey("AddPrivilege", t, func() {
+		id, err := d.AddPrivilege(tx, p)
+		convey.So(err, convey.ShouldBeNil)
+		convey.So(id, convey.ShouldNotBeNil)
+	})
+	convey.Convey("AddPrivilegeResources", t, func() {
+		a, err := d.AddPrivilegeResources(tx, &model.PrivilegeResources{
+			PID:  p.ID,
+			Link: "web",
+			Type: model.WebResources,
+		})
+		convey.So(err, convey.ShouldBeNil)
+		convey.So(a, convey.ShouldNotBeNil)
+		a, err = d.AddPrivilegeResources(tx, &model.PrivilegeResources{
+			PID:  p.ID,
+			Link: "app",
+			Type: model.AppResources,
+		})
+		convey.So(err, convey.ShouldBeNil)
+		convey.So(a, convey.ShouldNotBeNil)
+	})
+	convey.Convey("AddPrivilege Commit", t, func() {
+		err := tx.Commit().Error
+		convey.So(err, convey.ShouldBeNil)
+	})
+	convey.Convey("PrivilegeList", t, func() {
+		res, err := d.PrivilegeList(context.TODO(), 1)
+		convey.So(err, convey.ShouldBeNil)
+		convey.So(res, convey.ShouldNotBeNil)
+	})
+	convey.Convey("clean data", t, func() {
+		d.vip.Delete(p)
+		d.vip.Table(_vipPrivilegesResources).Where("pid >= ?", p.ID).Delete(model.PrivilegeResources{})
+	})
+}
+
+func TestDaoMaxOrder(t *testing.T) {
+	convey.Convey("MaxOrder", t, func() {
+		order, err := d.MaxOrder(context.TODO())
+		convey.So(err, convey.ShouldBeNil)
+		convey.So(order, convey.ShouldNotBeNil)
+	})
+}
+
+// go test  -test.v -test.run TestDaoUpdateStatePrivilege
+
+func TestDaoUpdateStatePrivilege(t *testing.T) {
+	convey.Convey("UpdateStatePrivilege", t, func() {
+		a, err := d.UpdateStatePrivilege(context.TODO(), &model.Privilege{
+			ID:    3,
+			State: 1,
+		})
+		convey.So(err, convey.ShouldBeNil)
+		convey.So(a, convey.ShouldNotBeNil)
+	})
+}
+
+// go test  -test.v -test.run TestDaoDeletePrivilege
+func TestDaoDeletePrivilege(t *testing.T) {
+	convey.Convey("DeletePrivilege", t, func() {
+		a, err := d.DeletePrivilege(context.TODO(), 3)
+		convey.So(err, convey.ShouldBeNil)
+		convey.So(a, convey.ShouldNotBeNil)
+	})
+}
+
+// go test  -test.v -test.run TestDaoUpdatePrivilege
+func TestDaoUpdatePrivilege(t *testing.T) {
+	convey.Convey("UpdatePrivilege", t, func() {
+		tx := d.BeginGormTran(context.TODO())
+		a, err := d.UpdatePrivilege(tx, &model.Privilege{
+			ID:          3,
+			Name:        "超高清",
+			Title:       "超高清标题",
+			Explain:     "超高清描述描述超多字超多字超多字超多字超多字超多字超多字超多字超多字超多字超多字超多字超多字",
+			Type:        1,
+			Operator:    "admin",
+			State:       0,
+			Deleted:     0,
+			IconURL:     "https://activity.hdslb.com/blackboard/activity9757/static/img/title_screen.c529058.jpg",
+			IconGrayURL: "https://activity.hdslb.com/blackboard/activity9757/static/img/title_screen.c529058.jpg",
+		})
+		convey.So(err, convey.ShouldBeNil)
+		convey.So(a, convey.ShouldNotBeNil)
+		err = tx.Commit().Error
+		convey.So(err, convey.ShouldBeNil)
+	})
+}
+
+// go test  -test.v -test.run TestDaoUpdatePrivilegeResources
+
+func TestDaoUpdatePrivilegeResources(t *testing.T) {
+	convey.Convey("UpdatePrivilegeResources", t, func() {
+		tx := d.BeginGormTran(context.TODO())
+		aff, err := d.UpdatePrivilegeResources(tx, &model.PrivilegeResources{
+			PID:  3,
+			Link: "app2",
+			Type: model.AppResources,
+		})
+		convey.So(err, convey.ShouldBeNil)
+		convey.So(aff, convey.ShouldNotBeNil)
+		err = tx.Commit().Error
+		convey.So(err, convey.ShouldBeNil)
+	})
+}
+
+// go test  -test.v -test.run TestDaoUpdateOrder
+func TestDaoUpdateOrder(t *testing.T) {
+	convey.Convey("UpdateOrder", t, func() {
+		a, err := d.UpdateOrder(context.TODO(), 4, 5)
+		convey.So(err, convey.ShouldBeNil)
+		convey.So(a, convey.ShouldNotBeNil)
+	})
+}

app/admin/main/vip/dao/push.go

@@ -0,0 +1,129 @@
+package dao
+
+import (
+	"context"
+	xsql "database/sql"
+	"fmt"
+
+	"go-common/app/admin/main/vip/model"
+	"go-common/library/database/sql"
+
+	"github.com/pkg/errors"
+)
+
+// GetPushData get push data by id
+func (d *Dao) GetPushData(c context.Context, id int64) (r *model.VipPushData, err error) {
+	row := d.db.QueryRow(c, _selPushDataByIDSQL, id)
+	r = new(model.VipPushData)
+	if err = row.Scan(&r.ID, &r.DisableType, &r.GroupName, &r.Title, &r.Content, &r.PushTotalCount, &r.PushedCount, &r.ProgressStatus, &r.Status, &r.Platform, &r.LinkType, &r.LinkURL, &r.ErrorCode, &r.ExpiredDayStart, &r.ExpiredDayEnd, &r.EffectStartDate, &r.EffectEndDate, &r.PushStartTime, &r.PushEndTime, &r.Operator); err != nil {
+		if err == sql.ErrNoRows {
+			r = nil
+			err = nil
+			return
+		}
+		err = errors.WithStack(err)
+		d.errProm.Incr("scan_error")
+	}
+	return
+}
+
+// AddPushData add push data
+func (d *Dao) AddPushData(c context.Context, r *model.VipPushData) (id int64, err error) {
+	var result xsql.Result
+	if result, err = d.db.Exec(c, _addPushDataSQL, r.GroupName, r.Title, r.Content, r.PushTotalCount, r.PushedCount, r.ProgressStatus, r.Status, r.Platform, r.LinkType, r.LinkURL, r.ExpiredDayStart, r.ExpiredDayEnd, r.EffectStartDate, r.EffectEndDate, r.PushStartTime, r.PushEndTime, r.Operator); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+
+	if id, err = result.LastInsertId(); err != nil {
+		err = errors.WithStack(err)
+	}
+	return
+}
+
+// UpdatePushData update push data
+func (d *Dao) UpdatePushData(c context.Context, r *model.VipPushData) (eff int64, err error) {
+	var result xsql.Result
+	if result, err = d.db.Exec(c, _updatePushDataSQL, r.GroupName, r.Title, r.Content, r.PushTotalCount, r.ProgressStatus, r.Platform, r.LinkType, r.LinkURL, r.ExpiredDayStart, r.ExpiredDayEnd, r.EffectStartDate, r.EffectEndDate, r.PushStartTime, r.PushEndTime, r.Operator, r.ID); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+
+	if eff, err = result.RowsAffected(); err != nil {
+		err = errors.WithStack(err)
+	}
+	return
+}
+
+// PushDataCount sel push data count
+func (d *Dao) PushDataCount(c context.Context, arg *model.ArgPushData) (count int64, err error) {
+	row := d.db.QueryRow(c, _selPushDataCountSQL+d.convertPushDataSQL(arg))
+
+	if err = row.Scan(&count); err != nil {
+		err = errors.WithStack(err)
+	}
+	return
+}
+
+// PushDatas sel push datas
+func (d *Dao) PushDatas(c context.Context, arg *model.ArgPushData) (res []*model.VipPushData, err error) {
+	var rows *sql.Rows
+	sql := _selPushDataSQL + d.convertPushDataSQL(arg)
+
+	if arg.PN == 0 {
+		arg.PN = 1
+	}
+
+	if arg.PS == 0 || arg.PS > 100 {
+		arg.PS = _defps
+	}
+
+	sql += fmt.Sprintf(" ORDER BY id DESC LIMIT %v,%v", (arg.PN-1)*arg.PS, arg.PS)
+
+	if rows, err = d.db.Query(c, sql); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		r := new(model.VipPushData)
+
+		if err = rows.Scan(&r.ID, &r.DisableType, &r.GroupName, &r.Title, &r.Content, &r.PushTotalCount, &r.PushedCount, &r.ProgressStatus, &r.Status, &r.Platform, &r.LinkType, &r.LinkURL, &r.ErrorCode, &r.ExpiredDayStart, &r.ExpiredDayEnd, &r.EffectStartDate, &r.EffectEndDate, &r.PushStartTime, &r.PushEndTime, &r.Operator); err != nil {
+			err = errors.WithStack(err)
+		}
+		res = append(res, r)
+	}
+
+	err = rows.Err()
+	return
+}
+
+func (d *Dao) convertPushDataSQL(arg *model.ArgPushData) string {
+	sql := " "
+	if arg.ProgressStatus != 0 {
+		sql += fmt.Sprintf(" AND progress_status=%v", arg.ProgressStatus)
+	}
+	if arg.Status != 0 {
+		sql += fmt.Sprintf(" AND status=%v", arg.Status)
+	}
+	return sql
+}
+
+// DelPushData .
+func (d *Dao) DelPushData(c context.Context, id int64) (err error) {
+	if _, err = d.db.Exec(c, _delPushDataSQL, id); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	return
+}
+
+// DisablePushData .
+func (d *Dao) DisablePushData(c context.Context, res *model.VipPushData) (err error) {
+	if _, err = d.db.Exec(c, _disablePushDataSQL, res.ProgressStatus, res.PushTotalCount, res.EffectEndDate, res.ID); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	return
+}

app/admin/main/vip/dao/push_test.go

@@ -0,0 +1,49 @@
+package dao
+
+import (
+	"context"
+	"go-common/app/admin/main/vip/model"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaoAddPushData(t *testing.T) {
+	var (
+		id  int64
+		err error
+	)
+	convey.Convey("AddPushData", t, func() {
+		id, err = d.AddPushData(context.TODO(), &model.VipPushData{Title: "test push"})
+		convey.So(err, convey.ShouldBeNil)
+		convey.So(id, convey.ShouldNotBeNil)
+	})
+	convey.Convey("GetPushData", t, func() {
+		r, err := d.GetPushData(context.TODO(), id)
+		convey.So(err, convey.ShouldBeNil)
+		convey.So(r, convey.ShouldNotBeNil)
+	})
+	convey.Convey("UpdatePushData", t, func() {
+		eff, err := d.UpdatePushData(context.TODO(), &model.VipPushData{ID: id, Title: "push test"})
+		convey.So(err, convey.ShouldBeNil)
+		convey.So(eff, convey.ShouldNotBeNil)
+	})
+	convey.Convey("PushDataCount", t, func() {
+		count, err := d.PushDataCount(context.TODO(), &model.ArgPushData{})
+		convey.So(err, convey.ShouldBeNil)
+		convey.So(count, convey.ShouldNotBeNil)
+	})
+	convey.Convey("PushDatas", t, func() {
+		res, err := d.PushDatas(context.TODO(), &model.ArgPushData{})
+		convey.So(err, convey.ShouldBeNil)
+		convey.So(res, convey.ShouldNotBeNil)
+	})
+	convey.Convey("DisablePushData", t, func() {
+		err := d.DisablePushData(context.TODO(), &model.VipPushData{ID: id, Title: "push test"})
+		convey.So(err, convey.ShouldBeNil)
+	})
+	convey.Convey("DelPushData", t, func() {
+		err := d.DelPushData(context.TODO(), id)
+		convey.So(err, convey.ShouldBeNil)
+	})
+}

app/admin/main/vip/dao/resouce.go

@@ -0,0 +1,302 @@
+package dao
+
+import (
+	"context"
+	xsql "database/sql"
+	"fmt"
+	"strconv"
+	"strings"
+
+	"go-common/app/admin/main/vip/model"
+	"go-common/library/database/sql"
+
+	"github.com/pkg/errors"
+)
+
+// SelBatchCodeCount .
+func (d *Dao) SelBatchCodeCount(c context.Context, arg *model.ArgBatchCode) (n int64, err error) {
+	autoSQLStr := d.batchCodeAutoArg(arg)
+	row := d.db.QueryRow(c, _selBatchCodeCountSQL+autoSQLStr)
+	if err = row.Scan(&n); err != nil {
+		if err == sql.ErrNoRows {
+			n = 0
+			err = nil
+			return
+		}
+		err = errors.WithStack(err)
+		return
+	}
+	return
+}
+
+func (d *Dao) selBatchCodeIDs(c context.Context, poolID, businessID, batchID int64) (ids []int64, err error) {
+	var rows *sql.Rows
+	autoSQL := d.batchCodeAutoArg(&model.ArgBatchCode{
+		BusinessID: businessID,
+		PoolID:     poolID,
+		ID:         batchID,
+	})
+	if rows, err = d.db.Query(c, _selBatchCodeIDSQL+autoSQL); err != nil {
+		err = errors.WithStack(err)
+		d.errProm.Incr("db_query")
+		return
+	}
+	for rows.Next() {
+		var r int64
+		if err = rows.Scan(&r); err != nil {
+			err = errors.WithStack(err)
+			ids = nil
+			d.errProm.Incr("db_scan")
+			return
+		}
+		ids = append(ids, r)
+	}
+	return
+}
+
+func (d *Dao) codeAutoArgSQL(arg *model.ArgCode) string {
+	autoSQLStr := ""
+	if len(arg.BatchCodeIDs) > 0 {
+		idStr := ""
+		for _, v := range arg.BatchCodeIDs {
+			idStr += "," + strconv.Itoa(int(v))
+		}
+		autoSQLStr += fmt.Sprintf(" AND batch_code_id in(%s) ", idStr[1:])
+	}
+	if arg.Status != 0 {
+		autoSQLStr += fmt.Sprintf(" AND status = %v ", arg.Status)
+	}
+	if arg.UseStartTime > 0 && arg.UseEndTime > 0 {
+		autoSQLStr += fmt.Sprintf(" AND use_time >='%v' AND use_time <= '%v'", arg.UseStartTime.Time().Format("2006-01-02 15:04:05"), arg.UseEndTime.Time().Format("2006-01-02 15:04:05"))
+	}
+	if len(arg.Code) > 0 {
+		autoSQLStr += fmt.Sprintf(" AND code = '%v' ", arg.Code)
+	}
+	if arg.Mid != 0 {
+		autoSQLStr += fmt.Sprintf(" AND mid = %v ", arg.Mid)
+	}
+
+	return autoSQLStr
+}
+
+// SelCode .
+func (d *Dao) SelCode(c context.Context, arg *model.ArgCode, cursor int64, ps int) (res []*model.ResourceCode, err error) {
+	var batchIDs []int64
+	if batchIDs, err = d.selBatchCodeIDs(c, arg.PoolID, arg.BusinessID, arg.BatchCodeID); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	arg.BatchCodeIDs = batchIDs
+	argSQL := d.codeAutoArgSQL(arg)
+	if ps <= 0 || ps > 2000 {
+		ps = _defps
+	}
+	var rows *sql.Rows
+	argSQL += fmt.Sprintf(" AND id>%v LIMIT %v", cursor, ps)
+	if rows, err = d.db.Query(c, _selCodeSQL+argSQL); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	for rows.Next() {
+		r := new(model.ResourceCode)
+		if err = rows.Scan(&r.ID, &r.BatchCodeID, &r.Status, &r.Code, &r.Mid, &r.UseTime, &r.Ctime); err != nil {
+			err = errors.WithStack(err)
+			res = nil
+			return
+		}
+		res = append(res, r)
+	}
+	return
+
+}
+
+// batchCodeAutoArg .
+func (d *Dao) batchCodeAutoArg(arg *model.ArgBatchCode) string {
+	autoSQLStr := ""
+	if arg.BusinessID > 0 {
+		autoSQLStr += fmt.Sprintf(" AND business_id=%v ", arg.BusinessID)
+	}
+	if arg.PoolID > 0 {
+		autoSQLStr += fmt.Sprintf(" AND pool_id = %v ", arg.PoolID)
+	}
+	if arg.ID > 0 {
+		autoSQLStr += fmt.Sprintf(" AND id = %v ", arg.ID)
+	}
+	if len(arg.Name) > 0 {
+		autoSQLStr += " AND batch_name like '%" + arg.Name + "%'"
+	}
+	if arg.Status > 0 {
+		autoSQLStr += fmt.Sprintf(" AND status = %v", arg.Status)
+	}
+
+	if arg.StartTime > 0 && arg.EndTime > 0 {
+		autoSQLStr += fmt.Sprintf(" AND ctime >='%v' AND ctime <= '%v'", arg.StartTime.Time().Format("2006-01-02 15:04:05"), arg.EndTime.Time().Format("2006-01-02 15:04:05"))
+	}
+	return autoSQLStr
+}
+
+// SelBatchCodes .
+func (d *Dao) SelBatchCodes(c context.Context, batchIds []int64) (res []*model.BatchCode, err error) {
+	var (
+		rows *sql.Rows
+		ids  []string
+	)
+	if len(batchIds) <= 0 {
+		return
+	}
+	for _, v := range batchIds {
+		ids = append(ids, fmt.Sprintf("%v", v))
+	}
+
+	if rows, err = d.db.Query(c, fmt.Sprintf(_selBatchCodesSQL, strings.Join(ids, ","))); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	for rows.Next() {
+		r := new(model.BatchCode)
+		if err = rows.Scan(&r.ID, &r.BusinessID, &r.PoolID, &r.Status, &r.Type, &r.LimitDay, &r.MaxCount, &r.BatchName, &r.Reason, &r.Unit, &r.Count, &r.SurplusCount, &r.Price, &r.StartTime, &r.EndTime, &r.Contacts, &r.ContactsNumber, &r.Ctime); err != nil {
+			err = errors.WithStack(err)
+			res = nil
+			return
+		}
+		res = append(res, r)
+	}
+	return
+}
+
+// SelBatchCode .
+func (d *Dao) SelBatchCode(c context.Context, arg *model.ArgBatchCode, pn, ps int) (res []*model.BatchCode, err error) {
+	var rows *sql.Rows
+	autoSQLStr := d.batchCodeAutoArg(arg)
+	if pn <= 0 {
+		pn = _defpn
+	}
+	if ps <= 0 || ps > _maxps {
+		ps = _defps
+	}
+
+	autoSQLStr += fmt.Sprintf(" LIMIT %v,%v", (pn-1)*ps, ps)
+
+	if rows, err = d.db.Query(c, _selBatchCodeSQL+autoSQLStr); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		r := new(model.BatchCode)
+		if err = rows.Scan(&r.ID, &r.BusinessID, &r.PoolID, &r.Status, &r.Type, &r.LimitDay, &r.MaxCount, &r.BatchName, &r.Reason, &r.Unit, &r.Count, &r.SurplusCount, &r.Price, &r.StartTime, &r.EndTime, &r.Contacts, &r.ContactsNumber, &r.Ctime); err != nil {
+			err = errors.WithStack(err)
+			res = nil
+			return
+		}
+		res = append(res, r)
+	}
+
+	return
+}
+
+// SelBatchCodeName .
+func (d *Dao) SelBatchCodeName(c context.Context, name string) (r *model.BatchCode, err error) {
+	row := d.db.QueryRow(c, _selBatchCodeByNameSQL, name)
+	r = new(model.BatchCode)
+	if err = row.Scan(&r.ID, &r.BusinessID, &r.PoolID, &r.Status, &r.Type, &r.LimitDay, &r.MaxCount, &r.BatchName, &r.Reason, &r.Unit, &r.Count, &r.SurplusCount, &r.Price, &r.StartTime, &r.EndTime, &r.Contacts, &r.ContactsNumber, &r.Ctime); err != nil {
+		if err == sql.ErrNoRows {
+			r = nil
+			err = nil
+			fmt.Printf("this is  %+v", err)
+			return
+		}
+		err = errors.WithStack(err)
+		return
+	}
+	return
+}
+
+// SelBatchCodeID .
+func (d *Dao) SelBatchCodeID(c context.Context, batchCodeID int64) (r *model.BatchCode, err error) {
+	row := d.db.QueryRow(c, _selBatchCodeByIDSQL, batchCodeID)
+	r = new(model.BatchCode)
+	if err = row.Scan(&r.ID, &r.BusinessID, &r.PoolID, &r.Status, &r.Type, &r.LimitDay, &r.MaxCount, &r.BatchName, &r.Reason, &r.Unit, &r.Count, &r.SurplusCount, &r.Price, &r.StartTime, &r.EndTime, &r.Contacts, &r.ContactsNumber, &r.Ctime); err != nil {
+		if err == sql.ErrNoRows {
+			r = nil
+			err = nil
+			return
+		}
+		err = errors.WithStack(err)
+		return
+	}
+	return
+}
+
+// SelCodeID .
+func (d *Dao) SelCodeID(c context.Context, codeID int64) (r *model.ResourceCode, err error) {
+
+	row := d.db.QueryRow(c, _selCodeByIDSQL, codeID)
+	r = new(model.ResourceCode)
+	if err = row.Scan(&r.ID, &r.BatchCodeID, &r.Status, &r.Code, &r.Mid, &r.UseTime, &r.Ctime); err != nil {
+		if err == sql.ErrNoRows {
+			r = nil
+			err = nil
+		}
+		err = errors.WithStack(err)
+		return
+	}
+	return
+}
+
+// TxAddBatchCode .
+func (d *Dao) TxAddBatchCode(tx *sql.Tx, bc *model.BatchCode) (ID int64, err error) {
+	var result xsql.Result
+	if result, err = tx.Exec(_addBatchCodeSQL, bc.BusinessID, bc.PoolID, bc.Status, bc.BatchName, bc.Reason, bc.Unit, bc.Count, bc.SurplusCount, bc.Price, bc.StartTime, bc.EndTime, bc.Contacts, bc.ContactsNumber, bc.Type, bc.LimitDay, bc.MaxCount, bc.Operator); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	if ID, err = result.LastInsertId(); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	return
+}
+
+// UpdateBatchCode .
+func (d *Dao) UpdateBatchCode(c context.Context, bc *model.BatchCode) (eff int64, err error) {
+	var result xsql.Result
+	if result, err = d.db.Exec(c, _updateBatchCodeSQL, &bc.Status, &bc.BatchName, &bc.Reason, &bc.Price, &bc.Contacts, &bc.ContactsNumber, &bc.Type, &bc.LimitDay, &bc.MaxCount, &bc.Operator, &bc.ID); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	if eff, err = result.RowsAffected(); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	return
+}
+
+// UpdateCode .
+func (d *Dao) UpdateCode(c context.Context, codeID int64, status int8) (eff int64, err error) {
+	var result xsql.Result
+	if result, err = d.db.Exec(c, _updateCodeSQL, status, codeID); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	if eff, err = result.RowsAffected(); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	return
+}
+
+// BatchAddCode .
+func (d *Dao) BatchAddCode(tx *sql.Tx, codes []*model.ResourceCode) (err error) {
+	values := make([]string, 0)
+	for _, v := range codes {
+		s := fmt.Sprintf("('%v','%v','%v')", v.BatchCodeID, v.Status, v.Code)
+		values = append(values, s)
+	}
+	valuesStr := strings.Join(values, ",")
+	if _, err = tx.Exec(_batchAddCodeSQL + valuesStr); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	return
+}

app/admin/main/vip/dao/resouce_test.go

@@ -0,0 +1,108 @@
+package dao
+
+import (
+	"context"
+	"math/rand"
+	"testing"
+
+	"go-common/app/admin/main/vip/model"
+	xsql "go-common/library/database/sql"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaoSelBatchCodeCount(t *testing.T) {
+	convey.Convey("SelBatchCodeCount", t, func() {
+		n, err := d.SelBatchCodeCount(context.TODO(), &model.ArgBatchCode{})
+		convey.So(err, convey.ShouldBeNil)
+		convey.So(n, convey.ShouldNotBeNil)
+	})
+}
+
+func TestDaoselBatchCodeIDs(t *testing.T) {
+	convey.Convey("selBatchCodeIDs", t, func() {
+		ids, err := d.selBatchCodeIDs(context.TODO(), 0, 0, 0)
+		convey.So(err, convey.ShouldBeNil)
+		convey.So(ids, convey.ShouldNotBeNil)
+	})
+}
+
+func TestDaocodeAutoArgSQL(t *testing.T) {
+	convey.Convey("codeAutoArgSQL", t, func() {
+		p1 := d.codeAutoArgSQL(&model.ArgCode{})
+		convey.So(p1, convey.ShouldNotBeNil)
+	})
+}
+
+func TestDaoSelCode(t *testing.T) {
+	convey.Convey("SelCode", t, func() {
+		_, err := d.SelCode(context.TODO(), &model.ArgCode{}, 0, 0)
+		convey.So(err, convey.ShouldBeNil)
+	})
+}
+
+func TestDaoSelBatchCodes(t *testing.T) {
+	convey.Convey("SelBatchCodes", t, func() {
+		_, err := d.SelBatchCodes(context.TODO(), []int64{})
+		convey.So(err, convey.ShouldBeNil)
+	})
+}
+
+func TestDaoSelBatchCode(t *testing.T) {
+	convey.Convey("SelBatchCode", t, func() {
+		_, err := d.SelBatchCode(context.TODO(), &model.ArgBatchCode{}, 0, 0)
+		convey.So(err, convey.ShouldBeNil)
+	})
+}
+
+func TestDaoTxAddBatchCode(t *testing.T) {
+	var (
+		id  int64
+		err error
+	)
+	convey.Convey("TxAddBatchCode", t, func() {
+		var tx *xsql.Tx
+		tx, err = d.BeginTran(context.Background())
+		convey.So(err, convey.ShouldBeNil)
+		id, err = d.TxAddBatchCode(tx, &model.BatchCode{BusinessID: 1, BatchName: "ut_test"})
+		convey.So(err, convey.ShouldBeNil)
+		convey.So(id, convey.ShouldNotBeNil)
+		tx.Commit()
+	})
+	convey.Convey("SelCodeID", t, func() {
+		r, err := d.SelCodeID(context.TODO(), id)
+		convey.So(err, convey.ShouldBeNil)
+		convey.So(r, convey.ShouldNotBeNil)
+	})
+	convey.Convey("SelBatchCodeID", t, func() {
+		r, err := d.SelBatchCodeID(context.TODO(), id)
+		convey.So(err, convey.ShouldBeNil)
+		convey.So(r, convey.ShouldNotBeNil)
+	})
+	convey.Convey("SelBatchCodeName", t, func() {
+		_, err := d.SelBatchCodeName(context.TODO(), "ut_test")
+		convey.So(err, convey.ShouldBeNil)
+	})
+	convey.Convey("UpdateBatchCode", t, func() {
+		eff, err := d.UpdateBatchCode(context.TODO(), &model.BatchCode{ID: id, BusinessID: 11})
+		convey.So(err, convey.ShouldBeNil)
+		convey.So(eff, convey.ShouldNotBeNil)
+	})
+	convey.Convey("UpdateCode", t, func() {
+		eff, err := d.UpdateCode(context.TODO(), id, 0)
+		convey.So(err, convey.ShouldBeNil)
+		convey.So(eff, convey.ShouldNotBeNil)
+	})
+}
+
+func TestDaoBatchAddCode(t *testing.T) {
+	codes := []*model.ResourceCode{
+		{BatchCodeID: int64(rand.Int31())},
+	}
+	convey.Convey("BatchAddCode", t, func() {
+		tx, err := d.BeginTran(context.Background())
+		convey.So(err, convey.ShouldBeNil)
+		err = d.BatchAddCode(tx, codes)
+		convey.So(err, convey.ShouldBeNil)
+	})
+}

app/admin/main/vip/dao/send.go

@@ -0,0 +1,176 @@
+package dao
+
+import (
+	"bytes"
+	"context"
+	"crypto/md5"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+
+	"go-common/app/admin/main/vip/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+
+	"github.com/google/uuid"
+	"github.com/pkg/errors"
+)
+
+const (
+	_SendUserNotify = "/api/notify/send.user.notify.do"
+
+	_payRefund = "/payplatform/refund/request"
+
+	_minRead = 1024 * 64
+)
+
+// SendMultipMsg send multip msg
+func (d *Dao) SendMultipMsg(c context.Context, mids, content, title, mc, ip string, dataType int) (err error) {
+
+	params := url.Values{}
+	params.Set("mc", mc)
+	params.Set("title", title)
+	params.Set("context", content)
+	params.Set("data_type", strconv.FormatInt(int64(dataType), 10))
+	params.Set("mid_list", mids)
+	if err = d.client.Post(c, d.c.Property.MsgURI+_SendUserNotify, "127.0.0.1", params, nil); err != nil {
+		log.Error("SendMultipMsg error(%v)", err)
+		return
+	}
+	return
+}
+
+//PayRefund .
+func (d *Dao) PayRefund(c context.Context, arg *model.PayOrder, refundAmount float64, refundID string) (err error) {
+	params := make(map[string]string)
+	params["customerId"] = strconv.FormatInt(d.c.PayConf.CustomerID, 10)
+	params["notifyUrl"] = d.c.PayConf.RefundURL
+	params["version"] = d.c.PayConf.Version
+	params["signType"] = "MD5"
+	params["timestamp"] = strconv.FormatInt(time.Now().UnixNano()/1e6, 10)
+	params["traceId"] = uuid.New().String()
+	params["refundDesc"] = "大会员退款"
+	params["customerRefundId"] = refundID
+	params["txId"] = arg.ThirdTradeNo
+	params["totalAmount"] = strconv.Itoa(int(arg.Money * 100))
+	params["refundAmount"] = strconv.Itoa(int(refundAmount * 100))
+	sign := d.paySign(params, d.c.PayConf.Token)
+	params["sign"] = sign
+	resq := new(struct {
+		Code int    `json:"errno"`
+		Msg  string `json:"msg"`
+	})
+	if err = d.doPaySend(c, d.c.PayConf.BaseURL, _payRefund, "", nil, nil, params, resq); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	if resq.Code != ecode.OK.Code() {
+		err = ecode.Int(resq.Code)
+	}
+	return
+}
+
+func (d *Dao) paySign(params map[string]string, token string) (sign string) {
+	tmp := d.sortParamsKey(params)
+	var b bytes.Buffer
+	b.WriteString(tmp)
+	b.WriteString(fmt.Sprintf("&token=%s", token))
+	log.Info("pay sign params:(%s) \n", b.String())
+	mh := md5.Sum(b.Bytes())
+	// query
+	sign = hex.EncodeToString(mh[:])
+	log.Info("pay sign (%v)", sign)
+	return
+}
+
+func (d *Dao) sortParamsKey(v map[string]string) string {
+	if v == nil {
+		return ""
+	}
+
+	var buf bytes.Buffer
+	keys := make([]string, 0, len(v))
+	for k := range v {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+	for _, k := range keys {
+		vs := v[k]
+		prefix := k + "="
+		if buf.Len() > 0 {
+			buf.WriteByte('&')
+		}
+		buf.WriteString(prefix)
+		buf.WriteString(vs)
+	}
+	return buf.String()
+}
+
+func (d *Dao) doPaySend(c context.Context, basePath, path, IP string, cookie []*http.Cookie, header map[string]string, params map[string]string, data interface{}) (err error) {
+	var (
+		req    *http.Request
+		client = new(http.Client)
+		resp   *http.Response
+		bs     []byte
+	)
+	url := basePath + path
+	marshal, _ := json.Marshal(params)
+	if req, err = http.NewRequest(http.MethodPost, url, strings.NewReader(string(marshal))); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	req.Header.Add("Content-Type", "application/json")
+	req.Header.Add("x-backend-bili-real-ip", IP)
+	for _, v := range cookie {
+		req.AddCookie(v)
+	}
+	for k, v := range header {
+		req.Header.Add(k, v)
+	}
+	if resp, err = client.Do(req); err != nil {
+		log.Error("call url:%v params:(%+v)", basePath+path, params)
+		err = errors.WithStack(err)
+		return
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode >= http.StatusBadRequest {
+		err = errors.Errorf("incorrect http status:%d host:%s, url:%s", resp.StatusCode, req.URL.Host, req.URL.String())
+		return
+	}
+	if bs, err = readAll(resp.Body, _minRead); err != nil {
+		err = errors.Wrapf(err, "host:%s, url:%s", req.URL.Host, req.URL.String())
+		return
+	}
+	if err = json.Unmarshal(bs, data); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	log.Info("call url:%v params:%+v result:%+v", url, params, data)
+	return
+}
+
+func readAll(r io.Reader, capacity int64) (b []byte, err error) {
+	buf := bytes.NewBuffer(make([]byte, 0, capacity))
+	// If the buffer overflows, we will get bytes.ErrTooLarge.
+	// Return that as an error. Any other panic remains.
+	defer func() {
+		e := recover()
+		if e == nil {
+			return
+		}
+		if panicErr, ok := e.(error); ok && panicErr == bytes.ErrTooLarge {
+			err = panicErr
+		} else {
+			panic(e)
+		}
+	}()
+	_, err = buf.ReadFrom(r)
+	return buf.Bytes(), err
+}

app/admin/main/vip/dao/send_test.go

@@ -0,0 +1,33 @@
+package dao
+
+import (
+	"context"
+	"go-common/app/admin/main/vip/model"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+	gock "gopkg.in/h2non/gock.v1"
+)
+
+func TestDaoSendMultipMsg(t *testing.T) {
+	convey.Convey("SendMultipMsg", t, func() {
+		defer gock.OffAll()
+		httpMock("POST", _SendUserNotify).Reply(200).JSON(`{"code":0}`)
+		err := d.SendMultipMsg(context.TODO(), "", "", "", "", "", 0)
+		convey.So(err, convey.ShouldBeNil)
+	})
+}
+
+func TestDaoPayRefund(t *testing.T) {
+	var (
+		arg                  = &model.PayOrder{}
+		refundAmount float64 = 1.0
+		refundID             = "test001"
+	)
+	convey.Convey("PayRefund", t, func() {
+		defer gock.OffAll()
+		httpMock("POST", _payRefund).Reply(200).JSON(`{"code":0}`)
+		err := d.PayRefund(context.Background(), arg, refundAmount, refundID)
+		convey.So(err, convey.ShouldBeNil)
+	})
+}

app/admin/main/vip/dao/tips.go

@@ -0,0 +1,128 @@
+package dao
+
+import (
+	"context"
+	xsql "database/sql"
+	"fmt"
+
+	"go-common/app/admin/main/vip/model"
+	"go-common/library/database/sql"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_tipsSQL      = "SELECT `id`,`platform`,`version`,`tip`,`link`,`start_time`,`end_time`,`level`,`judge_type`,`operator`,`deleted`, `position`,`ctime`,`mtime`FROM `vip_tips` WHERE  `deleted` = 0 "
+	_tipsByIDSQL  = "SELECT `id`,`platform`,`version`,`tip`,`link`,`start_time`,`end_time`,`level`,`judge_type`,`operator`,`deleted`, `position`,`ctime`,`mtime`FROM `vip_tips` WHERE  `id` = ?;"
+	_updateTipSQL = "UPDATE `vip_tips` SET `platform` = ?,`version` = ?,`tip` = ?,`link` = ?,`start_time` = ?,`end_time` = ?,`level` = ?, `judge_type` = ?, `operator` = ?, `position` = ? WHERE `id` = ?;"
+	_addTipSQL    = "INSERT INTO `vip_tips`(`platform`,`version`,`tip`,`link`,`start_time`,`end_time`,`level`,`judge_type`,`operator`,`deleted`,`ctime`, `position`)VALUES(?,?,?,?,?,?,?,?,?,?,?,?);"
+	_deleteTipSQL = "UPDATE `vip_tips` SET `deleted` = ?,`operator` = ? WHERE `id` = ?;"
+	_expireTipSQL = "UPDATE `vip_tips` SET `end_time` = ?,`operator` = ? WHERE `id` = ?;"
+)
+
+// TipList tips list.
+func (d *Dao) TipList(c context.Context, platform int8, state int8, now int64, position int8) (rs []*model.Tips, err error) {
+	var (
+		rows *sql.Rows
+		sql  = _tipsSQL
+	)
+	switch state {
+	case model.WaitShowTips:
+		sql += fmt.Sprintf(" AND `start_time` > %d ", now)
+	case model.EffectiveTips:
+		sql += fmt.Sprintf(" AND `start_time` < %d AND `end_time`> %d", now, now)
+	case model.ExpireTips:
+		sql += fmt.Sprintf(" AND `end_time` < %d ", now)
+	}
+	if platform != 0 {
+		sql += fmt.Sprintf(" AND `platform` = %d ", platform)
+	}
+	if position != 0 {
+		sql += fmt.Sprintf(" AND `position` = %d ", position)
+	}
+	if rows, err = d.db.Query(c, sql); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		r := new(model.Tips)
+		if err = rows.Scan(&r.ID, &r.Platform, &r.Version, &r.Tip, &r.Link, &r.StartTime, &r.EndTime, &r.Level, &r.JudgeType, &r.Operator, &r.Deleted, &r.Position, &r.Ctime, &r.Mtime); err != nil {
+			rs = nil
+			err = errors.WithStack(err)
+			return
+		}
+		rs = append(rs, r)
+	}
+	if err = rows.Err(); err != nil {
+		err = errors.WithStack(err)
+	}
+	return
+}
+
+// TipByID by id .
+func (d *Dao) TipByID(c context.Context, id int64) (r *model.Tips, err error) {
+	res := d.db.QueryRow(c, _tipsByIDSQL, id)
+	r = new(model.Tips)
+	if err = res.Scan(&r.ID, &r.Platform, &r.Version, &r.Tip, &r.Link, &r.StartTime, &r.EndTime, &r.Level, &r.JudgeType, &r.Operator, &r.Deleted, &r.Position, &r.Ctime, &r.Mtime); err != nil {
+		if err == sql.ErrNoRows {
+			err = nil
+			r = nil
+			return
+		}
+		err = errors.WithStack(err)
+	}
+	return
+}
+
+// TipUpdate tip update.
+func (d *Dao) TipUpdate(c context.Context, t *model.Tips) (eff int64, err error) {
+	var res xsql.Result
+	if res, err = d.db.Exec(c, _updateTipSQL, t.Platform, t.Version, t.Tip, t.Link, t.StartTime, t.EndTime, t.Level, t.JudgeType, t.Operator, t.Position, t.ID); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	if eff, err = res.RowsAffected(); err != nil {
+		err = errors.WithStack(err)
+	}
+	return
+}
+
+// AddTip add tip.
+func (d *Dao) AddTip(c context.Context, t *model.Tips) (lid int64, err error) {
+	var res xsql.Result
+	if res, err = d.db.Exec(c, _addTipSQL, t.Platform, t.Version, t.Tip, t.Link, t.StartTime, t.EndTime, t.Level, t.JudgeType, t.Operator, t.Deleted, t.Ctime, t.Position); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	if lid, err = res.LastInsertId(); err != nil {
+		err = errors.WithStack(err)
+	}
+	return
+}
+
+// DeleteTip tip delete.
+func (d *Dao) DeleteTip(c context.Context, id int64, deleted int8, operator string) (eff int64, err error) {
+	var res xsql.Result
+	if res, err = d.db.Exec(c, _deleteTipSQL, deleted, operator, id); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	if eff, err = res.RowsAffected(); err != nil {
+		err = errors.WithStack(err)
+	}
+	return
+}
+
+// ExpireTip tip expire.
+func (d *Dao) ExpireTip(c context.Context, id int64, operator string, t int64) (eff int64, err error) {
+	var res xsql.Result
+	if res, err = d.db.Exec(c, _expireTipSQL, t, operator, id); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	if eff, err = res.RowsAffected(); err != nil {
+		err = errors.WithStack(err)
+	}
+	return
+}

app/admin/main/vip/dao/tips_test.go

@@ -0,0 +1,50 @@
+package dao
+
+import (
+	"context"
+	"testing"
+
+	"go-common/app/admin/main/vip/model"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaoTipList(t *testing.T) {
+	convey.Convey("TipList", t, func() {
+		rs, err := d.TipList(context.TODO(), 0, 0, 0, 0)
+		convey.So(err, convey.ShouldBeNil)
+		convey.So(rs, convey.ShouldNotBeNil)
+	})
+}
+
+func TestDaoAddTip(t *testing.T) {
+	var (
+		id  int64
+		err error
+	)
+	convey.Convey("AddTip", t, func() {
+		id, err = d.AddTip(context.TODO(), &model.Tips{Tip: "test"})
+		convey.So(err, convey.ShouldBeNil)
+		convey.So(id, convey.ShouldNotBeNil)
+	})
+	convey.Convey("TipByID", t, func() {
+		r, err := d.TipByID(context.TODO(), id)
+		convey.So(err, convey.ShouldBeNil)
+		convey.So(r, convey.ShouldNotBeNil)
+	})
+	convey.Convey("TipUpdate", t, func() {
+		eff, err := d.TipUpdate(context.TODO(), &model.Tips{ID: id, Tip: "test"})
+		convey.So(err, convey.ShouldBeNil)
+		convey.So(eff, convey.ShouldNotBeNil)
+	})
+	convey.Convey("ExpireTip", t, func() {
+		eff, err := d.ExpireTip(context.TODO(), id, "", 0)
+		convey.So(err, convey.ShouldBeNil)
+		convey.So(eff, convey.ShouldNotBeNil)
+	})
+	convey.Convey("DeleteTip", t, func() {
+		eff, err := d.DeleteTip(context.TODO(), id, 0, "")
+		convey.So(err, convey.ShouldBeNil)
+		convey.So(eff, convey.ShouldNotBeNil)
+	})
+}

app/admin/main/vip/dao/vip.go

@@ -0,0 +1,71 @@
+package dao
+
+import (
+	"context"
+	xsql "database/sql"
+
+	"go-common/app/admin/main/vip/model"
+	"go-common/library/database/sql"
+	"go-common/library/log"
+	"go-common/library/time"
+)
+
+// const .
+const (
+	_selVipUserInfoByMid    = "SELECT id,mid,vip_type,vip_pay_type,vip_status,vip_start_time,vip_overdue_time,annual_vip_overdue_time,ctime,mtime,vip_recent_time FROM vip_user_info WHERE mid = ?"
+	_UpdateVipUserInfoByID  = "UPDATE vip_user_info SET vip_type=?,vip_status=?,vip_overdue_time=?,annual_vip_overdue_time=?,vip_recent_time=? WHERE id=?"
+	_InsertVipChangeHistory = "INSERT INTO vip_user_change_history(mid,change_type,change_time,days,operator_id,relation_id,batch_id,remark) VALUES(?,?,?,?,?,?,?,?)"
+	_DelBcoinSalary         = "DELETE FROM vip_user_bcoin_salary WHERE status = 0 AND mid = ? and payday>=?"
+)
+
+// DelBcoinSalary del bacoin salary
+func (d *Dao) DelBcoinSalary(tx *sql.Tx, mid int64, month time.Time) (err error) {
+	if _, err = tx.Exec(_DelBcoinSalary, mid, month); err != nil {
+		log.Error("InertVipBcoinSalary.exec(mid:%v,month:%v) error(%+v)", mid, month, err)
+	}
+	return
+}
+
+// SelVipUserInfo select user info by mid
+func (d *Dao) SelVipUserInfo(c context.Context, mid int64) (r *model.VipUserInfo, err error) {
+	var row = d.db.QueryRow(c, _selVipUserInfoByMid, mid)
+	r = new(model.VipUserInfo)
+	if err = row.Scan(&r.ID, &r.Mid, &r.VipType, &r.VipPayType, &r.VipStatus, &r.VipStartTime, &r.VipOverdueTime, &r.AnnualVipOverdueTime, &r.Ctime, &r.Mtime, &r.VipRecentTime); err != nil {
+		if err == sql.ErrNoRows {
+			r = nil
+			err = nil
+		} else {
+			log.Error("row.Scan() error(%v)", err)
+		}
+
+	}
+	return
+}
+
+// UpdateVipUserInfo update vip user info by id
+func (d *Dao) UpdateVipUserInfo(tx *sql.Tx, r *model.VipUserInfo) (a int64, err error) {
+	var res xsql.Result
+	if res, err = tx.Exec(_UpdateVipUserInfoByID, r.VipType, r.VipStatus, r.VipOverdueTime, r.AnnualVipOverdueTime, r.VipRecentTime, r.ID); err != nil {
+		log.Error("UpdateVipUserInfo: db.Exec(%v) error(%v)", r, err)
+		return
+	}
+	if a, err = res.RowsAffected(); err != nil {
+		log.Error("UpdateVipUserInfo: res.RowsAffected error(%v)", err)
+		return
+	}
+
+	return
+}
+
+// InsertVipChangeHistory insert vipChangeHistory
+func (d *Dao) InsertVipChangeHistory(tx *sql.Tx, r *model.VipChangeHistory) (id int64, err error) {
+	var res xsql.Result
+	if res, err = tx.Exec(_InsertVipChangeHistory, r.Mid, r.ChangeType, r.ChangeTime, r.Days, r.OperatorID, r.RelationID, r.BatchID, r.Remark); err != nil {
+		log.Error("InsertVipChangeHistory db.Exec(%v) error(%v)", r, err)
+	} else {
+		if id, err = res.LastInsertId(); err != nil {
+			log.Error("InsertVipChangeHistory LastInsertId() error(%v)", err)
+		}
+	}
+	return
+}

app/admin/main/vip/dao/vip_test.go

@@ -0,0 +1,97 @@
+package dao
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"go-common/app/admin/main/vip/model"
+	xtime "go-common/library/time"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaoDelBcoinSalary(t *testing.T) {
+	convey.Convey("DelBcoinSalary", t, func(ctx convey.C) {
+		var (
+			tx, _ = d.BeginTran(context.Background())
+			mid   = int64(1)
+			month = xtime.Time(time.Now().Unix())
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.DelBcoinSalary(tx, mid, month)
+			if err == nil {
+				if err = tx.Commit(); err != nil {
+					tx.Rollback()
+				}
+			} else {
+				tx.Rollback()
+			}
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoSelVipUserInfo(t *testing.T) {
+	convey.Convey("SelVipUserInfo", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			mid = int64(1)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			r, err := d.SelVipUserInfo(c, mid)
+			ctx.Convey("Then err should be nil.r should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(r, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoUpdateVipUserInfo(t *testing.T) {
+	convey.Convey("UpdateVipUserInfo", t, func(ctx convey.C) {
+		var (
+			tx, _ = d.BeginTran(context.Background())
+			r     = &model.VipUserInfo{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			a, err := d.UpdateVipUserInfo(tx, r)
+			if err == nil {
+				if err = tx.Commit(); err != nil {
+					tx.Rollback()
+				}
+			} else {
+				tx.Rollback()
+			}
+			ctx.Convey("Then err should be nil.a should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(a, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoInsertVipChangeHistory(t *testing.T) {
+	convey.Convey("InsertVipChangeHistory", t, func(ctx convey.C) {
+		var (
+			tx, _ = d.BeginTran(context.Background())
+			r     = &model.VipChangeHistory{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			id, err := d.InsertVipChangeHistory(tx, r)
+			if err == nil {
+				if err = tx.Commit(); err != nil {
+					tx.Rollback()
+				}
+			} else {
+				tx.Rollback()
+			}
+			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)
+			})
+		})
+	})
+}

app/admin/main/vip/dao/welfare.go

@@ -0,0 +1,212 @@
+package dao
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	"go-common/app/admin/main/vip/model"
+	"go-common/library/log"
+
+	"github.com/jinzhu/gorm"
+	"github.com/pkg/errors"
+)
+
+const (
+	_welfareTypeTable       = "vip_welfare_type"
+	_welfareTable           = "vip_welfare"
+	_codeBatchTable         = "vip_welfare_code_batch"
+	_welfareCodeTable       = "vip_welfare_code"
+	_notDelete              = 0
+	_nobody                 = 0
+	_noTid                  = 0
+	_batchInsertWelfareCode = "INSERT INTO vip_welfare_code (bid, wid, code) VALUES %s"
+)
+
+// WelfareTypeAdd add welfare type
+func (d *Dao) WelfareTypeAdd(wt *model.WelfareType) (err error) {
+	if err = d.vip.Save(wt).Error; err != nil {
+		err = errors.Wrapf(err, "WelfareTypeAdd(%+v)", wt)
+	}
+	return
+}
+
+// WelfareTypeUpd update welfare type
+func (d *Dao) WelfareTypeUpd(wt *model.WelfareType) (err error) {
+	if err = d.vip.Table(_welfareTypeTable).Where("id = ? and state = ?", wt.ID, _notDelete).
+		Update(map[string]interface{}{
+			"oper_id":   wt.OperID,
+			"oper_name": wt.OperName,
+			"state":     wt.State,
+			"name":      wt.Name,
+		}).Error; err != nil {
+		err = errors.Wrapf(err, "WelfareTypeUpd(%+v)", wt)
+	}
+	return
+}
+
+// WelfareTypeState delete welfare type
+func (d *Dao) WelfareTypeState(tx *gorm.DB, id, state, operId int, operName string) (err error) {
+	if err = tx.Table(_welfareTypeTable).Where("id = ?", id).
+		Update(map[string]interface{}{
+			"oper_id":   operId,
+			"oper_name": operName,
+			"state":     state,
+		}).Error; err != nil {
+		err = errors.Wrapf(err, "WelfareTypeState id(%v) state(%v)", id, state)
+	}
+	return
+}
+
+// WelfareTypeList get welfare type list
+func (d *Dao) WelfareTypeList() (wts []*model.WelfareTypeRes, err error) {
+	if err = d.vip.Table(_welfareTypeTable).Where("state = ?", _notDelete).Find(&wts).Error; err != nil {
+		err = errors.Wrapf(err, "WelfareTypeList")
+	}
+	return
+}
+
+// WelfareAdd add welfare
+func (d *Dao) WelfareAdd(wt *model.Welfare) (err error) {
+	if err = d.vip.Save(wt).Error; err != nil {
+		err = errors.Wrapf(err, "WelfareAdd(%+v)", wt)
+	}
+	return
+}
+
+// WelfareUpd update welfare
+func (d *Dao) WelfareUpd(wt *model.WelfareReq) (err error) {
+	if err = d.vip.Table(_welfareTable).Where("id = ? and state = ?", wt.ID, _notDelete).
+		Update(map[string]interface{}{
+			"welfare_name": wt.WelfareName,
+			"welfare_desc": wt.WelfareDesc,
+			"homepage_uri": wt.HomepageUri,
+			"backdrop_uri": wt.BackdropUri,
+			"recommend":    wt.Recommend,
+			"rank":         wt.Rank,
+			"tid":          wt.Tid,
+			"stime":        wt.Stime,
+			"etime":        wt.Etime,
+			"usage_form":   wt.UsageForm,
+			"receive_rate": wt.ReceiveRate,
+			"receive_uri":  wt.ReceiveUri,
+			"vip_type":     wt.VipType,
+			"oper_id":      wt.OperID,
+			"oper_name":    wt.OperName,
+		}).Error; err != nil {
+		err = errors.Wrapf(err, "WelfareUpd(%+v)", wt)
+	}
+	return
+}
+
+// WelfareState delete welfare
+func (d *Dao) WelfareState(id, state, operId int, operName string) (err error) {
+	if err = d.vip.Table(_welfareTable).Where("id = ?", id).
+		Update(map[string]interface{}{
+			"oper_id":   operId,
+			"oper_name": operName,
+			"state":     state,
+		}).Error; err != nil {
+		err = errors.Wrapf(err, "WelfareState id(%v) state(%v)", id, state)
+	}
+	return
+}
+
+// ResetWelfareTid reset welfare tid to 0
+func (d *Dao) ResetWelfareTid(tx *gorm.DB, tid int) (err error) {
+	if err = tx.Table(_welfareTable).Where("tid = ?", tid).Update("tid", _noTid).Error; err != nil {
+		err = errors.Wrapf(err, "ResetWelfareTid(%v)", tid)
+	}
+	return
+}
+
+// WelfareList get welfare list
+func (d *Dao) WelfareList(tid int) (ws []*model.WelfareRes, err error) {
+	db := d.vip.Table(_welfareTable)
+	if tid != 0 {
+		db = db.Where("tid = ?", tid)
+	}
+	if err = db.Where("state = ?", _notDelete).Order("recommend desc, rank").Find(&ws).Error; err != nil {
+		err = errors.Wrapf(err, "WelfareList(%+v)", tid)
+	}
+	return
+}
+
+// WelfareBatchSave add welfare batch
+func (d *Dao) WelfareBatchSave(wcb *model.WelfareCodeBatch) (err error) {
+	if err = d.vip.Table(_codeBatchTable).Save(wcb).Error; err != nil {
+		err = errors.Wrapf(err, "WelfareBatchSave(%+v)", wcb)
+	}
+	return
+}
+
+// WelfareBatchList get welfare list
+func (d *Dao) WelfareBatchList(wid int) (wbs []*model.WelfareBatchRes, err error) {
+	if err = d.vip.Table(_codeBatchTable).Where("wid = ? and state = ?", wid, _notDelete).Find(&wbs).Error; err != nil {
+		err = errors.Wrapf(err, "WelfareBatchList(%+v)", wid)
+	}
+	return
+}
+
+// WelfareBatchState delete welfare batch
+func (d *Dao) WelfareBatchState(tx *gorm.DB, id, state, operId int, operName string) (err error) {
+	if err = tx.Table(_codeBatchTable).Where("id = ?", id).
+		Update(map[string]interface{}{
+			"oper_id":   operId,
+			"oper_name": operName,
+			"state":     state,
+		}).Error; err != nil {
+		err = errors.Wrapf(err, "WelfareBatchState(%+v)", id)
+	}
+
+	return
+}
+
+// WelfareCodeBatchInsert insert welfare batch code
+func (d *Dao) WelfareCodeBatchInsert(wcs []*model.WelfareCode) (err error) {
+	log.Info("WelfareCodeBatchInsert start time (%s)", time.Now())
+	var (
+		buff    = make([]*model.WelfareCode, 2000)
+		buffEnd = 0
+	)
+	for _, wc := range wcs {
+		buff[buffEnd] = wc
+		buffEnd++
+		if buffEnd >= 2000 {
+			buffEnd = 0
+			stmt, valueArgs := getBatchInsertSQL(buff)
+			if err = d.vip.Exec(stmt, valueArgs...).Error; err != nil {
+				return
+			}
+		}
+	}
+	if buffEnd > 0 {
+		stmt, valueArgs := getBatchInsertSQL(buff[:buffEnd])
+		buffEnd = 0
+		if err = d.vip.Exec(stmt, valueArgs...).Error; err != nil {
+			return
+		}
+	}
+	log.Info("WelfareCodeBatchInsert end time (%s)", time.Now())
+	return
+}
+
+// WelfareCodeStatus delete welfare batch code
+func (d *Dao) WelfareCodeStatus(tx *gorm.DB, bid, state int) (err error) {
+	if err = tx.Table(_welfareCodeTable).Where("bid = ? and mid = ?", bid, _nobody).
+		Update("state", state).Error; err != nil {
+		err = errors.Wrapf(err, "WelfareCodeStatus(%+v) (%+v)", bid, state)
+	}
+
+	return
+}
+
+func getBatchInsertSQL(buff []*model.WelfareCode) (stmt string, valueArgs []interface{}) {
+	values := []string{}
+	for _, b := range buff {
+		values = append(values, "(?,?,?)")
+		valueArgs = append(valueArgs, b.Bid, b.Wid, b.Code)
+	}
+	stmt = fmt.Sprintf(_batchInsertWelfareCode, strings.Join(values, ","))
+	return
+}

app/admin/main/vip/dao/welfare_test.go

@@ -0,0 +1,255 @@
+package dao
+
+import (
+	"context"
+	"testing"
+
+	"go-common/app/admin/main/vip/model"
+	"go-common/library/log"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaoWelfareTypeAdd(t *testing.T) {
+	convey.Convey("WelfareTypeAdd", t, func(ctx convey.C) {
+		var (
+			wt = &model.WelfareType{ID: 1000000, Name: "utTestAdd"}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.WelfareTypeAdd(wt)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoWelfareTypeUpd(t *testing.T) {
+	convey.Convey("WelfareTypeUpd", t, func(ctx convey.C) {
+		var (
+			wt = &model.WelfareType{ID: 1000000, Name: "utTestUpd"}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.WelfareTypeUpd(wt)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoWelfareTypeState(t *testing.T) {
+	convey.Convey("WelfareTypeState", t, func(ctx convey.C) {
+		var (
+			tx       = d.BeginGormTran(context.Background())
+			id       = int(1000000)
+			state    = int(1)
+			operId   = int(0)
+			operName = "utTest"
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.WelfareTypeState(tx, id, state, operId, operName)
+			tx.Commit()
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoWelfareTypeList(t *testing.T) {
+	convey.Convey("WelfareTypeList", t, func(ctx convey.C) {
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			wts, err := d.WelfareTypeList()
+			ctx.Convey("Then err should be nil.wts should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(wts, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoWelfareAdd(t *testing.T) {
+	convey.Convey("WelfareAdd", t, func(ctx convey.C) {
+		var (
+			wt = &model.Welfare{ID: 100000, Tid: 100000, WelfareName: "utTestAdd"}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.WelfareAdd(wt)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoWelfareUpd(t *testing.T) {
+	convey.Convey("WelfareUpd", t, func(ctx convey.C) {
+		var (
+			wt = &model.WelfareReq{ID: 100000, Tid: 100000, WelfareName: "utTestUpd"}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.WelfareUpd(wt)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoWelfareState(t *testing.T) {
+	convey.Convey("WelfareState", t, func(ctx convey.C) {
+		var (
+			id       = int(100000)
+			state    = int(1)
+			operId   = int(0)
+			operName = "utTest"
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.WelfareState(id, state, operId, operName)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoResetWelfareTid(t *testing.T) {
+	convey.Convey("ResetWelfareTid", t, func(ctx convey.C) {
+		var (
+			tx  = d.BeginGormTran(context.Background())
+			tid = int(100000)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.ResetWelfareTid(tx, tid)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoWelfareList(t *testing.T) {
+	convey.Convey("WelfareList", t, func(ctx convey.C) {
+		var (
+			tid = int(100000)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			ws, err := d.WelfareList(tid)
+			ctx.Convey("Then err should be nil.ws should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(ws, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoWelfareBatchSave(t *testing.T) {
+	convey.Convey("WelfareBatchSave", t, func(ctx convey.C) {
+		var (
+			wcb = &model.WelfareCodeBatch{ID: 100000, BatchName: "utTest"}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.WelfareBatchSave(wcb)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoWelfareBatchList(t *testing.T) {
+	convey.Convey("WelfareBatchList", t, func(ctx convey.C) {
+		var (
+			wid = int(100000)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			wbs, err := d.WelfareBatchList(wid)
+			ctx.Convey("Then err should be nil.wbs should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(wbs, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoWelfareBatchState(t *testing.T) {
+	convey.Convey("WelfareBatchState", t, func(ctx convey.C) {
+		var (
+			tx       = d.BeginGormTran(context.Background())
+			id       = int(100000)
+			state    = int(1)
+			operId   = int(0)
+			operName = "utTest"
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.WelfareBatchState(tx, id, state, operId, operName)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoWelfareCodeBatchInsert(t *testing.T) {
+	convey.Convey("WelfareCodeBatchInsert", t, func(ctx convey.C) {
+		var (
+			wcs = []*model.WelfareCode{}
+			wc  = new(model.WelfareCode)
+		)
+		wc.Code = "utTest"
+		wc.Bid = 1000000
+		wc.Wid = 1000000
+		wcs = append(wcs, wc)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.WelfareCodeBatchInsert(wcs)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+		d.delCode()
+	})
+}
+
+func (d *Dao) delCode() {
+	codeInfo := &model.WelfareCode{
+		Bid:  1000000,
+		Wid:  1000000,
+		Code: "utTest",
+	}
+	if err := d.vip.Where("bid = ? and wid =? and code = ?", codeInfo.Bid, codeInfo.Wid, codeInfo.Code).Delete(codeInfo).Error; err != nil {
+		log.Error("DelUser error(%v)", err)
+	}
+}
+
+func TestDaoWelfareCodeStatus(t *testing.T) {
+	convey.Convey("WelfareCodeStatus", t, func(ctx convey.C) {
+		var (
+			tx    = d.BeginGormTran(context.Background())
+			bid   = int(100000)
+			state = int(1)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.WelfareCodeStatus(tx, bid, state)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaogetBatchInsertSQL(t *testing.T) {
+	convey.Convey("getBatchInsertSQL", t, func(ctx convey.C) {
+		var (
+			buff = []*model.WelfareCode{}
+		)
+		buff = append(buff, new(model.WelfareCode))
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			stmt, valueArgs := getBatchInsertSQL(buff)
+			ctx.Convey("Then stmt,valueArgs should not be nil.", func(ctx convey.C) {
+				ctx.So(valueArgs, convey.ShouldNotBeNil)
+				ctx.So(stmt, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}