Move db operation to store module. (#10)

Author: Argeric

api/stat_api.go

@@ -1,14 +1,9 @@
 package api
 
 import (
-	"encoding/json"
-
 	commonApi "github.com/Conflux-Chain/go-conflux-util/api"
 	"github.com/gin-gonic/gin"
-	"github.com/sirupsen/logrus"
-	"github.com/zero-gravity-labs/zerog-storage-scan/stat"
 	"github.com/zero-gravity-labs/zerog-storage-scan/store"
-	"gorm.io/gorm"
 )
 
 type Type int
@@ -20,7 +15,7 @@ const (
 )
 
 func dashboard(_ *gin.Context) (interface{}, error) {
-	submitStat, err := db.SubmitStatStore.LastByType(stat.Day)
+	submitStat, err := db.SubmitStatStore.LastByType(store.Day)
 	if err != nil {
 		return nil, commonApi.ErrInternal(err)
 	}
@@ -57,30 +52,8 @@ func getSubmitStatByType(c *gin.Context, t Type) (interface{}, error) {
 		return nil, err
 	}
 
-	r, _ := json.Marshal(statP)
-	logrus.WithFields(logrus.Fields{
-		"skip":         statP.Skip,
-		"limit":        statP.Limit,
-		"minTimestamp": statP.MinTimestamp,
-		"maxTimestamp": statP.MaxTimestamp,
-		"intervalType": statP.IntervalType,
-		"sort":         statP.Sort,
-	}).Infof("queryStat incoming %v", string(r))
-
-	var conds []func(db *gorm.DB) *gorm.DB
-	intervalType := stat.IntervalTypes[statP.IntervalType]
-	conds = append(conds, StatType(intervalType))
-	if statP.MinTimestamp != 0 {
-		conds = append(conds, MinTimestamp(statP.MinTimestamp))
-	}
-	if statP.MaxTimestamp != 0 {
-		conds = append(conds, MaxTimestamp(statP.MaxTimestamp))
-	}
-	dbRaw := db.DB.Model(&store.SubmitStat{})
-	dbRaw.Scopes(conds...)
-
-	records := new([]store.SubmitStat)
-	total, err := db.List(dbRaw, statP.isDesc(), statP.Skip, statP.Limit, records)
+	total, records, err := db.SubmitStatStore.List(&statP.IntervalType, statP.MinTimestamp, statP.MaxTimestamp,
+		statP.isDesc(), statP.Skip, statP.Limit)
 	if err != nil {
 		return nil, err
 	}
@@ -91,7 +64,7 @@ func getSubmitStatByType(c *gin.Context, t Type) (interface{}, error) {
 	switch t {
 	case StorageStatType:
 		list := make([]DataStat, 0)
-		for _, r := range *records {
+		for _, r := range records {
 			list = append(list, DataStat{
 				StatTime:  r.StatTime,
 				FileCount: r.FileCount,
@@ -103,7 +76,7 @@ func getSubmitStatByType(c *gin.Context, t Type) (interface{}, error) {
 		result["list"] = list
 	case TxStatType:
 		list := make([]TxStat, 0)
-		for _, r := range *records {
+		for _, r := range records {
 			list = append(list, TxStat{
 				StatTime: r.StatTime,
 				TxCount:  r.FileCount,
@@ -113,7 +86,7 @@ func getSubmitStatByType(c *gin.Context, t Type) (interface{}, error) {
 		result["list"] = list
 	case FeeStatType:
 		list := make([]FeeStat, 0)
-		for _, r := range *records {
+		for _, r := range records {
 			list = append(list, FeeStat{
 				StatTime:     r.StatTime,
 				BaseFee:      r.BaseFee,
@@ -127,21 +100,3 @@ func getSubmitStatByType(c *gin.Context, t Type) (interface{}, error) {
 
 	return result, nil
 }
-
-func StatType(t string) func(db *gorm.DB) *gorm.DB {
-	return func(db *gorm.DB) *gorm.DB {
-		return db.Where("stat_type = ?", t)
-	}
-}
-
-func MinTimestamp(minTimestamp int) func(db *gorm.DB) *gorm.DB {
-	return func(db *gorm.DB) *gorm.DB {
-		return db.Where("stat_time >= ?", minTimestamp)
-	}
-}
-
-func MaxTimestamp(maxTimestamp int) func(db *gorm.DB) *gorm.DB {
-	return func(db *gorm.DB) *gorm.DB {
-		return db.Where("stat_time <= ?", maxTimestamp)
-	}
-}

api/tx_api.go

@@ -4,15 +4,13 @@ import (
 	"encoding/hex"
 	"encoding/json"
 	"strconv"
-	"strings"
 
 	commonApi "github.com/Conflux-Chain/go-conflux-util/api"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/gin-gonic/gin"
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 	"github.com/zero-gravity-labs/zerog-storage-scan/store"
-	"gorm.io/gorm"
 )
 
 func listTx(c *gin.Context) (interface{}, error) {
@@ -21,40 +19,34 @@ func listTx(c *gin.Context) (interface{}, error) {
 		return nil, err
 	}
 
-	dbRaw := db.DB.Model(&store.Submit{})
-	var conds []func(db *gorm.DB) *gorm.DB
-	if param.Address != "" {
-		addr, exist, err := db.AddressStore.Get(param.Address)
+	var addrIDPtr *uint64
+	if param.Address != nil {
+		addr, exist, err := db.AddressStore.Get(*param.Address)
 		if err != nil {
 			return nil, commonApi.ErrInternal(err)
 		}
 		if !exist {
 			return TxList{}, nil
 		}
-		conds = append(conds, SenderID(addr.Id))
+		addrIDPtr = &addr.Id
 	}
-	if param.RootHash != "" {
-		conds = append(conds, RootHash(param.RootHash))
-	}
-	dbRaw.Scopes(conds...)
 
-	submits := new([]store.Submit)
-	total, err := db.List(dbRaw, true, param.Skip, param.Limit, submits)
+	total, submits, err := listSubmits(addrIDPtr, param.RootHash, param.isDesc(), param.Skip, param.Limit)
 	if err != nil {
 		return nil, err
 	}
 
-	addrIds := make([]uint64, 0)
-	for _, submit := range *submits {
-		addrIds = append(addrIds, submit.SenderID)
+	addrIDs := make([]uint64, 0)
+	for _, submit := range submits {
+		addrIDs = append(addrIDs, submit.SenderID)
 	}
-	addrMap, err := db.BatchGetAddresses(addrIds)
+	addrMap, err := db.BatchGetAddresses(addrIDs)
 	if err != nil {
 		return nil, err
 	}
 
 	storageTxs := make([]StorageTx, 0)
-	for _, submit := range *submits {
+	for _, submit := range submits {
 		storageTx := StorageTx{
 			TxSeq:     submit.SubmissionIndex,
 			BlockNum:  submit.BlockNumber,
@@ -70,11 +62,10 @@ func listTx(c *gin.Context) (interface{}, error) {
 		storageTxs = append(storageTxs, storageTx)
 	}
 
-	result := TxList{
+	return TxList{
 		Total: total,
 		List:  storageTxs,
-	}
-	return result, nil
+	}, nil
 }
 
 func getTxBrief(c *gin.Context) (interface{}, error) {
@@ -93,8 +84,8 @@ func getTxBrief(c *gin.Context) (interface{}, error) {
 		return nil, errors.Errorf("Record not found, txSeq %v", *param.TxSeq)
 	}
 
-	addrIds := []uint64{submit.SenderID}
-	addrMap, err := db.BatchGetAddresses(addrIds)
+	addrIDs := []uint64{submit.SenderID}
+	addrMap, err := db.BatchGetAddresses(addrIDs)
 	if err != nil {
 		return nil, err
 	}
@@ -175,14 +166,30 @@ func getTxDetail(c *gin.Context) (interface{}, error) {
 	return result, nil
 }
 
-func SenderID(si uint64) func(db *gorm.DB) *gorm.DB {
-	return func(db *gorm.DB) *gorm.DB {
-		return db.Where("sender_id = ?", si)
+func listSubmits(addressID *uint64, rootHash *string, idDesc bool, skip, limit int) (int64, []store.Submit, error) {
+	if addressID == nil {
+		return db.SubmitStore.List(rootHash, idDesc, skip, limit)
 	}
-}
 
-func RootHash(rh string) func(db *gorm.DB) *gorm.DB {
-	return func(db *gorm.DB) *gorm.DB {
-		return db.Where("root_hash = ?", strings.ToLower(strings.TrimPrefix(rh, "0x")))
+	total, addrSubmits, err := db.AddressSubmitStore.List(addressID, rootHash, idDesc, skip, limit)
+	if err != nil {
+		return 0, nil, err
+	}
+
+	submits := make([]store.Submit, 0)
+	for _, as := range addrSubmits {
+		submits = append(submits, store.Submit{
+			SubmissionIndex: as.SubmissionIndex,
+			RootHash:        as.RootHash,
+			SenderID:        as.SenderID,
+			Length:          as.Length,
+			BlockNumber:     as.BlockNumber,
+			BlockTime:       as.BlockTime,
+			TxHash:          as.TxHash,
+			Status:          as.Status,
+			Fee:             as.Fee,
+		})
 	}
+
+	return total, submits, nil
 }

api/types.go

@@ -15,8 +15,8 @@ type PageParam struct {
 
 type statParam struct {
 	PageParam
-	MinTimestamp int    `form:"minTimestamp,default=0" binding:"omitempty,number"`
-	MaxTimestamp int    `form:"maxTimestamp,default=0" binding:"omitempty,number"`
+	MinTimestamp *int   `form:"minTimestamp" binding:"omitempty,number"`
+	MaxTimestamp *int   `form:"maxTimestamp" binding:"omitempty,number"`
 	IntervalType string `form:"intervalType,default=day" binding:"omitempty,oneof=hour day"`
 	Sort         string `form:"sort,default=desc" binding:"omitempty,oneof=asc desc"`
 }
@@ -27,8 +27,13 @@ func (sp *statParam) isDesc() bool {
 
 type listTxParam struct {
 	PageParam
-	Address  string `form:"address" binding:"omitempty"`
-	RootHash string `form:"rootHash" binding:"omitempty"`
+	Address  *string `form:"address" binding:"omitempty"`
+	RootHash *string `form:"rootHash" binding:"omitempty"`
+	Sort     string  `form:"sort,default=desc" binding:"omitempty,oneof=asc desc"`
+}
+
+func (sp *listTxParam) isDesc() bool {
+	return strings.EqualFold(sp.Sort, "desc")
 }
 
 type queryTxParam struct {

stat/stat.go

@@ -2,41 +2,21 @@ package stat
 
 import (
 	"context"
+	"sync"
+	"time"
+
 	"github.com/Conflux-Chain/go-conflux-util/viper"
 	"github.com/openweb3/web3go"
 	"github.com/openweb3/web3go/types"
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 	"github.com/zero-gravity-labs/zerog-storage-scan/store"
-	"sync"
-	"time"
-)
-
-const (
-	Min    = "1m"
-	TenMin = "10m"
-	Hour   = "1h"
-	Day    = "1d"
 )
 
 var (
 	ErrTimeNotReach      = errors.New("time not reach")
 	ErrBlockNotSync      = errors.New("block not sync")
 	ErrBlockNotFinalized = errors.New("block not finalized")
-
-	Intervals = map[string]time.Duration{
-		Min:    time.Minute,
-		TenMin: time.Minute * 10,
-		Hour:   time.Hour,
-		Day:    time.Hour * 24,
-	}
-
-	IntervalTypes = map[string]string{
-		"min":   Min,
-		"10min": TenMin,
-		"hour":  Hour,
-		"day":   Day,
-	}
 )
 
 type StatConfig struct {
@@ -52,7 +32,7 @@ type TimeRange struct {
 
 type BaseStat struct {
 	Config    *StatConfig
-	Db        *store.MysqlStore
+	DB        *store.MysqlStore
 	Sdk       *web3go.Client
 	StartTime *time.Time
 }
@@ -123,7 +103,7 @@ func (bs *BaseStat) calStatRangeStart(t *time.Time, statType string) (*time.Time
 }
 
 func (bs *BaseStat) firstBlockAfterRangeEnd(rangeEnd *time.Time) (uint64, bool, error) {
-	return bs.Db.FirstBlockAfterTime(rangeEnd)
+	return bs.DB.FirstBlockAfterTime(rangeEnd)
 }
 
 type Stat interface {