Create & Init Project...

app/job/main/ugcpay/dao/BUILD

@@ -0,0 +1,71 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "dao.go",
+        "elec_mc.go",
+        "elec_mysql.go",
+        "grpc.go",
+        "http.go",
+        "mc.go",
+        "mysql.go",
+        "redis.go",
+    ],
+    importpath = "go-common/app/job/main/ugcpay/dao",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/job/main/ugcpay/conf:go_default_library",
+        "//app/job/main/ugcpay/model:go_default_library",
+        "//app/service/main/ugcpay-rank/api/v1:go_default_library",
+        "//library/cache/memcache:go_default_library",
+        "//library/cache/redis:go_default_library",
+        "//library/database/sql:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/stat/prom: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"],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "dao_test.go",
+        "elec_mc_test.go",
+        "elec_mysql_test.go",
+        "grpc_test.go",
+        "http_test.go",
+        "mc_test.go",
+        "mysql_test.go",
+        "redis_test.go",
+    ],
+    embed = [":go_default_library"],
+    tags = ["automanaged"],
+    deps = [
+        "//app/job/main/ugcpay/conf:go_default_library",
+        "//app/job/main/ugcpay/model:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)

app/job/main/ugcpay/dao/dao.go

@@ -0,0 +1,63 @@
+package dao
+
+import (
+	"context"
+
+	"go-common/app/job/main/ugcpay/conf"
+	ugcpay_rank "go-common/app/service/main/ugcpay-rank/api/v1"
+	"go-common/library/cache/memcache"
+	"go-common/library/cache/redis"
+	xsql "go-common/library/database/sql"
+)
+
+// Dao dao
+type Dao struct {
+	c             *conf.Config
+	mc            *memcache.Pool
+	mcRank        *memcache.Pool
+	redis         *redis.Pool
+	db            *xsql.DB
+	dbrank        *xsql.DB
+	dbrankold     *xsql.DB
+	ugcPayRankAPI ugcpay_rank.UGCPayRankClient
+}
+
+// New init mysql db
+func New(c *conf.Config) (dao *Dao) {
+	dao = &Dao{
+		c:         c,
+		mc:        memcache.NewPool(c.Memcache),
+		mcRank:    memcache.NewPool(c.MemcacheRank),
+		redis:     redis.NewPool(c.Redis),
+		db:        xsql.NewMySQL(c.MySQL),
+		dbrank:    xsql.NewMySQL(c.MySQLRank),
+		dbrankold: xsql.NewMySQL(c.MySQLRankOld),
+	}
+	var err error
+	if dao.ugcPayRankAPI, err = ugcpay_rank.NewClient(c.GRPCUGCPayRank); err != nil {
+		panic(err)
+	}
+	return
+}
+
+// Close close the resource.
+func (d *Dao) Close() {
+	d.mc.Close()
+	d.redis.Close()
+	d.db.Close()
+}
+
+// Ping dao ping
+func (d *Dao) Ping(c context.Context) error {
+	return nil
+}
+
+// BeginTran begin transaction.
+func (d *Dao) BeginTran(c context.Context) (*xsql.Tx, error) {
+	return d.db.Begin(c)
+}
+
+// BeginTranRank .
+func (d *Dao) BeginTranRank(c context.Context) (*xsql.Tx, error) {
+	return d.dbrank.Begin(c)
+}

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

@@ -0,0 +1,34 @@
+package dao
+
+import (
+	"flag"
+	"go-common/app/job/main/ugcpay/conf"
+	"os"
+	"testing"
+)
+
+var (
+	d *Dao
+)
+
+func TestMain(m *testing.M) {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.account.ugcpay-job")
+		flag.Set("conf_token", "1e43538fbcc8005ebd158898b7e7f6b1")
+		flag.Set("tree_id", "65679")
+		flag.Set("conf_version", "docker-1")
+		flag.Set("deploy_env", "uat")
+		flag.Set("conf_host", "config.bilibili.co")
+		flag.Set("conf_path", "/tmp")
+		flag.Set("region", "sh")
+		flag.Set("zone", "sh001")
+	} else {
+		flag.Set("conf", "../cmd/test.toml")
+	}
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	d = New(conf.Conf)
+	os.Exit(m.Run())
+}

app/job/main/ugcpay/dao/elec_mc.go

@@ -0,0 +1,52 @@
+package dao
+
+import (
+	"context"
+	"fmt"
+
+	"go-common/app/job/main/ugcpay/conf"
+	"go-common/library/cache/memcache"
+	"go-common/library/log"
+	"go-common/library/stat/prom"
+)
+
+func elecOrderIDKey(orderID string) string {
+	return fmt.Sprintf("ur_eoi_%s", orderID)
+}
+
+// AddCacheOrderID Set data to mc
+func (d *Dao) AddCacheOrderID(c context.Context, orderID string) (ok bool, err error) {
+	ok = true
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	key := elecOrderIDKey(orderID)
+	item := &memcache.Item{Key: key, Object: struct{}{}, Expiration: conf.Conf.CacheTTL.ElecOrderIDTTL, Flags: memcache.FlagJSON}
+	if err = conn.Add(item); err != nil {
+		if err == memcache.ErrNotStored {
+			ok = false
+			err = nil
+			return
+		}
+		prom.BusinessErrCount.Incr("mc:AddCacheOrderID")
+		log.Errorv(c, log.KV("AddCacheOrderID", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	return
+}
+
+// DelCacheOrderID .
+func (d *Dao) DelCacheOrderID(c context.Context, orderID string) (err error) {
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	key := elecOrderIDKey(orderID)
+	if err = conn.Delete(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		prom.BusinessErrCount.Incr("mc:DelCacheOrderID")
+		log.Errorv(c, log.KV("DelCacheOrderID", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	return
+}

app/job/main/ugcpay/dao/elec_mc_test.go

@@ -0,0 +1,39 @@
+package dao
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaoAddCacheOrderID(t *testing.T) {
+	convey.Convey("AddCacheOrderID", t, func(ctx convey.C) {
+		var (
+			c       = context.Background()
+			orderID = "233"
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			ok, err := d.AddCacheOrderID(c, orderID)
+			ctx.Convey("Then err should be nil.ok should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(ok, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoDelCacheOrderID(t *testing.T) {
+	convey.Convey("DelCacheOrderID", t, func(ctx convey.C) {
+		var (
+			c       = context.Background()
+			orderID = "233"
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.DelCacheOrderID(c, orderID)
+			ctx.Convey("Then err should be nil.ok should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}

app/job/main/ugcpay/dao/elec_mysql.go

@@ -0,0 +1,135 @@
+package dao
+
+import (
+	"context"
+	"math"
+
+	"go-common/app/job/main/ugcpay/model"
+	xsql "go-common/library/database/sql"
+)
+
+const (
+	_oldElecOrderList   = `SELECT id,mid,pay_mid,order_no,elec_num,status,ctime,mtime FROM elec_pay_order WHERE id>? ORDER BY ID ASC LIMIT ?`
+	_oldElecMessageList = `SELECT id,mid,ref_mid,IFNULL(ref_id,0),message,av_no,date_version,type,state,ctime,mtime FROM elec_message WHERE id>? ORDER BY ID ASC LIMIT ?`
+
+	_upsertElecMessage = "INSERT INTO elec_message (id,`ver`,avid,up_mid,pay_mid,message,replied,hidden,ctime,mtime) VALUES (?,?,?,?,?,?,?,?,?,?) ON DUPLICATE KEY UPDATE `ver`=?,avid=?,up_mid=?,pay_mid=?,message=?,replied=?,hidden=?"
+	_upsertElecReply   = "INSERT INTO elec_reply (id,message_id,reply,hidden,ctime,mtime) VALUES (?,?,?,?,?,?) ON DUPLICATE KEY UPDATE message_id=?,reply=?,hidden=?"
+	_upsertElecAVRank  = "INSERT INTO rank_elec_av (ver,avid,up_mid,pay_mid,pay_amount,hidden) VALUES (?,?,?,?,?,?) ON DUPLICATE KEY UPDATE pay_amount = pay_amount + ?"
+	_upsertElecUPRank  = "INSERT INTO rank_elec_up (ver,up_mid,pay_mid,pay_amount,hidden) VALUES (?,?,?,?,?) ON DUPLICATE KEY UPDATE pay_amount = pay_amount + ?"
+
+	_selectOldElecTradeInfo = "SELECT id,order_no,IFNULL(av_no,0) FROM elec_pay_trade_info WHERE order_no=? LIMIT 1"
+)
+
+// UpsertElecMessage .
+func (d *Dao) UpsertElecMessage(ctx context.Context, data *model.DBElecMessage) (err error) {
+	_, err = d.dbrank.Exec(ctx, _upsertElecMessage, data.ID, data.Ver, data.AVID, data.UPMID, data.PayMID, data.Message, data.Replied, data.Hidden, data.CTime, data.MTime, data.Ver, data.AVID, data.UPMID, data.PayMID, data.Message, data.Replied, data.Hidden)
+	return
+}
+
+// UpsertElecReply .
+func (d *Dao) UpsertElecReply(ctx context.Context, data *model.DBElecReply) (err error) {
+	_, err = d.dbrank.Exec(ctx, _upsertElecReply, data.ID, data.MSGID, data.Reply, data.Hidden, data.CTime, data.MTime, data.MSGID, data.Reply, data.Hidden)
+	return
+}
+
+// TXUpsertElecAVRank .
+func (d *Dao) TXUpsertElecAVRank(ctx context.Context, tx *xsql.Tx, ver int64, avID int64, upMID, payMID int64, deltaPayAmount int64, hidden bool) (err error) {
+	_, err = tx.Exec(_upsertElecAVRank, ver, avID, upMID, payMID, deltaPayAmount, hidden, deltaPayAmount)
+	return
+}
+
+// TXUpsertElecUPRank .
+func (d *Dao) TXUpsertElecUPRank(ctx context.Context, tx *xsql.Tx, ver int64, upMID, payMID int64, deltaPayAmount int64, hidden bool) (err error) {
+	_, err = tx.Exec(_upsertElecUPRank, ver, upMID, payMID, deltaPayAmount, hidden, deltaPayAmount)
+	return
+}
+
+// RawOldElecTradeInfo .
+func (d *Dao) RawOldElecTradeInfo(ctx context.Context, orderID string) (data *model.DBOldElecPayTradeInfo, err error) {
+	row := d.dbrankold.QueryRow(ctx, _selectOldElecTradeInfo, orderID)
+	data = &model.DBOldElecPayTradeInfo{}
+	if err = row.Scan(&data.ID, &data.OrderID, &data.AVID); err != nil {
+		if err == xsql.ErrNoRows {
+			err = nil
+			data = nil
+		}
+		return
+	}
+	return
+}
+
+// OldElecMessageList .
+func (d *Dao) OldElecMessageList(ctx context.Context, startID int64, limit int) (maxID int64, list []*model.DBOldElecMessage, err error) {
+	var (
+		rows *xsql.Rows
+	)
+	if rows, err = d.dbrankold.Query(ctx, _oldElecMessageList, startID, limit); err != nil {
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		var (
+			p = &model.DBOldElecMessage{}
+		)
+		if err = rows.Scan(&p.ID, &p.MID, &p.RefMID, &p.RefID, &p.Message, &p.AVID, &p.DateVer, &p.Type, &p.State, &p.CTime, &p.MTime); err != nil {
+			return
+		}
+		if maxID < p.ID {
+			maxID = p.ID
+		}
+		list = append(list, p)
+	}
+
+	if err = rows.Err(); err != nil {
+		return
+	}
+	return
+}
+
+// OldElecOrderList .
+func (d *Dao) OldElecOrderList(ctx context.Context, startID int64, limit int) (maxID int64, list []*model.DBOldElecPayOrder, err error) {
+	var (
+		rows *xsql.Rows
+	)
+	if rows, err = d.dbrankold.Query(ctx, _oldElecOrderList, startID, limit); err != nil {
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		var (
+			p = &model.DBOldElecPayOrder{}
+		)
+		if err = rows.Scan(&p.ID, &p.UPMID, &p.PayMID, &p.OrderID, &p.ElecNum, &p.Status, &p.CTime, &p.MTime); err != nil {
+			return
+		}
+		if maxID < p.ID {
+			maxID = p.ID
+		}
+		list = append(list, p)
+	}
+
+	if err = rows.Err(); err != nil {
+		return
+	}
+	return
+}
+
+const (
+	_elecAddSetting    = `INSERT INTO elec_user_setting (mid,value) VALUES (?,?) ON DUPLICATE KEY UPDATE value=value|?`
+	_elecDeleteSetting = `INSERT INTO elec_user_setting (mid,value) VALUES (?,?) ON DUPLICATE KEY UPDATE value=value&?`
+)
+
+// ElecAddSetting .
+func (d *Dao) ElecAddSetting(ctx context.Context, defaultValue int32, mid int64, bitValue int32) (err error) {
+	defaultValue |= bitValue
+	_, err = d.dbrank.Exec(ctx, _elecAddSetting, mid, defaultValue, bitValue)
+	return
+}
+
+// ElecDeleteSetting .
+func (d *Dao) ElecDeleteSetting(ctx context.Context, defaultValue int32, mid int64, bitValue int32) (err error) {
+	andValue := math.MaxInt32 ^ bitValue
+	defaultValue &= andValue
+	_, err = d.dbrank.Exec(ctx, _elecDeleteSetting, mid, defaultValue, andValue)
+	return
+}

app/job/main/ugcpay/dao/elec_mysql_test.go

@@ -0,0 +1,183 @@
+package dao
+
+import (
+	"context"
+	"math"
+	"testing"
+
+	"go-common/app/job/main/ugcpay/model"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaoRawOldElecTradeInfo(t *testing.T) {
+	convey.Convey("RawOldElecTradeInfo", t, func(ctx convey.C) {
+		var (
+			c       = context.Background()
+			orderID = "2016081812152789113137"
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			data, err := d.RawOldElecTradeInfo(c, orderID)
+			ctx.Convey("Then err should be nil.data should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(data, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoTXUpsertElecUPRank(t *testing.T) {
+	convey.Convey("TXUpsertElecUPRank", t, func(ctx convey.C) {
+		var (
+			c              = context.Background()
+			tx, _          = d.BeginTranRank(c)
+			ver            = int64(0)
+			upMID          = int64(233)
+			payMID         = int64(322)
+			deltaPayAmount = int64(0)
+			hidden         bool
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.TXUpsertElecUPRank(c, tx, ver, upMID, payMID, deltaPayAmount, hidden)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+		ctx.Reset(func() {
+			tx.Commit()
+		})
+	})
+}
+
+func TestDaoTXUpsertElecAVRank(t *testing.T) {
+	convey.Convey("TXUpsertElecAVRank", t, func(ctx convey.C) {
+		var (
+			c              = context.Background()
+			tx, _          = d.BeginTranRank(c)
+			ver            = int64(0)
+			avID           = int64(233)
+			upMID          = int64(233)
+			payMID         = int64(322)
+			deltaPayAmount = int64(0)
+			hidden         bool
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.TXUpsertElecAVRank(c, tx, ver, avID, upMID, payMID, deltaPayAmount, hidden)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+		ctx.Reset(func() {
+			tx.Commit()
+		})
+	})
+}
+
+func TestDaoUpsertElecMessage(t *testing.T) {
+	convey.Convey("UpsertElecMessage", t, func(ctx convey.C) {
+		var (
+			c    = context.Background()
+			data = &model.DBElecMessage{
+				ID:      233333,
+				AVID:    233,
+				UPMID:   233,
+				PayMID:  322,
+				Message: "ut",
+				Replied: true,
+			}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.UpsertElecMessage(c, data)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoUpsertElecReply(t *testing.T) {
+	convey.Convey("UpsertElecReply", t, func(ctx convey.C) {
+		var (
+			c    = context.Background()
+			data = &model.DBElecReply{
+				ID:     233334,
+				MSGID:  233333,
+				Reply:  "ut_reply",
+				Hidden: false,
+			}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.UpsertElecReply(c, data)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoOldElecMessageList(t *testing.T) {
+	convey.Convey("OldElecMessageList", t, func(ctx convey.C) {
+		var (
+			c       = context.Background()
+			startID = int64(0)
+			limit   = int(10)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			maxID, list, err := d.OldElecMessageList(c, startID, limit)
+			ctx.Convey("Then err should be nil.maxID,list should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(list, convey.ShouldNotBeNil)
+				ctx.So(maxID, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoOldElecOrderList(t *testing.T) {
+	convey.Convey("OldElecOrderList", t, func(ctx convey.C) {
+		var (
+			c       = context.Background()
+			startID = int64(0)
+			limit   = int(10)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			maxID, list, err := d.OldElecOrderList(c, startID, limit)
+			ctx.Convey("Then err should be nil.maxID,list should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(list, convey.ShouldNotBeNil)
+				ctx.So(maxID, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+func TestDaoElecAddSetting(t *testing.T) {
+	convey.Convey("ElecAddSetting", t, func(ctx convey.C) {
+		var (
+			c       = context.Background()
+			mid     = int64(46333)
+			orValue = int32(0x01)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.ElecAddSetting(c, math.MaxInt32, mid, orValue)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoElecDeleteSetting(t *testing.T) {
+	convey.Convey("ElecDeleteSetting", t, func(ctx convey.C) {
+		var (
+			c        = context.Background()
+			mid      = int64(46333)
+			andValue = int32(0x7ffffffd)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.ElecDeleteSetting(c, math.MaxInt32, mid, andValue)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}

app/job/main/ugcpay/dao/grpc.go

@@ -0,0 +1,38 @@
+package dao
+
+import (
+	"context"
+
+	ugcpay_rank "go-common/app/service/main/ugcpay-rank/api/v1"
+)
+
+// RankElecUpdateOrder .
+func (d *Dao) RankElecUpdateOrder(ctx context.Context, avID, upMID, payMID, ver, fee int64) (err error) {
+	var (
+		req = &ugcpay_rank.RankElecUpdateOrderReq{
+			AVID:   avID,
+			UPMID:  upMID,
+			PayMID: payMID,
+			Ver:    ver,
+			Fee:    fee,
+		}
+	)
+	_, err = d.ugcPayRankAPI.RankElecUpdateOrder(ctx, req)
+	return
+}
+
+// RankElecUpdateMessage .
+func (d *Dao) RankElecUpdateMessage(ctx context.Context, avID, upMID, payMID, ver int64, message string, hidden bool) (err error) {
+	var (
+		req = &ugcpay_rank.RankElecUpdateMessageReq{
+			AVID:    avID,
+			UPMID:   upMID,
+			PayMID:  payMID,
+			Ver:     ver,
+			Message: message,
+			Hidden:  hidden,
+		}
+	)
+	_, err = d.ugcPayRankAPI.RankElecUpdateMessage(ctx, req)
+	return
+}

app/job/main/ugcpay/dao/grpc_test.go

@@ -0,0 +1,47 @@
+package dao
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaoRankElecUpdateOrder(t *testing.T) {
+	convey.Convey("RankElecUpdateOrder", t, func(ctx convey.C) {
+		var (
+			c      = context.Background()
+			avID   = int64(0)
+			upMID  = int64(0)
+			payMID = int64(0)
+			ver    = int64(0)
+			fee    = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.RankElecUpdateOrder(c, avID, upMID, payMID, ver, fee)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoRankElecUpdateMessage(t *testing.T) {
+	convey.Convey("RankElecUpdateMessage", t, func(ctx convey.C) {
+		var (
+			c       = context.Background()
+			avID    = int64(0)
+			upMID   = int64(0)
+			payMID  = int64(0)
+			ver     = int64(0)
+			message = ""
+			hidden  bool
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.RankElecUpdateMessage(c, avID, upMID, payMID, ver, message, hidden)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}

app/job/main/ugcpay/dao/http.go

@@ -0,0 +1,124 @@
+package dao
+
+import (
+	"context"
+	"encoding/json"
+	"io/ioutil"
+	"net/http"
+	"strings"
+
+	"go-common/app/job/main/ugcpay/conf"
+	"go-common/app/job/main/ugcpay/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+
+	"github.com/pkg/errors"
+)
+
+// PayRechargeShell .
+func (d *Dao) PayRechargeShell(c context.Context, dataJSON string) (err error) {
+	resp := new(struct {
+		Code int    `json:"errno"`
+		Msg  string `json:"msg"`
+	})
+
+	if err = d.paySend(c, conf.Conf.Biz.Pay.RechargeShellURL, dataJSON, resp); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	if resp.Code != ecode.OK.Code() {
+		err = ecode.Int(resp.Code)
+	}
+	return
+}
+
+// PayCheckRefundOrder return map[txID]*model.PayCheckOrder
+func (d *Dao) PayCheckRefundOrder(c context.Context, dataJSON string) (orders map[string][]*model.PayCheckRefundOrderEle, err error) {
+	resp := new(struct {
+		Code int                          `json:"code"`
+		Msg  string                       `json:"message"`
+		Data []*model.PayCheckRefundOrder `json:"data"`
+	})
+
+	if err = d.paySend(c, conf.Conf.Biz.Pay.CheckRefundOrderURL, dataJSON, resp); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	if resp.Code != ecode.OK.Code() {
+		err = ecode.Int(resp.Code)
+		return
+	}
+	if resp.Data == nil {
+		err = errors.Errorf("PayCheckRefundOrder got nil data, url: %s, body: %s, resp: %+v", conf.Conf.Biz.Pay.CheckOrderURL, dataJSON, resp)
+		return
+	}
+	orders = make(map[string][]*model.PayCheckRefundOrderEle)
+	for _, o := range resp.Data {
+		orders[o.TXID] = append(orders[o.TXID], o.Elements...)
+	}
+	return
+}
+
+// PayCheckOrder return map[txID]*model.PayCheckOrder
+func (d *Dao) PayCheckOrder(c context.Context, dataJSON string) (orders map[string]*model.PayCheckOrder, err error) {
+	resp := new(struct {
+		Code int                    `json:"code"`
+		Msg  string                 `json:"message"`
+		Data []*model.PayCheckOrder `json:"data"`
+	})
+
+	if err = d.paySend(c, conf.Conf.Biz.Pay.CheckOrderURL, dataJSON, resp); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	if resp.Code != ecode.OK.Code() {
+		err = ecode.Int(resp.Code)
+		return
+	}
+	if resp.Data == nil {
+		err = errors.Errorf("PayCheckOrder got nil data, url: %s, body: %s, resp: %+v", conf.Conf.Biz.Pay.CheckOrderURL, dataJSON, resp)
+		return
+	}
+	orders = make(map[string]*model.PayCheckOrder)
+	for _, o := range resp.Data {
+		orders[o.TxID] = o
+	}
+	return
+}
+
+func (d *Dao) paySend(c context.Context, url string, jsonData string, respData interface{}) (err error) {
+	var (
+		req    *http.Request
+		client = new(http.Client)
+		resp   *http.Response
+		bs     []byte
+	)
+	log.Info("paySend call url: %s, body: %s", url, jsonData)
+	defer func() {
+		log.Info("paySend call url: %v, body: %s, resp: %+v, err: %+v", url, jsonData, respData, err)
+	}()
+
+	if req, err = http.NewRequest(http.MethodPost, url, strings.NewReader(jsonData)); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	req.Header.Add("Content-Type", "application/json")
+	if resp, err = client.Do(req); err != nil {
+		err = errors.Wrapf(err, "call url: %s, body: %s", url, jsonData)
+		return
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode >= http.StatusBadRequest {
+		err = errors.Errorf("d.paySend incorrect http status: %d, host: %s, url: %s", resp.StatusCode, req.URL.Host, req.URL.String())
+		return
+	}
+	if bs, err = ioutil.ReadAll(resp.Body); err != nil {
+		err = errors.Wrapf(err, "d.paySend ioutil.ReadAll")
+		return
+	}
+	if err = json.Unmarshal(bs, respData); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	return
+}

app/job/main/ugcpay/dao/http_test.go

@@ -0,0 +1,72 @@
+package dao
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaoPayRechargeShell(t *testing.T) {
+	convey.Convey("PayRechargeShell", t, func(ctx convey.C) {
+		var (
+			c        = context.Background()
+			dataJSON = ""
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.PayRechargeShell(c, dataJSON)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoPayCheckRefundOrder(t *testing.T) {
+	convey.Convey("PayCheckRefundOrder", t, func(ctx convey.C) {
+		var (
+			c        = context.Background()
+			dataJSON = `{"customerId":"10017","sign":"072dfe62a270c7c44f619244962737a6","signType":"MD5","txIds":"3059753508505497600"}`
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			_, err := d.PayCheckRefundOrder(c, dataJSON)
+			ctx.Convey("Then err should be nil.orders should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				// ctx.So(orders, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoPayCheckOrder(t *testing.T) {
+	convey.Convey("PayCheckOrder", t, func(ctx convey.C) {
+		var (
+			c        = context.Background()
+			dataJSON = `{"customerId":"10017","sign":"072dfe62a270c7c44f619244962737a6","signType":"MD5","txIds":"3059753508505497600"}`
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			_, err := d.PayCheckOrder(c, dataJSON)
+			ctx.Convey("Then err should be nil.orders should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				// ctx.So(orders, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaopaySend(t *testing.T) {
+	convey.Convey("paySend", t, func(ctx convey.C) {
+		var (
+			c        = context.Background()
+			url      = ""
+			jsonData = ""
+			respData = interface{}(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.paySend(c, url, jsonData, respData)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}

app/job/main/ugcpay/dao/mc.go

@@ -0,0 +1,125 @@
+package dao
+
+import (
+	"context"
+	"fmt"
+
+	"go-common/library/cache/memcache"
+	"go-common/library/log"
+	"go-common/library/stat/prom"
+
+	"github.com/pkg/errors"
+)
+
+func orderKey(id string) string {
+	return fmt.Sprintf("up_o_%s", id)
+}
+
+func assetKey(oid int64, otype string, currency string) string {
+	return fmt.Sprintf("up_a_%d_%s_%s", oid, otype, currency)
+}
+
+func taskKey(task string) string {
+	return fmt.Sprintf("up_t_%s", task)
+}
+
+// DelCacheOrderUser delete data from mc
+func (d *Dao) DelCacheOrderUser(c context.Context, orderID string) (err error) {
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	key := orderKey(orderID)
+	if err = conn.Delete(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		prom.BusinessErrCount.Incr("mc:DelCacheOrderUser")
+		log.Errorv(c, log.KV("DelCacheOrderUser", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	return
+}
+
+// DelCacheAsset delete data from mc
+func (d *Dao) DelCacheAsset(c context.Context, oid int64, otype string, currency string) (err error) {
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	key := assetKey(oid, otype, currency)
+	if err = conn.Delete(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		prom.BusinessErrCount.Incr("mc:DelCacheAsset")
+		log.Errorv(c, log.KV("DelCacheAsset", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	return
+}
+
+// AddCacheTask .
+func (d *Dao) AddCacheTask(c context.Context, task string, ttl int32) (ok bool, err error) {
+	var (
+		conn = d.mc.Get(c)
+		item = &memcache.Item{
+			Key:        taskKey(task),
+			Value:      []byte{0},
+			Expiration: ttl,
+		}
+	)
+	defer conn.Close()
+
+	if err = conn.Add(item); err != nil {
+		if err == memcache.ErrNotStored {
+			err = nil
+			ok = false
+			return
+		}
+		err = errors.WithStack(err)
+		return
+	}
+	ok = true
+	return
+}
+
+// DelCacheTask .
+func (d *Dao) DelCacheTask(c context.Context, task string) (err error) {
+	var (
+		conn = d.mc.Get(c)
+		key  = taskKey(task)
+	)
+	defer conn.Close()
+
+	if err = conn.Delete(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+		} else {
+			err = errors.WithStack(err)
+		}
+	}
+	return
+}
+
+// ugcpay-rank
+
+func elecUserSetting(mid int64) string {
+	return fmt.Sprintf("eus_%d", mid)
+}
+
+// DelCacheUserSetting .
+func (d *Dao) DelCacheUserSetting(c context.Context, mid int64) (err error) {
+	var (
+		conn = d.mcRank.Get(c)
+		key  = elecUserSetting(mid)
+	)
+	defer conn.Close()
+
+	if err = conn.Delete(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+		} else {
+			err = errors.WithStack(err)
+		}
+	}
+	return
+}

app/job/main/ugcpay/dao/mc_test.go

@@ -0,0 +1,130 @@
+package dao
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaoorderKey(t *testing.T) {
+	convey.Convey("orderKey", t, func(ctx convey.C) {
+		var (
+			id = ""
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			p1 := orderKey(id)
+			ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(p1, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoassetKey(t *testing.T) {
+	convey.Convey("assetKey", t, func(ctx convey.C) {
+		var (
+			oid      = int64(0)
+			otype    = ""
+			currency = ""
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			p1 := assetKey(oid, otype, currency)
+			ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(p1, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaotaskKey(t *testing.T) {
+	convey.Convey("taskKey", t, func(ctx convey.C) {
+		var (
+			task = ""
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			p1 := taskKey(task)
+			ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(p1, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoDelCacheOrderUser(t *testing.T) {
+	convey.Convey("DelCacheOrderUser", t, func(ctx convey.C) {
+		var (
+			c  = context.Background()
+			id = ""
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.DelCacheOrderUser(c, id)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoDelCacheAsset(t *testing.T) {
+	convey.Convey("DelCacheAsset", t, func(ctx convey.C) {
+		var (
+			c        = context.Background()
+			oid      = int64(0)
+			otype    = ""
+			currency = ""
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.DelCacheAsset(c, oid, otype, currency)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoAddCacheTask(t *testing.T) {
+	convey.Convey("AddCacheTask", t, func(ctx convey.C) {
+		var (
+			c    = context.Background()
+			task = ""
+			ttl  = int32(60)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			ok, err := d.AddCacheTask(c, task, ttl)
+			ctx.Convey("Then err should be nil.ok should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(ok, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoDelCacheTask(t *testing.T) {
+	convey.Convey("DelCacheTask", t, func(ctx convey.C) {
+		var (
+			c    = context.Background()
+			task = ""
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.DelCacheTask(c, task)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+func TestDaoDelCacheUserSetting(t *testing.T) {
+	convey.Convey("DelCacheUserSetting", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			mid = int64(46333)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.DelCacheUserSetting(c, mid)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}

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

@@ -0,0 +1,912 @@
+package dao
+
+import (
+	"context"
+	"math"
+	"time"
+
+	"go-common/app/job/main/ugcpay/model"
+	xsql "go-common/library/database/sql"
+)
+
+const (
+	_asset = `SELECT id,mid,oid,otype,currency,price,state,ctime,mtime FROM asset WHERE oid=? AND otype=? AND currency=? LIMIT 1`
+
+	_countPaidOrderUser          = "SELECT count(1) FROM order_user WHERE pay_time BETWEEN ? AND ? AND state='paid' LIMIT 1"
+	_countRefundedOrderUser      = "SELECT count(1) FROM order_user WHERE refund_time BETWEEN ? AND ? AND state='st_refunded' LIMIT 1"
+	_sumPaidOrderUserRealFee     = "SELECT IFNULL(sum(real_fee),0) FROM order_user WHERE pay_time BETWEEN ? AND ? AND state='settled' LIMIT 1"
+	_sumRefundedOrderUserRealFee = "SELECT IFNULL(sum(real_fee),0) FROM order_user WHERE refund_time BETWEEN ? AND ? AND state='ref_finished' LIMIT 1"
+	_minIDOrderPaid              = `SELECT id FROM order_user WHERE pay_time>=? AND state='paid' ORDER BY id ASC LIMIT 1`
+	_minIDOrderRefunded          = `SELECT id FROM order_user WHERE refund_time>=? AND state='st_refunded' ORDER BY id ASC LIMIT 1`
+	_orderPaidList               = `SELECT id,mid,order_id,biz,platform,oid,otype,fee,real_fee,currency,pay_id,pay_reason,pay_time,state,ctime,mtime,refund_time,version FROM order_user WHERE pay_time BETWEEN ? AND ? AND state='paid' AND id>? ORDER BY ID ASC LIMIT ?`
+	_orderRefundedList           = `SELECT id,mid,order_id,biz,platform,oid,otype,fee,real_fee,currency,pay_id,pay_reason,pay_time,state,ctime,mtime,refund_time,version FROM order_user WHERE refund_time BETWEEN ? AND ? AND state='st_refunded' AND id>? ORDER BY ID ASC LIMIT ?`
+	_updateOrder                 = `UPDATE order_user SET mid=?,order_id=?,biz=?,platform=?,oid=?,otype=?,fee=?,real_fee=?,currency=?,pay_id=?,pay_reason=?,pay_time=?,state=?,refund_time=?,version=version+1 WHERE id=? AND version=?`
+	_insertLogOrderUser          = "INSERT INTO log_order_user (order_id,from_state,to_state,`desc`) VALUES (?,?,?,?)"
+
+	_orderBadDebt       = `SELECT id,order_id,type,state,ctime,mtime FROM order_bad_debt WHERE order_id=? ORDER BY id ASC LIMIT 1`
+	_insertOrderBadDebt = `INSERT INTO order_bad_debt (order_id,type,state) VALUES (?,?,?)`
+	_updateOrderBadDebt = `UPDATE order_bad_debt SET order_id=?,type=?,state=? WHERE order_id=?`
+
+	_countDailyBillByVer      = "SELECT count(1) FROM bill_user_daily WHERE ver=? LIMIT 1"
+	_countDailyBillByMonthVer = "SELECT count(1) FROM bill_user_daily WHERE month_ver=? LIMIT 1"
+	_sumDailyBill             = "SELECT IFNULL(sum(`in`),0),IFNULL(sum(`out`),0) FROM bill_user_daily WHERE ver=? LIMIT 1"
+	_minIDDailyBillByMonthVer = `SELECT id FROM bill_user_daily WHERE month_ver=? ORDER BY id ASC LIMIT 1`
+	_dailyBillListByMonthVer  = "SELECT id,bill_id,mid,biz,currency,`in`,`out`,ver,month_ver,ctime,mtime,version FROM bill_user_daily WHERE month_ver=? AND id>? ORDER BY ID ASC LIMIT ?"
+	_minIDDailyBillByVer      = `SELECT id FROM bill_user_daily WHERE ver=? ORDER BY id ASC LIMIT 1`
+	_dailyBillListByVer       = "SELECT id,bill_id,mid,biz,currency,`in`,`out`,ver,month_ver,ctime,mtime,version FROM bill_user_daily WHERE ver=? AND id>? ORDER BY ID ASC LIMIT ?"
+	_dailyBill                = "SELECT id,bill_id,mid,biz,currency,`in`,`out`,ver,month_ver,ctime,mtime,version FROM bill_user_daily WHERE mid=? AND biz=? AND currency=? AND ver=? LIMIT 1"
+	_insertDailyBill          = "INSERT INTO bill_user_daily (bill_id,mid,biz,currency,`in`,`out`,ver,month_ver,version) VALUES (?,?,?,?,?,?,?,?,?)"
+	_updateDailyBill          = "UPDATE bill_user_daily SET bill_id=?,mid=?,biz=?,currency=?,`in`=?,`out`=?,ver=?,month_ver=?,version=version+1 WHERE mid=? AND biz=? AND currency=? AND ver=? AND version=?"
+	_insertDailyBillLog       = "INSERT INTO log_bill_user_daily (bill_id,from_in,to_in,from_out,to_out,order_id) VALUES (?,?,?,?,?,?)"
+
+	_countMonthlyBillByVer = "SELECT count(1) FROM bill_user_monthly WHERE ver=? LIMIT 1"
+	_minIDMonthlyBill      = `SELECT id FROM bill_user_monthly WHERE ver=? ORDER BY id ASC LIMIT 1`
+	_monthlyBillList       = "SELECT id,bill_id,mid,biz,currency,`in`,`out`,ver,ctime,mtime,version FROM bill_user_monthly WHERE ver=? AND id>? ORDER BY ID ASC LIMIT ?"
+	_monthlyBill           = "SELECT id,bill_id,mid,biz,currency,`in`,`out`,ver,ctime,mtime,version FROM bill_user_monthly WHERE mid=? AND biz=? AND currency=? AND ver=? LIMIT 1"
+	_insertMonthlyBill     = "INSERT INTO bill_user_monthly (bill_id,mid,biz,currency,`in`,`out`,ver,version) VALUES (?,?,?,?,?,?,?,?)"
+	_updateMonthlyBill     = "UPDATE bill_user_monthly SET bill_id=?,mid=?,biz=?,currency=?,`in`=?,`out`=?,ver=?,version=version+1 WHERE mid=? AND biz=? AND currency=? AND ver=? AND version=?"
+	_insertMonthlyBillLog  = "INSERT INTO log_bill_user_monthly (bill_id,from_in,to_in,from_out,to_out,bill_user_daily_id) VALUES (?,?,?,?,?,?)"
+
+	_minIDUserAccount     = `SELECT id FROM account_user WHERE mtime>=? ORDER BY id ASC LIMIT 1`
+	_userAccountList      = "SELECT id,mid,biz,currency,balance,ver,state,ctime,mtime FROM account_user WHERE mtime BETWEEN ? AND ? AND id>? ORDER BY ID ASC LIMIT ?"
+	_userAccount          = `SELECT id,mid,biz,currency,balance,ver,state,ctime,mtime FROM account_user WHERE mid=? AND biz=? AND currency=? LIMIT 1`
+	_insertUserAccount    = `INSERT INTO account_user (mid,biz,currency,balance,ver,state) VALUES (?,?,?,?,?,?)`
+	_updateUserAccount    = `UPDATE account_user SET mid=?,biz=?,currency=?,balance=?,ver=ver+1,state=? WHERE mid=? AND biz=? AND currency=? AND ver=?`
+	_insertUserAccountLog = "INSERT INTO log_account_user (account_id,`from`,`to`,ver,state,name) VALUES (?,?,?,?,?,?)"
+
+	_bizAccount          = `SELECT id,biz,currency,balance,ver,state,ctime,mtime FROM account_biz WHERE biz=? AND currency=? LIMIT 1`
+	_insertBizAccount    = `INSERT INTO account_biz (biz,currency,balance,ver,state) VALUES (?,?,?,?,?)`
+	_updateBizAccount    = `UPDATE account_biz SET biz=?,currency=?,balance=?,ver=ver+1,state=? WHERE biz=? AND currency=? AND ver=?`
+	_insertBizAccountLog = "INSERT INTO log_account_biz (account_id,`from`,`to`,ver,state,name) VALUES (?,?,?,?,?,?)"
+
+	_aggrIncomeUser       = "SELECT id,mid,currency,pay_success,pay_error,total_in,total_out,ctime,mtime FROM aggr_income_user WHERE mid=? AND currency=? LIMIT 1"
+	_insertAggrIncomeUser = "INSERT INTO aggr_income_user (mid,currency,pay_success,pay_error,total_in,total_out) VALUES (?,?,?,?,?,?)"
+	_updateAggrIncomeUser = "UPDATE aggr_income_user SET mid=?,currency=?,pay_success=?,pay_error=?,total_in=?,total_out=? WHERE mid=? AND currency=?"
+
+	_aggrIncomeUserAsset       = "SELECT id,mid,currency,ver,oid,otype,pay_success,pay_error,total_in,total_out,ctime,mtime FROM aggr_income_user_asset WHERE mid=? AND currency=? AND ver=? AND oid=? AND otype=? LIMIT 1"
+	_insertAggrIncomeUserAsset = "INSERT INTO aggr_income_user_asset (mid,currency,`ver`,oid,otype,pay_success,pay_error,total_in,total_out) VALUES (?,?,?,?,?,?,?,?,?)"
+	_updateAggrIncomeUserAsset = "UPDATE aggr_income_user_asset SET mid=?,currency=?,ver=?,oid=?,otype=?,pay_success=?,pay_error=?,total_in=?,total_out=? WHERE mid=? AND currency=? AND ver=? AND oid=? AND otype=?"
+
+	_insertOrderRechargeShell    = "INSERT INTO order_recharge_shell (mid,order_id,biz,amount,pay_msg,state,`ver`) VALUES (?,?,?,?,?,?,?)"
+	_insertOrderRechargeShellLog = "INSERT INTO log_order_recharge_shell (order_id,from_state,to_state,`desc`,bill_user_monthly_id) VALUES (?,?,?,?,?)"
+
+	_logTask            = "SELECT id,name,expect,success,failure,state,ctime,mtime FROM log_task WHERE name=? LIMIT 1"
+	_insertLogTask      = "INSERT INTO log_task (name,expect,success,failure,state) VALUES (?,?,?,?,?)"
+	_logTaskSuccessIncr = "UPDATE log_task SET success=success+1 WHERE name=?"
+	_logTaskFailureIncr = "UPDATE log_task SET failure=failure+1 WHERE name=?"
+)
+
+// CountPaidOrderUser .
+func (d *Dao) CountPaidOrderUser(ctx context.Context, beginTime, endTime time.Time) (count int64, err error) {
+	row := d.db.QueryRow(ctx, _countPaidOrderUser, beginTime, endTime)
+	if err = row.Scan(&count); err != nil {
+		if err == xsql.ErrNoRows {
+			err = nil
+			count = 0
+		}
+		return
+	}
+	return
+}
+
+// CountRefundedOrderUser .
+func (d *Dao) CountRefundedOrderUser(ctx context.Context, beginTime, endTime time.Time) (count int64, err error) {
+	row := d.db.QueryRow(ctx, _countRefundedOrderUser, beginTime, endTime)
+	if err = row.Scan(&count); err != nil {
+		if err == xsql.ErrNoRows {
+			err = nil
+			count = 0
+		}
+		return
+	}
+	return
+}
+
+// CountDailyBillByVer .
+func (d *Dao) CountDailyBillByVer(ctx context.Context, ver int64) (count int64, err error) {
+	row := d.db.QueryRow(ctx, _countDailyBillByVer, ver)
+	if err = row.Scan(&count); err != nil {
+		if err == xsql.ErrNoRows {
+			err = nil
+			count = 0
+		}
+		return
+	}
+	return
+}
+
+// CountDailyBillByMonthVer .
+func (d *Dao) CountDailyBillByMonthVer(ctx context.Context, monthVer int64) (count int64, err error) {
+	row := d.db.QueryRow(ctx, _countDailyBillByMonthVer, monthVer)
+	if err = row.Scan(&count); err != nil {
+		if err == xsql.ErrNoRows {
+			err = nil
+			count = 0
+		}
+		return
+	}
+	return
+}
+
+// CountMonthlyBillByVer .
+func (d *Dao) CountMonthlyBillByVer(ctx context.Context, ver int64) (count int64, err error) {
+	row := d.db.QueryRow(ctx, _countMonthlyBillByVer, ver)
+	if err = row.Scan(&count); err != nil {
+		if err == xsql.ErrNoRows {
+			err = nil
+			count = 0
+		}
+		return
+	}
+	return
+}
+
+// LogTask .
+func (d *Dao) LogTask(ctx context.Context, name string) (data *model.LogTask, err error) {
+	row := d.db.QueryRow(ctx, _logTask, name)
+	data = &model.LogTask{}
+	if err = row.Scan(&data.ID, &data.Name, &data.Expect, &data.Success, &data.Failure, &data.State, &data.CTime, &data.MTime); err != nil {
+		if err == xsql.ErrNoRows {
+			err = nil
+			data = nil
+		}
+		return
+	}
+	return
+}
+
+// InsertLogTask .
+func (d *Dao) InsertLogTask(ctx context.Context, data *model.LogTask) (id int64, err error) {
+	result, err := d.db.Exec(ctx, _insertLogTask, data.Name, data.Expect, data.Success, data.Failure, data.State)
+	if err != nil {
+		return
+	}
+	id, err = result.LastInsertId()
+	return
+}
+
+// TXIncrLogTaskSuccess .
+func (d *Dao) TXIncrLogTaskSuccess(ctx context.Context, tx *xsql.Tx, name string) (rows int64, err error) {
+	result, err := tx.Exec(_logTaskSuccessIncr, name)
+	if err != nil {
+		return
+	}
+	rows, err = result.RowsAffected()
+	return
+}
+
+// IncrLogTaskFailure .
+func (d *Dao) IncrLogTaskFailure(ctx context.Context, name string) (rows int64, err error) {
+	result, err := d.db.Exec(ctx, _logTaskFailureIncr, name)
+	if err != nil {
+		return
+	}
+	rows, err = result.RowsAffected()
+	return
+}
+
+// Asset .
+func (d *Dao) Asset(ctx context.Context, oid int64, otype string, currency string) (data *model.Asset, err error) {
+	row := d.db.QueryRow(ctx, _asset, oid, otype, currency)
+	data = &model.Asset{}
+	if err = row.Scan(&data.ID, &data.MID, &data.OID, &data.OType, &data.Currency, &data.Price, &data.State, &data.CTime, &data.MTime); err != nil {
+		if err == xsql.ErrNoRows {
+			err = nil
+			data = nil
+		}
+		return
+	}
+	return
+}
+
+// SumPaidOrderUserRealFee .
+func (d *Dao) SumPaidOrderUserRealFee(ctx context.Context, beginTime, endTime time.Time) (sum int64, err error) {
+	row := d.db.QueryRow(ctx, _sumPaidOrderUserRealFee, beginTime, endTime)
+	if err = row.Scan(&sum); err != nil {
+		if err == xsql.ErrNoRows {
+			err = nil
+			sum = 0
+		}
+		return
+	}
+	return
+}
+
+// SumRefundedOrderUserRealFee .
+func (d *Dao) SumRefundedOrderUserRealFee(ctx context.Context, beginTime, endTime time.Time) (sum int64, err error) {
+	row := d.db.QueryRow(ctx, _sumRefundedOrderUserRealFee, beginTime, endTime)
+	if err = row.Scan(&sum); err != nil {
+		if err == xsql.ErrNoRows {
+			err = nil
+			sum = 0
+		}
+		return
+	}
+	return
+}
+
+// SumDailyBill .
+func (d *Dao) SumDailyBill(ctx context.Context, ver int64) (sumIn int64, sumOut int64, err error) {
+	row := d.db.QueryRow(ctx, _sumDailyBill, ver)
+	if err = row.Scan(&sumIn, &sumOut); err != nil {
+		if err == xsql.ErrNoRows {
+			err = nil
+			sumIn = 0
+			sumOut = 0
+		}
+		return
+	}
+	return
+}
+
+// MinIDOrderPaid .
+func (d *Dao) MinIDOrderPaid(ctx context.Context, beginTime time.Time) (minID int64, err error) {
+	row := d.db.QueryRow(ctx, _minIDOrderPaid, beginTime)
+	if err = row.Scan(&minID); err != nil {
+		if err == xsql.ErrNoRows {
+			err = nil
+			minID = math.MaxInt32
+		}
+		return
+	}
+	minID--
+	return
+}
+
+// OrderPaidList order list
+func (d *Dao) OrderPaidList(ctx context.Context, beginTime time.Time, endTime time.Time, fromID int64, limit int) (maxID int64, data []*model.Order, err error) {
+	rows, err := d.db.Query(ctx, _orderPaidList, beginTime, endTime, fromID, limit)
+	if err != nil {
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		d := &model.Order{}
+		if err = rows.Scan(&d.ID, &d.MID, &d.OrderID, &d.Biz, &d.Platform, &d.OID, &d.OType, &d.Fee, &d.RealFee, &d.Currency, &d.PayID, &d.PayReason, &d.PayTime, &d.State, &d.CTime, &d.MTime, &d.RefundTime, &d.Version); err != nil {
+			return
+		}
+		if d.ID > maxID {
+			maxID = d.ID
+		}
+		data = append(data, d)
+	}
+	err = rows.Err()
+	return
+}
+
+// MinIDOrderRefunded .
+func (d *Dao) MinIDOrderRefunded(ctx context.Context, beginTime time.Time) (minID int64, err error) {
+	row := d.db.QueryRow(ctx, _minIDOrderRefunded, beginTime)
+	if err = row.Scan(&minID); err != nil {
+		if err == xsql.ErrNoRows {
+			err = nil
+			minID = math.MaxInt32
+		}
+		return
+	}
+	minID--
+	return
+}
+
+// OrderRefundedList order list
+func (d *Dao) OrderRefundedList(ctx context.Context, beginTime time.Time, endTime time.Time, fromID int64, limit int) (maxID int64, data []*model.Order, err error) {
+	rows, err := d.db.Query(ctx, _orderRefundedList, beginTime, endTime, fromID, limit)
+	if err != nil {
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		d := &model.Order{}
+		if err = rows.Scan(&d.ID, &d.MID, &d.OrderID, &d.Biz, &d.Platform, &d.OID, &d.OType, &d.Fee, &d.RealFee, &d.Currency, &d.PayID, &d.PayReason, &d.PayTime, &d.State, &d.CTime, &d.MTime, &d.RefundTime, &d.Version); err != nil {
+			return
+		}
+		if d.ID > maxID {
+			maxID = d.ID
+		}
+		data = append(data, d)
+	}
+	err = rows.Err()
+	return
+}
+
+// TXUpdateOrder .
+func (d *Dao) TXUpdateOrder(ctx context.Context, tx *xsql.Tx, order *model.Order) (rows int64, err error) {
+	result, err := tx.Exec(_updateOrder, order.MID, order.OrderID, order.Biz, order.Platform, order.OID, order.OType, order.Fee, order.RealFee, order.Currency, order.PayID, order.PayReason, order.PayTime, order.State, order.RefundTime, order.ID, order.Version)
+	if err != nil {
+		return
+	}
+	rows, err = result.RowsAffected()
+	return
+}
+
+// TXInsertOrderUserLog .
+func (d *Dao) TXInsertOrderUserLog(ctx context.Context, tx *xsql.Tx, data *model.LogOrder) (id int64, err error) {
+	result, err := tx.Exec(_insertLogOrderUser, data.OrderID, data.FromState, data.ToState, data.Desc)
+	if err != nil {
+		return
+	}
+	if id, err = result.LastInsertId(); err != nil {
+		return
+	}
+	return
+}
+
+// MinIDDailyBillByVer .
+func (d *Dao) MinIDDailyBillByVer(ctx context.Context, ver int64) (minID int64, err error) {
+	row := d.db.QueryRow(ctx, _minIDDailyBillByVer, ver)
+	if err = row.Scan(&minID); err != nil {
+		if err == xsql.ErrNoRows {
+			err = nil
+			minID = math.MaxInt32
+		}
+		return
+	}
+	minID--
+	return
+}
+
+// DailyBillListByVer bill list
+func (d *Dao) DailyBillListByVer(ctx context.Context, ver int64, fromID int64, limit int) (maxID int64, data []*model.DailyBill, err error) {
+	rows, err := d.db.Query(ctx, _dailyBillListByVer, ver, fromID, limit)
+	if err != nil {
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		d := &model.DailyBill{}
+		if err = rows.Scan(&d.ID, &d.BillID, &d.MID, &d.Biz, &d.Currency, &d.In, &d.Out, &d.Ver, &d.MonthVer, &d.CTime, &d.MTime, &d.Version); err != nil {
+			return
+		}
+		if d.ID > maxID {
+			maxID = d.ID
+		}
+		data = append(data, d)
+	}
+	err = rows.Err()
+	return
+}
+
+// MinIDDailyBillByMonthVer .
+func (d *Dao) MinIDDailyBillByMonthVer(ctx context.Context, monthVer int64) (minID int64, err error) {
+	row := d.db.QueryRow(ctx, _minIDDailyBillByMonthVer, monthVer)
+	if err = row.Scan(&minID); err != nil {
+		if err == xsql.ErrNoRows {
+			err = nil
+			minID = math.MaxInt32
+		}
+		return
+	}
+	minID--
+	return
+}
+
+// DailyBillListByMonthVer bill list
+func (d *Dao) DailyBillListByMonthVer(ctx context.Context, monthVer int64, fromID int64, limit int) (maxID int64, data []*model.DailyBill, err error) {
+	rows, err := d.db.Query(ctx, _dailyBillListByMonthVer, monthVer, fromID, limit)
+	if err != nil {
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		d := &model.DailyBill{}
+		if err = rows.Scan(&d.ID, &d.BillID, &d.MID, &d.Biz, &d.Currency, &d.In, &d.Out, &d.Ver, &d.MonthVer, &d.CTime, &d.MTime, &d.Version); err != nil {
+			return
+		}
+		if d.ID > maxID {
+			maxID = d.ID
+		}
+		data = append(data, d)
+	}
+	err = rows.Err()
+	return
+}
+
+// TXInsertLogDailyBill .
+func (d *Dao) TXInsertLogDailyBill(ctx context.Context, tx *xsql.Tx, log *model.LogBillDaily) (id int64, err error) {
+	result, err := tx.Exec(_insertDailyBillLog, log.BillID, log.FromIn, log.ToIn, log.FromOut, log.ToOut, log.OrderID)
+	if err != nil {
+		return
+	}
+	id, err = result.LastInsertId()
+	return
+}
+
+// TXInsertLogMonthlyBill .
+func (d *Dao) TXInsertLogMonthlyBill(ctx context.Context, tx *xsql.Tx, log *model.LogBillMonthly) (id int64, err error) {
+	result, err := tx.Exec(_insertMonthlyBillLog, log.BillID, log.FromIn, log.ToIn, log.FromOut, log.ToOut, log.BillUserDailyID)
+	if err != nil {
+		return
+	}
+	id, err = result.LastInsertId()
+	return
+}
+
+// MinIDMonthlyBill .
+func (d *Dao) MinIDMonthlyBill(ctx context.Context, ver int64) (minID int64, err error) {
+	row := d.db.QueryRow(ctx, _minIDMonthlyBill, ver)
+	if err = row.Scan(&minID); err != nil {
+		if err == xsql.ErrNoRows {
+			err = nil
+			minID = math.MaxInt32
+		}
+		return
+	}
+	minID--
+	return
+}
+
+// MonthlyBillList bill list
+func (d *Dao) MonthlyBillList(ctx context.Context, ver int64, fromID int64, limit int) (maxID int64, data []*model.Bill, err error) {
+	rows, err := d.db.Query(ctx, _monthlyBillList, ver, fromID, limit)
+	if err != nil {
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		d := &model.Bill{}
+		if err = rows.Scan(&d.ID, &d.BillID, &d.MID, &d.Biz, &d.Currency, &d.In, &d.Out, &d.Ver, &d.CTime, &d.MTime, &d.Version); err != nil {
+			return
+		}
+		if d.ID > maxID {
+			maxID = d.ID
+		}
+		data = append(data, d)
+	}
+	err = rows.Err()
+	return
+}
+
+// DailyBill .
+func (d *Dao) DailyBill(ctx context.Context, mid int64, biz string, currency string, ver int64) (data *model.DailyBill, err error) {
+	row := d.db.QueryRow(ctx, _dailyBill, mid, biz, currency, ver)
+	data = &model.DailyBill{}
+	if err = row.Scan(&data.ID, &data.BillID, &data.MID, &data.Biz, &data.Currency, &data.In, &data.Out, &data.Ver, &data.MonthVer, &data.CTime, &data.MTime, &data.Version); err != nil {
+		if err == xsql.ErrNoRows {
+			err = nil
+			data = nil
+		}
+		return
+	}
+	return
+}
+
+// InsertDailyBill .
+func (d *Dao) InsertDailyBill(ctx context.Context, bill *model.DailyBill) (id int64, err error) {
+	result, err := d.db.Exec(ctx, _insertDailyBill, bill.BillID, bill.MID, bill.Biz, bill.Currency, bill.In, bill.Out, bill.Ver, bill.MonthVer, bill.Version)
+	if err != nil {
+		return
+	}
+	id, err = result.LastInsertId()
+	return
+}
+
+// TXUpdateDailyBill .
+func (d *Dao) TXUpdateDailyBill(ctx context.Context, tx *xsql.Tx, bill *model.DailyBill) (rows int64, err error) {
+	result, err := tx.Exec(_updateDailyBill, bill.BillID, bill.MID, bill.Biz, bill.Currency, bill.In, bill.Out, bill.Ver, bill.MonthVer, bill.MID, bill.Biz, bill.Currency, bill.Ver, bill.Version)
+	if err != nil {
+		return
+	}
+	rows, err = result.RowsAffected()
+	return
+}
+
+const (
+	_upsertDeltaDailyBill = "INSERT INTO bill_user_daily (bill_id,mid,biz,currency,`in`,`out`,ver,month_ver) VALUES (?,?,?,?,?,?,?,?) ON DUPLICATE KEY UPDATE `in`=`in`+?,`out`=`out`+?"
+	_updateDeltaDailyBill = "UPDATE bill_user_daily SET `in`=`in`+?,`out`=`out`+? WHERE mid=? AND biz=? AND currency=? AND ver=?"
+)
+
+// TXUpsertDeltaDailyBill .
+func (d *Dao) TXUpsertDeltaDailyBill(ctx context.Context, tx *xsql.Tx, bill *model.DailyBill, deltaIn, deltaOut int64) (rows int64, err error) {
+	result, err := tx.Exec(_upsertDeltaDailyBill, bill.BillID, bill.MID, bill.Biz, bill.Currency, deltaIn, deltaOut, bill.Ver, bill.MonthVer, deltaIn, deltaOut)
+	if err != nil {
+		return
+	}
+	rows, err = result.RowsAffected()
+	return
+}
+
+// TXUpdateDeltaDailyBill .
+func (d *Dao) TXUpdateDeltaDailyBill(ctx context.Context, tx *xsql.Tx, deltaIn, deltaOut int64, mid int64, biz string, currency string, ver int64) (rows int64, err error) {
+	result, err := tx.Exec(_updateDeltaDailyBill, deltaIn, deltaOut, mid, biz, currency, ver)
+	if err != nil {
+		return
+	}
+	rows, err = result.RowsAffected()
+	return
+}
+
+// MonthlyBill .
+func (d *Dao) MonthlyBill(ctx context.Context, mid int64, biz string, currency string, ver int64) (data *model.Bill, err error) {
+	row := d.db.QueryRow(ctx, _monthlyBill, mid, biz, currency, ver)
+	data = &model.Bill{}
+	if err = row.Scan(&data.ID, &data.BillID, &data.MID, &data.Biz, &data.Currency, &data.In, &data.Out, &data.Ver, &data.CTime, &data.MTime, &data.Version); err != nil {
+		if err == xsql.ErrNoRows {
+			err = nil
+			data = nil
+		}
+		return
+	}
+	return
+}
+
+// InsertMonthlyBill .
+func (d *Dao) InsertMonthlyBill(ctx context.Context, bill *model.Bill) (id int64, err error) {
+	result, err := d.db.Exec(ctx, _insertMonthlyBill, bill.BillID, bill.MID, bill.Biz, bill.Currency, bill.In, bill.Out, bill.Ver, bill.Version)
+	if err != nil {
+		return
+	}
+	id, err = result.LastInsertId()
+	return
+}
+
+// TXUpdateMonthlyBill .
+func (d *Dao) TXUpdateMonthlyBill(ctx context.Context, tx *xsql.Tx, bill *model.Bill) (rows int64, err error) {
+	result, err := tx.Exec(_updateMonthlyBill, bill.BillID, bill.MID, bill.Biz, bill.Currency, bill.In, bill.Out, bill.Ver, bill.MID, bill.Biz, bill.Currency, bill.Ver, bill.Version)
+	if err != nil {
+		return
+	}
+	rows, err = result.RowsAffected()
+	return
+}
+
+const (
+	_upsertDeltaMonthlyBill = "INSERT INTO bill_user_monthly (bill_id,mid,biz,currency,`in`,`out`,ver) VALUES (?,?,?,?,?,?,?) ON DUPLICATE KEY UPDATE `in`=`in`+?,`out`=`out`+?"
+	_updateDeltaMonthlyBill = "UPDATE bill_user_monthly SET `in`=`in`+?,`out`=`out`+? WHERE mid=? AND biz=? AND currency=? AND ver=?"
+)
+
+// TXUpsertDeltaMonthlyBill .
+func (d *Dao) TXUpsertDeltaMonthlyBill(ctx context.Context, tx *xsql.Tx, bill *model.Bill, deltaIn, deltaOut int64) (rows int64, err error) {
+	result, err := tx.Exec(_upsertDeltaMonthlyBill, bill.BillID, bill.MID, bill.Biz, bill.Currency, deltaIn, deltaOut, bill.Ver, deltaIn, deltaOut)
+	if err != nil {
+		return
+	}
+	rows, err = result.RowsAffected()
+	return
+}
+
+// TXUpdateDeltaMonthlyBill .
+func (d *Dao) TXUpdateDeltaMonthlyBill(ctx context.Context, tx *xsql.Tx, deltaIn, deltaOut int64, mid int64, biz string, currency string, ver int64) (rows int64, err error) {
+	result, err := tx.Exec(_updateDeltaMonthlyBill, deltaIn, deltaOut, mid, biz, currency, ver)
+	if err != nil {
+		return
+	}
+	rows, err = result.RowsAffected()
+	return
+}
+
+// MinIDUserAccount .
+func (d *Dao) MinIDUserAccount(ctx context.Context, beginTime time.Time) (minID int64, err error) {
+	row := d.db.QueryRow(ctx, _minIDUserAccount, beginTime)
+	if err = row.Scan(&minID); err != nil {
+		if err == xsql.ErrNoRows {
+			err = nil
+			minID = math.MaxInt32
+		}
+		return
+	}
+	minID--
+	return
+}
+
+// UserAccountList bill list
+func (d *Dao) UserAccountList(ctx context.Context, beginTime time.Time, endTime time.Time, fromID int64, limit int) (maxID int64, datas []*model.UserAccount, err error) {
+	rows, err := d.db.Query(ctx, _userAccountList, beginTime, endTime, fromID, limit)
+	if err != nil {
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		data := &model.UserAccount{}
+		if err = rows.Scan(&data.ID, &data.MID, &data.Biz, &data.Currency, &data.Balance, &data.Ver, &data.State, &data.CTime, &data.MTime); err != nil {
+			return
+		}
+		if data.ID > maxID {
+			maxID = data.ID
+		}
+		datas = append(datas, data)
+	}
+	err = rows.Err()
+	return
+}
+
+// UserAccount .
+func (d *Dao) UserAccount(ctx context.Context, mid int64, biz string, currency string) (data *model.UserAccount, err error) {
+	row := d.db.QueryRow(ctx, _userAccount, mid, biz, currency)
+	data = &model.UserAccount{}
+	if err = row.Scan(&data.ID, &data.MID, &data.Biz, &data.Currency, &data.Balance, &data.Ver, &data.State, &data.CTime, &data.MTime); err != nil {
+		if err == xsql.ErrNoRows {
+			err = nil
+			data = nil
+		}
+		return
+	}
+	return
+}
+
+// InsertUserAccount .
+func (d *Dao) InsertUserAccount(ctx context.Context, account *model.UserAccount) (id int64, err error) {
+	result, err := d.db.Exec(ctx, _insertUserAccount, account.MID, account.Biz, account.Currency, account.Balance, account.Ver, account.State)
+	if err != nil {
+		return
+	}
+	id, err = result.LastInsertId()
+	return
+}
+
+// TXUpdateUserAccount .
+func (d *Dao) TXUpdateUserAccount(ctx context.Context, tx *xsql.Tx, account *model.UserAccount) (rows int64, err error) {
+	result, err := tx.Exec(_updateUserAccount, account.MID, account.Biz, account.Currency, account.Balance, account.State, account.MID, account.Biz, account.Currency, account.Ver)
+	if err != nil {
+		return
+	}
+	rows, err = result.RowsAffected()
+	return
+}
+
+const (
+	_upsertDeltaUserAccount = "INSERT INTO account_user (mid,biz,currency,balance,ver,state) VALUES (?,?,?,?,?,?) ON DUPLICATE KEY UPDATE balance=balance+?,ver=ver+1"
+	_updateDeltaUserAccount = `UPDATE account_user SET balance=balance+?,ver=ver+1 WHERE mid=? AND biz=? AND currency=?`
+)
+
+// TXUpsertDeltaUserAccount .
+func (d *Dao) TXUpsertDeltaUserAccount(ctx context.Context, tx *xsql.Tx, account *model.UserAccount, deltaBalance int64) (rows int64, err error) {
+	result, err := tx.Exec(_upsertDeltaUserAccount, account.MID, account.Biz, account.Currency, deltaBalance, account.Ver, account.State, deltaBalance)
+	if err != nil {
+		return
+	}
+	rows, err = result.RowsAffected()
+	return
+}
+
+// TXUpdateDeltaUserAccount .
+func (d *Dao) TXUpdateDeltaUserAccount(ctx context.Context, tx *xsql.Tx, deltaBalance int64, mid int64, biz string, currency string) (rows int64, err error) {
+	result, err := tx.Exec(_updateDeltaUserAccount, deltaBalance, mid, biz, currency)
+	if err != nil {
+		return
+	}
+	rows, err = result.RowsAffected()
+	return
+}
+
+// TXInsertUserAccountLog .
+func (d *Dao) TXInsertUserAccountLog(ctx context.Context, tx *xsql.Tx, accountLog *model.AccountLog) (err error) {
+	_, err = tx.Exec(_insertUserAccountLog, accountLog.AccountID, accountLog.From, accountLog.To, accountLog.Ver, accountLog.State, accountLog.Name)
+	return
+}
+
+// BizAccount .
+func (d *Dao) BizAccount(ctx context.Context, biz string, currency string) (data *model.BizAccount, err error) {
+	row := d.db.QueryRow(ctx, _bizAccount, biz, currency)
+	data = &model.BizAccount{}
+	if err = row.Scan(&data.ID, &data.Biz, &data.Currency, &data.Balance, &data.Ver, &data.State, &data.CTime, &data.MTime); err != nil {
+		if err == xsql.ErrNoRows {
+			err = nil
+			data = nil
+		}
+		return
+	}
+	return
+}
+
+// InsertBizAccount .
+func (d *Dao) InsertBizAccount(ctx context.Context, account *model.BizAccount) (id int64, err error) {
+	result, err := d.db.Exec(ctx, _insertBizAccount, account.Biz, account.Currency, account.Balance, account.Ver, account.State)
+	if err != nil {
+		return
+	}
+	id, err = result.LastInsertId()
+	return
+}
+
+// TXUpdateBizAccount .
+func (d *Dao) TXUpdateBizAccount(ctx context.Context, tx *xsql.Tx, account *model.BizAccount) (rows int64, err error) {
+	result, err := tx.Exec(_updateBizAccount, account.Biz, account.Currency, account.Balance, account.State, account.Biz, account.Currency, account.Ver)
+	if err != nil {
+		return
+	}
+	rows, err = result.RowsAffected()
+	return
+}
+
+const (
+	_upsertDeltaBizAccount = "INSERT INTO account_biz (biz,currency,balance,ver,state) VALUES (?,?,?,?,?) ON DUPLICATE KEY UPDATE balance=balance+?,ver=ver+1"
+	_updateDeltaBizAccount = `UPDATE account_biz SET balance=balance+?,ver=ver+1 WHERE biz=? AND currency=?`
+)
+
+// TXUpsertDeltaBizAccount .
+func (d *Dao) TXUpsertDeltaBizAccount(ctx context.Context, tx *xsql.Tx, account *model.BizAccount, deltaBalance int64) (rows int64, err error) {
+	result, err := tx.Exec(_upsertDeltaBizAccount, account.Biz, account.Currency, deltaBalance, account.Ver, account.State, deltaBalance)
+	if err != nil {
+		return
+	}
+	rows, err = result.RowsAffected()
+	return
+}
+
+// TXUpdateDeltaBizAccount .
+func (d *Dao) TXUpdateDeltaBizAccount(ctx context.Context, tx *xsql.Tx, deltaBalance int64, biz string, currency string) (rows int64, err error) {
+	result, err := tx.Exec(_updateDeltaBizAccount, deltaBalance, biz, currency)
+	if err != nil {
+		return
+	}
+	rows, err = result.RowsAffected()
+	return
+}
+
+// TXInsertBizAccountLog .
+func (d *Dao) TXInsertBizAccountLog(ctx context.Context, tx *xsql.Tx, accountLog *model.AccountLog) (err error) {
+	_, err = tx.Exec(_insertBizAccountLog, accountLog.AccountID, accountLog.From, accountLog.To, accountLog.Ver, accountLog.State, accountLog.Name)
+	return
+}
+
+// AggrIncomeUser .
+func (d *Dao) AggrIncomeUser(ctx context.Context, mid int64, currency string) (data *model.AggrIncomeUser, err error) {
+	row := d.db.QueryRow(ctx, _aggrIncomeUser, mid, currency)
+	data = &model.AggrIncomeUser{}
+	if err = row.Scan(&data.ID, &data.MID, &data.Currency, &data.PaySuccess, &data.PayError, &data.TotalIn, &data.TotalOut, &data.CTime, &data.MTime); err != nil {
+		if err == xsql.ErrNoRows {
+			err = nil
+			data = nil
+		}
+		return
+	}
+	return
+}
+
+// InsertAggrIncomeUser .
+func (d *Dao) InsertAggrIncomeUser(ctx context.Context, aggr *model.AggrIncomeUser) (id int64, err error) {
+	result, err := d.db.Exec(ctx, _insertAggrIncomeUser, aggr.MID, aggr.Currency, aggr.PaySuccess, aggr.PayError, aggr.TotalIn, aggr.TotalOut)
+	if err != nil {
+		return
+	}
+	id, err = result.LastInsertId()
+	return
+}
+
+// TXUpdateAggrIncomeUser .
+func (d *Dao) TXUpdateAggrIncomeUser(ctx context.Context, tx *xsql.Tx, aggr *model.AggrIncomeUser) (rows int64, err error) {
+	result, err := tx.Exec(_updateAggrIncomeUser, aggr.MID, aggr.Currency, aggr.PaySuccess, aggr.PayError, aggr.TotalIn, aggr.TotalOut, aggr.MID, aggr.Currency)
+	if err != nil {
+		return
+	}
+	rows, err = result.RowsAffected()
+	return
+}
+
+const (
+	_upsertDeltaAggrIncomeUser = "INSERT INTO aggr_income_user (mid,currency,pay_success,pay_error,total_in,total_out) VALUES (?,?,?,?,?,?) ON DUPLICATE KEY UPDATE pay_success=pay_success+?,pay_error=pay_error+?,total_in=total_in+?,total_out=total_out+?"
+	_updateDeltaAggrIncomeUser = "UPDATE aggr_income_user SET pay_success=pay_success+?,pay_error=pay_error+?,total_in=total_in+?,total_out=total_out+? WHERE mid=? AND currency=?"
+)
+
+// TXUpsertDeltaAggrIncomeUser .
+func (d *Dao) TXUpsertDeltaAggrIncomeUser(ctx context.Context, tx *xsql.Tx, aggr *model.AggrIncomeUser, deltaPaySuccess, deltaPayError, deltaTotalIn, deltaTotalOut int64) (rows int64, err error) {
+	result, err := tx.Exec(_upsertDeltaAggrIncomeUser, aggr.MID, aggr.Currency, deltaPaySuccess, deltaPayError, deltaTotalIn, deltaTotalOut, deltaPaySuccess, deltaPayError, deltaTotalIn, deltaTotalOut)
+	if err != nil {
+		return
+	}
+	rows, err = result.RowsAffected()
+	return
+}
+
+// TXUpdateDeltaAggrIncomeUser .
+func (d *Dao) TXUpdateDeltaAggrIncomeUser(ctx context.Context, tx *xsql.Tx, deltaPaySuccess, deltaPayError, deltaTotalIn, deltaTotalOut int64, mid int64, currency string) (rows int64, err error) {
+	result, err := tx.Exec(_updateDeltaAggrIncomeUser, deltaPaySuccess, deltaPayError, deltaTotalIn, deltaTotalOut, mid, currency)
+	if err != nil {
+		return
+	}
+	rows, err = result.RowsAffected()
+	return
+}
+
+// AggrIncomeUserAsset .
+func (d *Dao) AggrIncomeUserAsset(ctx context.Context, mid int64, currency string, ver int64, oid int64, otype string) (data *model.AggrIncomeUserAsset, err error) {
+	row := d.db.QueryRow(ctx, _aggrIncomeUserAsset, mid, currency, ver, oid, otype)
+	data = &model.AggrIncomeUserAsset{}
+	if err = row.Scan(&data.ID, &data.MID, &data.Currency, &data.Ver, &data.OID, &data.OType, &data.PaySuccess, &data.PayError, &data.TotalIn, &data.TotalOut, &data.CTime, &data.MTime); err != nil {
+		if err == xsql.ErrNoRows {
+			err = nil
+			data = nil
+		}
+		return
+	}
+	return
+}
+
+// InsertAggrIncomeUserAsset .
+func (d *Dao) InsertAggrIncomeUserAsset(ctx context.Context, aggr *model.AggrIncomeUserAsset) (id int64, err error) {
+	result, err := d.db.Exec(ctx, _insertAggrIncomeUserAsset, aggr.MID, aggr.Currency, aggr.Ver, aggr.OID, aggr.OType, aggr.PaySuccess, aggr.PayError, aggr.TotalIn, aggr.TotalOut)
+	if err != nil {
+		return
+	}
+	id, err = result.LastInsertId()
+	return
+}
+
+// TXUpdateAggrIncomeUserAsset .
+func (d *Dao) TXUpdateAggrIncomeUserAsset(ctx context.Context, tx *xsql.Tx, aggr *model.AggrIncomeUserAsset) (rows int64, err error) {
+	result, err := tx.Exec(_updateAggrIncomeUserAsset, aggr.MID, aggr.Currency, aggr.Ver, aggr.OID, aggr.OType, aggr.PaySuccess, aggr.PayError, aggr.TotalIn, aggr.TotalOut, aggr.MID, aggr.Currency, aggr.Ver, aggr.OID, aggr.OType)
+	if err != nil {
+		return
+	}
+	rows, err = result.RowsAffected()
+	return
+}
+
+const (
+	_upsertDeltaAggrIncomeUserAsset = "INSERT INTO aggr_income_user_asset (mid,currency,`ver`,oid,otype,pay_success,pay_error,total_in,total_out) VALUES (?,?,?,?,?,?,?,?,?) ON DUPLICATE KEY UPDATE pay_success=pay_success+?,pay_error=pay_error+?,total_in=total_in+?,total_out=total_out+?"
+	_updateDeltaAggrIncomeUserAsset = "UPDATE aggr_income_user_asset SET pay_success=pay_success+?,pay_error=pay_error+?,total_in=total_in+?,total_out=total_out+? WHERE mid=? AND currency=? AND ver=? AND oid=? AND otype=?"
+)
+
+// TXUpsertDeltaAggrIncomeUserAsset .
+func (d *Dao) TXUpsertDeltaAggrIncomeUserAsset(ctx context.Context, tx *xsql.Tx, aggr *model.AggrIncomeUserAsset, deltaPaySuccess, deltaPayError, deltaTotalIn, deltaTotalOut int64) (rows int64, err error) {
+	result, err := tx.Exec(_upsertDeltaAggrIncomeUserAsset, aggr.MID, aggr.Currency, aggr.Ver, aggr.OID, aggr.OType, deltaPaySuccess, deltaPayError, deltaTotalIn, deltaTotalOut, deltaPaySuccess, deltaPayError, deltaTotalIn, deltaTotalOut)
+	if err != nil {
+		return
+	}
+	rows, err = result.RowsAffected()
+	return
+}
+
+// TXUpdateDeltaAggrIncomeUserAsset .
+func (d *Dao) TXUpdateDeltaAggrIncomeUserAsset(ctx context.Context, tx *xsql.Tx, deltaPaySuccess, deltaPayError, deltaTotalIn, deltaTotalOut int64, mid int64, currency string, ver int64, oid int64, otype string) (rows int64, err error) {
+	result, err := tx.Exec(_updateDeltaAggrIncomeUserAsset, deltaPaySuccess, deltaPayError, deltaTotalIn, deltaTotalOut, mid, currency, ver, oid, otype)
+	if err != nil {
+		return
+	}
+	rows, err = result.RowsAffected()
+	return
+}
+
+// OrderBadDebt .
+func (d *Dao) OrderBadDebt(ctx context.Context, orderID string) (data *model.OrderBadDebt, err error) {
+	row := d.db.QueryRow(ctx, _orderBadDebt, orderID)
+	data = &model.OrderBadDebt{}
+	if err = row.Scan(&data.ID, &data.OrderID, &data.Type, &data.State, &data.CTime, &data.MTime); err != nil {
+		if err == xsql.ErrNoRows {
+			err = nil
+			data = nil
+		}
+		return
+	}
+	return
+}
+
+// InsertOrderBadDebt .
+func (d *Dao) InsertOrderBadDebt(ctx context.Context, order *model.OrderBadDebt) (id int64, err error) {
+	result, err := d.db.Exec(ctx, _insertOrderBadDebt, order.OrderID, order.Type, order.State)
+	if err != nil {
+		return
+	}
+	id, err = result.LastInsertId()
+	return
+}
+
+// TXUpdateOrderBadDebt .
+func (d *Dao) TXUpdateOrderBadDebt(ctx context.Context, tx *xsql.Tx, order *model.OrderBadDebt) (rows int64, err error) {
+	result, err := tx.Exec(_updateOrderBadDebt, order.OrderID, order.Type, order.State, order.OrderID)
+	if err != nil {
+		return
+	}
+	rows, err = result.RowsAffected()
+	return
+}
+
+// TXInsertOrderRechargeShell .
+func (d *Dao) TXInsertOrderRechargeShell(ctx context.Context, tx *xsql.Tx, order *model.OrderRechargeShell) (id int64, err error) {
+	result, err := tx.Exec(_insertOrderRechargeShell, order.MID, order.OrderID, order.Biz, order.Amount, order.PayMSG, order.State, order.Ver)
+	if err != nil {
+		return
+	}
+	id, err = result.LastInsertId()
+	return
+}
+
+// TXInsertOrderRechargeShellLog .
+func (d *Dao) TXInsertOrderRechargeShellLog(ctx context.Context, tx *xsql.Tx, order *model.OrderRechargeShellLog) (id int64, err error) {
+	result, err := tx.Exec(_insertOrderRechargeShellLog, order.OrderID, order.FromState, order.ToState, order.Desc, order.BillUserMonthlyID)
+	if err != nil {
+		return
+	}
+	id, err = result.LastInsertId()
+	return
+}

app/job/main/ugcpay/dao/redis.go

@@ -0,0 +1,31 @@
+package dao
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/pkg/errors"
+)
+
+func assetRelationKey(mid int64) string {
+	return fmt.Sprintf("up_ar_%d", mid)
+}
+
+func assetRelationField(oid int64, otype string) string {
+	return fmt.Sprintf("%s_%d", otype, oid)
+}
+
+// DelCacheAssetRelationState delete asset relation state.
+func (d *Dao) DelCacheAssetRelationState(c context.Context, oid int64, otype string, mid int64) (err error) {
+	var (
+		key   = assetRelationKey(mid)
+		field = assetRelationField(oid, otype)
+		conn  = d.redis.Get(c)
+	)
+	defer conn.Close()
+	if _, err = conn.Do("HDEL", key, field); err != nil {
+		err = errors.Wrapf(err, "conn.Do(HDEL, %s, %s)", key, field)
+		return
+	}
+	return
+}

app/job/main/ugcpay/dao/redis_test.go

@@ -0,0 +1,54 @@
+package dao
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaoassetRelationKey(t *testing.T) {
+	convey.Convey("assetRelationKey", t, func(ctx convey.C) {
+		var (
+			mid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			p1 := assetRelationKey(mid)
+			ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(p1, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoassetRelationField(t *testing.T) {
+	convey.Convey("assetRelationField", t, func(ctx convey.C) {
+		var (
+			oid   = int64(0)
+			otype = ""
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			p1 := assetRelationField(oid, otype)
+			ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(p1, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoDelCacheAssetRelationState(t *testing.T) {
+	convey.Convey("DelCacheAssetRelationState", t, func(ctx convey.C) {
+		var (
+			c     = context.Background()
+			oid   = int64(0)
+			otype = ""
+			mid   = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.DelCacheAssetRelationState(c, oid, otype, mid)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}