Create & Init Project...

app/job/main/point/dao/BUILD

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

@@ -0,0 +1,52 @@
+package dao
+
+import (
+	"context"
+
+	"go-common/app/job/main/point/conf"
+	"go-common/library/cache/memcache"
+	xsql "go-common/library/database/sql"
+	bm "go-common/library/net/http/blademaster"
+)
+
+// Dao dao
+type Dao struct {
+	c      *conf.Config
+	mc     *memcache.Pool
+	db     *xsql.DB
+	client *bm.Client
+}
+
+// New init mysql db
+func New(c *conf.Config) (dao *Dao) {
+	dao = &Dao{
+		c:      c,
+		mc:     memcache.NewPool(c.Memcache),
+		db:     xsql.NewMySQL(c.MySQL),
+		client: bm.NewClient(c.HTTPClient),
+	}
+	return
+}
+
+// Close close the resource.
+func (dao *Dao) Close() {
+	dao.mc.Close()
+	dao.db.Close()
+}
+
+// Ping dao ping
+func (dao *Dao) Ping(c context.Context) (err error) {
+	if err = dao.db.Ping(c); err != nil {
+		return
+	}
+	err = dao.pingMC(c)
+	return
+}
+
+// pingMc ping
+func (dao *Dao) pingMC(c context.Context) (err error) {
+	conn := dao.mc.Get(c)
+	defer conn.Close()
+	item := memcache.Item{Key: "ping", Value: []byte{1}, Expiration: 60}
+	return conn.Set(&item)
+}

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

@@ -0,0 +1,81 @@
+package dao
+
+import (
+	"context"
+	"flag"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"go-common/app/job/main/point/conf"
+	"go-common/app/job/main/point/model"
+	xtime "go-common/library/time"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	mid int64 = 7593623
+	d   *Dao
+	c   = context.TODO()
+)
+
+func init() {
+	dir, _ := filepath.Abs("../cmd/point-job.toml")
+	flag.Set("conf", dir)
+	conf.Init()
+	d = New(conf.Conf)
+}
+
+func TestAddPoint(t *testing.T) {
+	Convey("TestAddPoint", t, func() {
+		p := &model.VipPoint{
+			Mid:          111,
+			PointBalance: 1,
+			Ver:          1,
+		}
+		_, err := d.AddPoint(c, p)
+		So(err, ShouldBeNil)
+	})
+}
+
+// go test  -test.v -test.run TestUpdatePoint
+func TestUpdatePoint(t *testing.T) {
+	Convey("TestUpdatePoint", t, func() {
+		p := &model.VipPoint{
+			Mid:          111,
+			PointBalance: 2,
+			Ver:          1,
+		}
+		oldp := &model.VipPoint{
+			Ver: 1,
+		}
+		_, err := d.UpdatePoint(c, p, oldp.Ver)
+		So(err, ShouldBeNil)
+	})
+}
+
+// go test  -test.v -test.run TestChangeHistory
+func TestChangeHistory(t *testing.T) {
+	Convey("TestChangeHistory", t, func() {
+		h := &model.VipPointChangeHistory{
+			Mid:          111,
+			Point:        2,
+			OrderID:      "wqwqe22112",
+			ChangeType:   10,
+			ChangeTime:   xtime.Time(time.Now().Unix()),
+			RelationID:   "11",
+			PointBalance: 111,
+		}
+		_, err := d.AddPointHistory(c, h)
+		So(err, ShouldBeNil)
+	})
+}
+
+// go test  -test.v -test.run TestDeletePointCache
+func TestDeletePointCache(t *testing.T) {
+	Convey("TestDeletePointCache", t, func() {
+		err := d.DelPointInfoCache(c, mid)
+		So(err, ShouldBeNil)
+	})
+}

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

@@ -0,0 +1,36 @@
+package dao
+
+import (
+	"context"
+	"fmt"
+
+	"go-common/library/cache/memcache"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_pointInfo = "pt:%d"
+)
+
+func pointKey(mid int64) string {
+	return fmt.Sprintf(_pointInfo, mid)
+}
+
+//DelPointInfoCache .
+func (d *Dao) DelPointInfoCache(c context.Context, mid int64) (err error) {
+	return d.delCache(c, pointKey(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 {
+		if err == memcache.ErrNotFound {
+			err = nil
+		} else {
+			err = errors.Wrapf(err, "conn.Delete(%s)", key)
+		}
+	}
+	return
+}

app/job/main/point/dao/mysql.go

@@ -0,0 +1,186 @@
+package dao
+
+import (
+	"context"
+	xsql "database/sql"
+	"time"
+
+	"go-common/app/job/main/point/model"
+	"go-common/library/database/sql"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_insertPoint           = "INSERT INTO point_info(mid,point_balance,ver) VALUES(?,?,?);"
+	_updatePoint           = "UPDATE point_info SET point_balance=?,ver=? WHERE mid=? AND ver=?;"
+	_insertPointHistory    = "INSERT INTO point_change_history(mid,point,order_id,change_type,change_time,relation_id,point_balance,remark,operator) VALUES(?,?,?,?,?,?,?,?,?);"
+	_checkHistoryCount     = "SELECT COUNT(1) FROM  point_change_history WHERE mid = ? AND order_id = ?;"
+	_insertPointSQL        = "INSERT INTO point_info(mid,point_balance,ver) VALUES(?,?,?)"
+	_updatePointSQL        = "UPDATE point_info SET point_balance = ?,ver=? WHERE mid=? AND ver=?"
+	_pointInfoSQL          = "SELECT mid,point_balance,ver FROM point_info WHERE mid=?"
+	_InsertPointHistorySQL = "INSERT INTO point_change_history(mid,point,order_id,change_type,change_time,relation_id,point_balance,remark,operator) VALUES(?,?,?,?,?,?,?,?,?)"
+	_midByMtime            = "SELECT mid, point_balance FROM point_info where mtime > ?;"
+	_lastOneHistory        = "SELECT `point_balance` FROM `point_change_history` WHERE mid =?  ORDER  BY id DESC LIMIT 1;"
+	_fixUpdatePointSQL     = "UPDATE point_info SET point_balance = ? WHERE mid=?"
+)
+
+// BeginTran begin transaction.
+func (d *Dao) BeginTran(c context.Context) (*sql.Tx, error) {
+	return d.db.Begin(c)
+}
+
+//TxPointInfo .
+func (d *Dao) TxPointInfo(c context.Context, tx *sql.Tx, mid int64) (pi *model.PointInfo, err error) {
+	row := tx.QueryRow(_pointInfoSQL, mid)
+	pi = new(model.PointInfo)
+	if err = row.Scan(&pi.Mid, &pi.PointBalance, &pi.Ver); err != nil {
+		if err == sql.ErrNoRows {
+			err = nil
+			pi = nil
+		} else {
+			err = errors.WithStack(err)
+		}
+	}
+	return
+}
+
+//InsertPoint .
+func (d *Dao) InsertPoint(c context.Context, tx *sql.Tx, pi *model.PointInfo) (a int64, err error) {
+	var res xsql.Result
+	if res, err = tx.Exec(_insertPointSQL, pi.Mid, pi.PointBalance, pi.Ver); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	if a, err = res.RowsAffected(); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	return
+}
+
+//UpdatePointInfo .
+func (d *Dao) UpdatePointInfo(c context.Context, tx *sql.Tx, pi *model.PointInfo, ver int64) (a int64, err error) {
+	var res xsql.Result
+	if res, err = tx.Exec(_updatePointSQL, pi.PointBalance, pi.Ver, pi.Mid, ver); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	if a, err = res.RowsAffected(); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	return
+}
+
+//InsertPointHistory .
+func (d *Dao) InsertPointHistory(c context.Context, tx *sql.Tx, ph *model.PointHistory) (a int64, err error) {
+	var res xsql.Result
+	if res, err = tx.Exec(_InsertPointHistorySQL, ph.Mid, ph.Point, ph.OrderID, ph.ChangeType, ph.ChangeTime, ph.RelationID, ph.PointBalance, ph.Remark, ph.Operator); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	if a, err = res.RowsAffected(); err != nil {
+		err = errors.WithStack(err)
+	}
+	return
+}
+
+//AddPoint addPoint
+func (d *Dao) AddPoint(c context.Context, p *model.VipPoint) (a int64, err error) {
+	var res xsql.Result
+	if res, err = d.db.Exec(c, _insertPoint, &p.Mid, &p.PointBalance, &p.Ver); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	if a, err = res.RowsAffected(); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	return
+}
+
+//UpdatePoint UpdatePoint row
+func (d *Dao) UpdatePoint(c context.Context, p *model.VipPoint, oldver int64) (a int64, err error) {
+	var res xsql.Result
+	if res, err = d.db.Exec(c, _updatePoint, &p.PointBalance, &p.Ver, &p.Mid, oldver); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	if a, err = res.RowsAffected(); err != nil {
+		err = errors.WithStack(err)
+	}
+	return
+}
+
+//AddPointHistory add point history
+func (d *Dao) AddPointHistory(c context.Context, ph *model.VipPointChangeHistory) (a int64, err error) {
+	var res xsql.Result
+	if res, err = d.db.Exec(c, _insertPointHistory, &ph.Mid, &ph.Point, &ph.OrderID, &ph.ChangeType, &ph.ChangeTime, &ph.RelationID, &ph.PointBalance, &ph.Remark, &ph.Operator); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	if a, err = res.RowsAffected(); err != nil {
+		err = errors.WithStack(err)
+	}
+	return
+}
+
+//HistoryCount check if have repeat record.
+func (d *Dao) HistoryCount(c context.Context, mid int64, orderID string) (count int64, err error) {
+	row := d.db.QueryRow(c, _checkHistoryCount, mid, orderID)
+	if err = row.Scan(&count); err != nil {
+		if err == xsql.ErrNoRows {
+			err = nil
+		} else {
+			err = errors.WithStack(err)
+		}
+	}
+	return
+}
+
+//MidsByMtime point mids by mtime.
+func (d *Dao) MidsByMtime(c context.Context, mtime time.Time) (pis []*model.PointInfo, err error) {
+	var rows *sql.Rows
+	if rows, err = d.db.Query(c, _midByMtime, mtime); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	for rows.Next() {
+		pi := new(model.PointInfo)
+		if err = rows.Scan(&pi.Mid, &pi.PointBalance); err != nil {
+			pis = nil
+			err = errors.WithStack(err)
+			return
+		}
+		pis = append(pis, pi)
+	}
+	return
+}
+
+//LastOneHistory last one history.
+func (d *Dao) LastOneHistory(c context.Context, mid int64) (point int64, err error) {
+	row := d.db.QueryRow(c, _lastOneHistory, mid)
+	if err = row.Scan(&point); err != nil {
+		if err == xsql.ErrNoRows {
+			err = nil
+		} else {
+			err = errors.WithStack(err)
+		}
+	}
+	return
+}
+
+//FixPointInfo fix point data .
+func (d *Dao) FixPointInfo(c context.Context, mid int64, pointBalance int64) (a int64, err error) {
+	var res xsql.Result
+	if res, err = d.db.Exec(c, _fixUpdatePointSQL, pointBalance, mid); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	if a, err = res.RowsAffected(); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	return
+}

app/job/main/point/dao/notify.go

@@ -0,0 +1,65 @@
+package dao
+
+import (
+	"context"
+	"go-common/library/log"
+	"net/http"
+	"net/url"
+	"strconv"
+
+	"github.com/pkg/errors"
+)
+
+//notify status.
+const (
+	_notifySuccess = "1"
+)
+
+// Notify point change .
+func (d *Dao) Notify(c context.Context, notifyURL string, mid int64, orderID string, ip string) (err error) {
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("order_id", orderID)
+	params.Set("status", _notifySuccess)
+	req, err := d.client.NewRequest(http.MethodPost, notifyURL, ip, params)
+	if err != nil {
+		err = errors.Wrapf(err, "Notify NewRequest(%s)", notifyURL+"?"+params.Encode())
+		return
+	}
+	var res struct {
+		Code int `json:"code"`
+	}
+	if err = d.client.Do(c, req, &res); err != nil {
+		err = errors.Wrapf(err, "Notify d.client.Do(%s)", notifyURL+"?"+params.Encode())
+		return
+	}
+	if res.Code != 0 {
+		err = errors.Wrapf(err, "Notify code != 0 (%s)", notifyURL+"?"+params.Encode())
+		return
+	}
+	return
+}
+
+// NotifyCacheDel notify cache del.
+func (d *Dao) NotifyCacheDel(c context.Context, notifyURL string, mid int64, ip string) (err error) {
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	req, err := d.client.NewRequest(http.MethodGet, notifyURL, ip, params)
+	if err != nil {
+		err = errors.Wrapf(err, "NotifyCacheDel NewRequest(%s)", notifyURL+"?"+params.Encode())
+		return
+	}
+	var res struct {
+		Code int `json:"code"`
+	}
+	if err = d.client.Do(c, req, &res); err != nil {
+		err = errors.Wrapf(err, "NotifyCacheDel d.client.Do(%s)", notifyURL+"?"+params.Encode())
+		return
+	}
+	if res.Code != 0 {
+		err = errors.Wrapf(err, "NotifyCacheDel code != 0 (%s)", notifyURL+"?"+params.Encode())
+		return
+	}
+	log.Info("notify suc(%d) url(%s)", mid, notifyURL)
+	return
+}