diff --git a/.github/workflows/dev.yml b/.github/workflows/dev.yml index 80ea898..888fae8 100644 --- a/.github/workflows/dev.yml +++ b/.github/workflows/dev.yml @@ -13,6 +13,11 @@ jobs: ports: - 8000:8000 options: --name dynamo-local + mysql-local: + image: mysql:latest + ports: + - 3306:3306 + options: --name mysql-local -e MYSQL_ROOT_PASSWORD=123456 steps: - name: Checkout uses: actions/checkout@v3 @@ -25,5 +30,8 @@ jobs: - name: Wait for DynamoDB Local to start run: | while ! nc -z localhost 8000; do sleep 1; done + - name: Wait for MySQL Local to start + run: | + while ! nc -z localhost 3306; do sleep 1; done - name: Run tests run: go test -v ./... diff --git a/dal/dal.go b/dal/dal.go new file mode 100644 index 0000000..aac6479 --- /dev/null +++ b/dal/dal.go @@ -0,0 +1,30 @@ +package dal + +import ( + "sync" + + "gorm.io/driver/mysql" + "gorm.io/gorm" +) + +var ( + // DB is the database connection. + DB *gorm.DB + once sync.Once +) + +func init() { + once.Do(func() { + DB = ConnectDB() + }) +} + +// ConnectDB connects to the database. +func ConnectDB() *gorm.DB { + dsn := "root:123456@tcp(127.0.0.1:3306)/toolkit?charset=utf8mb4&parseTime=True" + db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{}) + if err != nil { + panic(err) + } + return db +} diff --git a/dal/dao/chain_metrics.gen.go b/dal/dao/chain_metrics.gen.go new file mode 100644 index 0000000..40802b3 --- /dev/null +++ b/dal/dao/chain_metrics.gen.go @@ -0,0 +1,383 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package dao + +import ( + "context" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "github.com/0311xuyang/chain-util/dal/model" +) + +func newChainMetric(db *gorm.DB, opts ...gen.DOOption) chainMetric { + _chainMetric := chainMetric{} + + _chainMetric.chainMetricDo.UseDB(db, opts...) + _chainMetric.chainMetricDo.UseModel(&model.ChainMetric{}) + + tableName := _chainMetric.chainMetricDo.TableName() + _chainMetric.ALL = field.NewAsterisk(tableName) + _chainMetric.UniqueDelegate = field.NewInt32(tableName, "unique_delegate") + _chainMetric.Date = field.NewTime(tableName, "date") + _chainMetric.ChainName = field.NewString(tableName, "chain_name") + _chainMetric.UniqueDelegation = field.NewInt32(tableName, "unique_delegation") + _chainMetric.UnbondedTokens = field.NewInt64(tableName, "unbonded_tokens") + _chainMetric.BondedTokens = field.NewInt64(tableName, "bonded_tokens") + _chainMetric.MarketCap = field.NewInt64(tableName, "market_cap") + _chainMetric.TotalSupply = field.NewInt64(tableName, "total_supply") + _chainMetric.CirculatingSupply = field.NewInt64(tableName, "circulating_supply") + _chainMetric.Transactions = field.NewInt64(tableName, "transactions") + _chainMetric.BlockTime = field.NewString(tableName, "block_time") + _chainMetric.Inflation = field.NewString(tableName, "inflation") + _chainMetric.StakingApr = field.NewString(tableName, "staking_apr") + _chainMetric.TxsPerBlock = field.NewString(tableName, "txs_per_block") + _chainMetric.CommunityPool = field.NewInt64(tableName, "community_pool") + _chainMetric.BlockHeight = field.NewInt64(tableName, "block_height") + _chainMetric.TotalStake = field.NewInt64(tableName, "total_stake") + + _chainMetric.fillFieldMap() + + return _chainMetric +} + +type chainMetric struct { + chainMetricDo + + ALL field.Asterisk + UniqueDelegate field.Int32 + Date field.Time + ChainName field.String + UniqueDelegation field.Int32 + UnbondedTokens field.Int64 + BondedTokens field.Int64 + MarketCap field.Int64 + TotalSupply field.Int64 + CirculatingSupply field.Int64 + Transactions field.Int64 + BlockTime field.String + Inflation field.String + StakingApr field.String + TxsPerBlock field.String + CommunityPool field.Int64 + BlockHeight field.Int64 + TotalStake field.Int64 + + fieldMap map[string]field.Expr +} + +func (c chainMetric) Table(newTableName string) *chainMetric { + c.chainMetricDo.UseTable(newTableName) + return c.updateTableName(newTableName) +} + +func (c chainMetric) As(alias string) *chainMetric { + c.chainMetricDo.DO = *(c.chainMetricDo.As(alias).(*gen.DO)) + return c.updateTableName(alias) +} + +func (c *chainMetric) updateTableName(table string) *chainMetric { + c.ALL = field.NewAsterisk(table) + c.UniqueDelegate = field.NewInt32(table, "unique_delegate") + c.Date = field.NewTime(table, "date") + c.ChainName = field.NewString(table, "chain_name") + c.UniqueDelegation = field.NewInt32(table, "unique_delegation") + c.UnbondedTokens = field.NewInt64(table, "unbonded_tokens") + c.BondedTokens = field.NewInt64(table, "bonded_tokens") + c.MarketCap = field.NewInt64(table, "market_cap") + c.TotalSupply = field.NewInt64(table, "total_supply") + c.CirculatingSupply = field.NewInt64(table, "circulating_supply") + c.Transactions = field.NewInt64(table, "transactions") + c.BlockTime = field.NewString(table, "block_time") + c.Inflation = field.NewString(table, "inflation") + c.StakingApr = field.NewString(table, "staking_apr") + c.TxsPerBlock = field.NewString(table, "txs_per_block") + c.CommunityPool = field.NewInt64(table, "community_pool") + c.BlockHeight = field.NewInt64(table, "block_height") + c.TotalStake = field.NewInt64(table, "total_stake") + + c.fillFieldMap() + + return c +} + +func (c *chainMetric) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := c.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (c *chainMetric) fillFieldMap() { + c.fieldMap = make(map[string]field.Expr, 17) + c.fieldMap["unique_delegate"] = c.UniqueDelegate + c.fieldMap["date"] = c.Date + c.fieldMap["chain_name"] = c.ChainName + c.fieldMap["unique_delegation"] = c.UniqueDelegation + c.fieldMap["unbonded_tokens"] = c.UnbondedTokens + c.fieldMap["bonded_tokens"] = c.BondedTokens + c.fieldMap["market_cap"] = c.MarketCap + c.fieldMap["total_supply"] = c.TotalSupply + c.fieldMap["circulating_supply"] = c.CirculatingSupply + c.fieldMap["transactions"] = c.Transactions + c.fieldMap["block_time"] = c.BlockTime + c.fieldMap["inflation"] = c.Inflation + c.fieldMap["staking_apr"] = c.StakingApr + c.fieldMap["txs_per_block"] = c.TxsPerBlock + c.fieldMap["community_pool"] = c.CommunityPool + c.fieldMap["block_height"] = c.BlockHeight + c.fieldMap["total_stake"] = c.TotalStake +} + +func (c chainMetric) clone(db *gorm.DB) chainMetric { + c.chainMetricDo.ReplaceConnPool(db.Statement.ConnPool) + return c +} + +func (c chainMetric) replaceDB(db *gorm.DB) chainMetric { + c.chainMetricDo.ReplaceDB(db) + return c +} + +type chainMetricDo struct{ gen.DO } + +func (c chainMetricDo) Debug() *chainMetricDo { + return c.withDO(c.DO.Debug()) +} + +func (c chainMetricDo) WithContext(ctx context.Context) *chainMetricDo { + return c.withDO(c.DO.WithContext(ctx)) +} + +func (c chainMetricDo) ReadDB() *chainMetricDo { + return c.Clauses(dbresolver.Read) +} + +func (c chainMetricDo) WriteDB() *chainMetricDo { + return c.Clauses(dbresolver.Write) +} + +func (c chainMetricDo) Session(config *gorm.Session) *chainMetricDo { + return c.withDO(c.DO.Session(config)) +} + +func (c chainMetricDo) Clauses(conds ...clause.Expression) *chainMetricDo { + return c.withDO(c.DO.Clauses(conds...)) +} + +func (c chainMetricDo) Returning(value interface{}, columns ...string) *chainMetricDo { + return c.withDO(c.DO.Returning(value, columns...)) +} + +func (c chainMetricDo) Not(conds ...gen.Condition) *chainMetricDo { + return c.withDO(c.DO.Not(conds...)) +} + +func (c chainMetricDo) Or(conds ...gen.Condition) *chainMetricDo { + return c.withDO(c.DO.Or(conds...)) +} + +func (c chainMetricDo) Select(conds ...field.Expr) *chainMetricDo { + return c.withDO(c.DO.Select(conds...)) +} + +func (c chainMetricDo) Where(conds ...gen.Condition) *chainMetricDo { + return c.withDO(c.DO.Where(conds...)) +} + +func (c chainMetricDo) Order(conds ...field.Expr) *chainMetricDo { + return c.withDO(c.DO.Order(conds...)) +} + +func (c chainMetricDo) Distinct(cols ...field.Expr) *chainMetricDo { + return c.withDO(c.DO.Distinct(cols...)) +} + +func (c chainMetricDo) Omit(cols ...field.Expr) *chainMetricDo { + return c.withDO(c.DO.Omit(cols...)) +} + +func (c chainMetricDo) Join(table schema.Tabler, on ...field.Expr) *chainMetricDo { + return c.withDO(c.DO.Join(table, on...)) +} + +func (c chainMetricDo) LeftJoin(table schema.Tabler, on ...field.Expr) *chainMetricDo { + return c.withDO(c.DO.LeftJoin(table, on...)) +} + +func (c chainMetricDo) RightJoin(table schema.Tabler, on ...field.Expr) *chainMetricDo { + return c.withDO(c.DO.RightJoin(table, on...)) +} + +func (c chainMetricDo) Group(cols ...field.Expr) *chainMetricDo { + return c.withDO(c.DO.Group(cols...)) +} + +func (c chainMetricDo) Having(conds ...gen.Condition) *chainMetricDo { + return c.withDO(c.DO.Having(conds...)) +} + +func (c chainMetricDo) Limit(limit int) *chainMetricDo { + return c.withDO(c.DO.Limit(limit)) +} + +func (c chainMetricDo) Offset(offset int) *chainMetricDo { + return c.withDO(c.DO.Offset(offset)) +} + +func (c chainMetricDo) Scopes(funcs ...func(gen.Dao) gen.Dao) *chainMetricDo { + return c.withDO(c.DO.Scopes(funcs...)) +} + +func (c chainMetricDo) Unscoped() *chainMetricDo { + return c.withDO(c.DO.Unscoped()) +} + +func (c chainMetricDo) Create(values ...*model.ChainMetric) error { + if len(values) == 0 { + return nil + } + return c.DO.Create(values) +} + +func (c chainMetricDo) CreateInBatches(values []*model.ChainMetric, batchSize int) error { + return c.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (c chainMetricDo) Save(values ...*model.ChainMetric) error { + if len(values) == 0 { + return nil + } + return c.DO.Save(values) +} + +func (c chainMetricDo) First() (*model.ChainMetric, error) { + if result, err := c.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.ChainMetric), nil + } +} + +func (c chainMetricDo) Take() (*model.ChainMetric, error) { + if result, err := c.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.ChainMetric), nil + } +} + +func (c chainMetricDo) Last() (*model.ChainMetric, error) { + if result, err := c.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.ChainMetric), nil + } +} + +func (c chainMetricDo) Find() ([]*model.ChainMetric, error) { + result, err := c.DO.Find() + return result.([]*model.ChainMetric), err +} + +func (c chainMetricDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.ChainMetric, err error) { + buf := make([]*model.ChainMetric, 0, batchSize) + err = c.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (c chainMetricDo) FindInBatches(result *[]*model.ChainMetric, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return c.DO.FindInBatches(result, batchSize, fc) +} + +func (c chainMetricDo) Attrs(attrs ...field.AssignExpr) *chainMetricDo { + return c.withDO(c.DO.Attrs(attrs...)) +} + +func (c chainMetricDo) Assign(attrs ...field.AssignExpr) *chainMetricDo { + return c.withDO(c.DO.Assign(attrs...)) +} + +func (c chainMetricDo) Joins(fields ...field.RelationField) *chainMetricDo { + for _, _f := range fields { + c = *c.withDO(c.DO.Joins(_f)) + } + return &c +} + +func (c chainMetricDo) Preload(fields ...field.RelationField) *chainMetricDo { + for _, _f := range fields { + c = *c.withDO(c.DO.Preload(_f)) + } + return &c +} + +func (c chainMetricDo) FirstOrInit() (*model.ChainMetric, error) { + if result, err := c.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.ChainMetric), nil + } +} + +func (c chainMetricDo) FirstOrCreate() (*model.ChainMetric, error) { + if result, err := c.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.ChainMetric), nil + } +} + +func (c chainMetricDo) FindByPage(offset int, limit int) (result []*model.ChainMetric, count int64, err error) { + result, err = c.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = c.Offset(-1).Limit(-1).Count() + return +} + +func (c chainMetricDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = c.Count() + if err != nil { + return + } + + err = c.Offset(offset).Limit(limit).Scan(result) + return +} + +func (c chainMetricDo) Scan(result interface{}) (err error) { + return c.DO.Scan(result) +} + +func (c chainMetricDo) Delete(models ...*model.ChainMetric) (result gen.ResultInfo, err error) { + return c.DO.Delete(models) +} + +func (c *chainMetricDo) withDO(do gen.Dao) *chainMetricDo { + c.DO = *do.(*gen.DO) + return c +} diff --git a/dal/dao/coin_price.gen.go b/dal/dao/coin_price.gen.go new file mode 100644 index 0000000..0b3b234 --- /dev/null +++ b/dal/dao/coin_price.gen.go @@ -0,0 +1,331 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package dao + +import ( + "context" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "github.com/0311xuyang/chain-util/dal/model" +) + +func newCoinPrice(db *gorm.DB, opts ...gen.DOOption) coinPrice { + _coinPrice := coinPrice{} + + _coinPrice.coinPriceDo.UseDB(db, opts...) + _coinPrice.coinPriceDo.UseModel(&model.CoinPrice{}) + + tableName := _coinPrice.coinPriceDo.TableName() + _coinPrice.ALL = field.NewAsterisk(tableName) + _coinPrice.Date = field.NewTime(tableName, "date") + _coinPrice.Price = field.NewString(tableName, "price") + _coinPrice.Symbol = field.NewString(tableName, "symbol") + _coinPrice.ChainName = field.NewString(tableName, "chain_name") + + _coinPrice.fillFieldMap() + + return _coinPrice +} + +type coinPrice struct { + coinPriceDo + + ALL field.Asterisk + Date field.Time + Price field.String + Symbol field.String + ChainName field.String + + fieldMap map[string]field.Expr +} + +func (c coinPrice) Table(newTableName string) *coinPrice { + c.coinPriceDo.UseTable(newTableName) + return c.updateTableName(newTableName) +} + +func (c coinPrice) As(alias string) *coinPrice { + c.coinPriceDo.DO = *(c.coinPriceDo.As(alias).(*gen.DO)) + return c.updateTableName(alias) +} + +func (c *coinPrice) updateTableName(table string) *coinPrice { + c.ALL = field.NewAsterisk(table) + c.Date = field.NewTime(table, "date") + c.Price = field.NewString(table, "price") + c.Symbol = field.NewString(table, "symbol") + c.ChainName = field.NewString(table, "chain_name") + + c.fillFieldMap() + + return c +} + +func (c *coinPrice) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := c.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (c *coinPrice) fillFieldMap() { + c.fieldMap = make(map[string]field.Expr, 4) + c.fieldMap["date"] = c.Date + c.fieldMap["price"] = c.Price + c.fieldMap["symbol"] = c.Symbol + c.fieldMap["chain_name"] = c.ChainName +} + +func (c coinPrice) clone(db *gorm.DB) coinPrice { + c.coinPriceDo.ReplaceConnPool(db.Statement.ConnPool) + return c +} + +func (c coinPrice) replaceDB(db *gorm.DB) coinPrice { + c.coinPriceDo.ReplaceDB(db) + return c +} + +type coinPriceDo struct{ gen.DO } + +func (c coinPriceDo) Debug() *coinPriceDo { + return c.withDO(c.DO.Debug()) +} + +func (c coinPriceDo) WithContext(ctx context.Context) *coinPriceDo { + return c.withDO(c.DO.WithContext(ctx)) +} + +func (c coinPriceDo) ReadDB() *coinPriceDo { + return c.Clauses(dbresolver.Read) +} + +func (c coinPriceDo) WriteDB() *coinPriceDo { + return c.Clauses(dbresolver.Write) +} + +func (c coinPriceDo) Session(config *gorm.Session) *coinPriceDo { + return c.withDO(c.DO.Session(config)) +} + +func (c coinPriceDo) Clauses(conds ...clause.Expression) *coinPriceDo { + return c.withDO(c.DO.Clauses(conds...)) +} + +func (c coinPriceDo) Returning(value interface{}, columns ...string) *coinPriceDo { + return c.withDO(c.DO.Returning(value, columns...)) +} + +func (c coinPriceDo) Not(conds ...gen.Condition) *coinPriceDo { + return c.withDO(c.DO.Not(conds...)) +} + +func (c coinPriceDo) Or(conds ...gen.Condition) *coinPriceDo { + return c.withDO(c.DO.Or(conds...)) +} + +func (c coinPriceDo) Select(conds ...field.Expr) *coinPriceDo { + return c.withDO(c.DO.Select(conds...)) +} + +func (c coinPriceDo) Where(conds ...gen.Condition) *coinPriceDo { + return c.withDO(c.DO.Where(conds...)) +} + +func (c coinPriceDo) Order(conds ...field.Expr) *coinPriceDo { + return c.withDO(c.DO.Order(conds...)) +} + +func (c coinPriceDo) Distinct(cols ...field.Expr) *coinPriceDo { + return c.withDO(c.DO.Distinct(cols...)) +} + +func (c coinPriceDo) Omit(cols ...field.Expr) *coinPriceDo { + return c.withDO(c.DO.Omit(cols...)) +} + +func (c coinPriceDo) Join(table schema.Tabler, on ...field.Expr) *coinPriceDo { + return c.withDO(c.DO.Join(table, on...)) +} + +func (c coinPriceDo) LeftJoin(table schema.Tabler, on ...field.Expr) *coinPriceDo { + return c.withDO(c.DO.LeftJoin(table, on...)) +} + +func (c coinPriceDo) RightJoin(table schema.Tabler, on ...field.Expr) *coinPriceDo { + return c.withDO(c.DO.RightJoin(table, on...)) +} + +func (c coinPriceDo) Group(cols ...field.Expr) *coinPriceDo { + return c.withDO(c.DO.Group(cols...)) +} + +func (c coinPriceDo) Having(conds ...gen.Condition) *coinPriceDo { + return c.withDO(c.DO.Having(conds...)) +} + +func (c coinPriceDo) Limit(limit int) *coinPriceDo { + return c.withDO(c.DO.Limit(limit)) +} + +func (c coinPriceDo) Offset(offset int) *coinPriceDo { + return c.withDO(c.DO.Offset(offset)) +} + +func (c coinPriceDo) Scopes(funcs ...func(gen.Dao) gen.Dao) *coinPriceDo { + return c.withDO(c.DO.Scopes(funcs...)) +} + +func (c coinPriceDo) Unscoped() *coinPriceDo { + return c.withDO(c.DO.Unscoped()) +} + +func (c coinPriceDo) Create(values ...*model.CoinPrice) error { + if len(values) == 0 { + return nil + } + return c.DO.Create(values) +} + +func (c coinPriceDo) CreateInBatches(values []*model.CoinPrice, batchSize int) error { + return c.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (c coinPriceDo) Save(values ...*model.CoinPrice) error { + if len(values) == 0 { + return nil + } + return c.DO.Save(values) +} + +func (c coinPriceDo) First() (*model.CoinPrice, error) { + if result, err := c.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.CoinPrice), nil + } +} + +func (c coinPriceDo) Take() (*model.CoinPrice, error) { + if result, err := c.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.CoinPrice), nil + } +} + +func (c coinPriceDo) Last() (*model.CoinPrice, error) { + if result, err := c.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.CoinPrice), nil + } +} + +func (c coinPriceDo) Find() ([]*model.CoinPrice, error) { + result, err := c.DO.Find() + return result.([]*model.CoinPrice), err +} + +func (c coinPriceDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.CoinPrice, err error) { + buf := make([]*model.CoinPrice, 0, batchSize) + err = c.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (c coinPriceDo) FindInBatches(result *[]*model.CoinPrice, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return c.DO.FindInBatches(result, batchSize, fc) +} + +func (c coinPriceDo) Attrs(attrs ...field.AssignExpr) *coinPriceDo { + return c.withDO(c.DO.Attrs(attrs...)) +} + +func (c coinPriceDo) Assign(attrs ...field.AssignExpr) *coinPriceDo { + return c.withDO(c.DO.Assign(attrs...)) +} + +func (c coinPriceDo) Joins(fields ...field.RelationField) *coinPriceDo { + for _, _f := range fields { + c = *c.withDO(c.DO.Joins(_f)) + } + return &c +} + +func (c coinPriceDo) Preload(fields ...field.RelationField) *coinPriceDo { + for _, _f := range fields { + c = *c.withDO(c.DO.Preload(_f)) + } + return &c +} + +func (c coinPriceDo) FirstOrInit() (*model.CoinPrice, error) { + if result, err := c.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.CoinPrice), nil + } +} + +func (c coinPriceDo) FirstOrCreate() (*model.CoinPrice, error) { + if result, err := c.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.CoinPrice), nil + } +} + +func (c coinPriceDo) FindByPage(offset int, limit int) (result []*model.CoinPrice, count int64, err error) { + result, err = c.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = c.Offset(-1).Limit(-1).Count() + return +} + +func (c coinPriceDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = c.Count() + if err != nil { + return + } + + err = c.Offset(offset).Limit(limit).Scan(result) + return +} + +func (c coinPriceDo) Scan(result interface{}) (err error) { + return c.DO.Scan(result) +} + +func (c coinPriceDo) Delete(models ...*model.CoinPrice) (result gen.ResultInfo, err error) { + return c.DO.Delete(models) +} + +func (c *coinPriceDo) withDO(do gen.Dao) *coinPriceDo { + c.DO = *do.(*gen.DO) + return c +} diff --git a/dal/dao/gen.go b/dal/dao/gen.go new file mode 100644 index 0000000..07bc5c9 --- /dev/null +++ b/dal/dao/gen.go @@ -0,0 +1,135 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package dao + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + + "gorm.io/gen" + + "gorm.io/plugin/dbresolver" +) + +func Use(db *gorm.DB, opts ...gen.DOOption) *Query { + return &Query{ + db: db, + ChainMetric: newChainMetric(db, opts...), + CoinPrice: newCoinPrice(db, opts...), + MultisigAccount: newMultisigAccount(db, opts...), + MultisigHistory: newMultisigHistory(db, opts...), + PendingTransaction: newPendingTransaction(db, opts...), + StakingPercentage: newStakingPercentage(db, opts...), + TopDelegation: newTopDelegation(db, opts...), + TopUndelegation: newTopUndelegation(db, opts...), + } +} + +type Query struct { + db *gorm.DB + + ChainMetric chainMetric + CoinPrice coinPrice + MultisigAccount multisigAccount + MultisigHistory multisigHistory + PendingTransaction pendingTransaction + StakingPercentage stakingPercentage + TopDelegation topDelegation + TopUndelegation topUndelegation +} + +func (q *Query) Available() bool { return q.db != nil } + +func (q *Query) clone(db *gorm.DB) *Query { + return &Query{ + db: db, + ChainMetric: q.ChainMetric.clone(db), + CoinPrice: q.CoinPrice.clone(db), + MultisigAccount: q.MultisigAccount.clone(db), + MultisigHistory: q.MultisigHistory.clone(db), + PendingTransaction: q.PendingTransaction.clone(db), + StakingPercentage: q.StakingPercentage.clone(db), + TopDelegation: q.TopDelegation.clone(db), + TopUndelegation: q.TopUndelegation.clone(db), + } +} + +func (q *Query) ReadDB() *Query { + return q.ReplaceDB(q.db.Clauses(dbresolver.Read)) +} + +func (q *Query) WriteDB() *Query { + return q.ReplaceDB(q.db.Clauses(dbresolver.Write)) +} + +func (q *Query) ReplaceDB(db *gorm.DB) *Query { + return &Query{ + db: db, + ChainMetric: q.ChainMetric.replaceDB(db), + CoinPrice: q.CoinPrice.replaceDB(db), + MultisigAccount: q.MultisigAccount.replaceDB(db), + MultisigHistory: q.MultisigHistory.replaceDB(db), + PendingTransaction: q.PendingTransaction.replaceDB(db), + StakingPercentage: q.StakingPercentage.replaceDB(db), + TopDelegation: q.TopDelegation.replaceDB(db), + TopUndelegation: q.TopUndelegation.replaceDB(db), + } +} + +type queryCtx struct { + ChainMetric *chainMetricDo + CoinPrice *coinPriceDo + MultisigAccount *multisigAccountDo + MultisigHistory *multisigHistoryDo + PendingTransaction *pendingTransactionDo + StakingPercentage *stakingPercentageDo + TopDelegation *topDelegationDo + TopUndelegation *topUndelegationDo +} + +func (q *Query) WithContext(ctx context.Context) *queryCtx { + return &queryCtx{ + ChainMetric: q.ChainMetric.WithContext(ctx), + CoinPrice: q.CoinPrice.WithContext(ctx), + MultisigAccount: q.MultisigAccount.WithContext(ctx), + MultisigHistory: q.MultisigHistory.WithContext(ctx), + PendingTransaction: q.PendingTransaction.WithContext(ctx), + StakingPercentage: q.StakingPercentage.WithContext(ctx), + TopDelegation: q.TopDelegation.WithContext(ctx), + TopUndelegation: q.TopUndelegation.WithContext(ctx), + } +} + +func (q *Query) Transaction(fc func(tx *Query) error, opts ...*sql.TxOptions) error { + return q.db.Transaction(func(tx *gorm.DB) error { return fc(q.clone(tx)) }, opts...) +} + +func (q *Query) Begin(opts ...*sql.TxOptions) *QueryTx { + tx := q.db.Begin(opts...) + return &QueryTx{Query: q.clone(tx), Error: tx.Error} +} + +type QueryTx struct { + *Query + Error error +} + +func (q *QueryTx) Commit() error { + return q.db.Commit().Error +} + +func (q *QueryTx) Rollback() error { + return q.db.Rollback().Error +} + +func (q *QueryTx) SavePoint(name string) error { + return q.db.SavePoint(name).Error +} + +func (q *QueryTx) RollbackTo(name string) error { + return q.db.RollbackTo(name).Error +} diff --git a/dal/dao/multisig_account.gen.go b/dal/dao/multisig_account.gen.go new file mode 100644 index 0000000..3c16b4a --- /dev/null +++ b/dal/dao/multisig_account.gen.go @@ -0,0 +1,347 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package dao + +import ( + "context" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "github.com/0311xuyang/chain-util/dal/model" +) + +func newMultisigAccount(db *gorm.DB, opts ...gen.DOOption) multisigAccount { + _multisigAccount := multisigAccount{} + + _multisigAccount.multisigAccountDo.UseDB(db, opts...) + _multisigAccount.multisigAccountDo.UseModel(&model.MultisigAccount{}) + + tableName := _multisigAccount.multisigAccountDo.TableName() + _multisigAccount.ALL = field.NewAsterisk(tableName) + _multisigAccount.Address = field.NewString(tableName, "address") + _multisigAccount.Name = field.NewString(tableName, "name") + _multisigAccount.Threshold = field.NewInt32(tableName, "threshold") + _multisigAccount.ChainName = field.NewString(tableName, "chain_name") + _multisigAccount.Members = field.NewString(tableName, "members") + _multisigAccount.Status = field.NewString(tableName, "status") + _multisigAccount.Pubkey = field.NewString(tableName, "pubkey") + _multisigAccount.CreateTime = field.NewTime(tableName, "create_time") + + _multisigAccount.fillFieldMap() + + return _multisigAccount +} + +type multisigAccount struct { + multisigAccountDo + + ALL field.Asterisk + Address field.String + Name field.String + Threshold field.Int32 + ChainName field.String + Members field.String + Status field.String + Pubkey field.String + CreateTime field.Time + + fieldMap map[string]field.Expr +} + +func (m multisigAccount) Table(newTableName string) *multisigAccount { + m.multisigAccountDo.UseTable(newTableName) + return m.updateTableName(newTableName) +} + +func (m multisigAccount) As(alias string) *multisigAccount { + m.multisigAccountDo.DO = *(m.multisigAccountDo.As(alias).(*gen.DO)) + return m.updateTableName(alias) +} + +func (m *multisigAccount) updateTableName(table string) *multisigAccount { + m.ALL = field.NewAsterisk(table) + m.Address = field.NewString(table, "address") + m.Name = field.NewString(table, "name") + m.Threshold = field.NewInt32(table, "threshold") + m.ChainName = field.NewString(table, "chain_name") + m.Members = field.NewString(table, "members") + m.Status = field.NewString(table, "status") + m.Pubkey = field.NewString(table, "pubkey") + m.CreateTime = field.NewTime(table, "create_time") + + m.fillFieldMap() + + return m +} + +func (m *multisigAccount) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := m.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (m *multisigAccount) fillFieldMap() { + m.fieldMap = make(map[string]field.Expr, 8) + m.fieldMap["address"] = m.Address + m.fieldMap["name"] = m.Name + m.fieldMap["threshold"] = m.Threshold + m.fieldMap["chain_name"] = m.ChainName + m.fieldMap["members"] = m.Members + m.fieldMap["status"] = m.Status + m.fieldMap["pubkey"] = m.Pubkey + m.fieldMap["create_time"] = m.CreateTime +} + +func (m multisigAccount) clone(db *gorm.DB) multisigAccount { + m.multisigAccountDo.ReplaceConnPool(db.Statement.ConnPool) + return m +} + +func (m multisigAccount) replaceDB(db *gorm.DB) multisigAccount { + m.multisigAccountDo.ReplaceDB(db) + return m +} + +type multisigAccountDo struct{ gen.DO } + +func (m multisigAccountDo) Debug() *multisigAccountDo { + return m.withDO(m.DO.Debug()) +} + +func (m multisigAccountDo) WithContext(ctx context.Context) *multisigAccountDo { + return m.withDO(m.DO.WithContext(ctx)) +} + +func (m multisigAccountDo) ReadDB() *multisigAccountDo { + return m.Clauses(dbresolver.Read) +} + +func (m multisigAccountDo) WriteDB() *multisigAccountDo { + return m.Clauses(dbresolver.Write) +} + +func (m multisigAccountDo) Session(config *gorm.Session) *multisigAccountDo { + return m.withDO(m.DO.Session(config)) +} + +func (m multisigAccountDo) Clauses(conds ...clause.Expression) *multisigAccountDo { + return m.withDO(m.DO.Clauses(conds...)) +} + +func (m multisigAccountDo) Returning(value interface{}, columns ...string) *multisigAccountDo { + return m.withDO(m.DO.Returning(value, columns...)) +} + +func (m multisigAccountDo) Not(conds ...gen.Condition) *multisigAccountDo { + return m.withDO(m.DO.Not(conds...)) +} + +func (m multisigAccountDo) Or(conds ...gen.Condition) *multisigAccountDo { + return m.withDO(m.DO.Or(conds...)) +} + +func (m multisigAccountDo) Select(conds ...field.Expr) *multisigAccountDo { + return m.withDO(m.DO.Select(conds...)) +} + +func (m multisigAccountDo) Where(conds ...gen.Condition) *multisigAccountDo { + return m.withDO(m.DO.Where(conds...)) +} + +func (m multisigAccountDo) Order(conds ...field.Expr) *multisigAccountDo { + return m.withDO(m.DO.Order(conds...)) +} + +func (m multisigAccountDo) Distinct(cols ...field.Expr) *multisigAccountDo { + return m.withDO(m.DO.Distinct(cols...)) +} + +func (m multisigAccountDo) Omit(cols ...field.Expr) *multisigAccountDo { + return m.withDO(m.DO.Omit(cols...)) +} + +func (m multisigAccountDo) Join(table schema.Tabler, on ...field.Expr) *multisigAccountDo { + return m.withDO(m.DO.Join(table, on...)) +} + +func (m multisigAccountDo) LeftJoin(table schema.Tabler, on ...field.Expr) *multisigAccountDo { + return m.withDO(m.DO.LeftJoin(table, on...)) +} + +func (m multisigAccountDo) RightJoin(table schema.Tabler, on ...field.Expr) *multisigAccountDo { + return m.withDO(m.DO.RightJoin(table, on...)) +} + +func (m multisigAccountDo) Group(cols ...field.Expr) *multisigAccountDo { + return m.withDO(m.DO.Group(cols...)) +} + +func (m multisigAccountDo) Having(conds ...gen.Condition) *multisigAccountDo { + return m.withDO(m.DO.Having(conds...)) +} + +func (m multisigAccountDo) Limit(limit int) *multisigAccountDo { + return m.withDO(m.DO.Limit(limit)) +} + +func (m multisigAccountDo) Offset(offset int) *multisigAccountDo { + return m.withDO(m.DO.Offset(offset)) +} + +func (m multisigAccountDo) Scopes(funcs ...func(gen.Dao) gen.Dao) *multisigAccountDo { + return m.withDO(m.DO.Scopes(funcs...)) +} + +func (m multisigAccountDo) Unscoped() *multisigAccountDo { + return m.withDO(m.DO.Unscoped()) +} + +func (m multisigAccountDo) Create(values ...*model.MultisigAccount) error { + if len(values) == 0 { + return nil + } + return m.DO.Create(values) +} + +func (m multisigAccountDo) CreateInBatches(values []*model.MultisigAccount, batchSize int) error { + return m.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (m multisigAccountDo) Save(values ...*model.MultisigAccount) error { + if len(values) == 0 { + return nil + } + return m.DO.Save(values) +} + +func (m multisigAccountDo) First() (*model.MultisigAccount, error) { + if result, err := m.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.MultisigAccount), nil + } +} + +func (m multisigAccountDo) Take() (*model.MultisigAccount, error) { + if result, err := m.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.MultisigAccount), nil + } +} + +func (m multisigAccountDo) Last() (*model.MultisigAccount, error) { + if result, err := m.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.MultisigAccount), nil + } +} + +func (m multisigAccountDo) Find() ([]*model.MultisigAccount, error) { + result, err := m.DO.Find() + return result.([]*model.MultisigAccount), err +} + +func (m multisigAccountDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.MultisigAccount, err error) { + buf := make([]*model.MultisigAccount, 0, batchSize) + err = m.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (m multisigAccountDo) FindInBatches(result *[]*model.MultisigAccount, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return m.DO.FindInBatches(result, batchSize, fc) +} + +func (m multisigAccountDo) Attrs(attrs ...field.AssignExpr) *multisigAccountDo { + return m.withDO(m.DO.Attrs(attrs...)) +} + +func (m multisigAccountDo) Assign(attrs ...field.AssignExpr) *multisigAccountDo { + return m.withDO(m.DO.Assign(attrs...)) +} + +func (m multisigAccountDo) Joins(fields ...field.RelationField) *multisigAccountDo { + for _, _f := range fields { + m = *m.withDO(m.DO.Joins(_f)) + } + return &m +} + +func (m multisigAccountDo) Preload(fields ...field.RelationField) *multisigAccountDo { + for _, _f := range fields { + m = *m.withDO(m.DO.Preload(_f)) + } + return &m +} + +func (m multisigAccountDo) FirstOrInit() (*model.MultisigAccount, error) { + if result, err := m.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.MultisigAccount), nil + } +} + +func (m multisigAccountDo) FirstOrCreate() (*model.MultisigAccount, error) { + if result, err := m.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.MultisigAccount), nil + } +} + +func (m multisigAccountDo) FindByPage(offset int, limit int) (result []*model.MultisigAccount, count int64, err error) { + result, err = m.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = m.Offset(-1).Limit(-1).Count() + return +} + +func (m multisigAccountDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = m.Count() + if err != nil { + return + } + + err = m.Offset(offset).Limit(limit).Scan(result) + return +} + +func (m multisigAccountDo) Scan(result interface{}) (err error) { + return m.DO.Scan(result) +} + +func (m multisigAccountDo) Delete(models ...*model.MultisigAccount) (result gen.ResultInfo, err error) { + return m.DO.Delete(models) +} + +func (m *multisigAccountDo) withDO(do gen.Dao) *multisigAccountDo { + m.DO = *do.(*gen.DO) + return m +} diff --git a/dal/dao/multisig_history.gen.go b/dal/dao/multisig_history.gen.go new file mode 100644 index 0000000..afb5cbe --- /dev/null +++ b/dal/dao/multisig_history.gen.go @@ -0,0 +1,363 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package dao + +import ( + "context" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "github.com/0311xuyang/chain-util/dal/model" +) + +func newMultisigHistory(db *gorm.DB, opts ...gen.DOOption) multisigHistory { + _multisigHistory := multisigHistory{} + + _multisigHistory.multisigHistoryDo.UseDB(db, opts...) + _multisigHistory.multisigHistoryDo.UseModel(&model.MultisigHistory{}) + + tableName := _multisigHistory.multisigHistoryDo.TableName() + _multisigHistory.ALL = field.NewAsterisk(tableName) + _multisigHistory.TxHash = field.NewString(tableName, "tx_hash") + _multisigHistory.Status = field.NewInt32(tableName, "status") + _multisigHistory.CreateTime = field.NewTime(tableName, "create_time") + _multisigHistory.MultisigAddr = field.NewString(tableName, "multisig_addr") + _multisigHistory.Memo = field.NewString(tableName, "memo") + _multisigHistory.Fees = field.NewString(tableName, "fees") + _multisigHistory.Height = field.NewString(tableName, "height") + _multisigHistory.GasUsed = field.NewString(tableName, "gas_used") + _multisigHistory.GasWanted = field.NewString(tableName, "gas_wanted") + _multisigHistory.TotalAmount = field.NewString(tableName, "total_amount") + _multisigHistory.SequenceNumber = field.NewString(tableName, "sequence_number") + _multisigHistory.Tx = field.NewString(tableName, "tx") + + _multisigHistory.fillFieldMap() + + return _multisigHistory +} + +type multisigHistory struct { + multisigHistoryDo + + ALL field.Asterisk + TxHash field.String + Status field.Int32 + CreateTime field.Time + MultisigAddr field.String + Memo field.String + Fees field.String + Height field.String + GasUsed field.String + GasWanted field.String + TotalAmount field.String + SequenceNumber field.String + Tx field.String + + fieldMap map[string]field.Expr +} + +func (m multisigHistory) Table(newTableName string) *multisigHistory { + m.multisigHistoryDo.UseTable(newTableName) + return m.updateTableName(newTableName) +} + +func (m multisigHistory) As(alias string) *multisigHistory { + m.multisigHistoryDo.DO = *(m.multisigHistoryDo.As(alias).(*gen.DO)) + return m.updateTableName(alias) +} + +func (m *multisigHistory) updateTableName(table string) *multisigHistory { + m.ALL = field.NewAsterisk(table) + m.TxHash = field.NewString(table, "tx_hash") + m.Status = field.NewInt32(table, "status") + m.CreateTime = field.NewTime(table, "create_time") + m.MultisigAddr = field.NewString(table, "multisig_addr") + m.Memo = field.NewString(table, "memo") + m.Fees = field.NewString(table, "fees") + m.Height = field.NewString(table, "height") + m.GasUsed = field.NewString(table, "gas_used") + m.GasWanted = field.NewString(table, "gas_wanted") + m.TotalAmount = field.NewString(table, "total_amount") + m.SequenceNumber = field.NewString(table, "sequence_number") + m.Tx = field.NewString(table, "tx") + + m.fillFieldMap() + + return m +} + +func (m *multisigHistory) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := m.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (m *multisigHistory) fillFieldMap() { + m.fieldMap = make(map[string]field.Expr, 12) + m.fieldMap["tx_hash"] = m.TxHash + m.fieldMap["status"] = m.Status + m.fieldMap["create_time"] = m.CreateTime + m.fieldMap["multisig_addr"] = m.MultisigAddr + m.fieldMap["memo"] = m.Memo + m.fieldMap["fees"] = m.Fees + m.fieldMap["height"] = m.Height + m.fieldMap["gas_used"] = m.GasUsed + m.fieldMap["gas_wanted"] = m.GasWanted + m.fieldMap["total_amount"] = m.TotalAmount + m.fieldMap["sequence_number"] = m.SequenceNumber + m.fieldMap["tx"] = m.Tx +} + +func (m multisigHistory) clone(db *gorm.DB) multisigHistory { + m.multisigHistoryDo.ReplaceConnPool(db.Statement.ConnPool) + return m +} + +func (m multisigHistory) replaceDB(db *gorm.DB) multisigHistory { + m.multisigHistoryDo.ReplaceDB(db) + return m +} + +type multisigHistoryDo struct{ gen.DO } + +func (m multisigHistoryDo) Debug() *multisigHistoryDo { + return m.withDO(m.DO.Debug()) +} + +func (m multisigHistoryDo) WithContext(ctx context.Context) *multisigHistoryDo { + return m.withDO(m.DO.WithContext(ctx)) +} + +func (m multisigHistoryDo) ReadDB() *multisigHistoryDo { + return m.Clauses(dbresolver.Read) +} + +func (m multisigHistoryDo) WriteDB() *multisigHistoryDo { + return m.Clauses(dbresolver.Write) +} + +func (m multisigHistoryDo) Session(config *gorm.Session) *multisigHistoryDo { + return m.withDO(m.DO.Session(config)) +} + +func (m multisigHistoryDo) Clauses(conds ...clause.Expression) *multisigHistoryDo { + return m.withDO(m.DO.Clauses(conds...)) +} + +func (m multisigHistoryDo) Returning(value interface{}, columns ...string) *multisigHistoryDo { + return m.withDO(m.DO.Returning(value, columns...)) +} + +func (m multisigHistoryDo) Not(conds ...gen.Condition) *multisigHistoryDo { + return m.withDO(m.DO.Not(conds...)) +} + +func (m multisigHistoryDo) Or(conds ...gen.Condition) *multisigHistoryDo { + return m.withDO(m.DO.Or(conds...)) +} + +func (m multisigHistoryDo) Select(conds ...field.Expr) *multisigHistoryDo { + return m.withDO(m.DO.Select(conds...)) +} + +func (m multisigHistoryDo) Where(conds ...gen.Condition) *multisigHistoryDo { + return m.withDO(m.DO.Where(conds...)) +} + +func (m multisigHistoryDo) Order(conds ...field.Expr) *multisigHistoryDo { + return m.withDO(m.DO.Order(conds...)) +} + +func (m multisigHistoryDo) Distinct(cols ...field.Expr) *multisigHistoryDo { + return m.withDO(m.DO.Distinct(cols...)) +} + +func (m multisigHistoryDo) Omit(cols ...field.Expr) *multisigHistoryDo { + return m.withDO(m.DO.Omit(cols...)) +} + +func (m multisigHistoryDo) Join(table schema.Tabler, on ...field.Expr) *multisigHistoryDo { + return m.withDO(m.DO.Join(table, on...)) +} + +func (m multisigHistoryDo) LeftJoin(table schema.Tabler, on ...field.Expr) *multisigHistoryDo { + return m.withDO(m.DO.LeftJoin(table, on...)) +} + +func (m multisigHistoryDo) RightJoin(table schema.Tabler, on ...field.Expr) *multisigHistoryDo { + return m.withDO(m.DO.RightJoin(table, on...)) +} + +func (m multisigHistoryDo) Group(cols ...field.Expr) *multisigHistoryDo { + return m.withDO(m.DO.Group(cols...)) +} + +func (m multisigHistoryDo) Having(conds ...gen.Condition) *multisigHistoryDo { + return m.withDO(m.DO.Having(conds...)) +} + +func (m multisigHistoryDo) Limit(limit int) *multisigHistoryDo { + return m.withDO(m.DO.Limit(limit)) +} + +func (m multisigHistoryDo) Offset(offset int) *multisigHistoryDo { + return m.withDO(m.DO.Offset(offset)) +} + +func (m multisigHistoryDo) Scopes(funcs ...func(gen.Dao) gen.Dao) *multisigHistoryDo { + return m.withDO(m.DO.Scopes(funcs...)) +} + +func (m multisigHistoryDo) Unscoped() *multisigHistoryDo { + return m.withDO(m.DO.Unscoped()) +} + +func (m multisigHistoryDo) Create(values ...*model.MultisigHistory) error { + if len(values) == 0 { + return nil + } + return m.DO.Create(values) +} + +func (m multisigHistoryDo) CreateInBatches(values []*model.MultisigHistory, batchSize int) error { + return m.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (m multisigHistoryDo) Save(values ...*model.MultisigHistory) error { + if len(values) == 0 { + return nil + } + return m.DO.Save(values) +} + +func (m multisigHistoryDo) First() (*model.MultisigHistory, error) { + if result, err := m.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.MultisigHistory), nil + } +} + +func (m multisigHistoryDo) Take() (*model.MultisigHistory, error) { + if result, err := m.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.MultisigHistory), nil + } +} + +func (m multisigHistoryDo) Last() (*model.MultisigHistory, error) { + if result, err := m.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.MultisigHistory), nil + } +} + +func (m multisigHistoryDo) Find() ([]*model.MultisigHistory, error) { + result, err := m.DO.Find() + return result.([]*model.MultisigHistory), err +} + +func (m multisigHistoryDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.MultisigHistory, err error) { + buf := make([]*model.MultisigHistory, 0, batchSize) + err = m.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (m multisigHistoryDo) FindInBatches(result *[]*model.MultisigHistory, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return m.DO.FindInBatches(result, batchSize, fc) +} + +func (m multisigHistoryDo) Attrs(attrs ...field.AssignExpr) *multisigHistoryDo { + return m.withDO(m.DO.Attrs(attrs...)) +} + +func (m multisigHistoryDo) Assign(attrs ...field.AssignExpr) *multisigHistoryDo { + return m.withDO(m.DO.Assign(attrs...)) +} + +func (m multisigHistoryDo) Joins(fields ...field.RelationField) *multisigHistoryDo { + for _, _f := range fields { + m = *m.withDO(m.DO.Joins(_f)) + } + return &m +} + +func (m multisigHistoryDo) Preload(fields ...field.RelationField) *multisigHistoryDo { + for _, _f := range fields { + m = *m.withDO(m.DO.Preload(_f)) + } + return &m +} + +func (m multisigHistoryDo) FirstOrInit() (*model.MultisigHistory, error) { + if result, err := m.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.MultisigHistory), nil + } +} + +func (m multisigHistoryDo) FirstOrCreate() (*model.MultisigHistory, error) { + if result, err := m.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.MultisigHistory), nil + } +} + +func (m multisigHistoryDo) FindByPage(offset int, limit int) (result []*model.MultisigHistory, count int64, err error) { + result, err = m.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = m.Offset(-1).Limit(-1).Count() + return +} + +func (m multisigHistoryDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = m.Count() + if err != nil { + return + } + + err = m.Offset(offset).Limit(limit).Scan(result) + return +} + +func (m multisigHistoryDo) Scan(result interface{}) (err error) { + return m.DO.Scan(result) +} + +func (m multisigHistoryDo) Delete(models ...*model.MultisigHistory) (result gen.ResultInfo, err error) { + return m.DO.Delete(models) +} + +func (m *multisigHistoryDo) withDO(do gen.Dao) *multisigHistoryDo { + m.DO = *do.(*gen.DO) + return m +} diff --git a/dal/dao/pending_transaction.gen.go b/dal/dao/pending_transaction.gen.go new file mode 100644 index 0000000..f8a3fb5 --- /dev/null +++ b/dal/dao/pending_transaction.gen.go @@ -0,0 +1,347 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package dao + +import ( + "context" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "github.com/0311xuyang/chain-util/dal/model" +) + +func newPendingTransaction(db *gorm.DB, opts ...gen.DOOption) pendingTransaction { + _pendingTransaction := pendingTransaction{} + + _pendingTransaction.pendingTransactionDo.UseDB(db, opts...) + _pendingTransaction.pendingTransactionDo.UseModel(&model.PendingTransaction{}) + + tableName := _pendingTransaction.pendingTransactionDo.TableName() + _pendingTransaction.ALL = field.NewAsterisk(tableName) + _pendingTransaction.ID = field.NewString(tableName, "id") + _pendingTransaction.WalletAddress = field.NewString(tableName, "wallet_address") + _pendingTransaction.Sequence = field.NewString(tableName, "sequence") + _pendingTransaction.TxContent = field.NewString(tableName, "tx_content") + _pendingTransaction.Signatures = field.NewString(tableName, "signatures") + _pendingTransaction.CreateTime = field.NewTime(tableName, "create_time") + _pendingTransaction.Memo = field.NewString(tableName, "memo") + _pendingTransaction.Deleted = field.NewInt32(tableName, "deleted") + + _pendingTransaction.fillFieldMap() + + return _pendingTransaction +} + +type pendingTransaction struct { + pendingTransactionDo + + ALL field.Asterisk + ID field.String + WalletAddress field.String + Sequence field.String + TxContent field.String + Signatures field.String + CreateTime field.Time + Memo field.String + Deleted field.Int32 + + fieldMap map[string]field.Expr +} + +func (p pendingTransaction) Table(newTableName string) *pendingTransaction { + p.pendingTransactionDo.UseTable(newTableName) + return p.updateTableName(newTableName) +} + +func (p pendingTransaction) As(alias string) *pendingTransaction { + p.pendingTransactionDo.DO = *(p.pendingTransactionDo.As(alias).(*gen.DO)) + return p.updateTableName(alias) +} + +func (p *pendingTransaction) updateTableName(table string) *pendingTransaction { + p.ALL = field.NewAsterisk(table) + p.ID = field.NewString(table, "id") + p.WalletAddress = field.NewString(table, "wallet_address") + p.Sequence = field.NewString(table, "sequence") + p.TxContent = field.NewString(table, "tx_content") + p.Signatures = field.NewString(table, "signatures") + p.CreateTime = field.NewTime(table, "create_time") + p.Memo = field.NewString(table, "memo") + p.Deleted = field.NewInt32(table, "deleted") + + p.fillFieldMap() + + return p +} + +func (p *pendingTransaction) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := p.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (p *pendingTransaction) fillFieldMap() { + p.fieldMap = make(map[string]field.Expr, 8) + p.fieldMap["id"] = p.ID + p.fieldMap["wallet_address"] = p.WalletAddress + p.fieldMap["sequence"] = p.Sequence + p.fieldMap["tx_content"] = p.TxContent + p.fieldMap["signatures"] = p.Signatures + p.fieldMap["create_time"] = p.CreateTime + p.fieldMap["memo"] = p.Memo + p.fieldMap["deleted"] = p.Deleted +} + +func (p pendingTransaction) clone(db *gorm.DB) pendingTransaction { + p.pendingTransactionDo.ReplaceConnPool(db.Statement.ConnPool) + return p +} + +func (p pendingTransaction) replaceDB(db *gorm.DB) pendingTransaction { + p.pendingTransactionDo.ReplaceDB(db) + return p +} + +type pendingTransactionDo struct{ gen.DO } + +func (p pendingTransactionDo) Debug() *pendingTransactionDo { + return p.withDO(p.DO.Debug()) +} + +func (p pendingTransactionDo) WithContext(ctx context.Context) *pendingTransactionDo { + return p.withDO(p.DO.WithContext(ctx)) +} + +func (p pendingTransactionDo) ReadDB() *pendingTransactionDo { + return p.Clauses(dbresolver.Read) +} + +func (p pendingTransactionDo) WriteDB() *pendingTransactionDo { + return p.Clauses(dbresolver.Write) +} + +func (p pendingTransactionDo) Session(config *gorm.Session) *pendingTransactionDo { + return p.withDO(p.DO.Session(config)) +} + +func (p pendingTransactionDo) Clauses(conds ...clause.Expression) *pendingTransactionDo { + return p.withDO(p.DO.Clauses(conds...)) +} + +func (p pendingTransactionDo) Returning(value interface{}, columns ...string) *pendingTransactionDo { + return p.withDO(p.DO.Returning(value, columns...)) +} + +func (p pendingTransactionDo) Not(conds ...gen.Condition) *pendingTransactionDo { + return p.withDO(p.DO.Not(conds...)) +} + +func (p pendingTransactionDo) Or(conds ...gen.Condition) *pendingTransactionDo { + return p.withDO(p.DO.Or(conds...)) +} + +func (p pendingTransactionDo) Select(conds ...field.Expr) *pendingTransactionDo { + return p.withDO(p.DO.Select(conds...)) +} + +func (p pendingTransactionDo) Where(conds ...gen.Condition) *pendingTransactionDo { + return p.withDO(p.DO.Where(conds...)) +} + +func (p pendingTransactionDo) Order(conds ...field.Expr) *pendingTransactionDo { + return p.withDO(p.DO.Order(conds...)) +} + +func (p pendingTransactionDo) Distinct(cols ...field.Expr) *pendingTransactionDo { + return p.withDO(p.DO.Distinct(cols...)) +} + +func (p pendingTransactionDo) Omit(cols ...field.Expr) *pendingTransactionDo { + return p.withDO(p.DO.Omit(cols...)) +} + +func (p pendingTransactionDo) Join(table schema.Tabler, on ...field.Expr) *pendingTransactionDo { + return p.withDO(p.DO.Join(table, on...)) +} + +func (p pendingTransactionDo) LeftJoin(table schema.Tabler, on ...field.Expr) *pendingTransactionDo { + return p.withDO(p.DO.LeftJoin(table, on...)) +} + +func (p pendingTransactionDo) RightJoin(table schema.Tabler, on ...field.Expr) *pendingTransactionDo { + return p.withDO(p.DO.RightJoin(table, on...)) +} + +func (p pendingTransactionDo) Group(cols ...field.Expr) *pendingTransactionDo { + return p.withDO(p.DO.Group(cols...)) +} + +func (p pendingTransactionDo) Having(conds ...gen.Condition) *pendingTransactionDo { + return p.withDO(p.DO.Having(conds...)) +} + +func (p pendingTransactionDo) Limit(limit int) *pendingTransactionDo { + return p.withDO(p.DO.Limit(limit)) +} + +func (p pendingTransactionDo) Offset(offset int) *pendingTransactionDo { + return p.withDO(p.DO.Offset(offset)) +} + +func (p pendingTransactionDo) Scopes(funcs ...func(gen.Dao) gen.Dao) *pendingTransactionDo { + return p.withDO(p.DO.Scopes(funcs...)) +} + +func (p pendingTransactionDo) Unscoped() *pendingTransactionDo { + return p.withDO(p.DO.Unscoped()) +} + +func (p pendingTransactionDo) Create(values ...*model.PendingTransaction) error { + if len(values) == 0 { + return nil + } + return p.DO.Create(values) +} + +func (p pendingTransactionDo) CreateInBatches(values []*model.PendingTransaction, batchSize int) error { + return p.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (p pendingTransactionDo) Save(values ...*model.PendingTransaction) error { + if len(values) == 0 { + return nil + } + return p.DO.Save(values) +} + +func (p pendingTransactionDo) First() (*model.PendingTransaction, error) { + if result, err := p.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.PendingTransaction), nil + } +} + +func (p pendingTransactionDo) Take() (*model.PendingTransaction, error) { + if result, err := p.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.PendingTransaction), nil + } +} + +func (p pendingTransactionDo) Last() (*model.PendingTransaction, error) { + if result, err := p.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.PendingTransaction), nil + } +} + +func (p pendingTransactionDo) Find() ([]*model.PendingTransaction, error) { + result, err := p.DO.Find() + return result.([]*model.PendingTransaction), err +} + +func (p pendingTransactionDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.PendingTransaction, err error) { + buf := make([]*model.PendingTransaction, 0, batchSize) + err = p.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (p pendingTransactionDo) FindInBatches(result *[]*model.PendingTransaction, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return p.DO.FindInBatches(result, batchSize, fc) +} + +func (p pendingTransactionDo) Attrs(attrs ...field.AssignExpr) *pendingTransactionDo { + return p.withDO(p.DO.Attrs(attrs...)) +} + +func (p pendingTransactionDo) Assign(attrs ...field.AssignExpr) *pendingTransactionDo { + return p.withDO(p.DO.Assign(attrs...)) +} + +func (p pendingTransactionDo) Joins(fields ...field.RelationField) *pendingTransactionDo { + for _, _f := range fields { + p = *p.withDO(p.DO.Joins(_f)) + } + return &p +} + +func (p pendingTransactionDo) Preload(fields ...field.RelationField) *pendingTransactionDo { + for _, _f := range fields { + p = *p.withDO(p.DO.Preload(_f)) + } + return &p +} + +func (p pendingTransactionDo) FirstOrInit() (*model.PendingTransaction, error) { + if result, err := p.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.PendingTransaction), nil + } +} + +func (p pendingTransactionDo) FirstOrCreate() (*model.PendingTransaction, error) { + if result, err := p.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.PendingTransaction), nil + } +} + +func (p pendingTransactionDo) FindByPage(offset int, limit int) (result []*model.PendingTransaction, count int64, err error) { + result, err = p.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = p.Offset(-1).Limit(-1).Count() + return +} + +func (p pendingTransactionDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = p.Count() + if err != nil { + return + } + + err = p.Offset(offset).Limit(limit).Scan(result) + return +} + +func (p pendingTransactionDo) Scan(result interface{}) (err error) { + return p.DO.Scan(result) +} + +func (p pendingTransactionDo) Delete(models ...*model.PendingTransaction) (result gen.ResultInfo, err error) { + return p.DO.Delete(models) +} + +func (p *pendingTransactionDo) withDO(do gen.Dao) *pendingTransactionDo { + p.DO = *do.(*gen.DO) + return p +} diff --git a/dal/dao/staking_percentage.gen.go b/dal/dao/staking_percentage.gen.go new file mode 100644 index 0000000..db9b9b9 --- /dev/null +++ b/dal/dao/staking_percentage.gen.go @@ -0,0 +1,331 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package dao + +import ( + "context" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "github.com/0311xuyang/chain-util/dal/model" +) + +func newStakingPercentage(db *gorm.DB, opts ...gen.DOOption) stakingPercentage { + _stakingPercentage := stakingPercentage{} + + _stakingPercentage.stakingPercentageDo.UseDB(db, opts...) + _stakingPercentage.stakingPercentageDo.UseModel(&model.StakingPercentage{}) + + tableName := _stakingPercentage.stakingPercentageDo.TableName() + _stakingPercentage.ALL = field.NewAsterisk(tableName) + _stakingPercentage.Date = field.NewTime(tableName, "date") + _stakingPercentage.Point = field.NewString(tableName, "point") + _stakingPercentage.Value = field.NewInt64(tableName, "value") + _stakingPercentage.ChainName = field.NewString(tableName, "chain_name") + + _stakingPercentage.fillFieldMap() + + return _stakingPercentage +} + +type stakingPercentage struct { + stakingPercentageDo + + ALL field.Asterisk + Date field.Time + Point field.String + Value field.Int64 + ChainName field.String + + fieldMap map[string]field.Expr +} + +func (s stakingPercentage) Table(newTableName string) *stakingPercentage { + s.stakingPercentageDo.UseTable(newTableName) + return s.updateTableName(newTableName) +} + +func (s stakingPercentage) As(alias string) *stakingPercentage { + s.stakingPercentageDo.DO = *(s.stakingPercentageDo.As(alias).(*gen.DO)) + return s.updateTableName(alias) +} + +func (s *stakingPercentage) updateTableName(table string) *stakingPercentage { + s.ALL = field.NewAsterisk(table) + s.Date = field.NewTime(table, "date") + s.Point = field.NewString(table, "point") + s.Value = field.NewInt64(table, "value") + s.ChainName = field.NewString(table, "chain_name") + + s.fillFieldMap() + + return s +} + +func (s *stakingPercentage) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := s.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (s *stakingPercentage) fillFieldMap() { + s.fieldMap = make(map[string]field.Expr, 4) + s.fieldMap["date"] = s.Date + s.fieldMap["point"] = s.Point + s.fieldMap["value"] = s.Value + s.fieldMap["chain_name"] = s.ChainName +} + +func (s stakingPercentage) clone(db *gorm.DB) stakingPercentage { + s.stakingPercentageDo.ReplaceConnPool(db.Statement.ConnPool) + return s +} + +func (s stakingPercentage) replaceDB(db *gorm.DB) stakingPercentage { + s.stakingPercentageDo.ReplaceDB(db) + return s +} + +type stakingPercentageDo struct{ gen.DO } + +func (s stakingPercentageDo) Debug() *stakingPercentageDo { + return s.withDO(s.DO.Debug()) +} + +func (s stakingPercentageDo) WithContext(ctx context.Context) *stakingPercentageDo { + return s.withDO(s.DO.WithContext(ctx)) +} + +func (s stakingPercentageDo) ReadDB() *stakingPercentageDo { + return s.Clauses(dbresolver.Read) +} + +func (s stakingPercentageDo) WriteDB() *stakingPercentageDo { + return s.Clauses(dbresolver.Write) +} + +func (s stakingPercentageDo) Session(config *gorm.Session) *stakingPercentageDo { + return s.withDO(s.DO.Session(config)) +} + +func (s stakingPercentageDo) Clauses(conds ...clause.Expression) *stakingPercentageDo { + return s.withDO(s.DO.Clauses(conds...)) +} + +func (s stakingPercentageDo) Returning(value interface{}, columns ...string) *stakingPercentageDo { + return s.withDO(s.DO.Returning(value, columns...)) +} + +func (s stakingPercentageDo) Not(conds ...gen.Condition) *stakingPercentageDo { + return s.withDO(s.DO.Not(conds...)) +} + +func (s stakingPercentageDo) Or(conds ...gen.Condition) *stakingPercentageDo { + return s.withDO(s.DO.Or(conds...)) +} + +func (s stakingPercentageDo) Select(conds ...field.Expr) *stakingPercentageDo { + return s.withDO(s.DO.Select(conds...)) +} + +func (s stakingPercentageDo) Where(conds ...gen.Condition) *stakingPercentageDo { + return s.withDO(s.DO.Where(conds...)) +} + +func (s stakingPercentageDo) Order(conds ...field.Expr) *stakingPercentageDo { + return s.withDO(s.DO.Order(conds...)) +} + +func (s stakingPercentageDo) Distinct(cols ...field.Expr) *stakingPercentageDo { + return s.withDO(s.DO.Distinct(cols...)) +} + +func (s stakingPercentageDo) Omit(cols ...field.Expr) *stakingPercentageDo { + return s.withDO(s.DO.Omit(cols...)) +} + +func (s stakingPercentageDo) Join(table schema.Tabler, on ...field.Expr) *stakingPercentageDo { + return s.withDO(s.DO.Join(table, on...)) +} + +func (s stakingPercentageDo) LeftJoin(table schema.Tabler, on ...field.Expr) *stakingPercentageDo { + return s.withDO(s.DO.LeftJoin(table, on...)) +} + +func (s stakingPercentageDo) RightJoin(table schema.Tabler, on ...field.Expr) *stakingPercentageDo { + return s.withDO(s.DO.RightJoin(table, on...)) +} + +func (s stakingPercentageDo) Group(cols ...field.Expr) *stakingPercentageDo { + return s.withDO(s.DO.Group(cols...)) +} + +func (s stakingPercentageDo) Having(conds ...gen.Condition) *stakingPercentageDo { + return s.withDO(s.DO.Having(conds...)) +} + +func (s stakingPercentageDo) Limit(limit int) *stakingPercentageDo { + return s.withDO(s.DO.Limit(limit)) +} + +func (s stakingPercentageDo) Offset(offset int) *stakingPercentageDo { + return s.withDO(s.DO.Offset(offset)) +} + +func (s stakingPercentageDo) Scopes(funcs ...func(gen.Dao) gen.Dao) *stakingPercentageDo { + return s.withDO(s.DO.Scopes(funcs...)) +} + +func (s stakingPercentageDo) Unscoped() *stakingPercentageDo { + return s.withDO(s.DO.Unscoped()) +} + +func (s stakingPercentageDo) Create(values ...*model.StakingPercentage) error { + if len(values) == 0 { + return nil + } + return s.DO.Create(values) +} + +func (s stakingPercentageDo) CreateInBatches(values []*model.StakingPercentage, batchSize int) error { + return s.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (s stakingPercentageDo) Save(values ...*model.StakingPercentage) error { + if len(values) == 0 { + return nil + } + return s.DO.Save(values) +} + +func (s stakingPercentageDo) First() (*model.StakingPercentage, error) { + if result, err := s.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.StakingPercentage), nil + } +} + +func (s stakingPercentageDo) Take() (*model.StakingPercentage, error) { + if result, err := s.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.StakingPercentage), nil + } +} + +func (s stakingPercentageDo) Last() (*model.StakingPercentage, error) { + if result, err := s.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.StakingPercentage), nil + } +} + +func (s stakingPercentageDo) Find() ([]*model.StakingPercentage, error) { + result, err := s.DO.Find() + return result.([]*model.StakingPercentage), err +} + +func (s stakingPercentageDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.StakingPercentage, err error) { + buf := make([]*model.StakingPercentage, 0, batchSize) + err = s.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (s stakingPercentageDo) FindInBatches(result *[]*model.StakingPercentage, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return s.DO.FindInBatches(result, batchSize, fc) +} + +func (s stakingPercentageDo) Attrs(attrs ...field.AssignExpr) *stakingPercentageDo { + return s.withDO(s.DO.Attrs(attrs...)) +} + +func (s stakingPercentageDo) Assign(attrs ...field.AssignExpr) *stakingPercentageDo { + return s.withDO(s.DO.Assign(attrs...)) +} + +func (s stakingPercentageDo) Joins(fields ...field.RelationField) *stakingPercentageDo { + for _, _f := range fields { + s = *s.withDO(s.DO.Joins(_f)) + } + return &s +} + +func (s stakingPercentageDo) Preload(fields ...field.RelationField) *stakingPercentageDo { + for _, _f := range fields { + s = *s.withDO(s.DO.Preload(_f)) + } + return &s +} + +func (s stakingPercentageDo) FirstOrInit() (*model.StakingPercentage, error) { + if result, err := s.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.StakingPercentage), nil + } +} + +func (s stakingPercentageDo) FirstOrCreate() (*model.StakingPercentage, error) { + if result, err := s.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.StakingPercentage), nil + } +} + +func (s stakingPercentageDo) FindByPage(offset int, limit int) (result []*model.StakingPercentage, count int64, err error) { + result, err = s.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = s.Offset(-1).Limit(-1).Count() + return +} + +func (s stakingPercentageDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = s.Count() + if err != nil { + return + } + + err = s.Offset(offset).Limit(limit).Scan(result) + return +} + +func (s stakingPercentageDo) Scan(result interface{}) (err error) { + return s.DO.Scan(result) +} + +func (s stakingPercentageDo) Delete(models ...*model.StakingPercentage) (result gen.ResultInfo, err error) { + return s.DO.Delete(models) +} + +func (s *stakingPercentageDo) withDO(do gen.Dao) *stakingPercentageDo { + s.DO = *do.(*gen.DO) + return s +} diff --git a/dal/dao/top_delegation.gen.go b/dal/dao/top_delegation.gen.go new file mode 100644 index 0000000..4649e12 --- /dev/null +++ b/dal/dao/top_delegation.gen.go @@ -0,0 +1,331 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package dao + +import ( + "context" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "github.com/0311xuyang/chain-util/dal/model" +) + +func newTopDelegation(db *gorm.DB, opts ...gen.DOOption) topDelegation { + _topDelegation := topDelegation{} + + _topDelegation.topDelegationDo.UseDB(db, opts...) + _topDelegation.topDelegationDo.UseModel(&model.TopDelegation{}) + + tableName := _topDelegation.topDelegationDo.TableName() + _topDelegation.ALL = field.NewAsterisk(tableName) + _topDelegation.Delegator = field.NewString(tableName, "delegator") + _topDelegation.Amount = field.NewInt64(tableName, "amount") + _topDelegation.ChainName = field.NewString(tableName, "chain_name") + _topDelegation.Validator = field.NewString(tableName, "validator") + + _topDelegation.fillFieldMap() + + return _topDelegation +} + +type topDelegation struct { + topDelegationDo + + ALL field.Asterisk + Delegator field.String + Amount field.Int64 + ChainName field.String + Validator field.String + + fieldMap map[string]field.Expr +} + +func (t topDelegation) Table(newTableName string) *topDelegation { + t.topDelegationDo.UseTable(newTableName) + return t.updateTableName(newTableName) +} + +func (t topDelegation) As(alias string) *topDelegation { + t.topDelegationDo.DO = *(t.topDelegationDo.As(alias).(*gen.DO)) + return t.updateTableName(alias) +} + +func (t *topDelegation) updateTableName(table string) *topDelegation { + t.ALL = field.NewAsterisk(table) + t.Delegator = field.NewString(table, "delegator") + t.Amount = field.NewInt64(table, "amount") + t.ChainName = field.NewString(table, "chain_name") + t.Validator = field.NewString(table, "validator") + + t.fillFieldMap() + + return t +} + +func (t *topDelegation) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := t.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (t *topDelegation) fillFieldMap() { + t.fieldMap = make(map[string]field.Expr, 4) + t.fieldMap["delegator"] = t.Delegator + t.fieldMap["amount"] = t.Amount + t.fieldMap["chain_name"] = t.ChainName + t.fieldMap["validator"] = t.Validator +} + +func (t topDelegation) clone(db *gorm.DB) topDelegation { + t.topDelegationDo.ReplaceConnPool(db.Statement.ConnPool) + return t +} + +func (t topDelegation) replaceDB(db *gorm.DB) topDelegation { + t.topDelegationDo.ReplaceDB(db) + return t +} + +type topDelegationDo struct{ gen.DO } + +func (t topDelegationDo) Debug() *topDelegationDo { + return t.withDO(t.DO.Debug()) +} + +func (t topDelegationDo) WithContext(ctx context.Context) *topDelegationDo { + return t.withDO(t.DO.WithContext(ctx)) +} + +func (t topDelegationDo) ReadDB() *topDelegationDo { + return t.Clauses(dbresolver.Read) +} + +func (t topDelegationDo) WriteDB() *topDelegationDo { + return t.Clauses(dbresolver.Write) +} + +func (t topDelegationDo) Session(config *gorm.Session) *topDelegationDo { + return t.withDO(t.DO.Session(config)) +} + +func (t topDelegationDo) Clauses(conds ...clause.Expression) *topDelegationDo { + return t.withDO(t.DO.Clauses(conds...)) +} + +func (t topDelegationDo) Returning(value interface{}, columns ...string) *topDelegationDo { + return t.withDO(t.DO.Returning(value, columns...)) +} + +func (t topDelegationDo) Not(conds ...gen.Condition) *topDelegationDo { + return t.withDO(t.DO.Not(conds...)) +} + +func (t topDelegationDo) Or(conds ...gen.Condition) *topDelegationDo { + return t.withDO(t.DO.Or(conds...)) +} + +func (t topDelegationDo) Select(conds ...field.Expr) *topDelegationDo { + return t.withDO(t.DO.Select(conds...)) +} + +func (t topDelegationDo) Where(conds ...gen.Condition) *topDelegationDo { + return t.withDO(t.DO.Where(conds...)) +} + +func (t topDelegationDo) Order(conds ...field.Expr) *topDelegationDo { + return t.withDO(t.DO.Order(conds...)) +} + +func (t topDelegationDo) Distinct(cols ...field.Expr) *topDelegationDo { + return t.withDO(t.DO.Distinct(cols...)) +} + +func (t topDelegationDo) Omit(cols ...field.Expr) *topDelegationDo { + return t.withDO(t.DO.Omit(cols...)) +} + +func (t topDelegationDo) Join(table schema.Tabler, on ...field.Expr) *topDelegationDo { + return t.withDO(t.DO.Join(table, on...)) +} + +func (t topDelegationDo) LeftJoin(table schema.Tabler, on ...field.Expr) *topDelegationDo { + return t.withDO(t.DO.LeftJoin(table, on...)) +} + +func (t topDelegationDo) RightJoin(table schema.Tabler, on ...field.Expr) *topDelegationDo { + return t.withDO(t.DO.RightJoin(table, on...)) +} + +func (t topDelegationDo) Group(cols ...field.Expr) *topDelegationDo { + return t.withDO(t.DO.Group(cols...)) +} + +func (t topDelegationDo) Having(conds ...gen.Condition) *topDelegationDo { + return t.withDO(t.DO.Having(conds...)) +} + +func (t topDelegationDo) Limit(limit int) *topDelegationDo { + return t.withDO(t.DO.Limit(limit)) +} + +func (t topDelegationDo) Offset(offset int) *topDelegationDo { + return t.withDO(t.DO.Offset(offset)) +} + +func (t topDelegationDo) Scopes(funcs ...func(gen.Dao) gen.Dao) *topDelegationDo { + return t.withDO(t.DO.Scopes(funcs...)) +} + +func (t topDelegationDo) Unscoped() *topDelegationDo { + return t.withDO(t.DO.Unscoped()) +} + +func (t topDelegationDo) Create(values ...*model.TopDelegation) error { + if len(values) == 0 { + return nil + } + return t.DO.Create(values) +} + +func (t topDelegationDo) CreateInBatches(values []*model.TopDelegation, batchSize int) error { + return t.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (t topDelegationDo) Save(values ...*model.TopDelegation) error { + if len(values) == 0 { + return nil + } + return t.DO.Save(values) +} + +func (t topDelegationDo) First() (*model.TopDelegation, error) { + if result, err := t.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.TopDelegation), nil + } +} + +func (t topDelegationDo) Take() (*model.TopDelegation, error) { + if result, err := t.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.TopDelegation), nil + } +} + +func (t topDelegationDo) Last() (*model.TopDelegation, error) { + if result, err := t.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.TopDelegation), nil + } +} + +func (t topDelegationDo) Find() ([]*model.TopDelegation, error) { + result, err := t.DO.Find() + return result.([]*model.TopDelegation), err +} + +func (t topDelegationDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.TopDelegation, err error) { + buf := make([]*model.TopDelegation, 0, batchSize) + err = t.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (t topDelegationDo) FindInBatches(result *[]*model.TopDelegation, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return t.DO.FindInBatches(result, batchSize, fc) +} + +func (t topDelegationDo) Attrs(attrs ...field.AssignExpr) *topDelegationDo { + return t.withDO(t.DO.Attrs(attrs...)) +} + +func (t topDelegationDo) Assign(attrs ...field.AssignExpr) *topDelegationDo { + return t.withDO(t.DO.Assign(attrs...)) +} + +func (t topDelegationDo) Joins(fields ...field.RelationField) *topDelegationDo { + for _, _f := range fields { + t = *t.withDO(t.DO.Joins(_f)) + } + return &t +} + +func (t topDelegationDo) Preload(fields ...field.RelationField) *topDelegationDo { + for _, _f := range fields { + t = *t.withDO(t.DO.Preload(_f)) + } + return &t +} + +func (t topDelegationDo) FirstOrInit() (*model.TopDelegation, error) { + if result, err := t.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.TopDelegation), nil + } +} + +func (t topDelegationDo) FirstOrCreate() (*model.TopDelegation, error) { + if result, err := t.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.TopDelegation), nil + } +} + +func (t topDelegationDo) FindByPage(offset int, limit int) (result []*model.TopDelegation, count int64, err error) { + result, err = t.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = t.Offset(-1).Limit(-1).Count() + return +} + +func (t topDelegationDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = t.Count() + if err != nil { + return + } + + err = t.Offset(offset).Limit(limit).Scan(result) + return +} + +func (t topDelegationDo) Scan(result interface{}) (err error) { + return t.DO.Scan(result) +} + +func (t topDelegationDo) Delete(models ...*model.TopDelegation) (result gen.ResultInfo, err error) { + return t.DO.Delete(models) +} + +func (t *topDelegationDo) withDO(do gen.Dao) *topDelegationDo { + t.DO = *do.(*gen.DO) + return t +} diff --git a/dal/dao/top_undelegation.gen.go b/dal/dao/top_undelegation.gen.go new file mode 100644 index 0000000..9a044ce --- /dev/null +++ b/dal/dao/top_undelegation.gen.go @@ -0,0 +1,335 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package dao + +import ( + "context" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "github.com/0311xuyang/chain-util/dal/model" +) + +func newTopUndelegation(db *gorm.DB, opts ...gen.DOOption) topUndelegation { + _topUndelegation := topUndelegation{} + + _topUndelegation.topUndelegationDo.UseDB(db, opts...) + _topUndelegation.topUndelegationDo.UseModel(&model.TopUndelegation{}) + + tableName := _topUndelegation.topUndelegationDo.TableName() + _topUndelegation.ALL = field.NewAsterisk(tableName) + _topUndelegation.Delegator = field.NewString(tableName, "delegator") + _topUndelegation.Validator = field.NewString(tableName, "validator") + _topUndelegation.Amount = field.NewInt64(tableName, "amount") + _topUndelegation.ReleaseTime = field.NewTime(tableName, "release_time") + _topUndelegation.ChainName = field.NewString(tableName, "chain_name") + + _topUndelegation.fillFieldMap() + + return _topUndelegation +} + +type topUndelegation struct { + topUndelegationDo + + ALL field.Asterisk + Delegator field.String + Validator field.String + Amount field.Int64 + ReleaseTime field.Time + ChainName field.String + + fieldMap map[string]field.Expr +} + +func (t topUndelegation) Table(newTableName string) *topUndelegation { + t.topUndelegationDo.UseTable(newTableName) + return t.updateTableName(newTableName) +} + +func (t topUndelegation) As(alias string) *topUndelegation { + t.topUndelegationDo.DO = *(t.topUndelegationDo.As(alias).(*gen.DO)) + return t.updateTableName(alias) +} + +func (t *topUndelegation) updateTableName(table string) *topUndelegation { + t.ALL = field.NewAsterisk(table) + t.Delegator = field.NewString(table, "delegator") + t.Validator = field.NewString(table, "validator") + t.Amount = field.NewInt64(table, "amount") + t.ReleaseTime = field.NewTime(table, "release_time") + t.ChainName = field.NewString(table, "chain_name") + + t.fillFieldMap() + + return t +} + +func (t *topUndelegation) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := t.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (t *topUndelegation) fillFieldMap() { + t.fieldMap = make(map[string]field.Expr, 5) + t.fieldMap["delegator"] = t.Delegator + t.fieldMap["validator"] = t.Validator + t.fieldMap["amount"] = t.Amount + t.fieldMap["release_time"] = t.ReleaseTime + t.fieldMap["chain_name"] = t.ChainName +} + +func (t topUndelegation) clone(db *gorm.DB) topUndelegation { + t.topUndelegationDo.ReplaceConnPool(db.Statement.ConnPool) + return t +} + +func (t topUndelegation) replaceDB(db *gorm.DB) topUndelegation { + t.topUndelegationDo.ReplaceDB(db) + return t +} + +type topUndelegationDo struct{ gen.DO } + +func (t topUndelegationDo) Debug() *topUndelegationDo { + return t.withDO(t.DO.Debug()) +} + +func (t topUndelegationDo) WithContext(ctx context.Context) *topUndelegationDo { + return t.withDO(t.DO.WithContext(ctx)) +} + +func (t topUndelegationDo) ReadDB() *topUndelegationDo { + return t.Clauses(dbresolver.Read) +} + +func (t topUndelegationDo) WriteDB() *topUndelegationDo { + return t.Clauses(dbresolver.Write) +} + +func (t topUndelegationDo) Session(config *gorm.Session) *topUndelegationDo { + return t.withDO(t.DO.Session(config)) +} + +func (t topUndelegationDo) Clauses(conds ...clause.Expression) *topUndelegationDo { + return t.withDO(t.DO.Clauses(conds...)) +} + +func (t topUndelegationDo) Returning(value interface{}, columns ...string) *topUndelegationDo { + return t.withDO(t.DO.Returning(value, columns...)) +} + +func (t topUndelegationDo) Not(conds ...gen.Condition) *topUndelegationDo { + return t.withDO(t.DO.Not(conds...)) +} + +func (t topUndelegationDo) Or(conds ...gen.Condition) *topUndelegationDo { + return t.withDO(t.DO.Or(conds...)) +} + +func (t topUndelegationDo) Select(conds ...field.Expr) *topUndelegationDo { + return t.withDO(t.DO.Select(conds...)) +} + +func (t topUndelegationDo) Where(conds ...gen.Condition) *topUndelegationDo { + return t.withDO(t.DO.Where(conds...)) +} + +func (t topUndelegationDo) Order(conds ...field.Expr) *topUndelegationDo { + return t.withDO(t.DO.Order(conds...)) +} + +func (t topUndelegationDo) Distinct(cols ...field.Expr) *topUndelegationDo { + return t.withDO(t.DO.Distinct(cols...)) +} + +func (t topUndelegationDo) Omit(cols ...field.Expr) *topUndelegationDo { + return t.withDO(t.DO.Omit(cols...)) +} + +func (t topUndelegationDo) Join(table schema.Tabler, on ...field.Expr) *topUndelegationDo { + return t.withDO(t.DO.Join(table, on...)) +} + +func (t topUndelegationDo) LeftJoin(table schema.Tabler, on ...field.Expr) *topUndelegationDo { + return t.withDO(t.DO.LeftJoin(table, on...)) +} + +func (t topUndelegationDo) RightJoin(table schema.Tabler, on ...field.Expr) *topUndelegationDo { + return t.withDO(t.DO.RightJoin(table, on...)) +} + +func (t topUndelegationDo) Group(cols ...field.Expr) *topUndelegationDo { + return t.withDO(t.DO.Group(cols...)) +} + +func (t topUndelegationDo) Having(conds ...gen.Condition) *topUndelegationDo { + return t.withDO(t.DO.Having(conds...)) +} + +func (t topUndelegationDo) Limit(limit int) *topUndelegationDo { + return t.withDO(t.DO.Limit(limit)) +} + +func (t topUndelegationDo) Offset(offset int) *topUndelegationDo { + return t.withDO(t.DO.Offset(offset)) +} + +func (t topUndelegationDo) Scopes(funcs ...func(gen.Dao) gen.Dao) *topUndelegationDo { + return t.withDO(t.DO.Scopes(funcs...)) +} + +func (t topUndelegationDo) Unscoped() *topUndelegationDo { + return t.withDO(t.DO.Unscoped()) +} + +func (t topUndelegationDo) Create(values ...*model.TopUndelegation) error { + if len(values) == 0 { + return nil + } + return t.DO.Create(values) +} + +func (t topUndelegationDo) CreateInBatches(values []*model.TopUndelegation, batchSize int) error { + return t.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (t topUndelegationDo) Save(values ...*model.TopUndelegation) error { + if len(values) == 0 { + return nil + } + return t.DO.Save(values) +} + +func (t topUndelegationDo) First() (*model.TopUndelegation, error) { + if result, err := t.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.TopUndelegation), nil + } +} + +func (t topUndelegationDo) Take() (*model.TopUndelegation, error) { + if result, err := t.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.TopUndelegation), nil + } +} + +func (t topUndelegationDo) Last() (*model.TopUndelegation, error) { + if result, err := t.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.TopUndelegation), nil + } +} + +func (t topUndelegationDo) Find() ([]*model.TopUndelegation, error) { + result, err := t.DO.Find() + return result.([]*model.TopUndelegation), err +} + +func (t topUndelegationDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.TopUndelegation, err error) { + buf := make([]*model.TopUndelegation, 0, batchSize) + err = t.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (t topUndelegationDo) FindInBatches(result *[]*model.TopUndelegation, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return t.DO.FindInBatches(result, batchSize, fc) +} + +func (t topUndelegationDo) Attrs(attrs ...field.AssignExpr) *topUndelegationDo { + return t.withDO(t.DO.Attrs(attrs...)) +} + +func (t topUndelegationDo) Assign(attrs ...field.AssignExpr) *topUndelegationDo { + return t.withDO(t.DO.Assign(attrs...)) +} + +func (t topUndelegationDo) Joins(fields ...field.RelationField) *topUndelegationDo { + for _, _f := range fields { + t = *t.withDO(t.DO.Joins(_f)) + } + return &t +} + +func (t topUndelegationDo) Preload(fields ...field.RelationField) *topUndelegationDo { + for _, _f := range fields { + t = *t.withDO(t.DO.Preload(_f)) + } + return &t +} + +func (t topUndelegationDo) FirstOrInit() (*model.TopUndelegation, error) { + if result, err := t.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.TopUndelegation), nil + } +} + +func (t topUndelegationDo) FirstOrCreate() (*model.TopUndelegation, error) { + if result, err := t.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.TopUndelegation), nil + } +} + +func (t topUndelegationDo) FindByPage(offset int, limit int) (result []*model.TopUndelegation, count int64, err error) { + result, err = t.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = t.Offset(-1).Limit(-1).Count() + return +} + +func (t topUndelegationDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = t.Count() + if err != nil { + return + } + + err = t.Offset(offset).Limit(limit).Scan(result) + return +} + +func (t topUndelegationDo) Scan(result interface{}) (err error) { + return t.DO.Scan(result) +} + +func (t topUndelegationDo) Delete(models ...*model.TopUndelegation) (result gen.ResultInfo, err error) { + return t.DO.Delete(models) +} + +func (t *topUndelegationDo) withDO(do gen.Dao) *topUndelegationDo { + t.DO = *do.(*gen.DO) + return t +} diff --git a/dal/model/chain_metrics.gen.go b/dal/model/chain_metrics.gen.go new file mode 100644 index 0000000..16000a1 --- /dev/null +++ b/dal/model/chain_metrics.gen.go @@ -0,0 +1,37 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package model + +import ( + "time" +) + +const TableNameChainMetric = "chain_metrics" + +// ChainMetric mapped from table +type ChainMetric struct { + UniqueDelegate int32 `gorm:"column:unique_delegate" json:"unique_delegate"` + Date time.Time `gorm:"column:date;primaryKey" json:"date"` + ChainName string `gorm:"column:chain_name;primaryKey" json:"chain_name"` + UniqueDelegation int32 `gorm:"column:unique_delegation" json:"unique_delegation"` + UnbondedTokens int64 `gorm:"column:unbonded_tokens" json:"unbonded_tokens"` + BondedTokens int64 `gorm:"column:bonded_tokens" json:"bonded_tokens"` + MarketCap int64 `gorm:"column:market_cap" json:"market_cap"` + TotalSupply int64 `gorm:"column:total_supply" json:"total_supply"` + CirculatingSupply int64 `gorm:"column:circulating_supply" json:"circulating_supply"` + Transactions int64 `gorm:"column:transactions" json:"transactions"` + BlockTime string `gorm:"column:block_time" json:"block_time"` + Inflation string `gorm:"column:inflation" json:"inflation"` + StakingApr string `gorm:"column:staking_apr" json:"staking_apr"` + TxsPerBlock string `gorm:"column:txs_per_block" json:"txs_per_block"` + CommunityPool int64 `gorm:"column:community_pool" json:"community_pool"` + BlockHeight int64 `gorm:"column:block_height" json:"block_height"` + TotalStake int64 `gorm:"column:total_stake" json:"total_stake"` +} + +// TableName ChainMetric's table name +func (*ChainMetric) TableName() string { + return TableNameChainMetric +} diff --git a/dal/model/coin_price.gen.go b/dal/model/coin_price.gen.go new file mode 100644 index 0000000..20da704 --- /dev/null +++ b/dal/model/coin_price.gen.go @@ -0,0 +1,24 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package model + +import ( + "time" +) + +const TableNameCoinPrice = "coin_price" + +// CoinPrice mapped from table +type CoinPrice struct { + Date time.Time `gorm:"column:date;primaryKey" json:"date"` + Price string `gorm:"column:price" json:"price"` + Symbol string `gorm:"column:symbol" json:"symbol"` + ChainName string `gorm:"column:chain_name;primaryKey" json:"chain_name"` +} + +// TableName CoinPrice's table name +func (*CoinPrice) TableName() string { + return TableNameCoinPrice +} diff --git a/dal/model/multisig_account.gen.go b/dal/model/multisig_account.gen.go new file mode 100644 index 0000000..0d40382 --- /dev/null +++ b/dal/model/multisig_account.gen.go @@ -0,0 +1,28 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package model + +import ( + "time" +) + +const TableNameMultisigAccount = "multisig_account" + +// MultisigAccount mapped from table +type MultisigAccount struct { + Address string `gorm:"column:address;primaryKey" json:"address"` + Name string `gorm:"column:name" json:"name"` + Threshold int32 `gorm:"column:threshold;not null" json:"threshold"` + ChainName string `gorm:"column:chain_name;not null" json:"chain_name"` + Members string `gorm:"column:members;not null" json:"members"` + Status string `gorm:"column:status;not null" json:"status"` + Pubkey string `gorm:"column:pubkey;not null" json:"pubkey"` + CreateTime time.Time `gorm:"column:create_time" json:"create_time"` +} + +// TableName MultisigAccount's table name +func (*MultisigAccount) TableName() string { + return TableNameMultisigAccount +} diff --git a/dal/model/multisig_history.gen.go b/dal/model/multisig_history.gen.go new file mode 100644 index 0000000..5297798 --- /dev/null +++ b/dal/model/multisig_history.gen.go @@ -0,0 +1,32 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package model + +import ( + "time" +) + +const TableNameMultisigHistory = "multisig_history" + +// MultisigHistory mapped from table +type MultisigHistory struct { + TxHash string `gorm:"column:tx_hash;primaryKey" json:"tx_hash"` + Status int32 `gorm:"column:status" json:"status"` + CreateTime time.Time `gorm:"column:create_time;not null" json:"create_time"` + MultisigAddr string `gorm:"column:multisig_addr;not null" json:"multisig_addr"` + Memo string `gorm:"column:memo" json:"memo"` + Fees string `gorm:"column:fees" json:"fees"` + Height string `gorm:"column:height" json:"height"` + GasUsed string `gorm:"column:gas_used" json:"gas_used"` + GasWanted string `gorm:"column:gas_wanted" json:"gas_wanted"` + TotalAmount string `gorm:"column:total_amount" json:"total_amount"` + SequenceNumber string `gorm:"column:sequence_number" json:"sequence_number"` + Tx string `gorm:"column:tx" json:"tx"` +} + +// TableName MultisigHistory's table name +func (*MultisigHistory) TableName() string { + return TableNameMultisigHistory +} diff --git a/dal/model/pending_transaction.gen.go b/dal/model/pending_transaction.gen.go new file mode 100644 index 0000000..45fcbac --- /dev/null +++ b/dal/model/pending_transaction.gen.go @@ -0,0 +1,28 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package model + +import ( + "time" +) + +const TableNamePendingTransaction = "pending_transaction" + +// PendingTransaction mapped from table +type PendingTransaction struct { + ID string `gorm:"column:id;primaryKey" json:"id"` + WalletAddress string `gorm:"column:wallet_address;not null" json:"wallet_address"` + Sequence string `gorm:"column:sequence" json:"sequence"` + TxContent string `gorm:"column:tx_content;not null" json:"tx_content"` + Signatures string `gorm:"column:signatures" json:"signatures"` + CreateTime time.Time `gorm:"column:create_time;not null" json:"create_time"` + Memo string `gorm:"column:memo" json:"memo"` + Deleted int32 `gorm:"column:deleted" json:"deleted"` +} + +// TableName PendingTransaction's table name +func (*PendingTransaction) TableName() string { + return TableNamePendingTransaction +} diff --git a/dal/model/staking_percentage.gen.go b/dal/model/staking_percentage.gen.go new file mode 100644 index 0000000..235ec74 --- /dev/null +++ b/dal/model/staking_percentage.gen.go @@ -0,0 +1,24 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package model + +import ( + "time" +) + +const TableNameStakingPercentage = "staking_percentage" + +// StakingPercentage mapped from table +type StakingPercentage struct { + Date time.Time `gorm:"column:date;primaryKey" json:"date"` + Point string `gorm:"column:point;primaryKey" json:"point"` + Value int64 `gorm:"column:value" json:"value"` + ChainName string `gorm:"column:chain_name;primaryKey" json:"chain_name"` +} + +// TableName StakingPercentage's table name +func (*StakingPercentage) TableName() string { + return TableNameStakingPercentage +} diff --git a/dal/model/top_delegation.gen.go b/dal/model/top_delegation.gen.go new file mode 100644 index 0000000..12141cb --- /dev/null +++ b/dal/model/top_delegation.gen.go @@ -0,0 +1,20 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package model + +const TableNameTopDelegation = "top_delegation" + +// TopDelegation mapped from table +type TopDelegation struct { + Delegator string `gorm:"column:delegator;primaryKey" json:"delegator"` + Amount int64 `gorm:"column:amount" json:"amount"` + ChainName string `gorm:"column:chain_name;primaryKey" json:"chain_name"` + Validator string `gorm:"column:validator;primaryKey" json:"validator"` +} + +// TableName TopDelegation's table name +func (*TopDelegation) TableName() string { + return TableNameTopDelegation +} diff --git a/dal/model/top_undelegation.gen.go b/dal/model/top_undelegation.gen.go new file mode 100644 index 0000000..3904e8b --- /dev/null +++ b/dal/model/top_undelegation.gen.go @@ -0,0 +1,25 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package model + +import ( + "time" +) + +const TableNameTopUndelegation = "top_undelegation" + +// TopUndelegation mapped from table +type TopUndelegation struct { + Delegator string `gorm:"column:delegator;primaryKey" json:"delegator"` + Validator string `gorm:"column:validator;primaryKey" json:"validator"` + Amount int64 `gorm:"column:amount" json:"amount"` + ReleaseTime time.Time `gorm:"column:release_time;not null" json:"release_time"` + ChainName string `gorm:"column:chain_name;primaryKey" json:"chain_name"` +} + +// TableName TopUndelegation's table name +func (*TopUndelegation) TableName() string { + return TableNameTopUndelegation +} diff --git a/generate/gen.go b/generate/gen.go new file mode 100644 index 0000000..b91fb31 --- /dev/null +++ b/generate/gen.go @@ -0,0 +1,32 @@ +package main + +import ( + "gorm.io/driver/mysql" + "gorm.io/gen" + "gorm.io/gorm" +) + +var db *gorm.DB + +func init() { + var err error + dsn := "root:123456@tcp(127.0.0.1:3306)/toolkit?charset=utf8mb4&parseTime=True" + db, err = gorm.Open(mysql.Open(dsn), &gorm.Config{}) + if err != nil { + panic(err) + } + prepare(db) +} + +func main() { + g := gen.NewGenerator(gen.Config{ + OutPath: "./dal/dao", + Mode: gen.WithoutContext, + FieldSignable: true, + }) + // generate code + g.UseDB(db) + g.GenerateAllTable() + g.ApplyBasic(g.GenerateAllTable()...) + g.Execute() +} diff --git a/generate/prepare.go b/generate/prepare.go new file mode 100644 index 0000000..19cc1ba --- /dev/null +++ b/generate/prepare.go @@ -0,0 +1,28 @@ +package main + +import ( + "gorm.io/gorm" +) + +// prepare table for test +const ( + multisigAccountSQL = "CREATE TABLE `multisig_account` ( `address` varchar(255) NOT NULL, `name` varchar(512) DEFAULT NULL, `threshold` int NOT NULL, `chain_name` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL, `members` text NOT NULL, `status` varchar(255) NOT NULL, `pubkey` text NOT NULL, `create_time` timestamp NULL DEFAULT NULL, PRIMARY KEY (`address`) USING BTREE\n) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;" + multisigHistorySQL = "CREATE TABLE `multisig_history` ( `tx_hash` varchar(255) NOT NULL, `status` int DEFAULT NULL, `create_time` timestamp NOT NULL ON UPDATE CURRENT_TIMESTAMP, `multisig_addr` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL, `memo` varchar(256) DEFAULT NULL, `fees` varchar(255) DEFAULT NULL, `height` varchar(255) DEFAULT NULL, `gas_used` varchar(255) DEFAULT NULL, `gas_wanted` varchar(255) DEFAULT NULL, `total_amount` varchar(255) DEFAULT NULL, `sequence_number` varchar(255) DEFAULT NULL, `tx` text, PRIMARY KEY (`tx_hash`)\n) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;" + pendingTxSQL = "CREATE TABLE `pending_transaction` ( `id` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL, `wallet_address` varchar(255) NOT NULL, `sequence` varchar(255) DEFAULT NULL, `tx_content` text NOT NULL, `signatures` text, `create_time` timestamp NOT NULL, `memo` varchar(256) DEFAULT NULL, `deleted` smallint DEFAULT '0', PRIMARY KEY (`id`) USING BTREE\n) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;" + stakingPercentageSQL = "CREATE TABLE `staking_percentage` ( `date` date NOT NULL, `point` varchar(10) NOT NULL, `value` bigint DEFAULT NULL, `chain_name` varchar(255) NOT NULL, PRIMARY KEY (`date`,`chain_name`,`point`) USING BTREE\n) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;" + chainMetricsSQL = "CREATE TABLE `chain_metrics` ( `unique_delegate` int DEFAULT NULL, `date` date NOT NULL, `chain_name` varchar(255) NOT NULL, `unique_delegation` int DEFAULT NULL, `unbonded_tokens` bigint DEFAULT NULL, `bonded_tokens` bigint DEFAULT NULL, `market_cap` bigint DEFAULT NULL, `total_supply` bigint DEFAULT NULL, `circulating_supply` bigint DEFAULT NULL, `transactions` bigint DEFAULT NULL, `block_time` varchar(255) DEFAULT NULL, `inflation` varchar(255) DEFAULT NULL, `staking_apr` varchar(255) DEFAULT NULL, `txs_per_block` varchar(255) DEFAULT NULL, `community_pool` bigint DEFAULT NULL, `block_height` bigint DEFAULT NULL, `total_stake` bigint DEFAULT NULL, PRIMARY KEY (`chain_name`,`date`) USING BTREE\n) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;" + topDelegationSQL = "CREATE TABLE `top_delegation` ( `delegator` varchar(255) NOT NULL, `amount` bigint DEFAULT NULL, `chain_name` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL, `validator` varchar(255) NOT NULL, PRIMARY KEY (`delegator`,`chain_name`,`validator`) USING BTREE\n) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;" + topUndelegationSQL = "CREATE TABLE `top_undelegation` ( `delegator` varchar(255) NOT NULL, `validator` varchar(255) NOT NULL, `amount` bigint DEFAULT NULL, `release_time` timestamp NOT NULL, `chain_name` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL, PRIMARY KEY (`delegator`,`validator`,`chain_name`) USING BTREE\n) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;" + coinPriceSQL = "CREATE TABLE `coin_price` ( `date` date NOT NULL, `price` varchar(255) DEFAULT NULL, `symbol` varchar(255) DEFAULT NULL, `chain_name` varchar(255) NOT NULL, PRIMARY KEY (`date`,`chain_name`)\n) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;" +) + +func prepare(db *gorm.DB) { + db.Exec(multisigAccountSQL) + db.Exec(multisigHistorySQL) + db.Exec(pendingTxSQL) + db.Exec(stakingPercentageSQL) + db.Exec(chainMetricsSQL) + db.Exec(topDelegationSQL) + db.Exec(topUndelegationSQL) + db.Exec(coinPriceSQL) +} diff --git a/go.mod b/go.mod index 57b544f..af82aae 100644 --- a/go.mod +++ b/go.mod @@ -2,11 +2,51 @@ module github.com/0311xuyang/chain-util go 1.22 -require github.com/guregu/dynamo v1.23.0 +require ( + github.com/aws/aws-sdk-go v1.48.10 + github.com/gin-gonic/gin v1.10.0 + github.com/guregu/dynamo v1.23.0 + gorm.io/driver/mysql v1.5.7 + gorm.io/gen v0.3.26 + gorm.io/gorm v1.25.11 +) require ( - github.com/aws/aws-sdk-go v1.48.10 // indirect + github.com/bytedance/sonic v1.11.6 // indirect + github.com/bytedance/sonic/loader v0.1.1 // indirect github.com/cenkalti/backoff/v4 v4.2.1 // indirect + github.com/cloudwego/base64x v0.1.4 // indirect + github.com/cloudwego/iasm v0.2.0 // indirect + github.com/gabriel-vasile/mimetype v1.4.3 // indirect + github.com/gin-contrib/sse v0.1.0 // indirect + github.com/go-playground/locales v0.14.1 // indirect + github.com/go-playground/universal-translator v0.18.1 // indirect + github.com/go-playground/validator/v10 v10.20.0 // indirect + github.com/go-sql-driver/mysql v1.7.0 // indirect + github.com/goccy/go-json v0.10.2 // indirect + github.com/jinzhu/inflection v1.0.0 // indirect + github.com/jinzhu/now v1.1.5 // indirect github.com/jmespath/go-jmespath v0.4.0 // indirect - golang.org/x/sync v0.5.0 // indirect + github.com/json-iterator/go v1.1.12 // indirect + github.com/klauspost/cpuid/v2 v2.2.7 // indirect + github.com/leodido/go-urn v1.4.0 // indirect + github.com/mattn/go-isatty v0.0.20 // indirect + github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect + github.com/modern-go/reflect2 v1.0.2 // indirect + github.com/pelletier/go-toml/v2 v2.2.2 // indirect + github.com/twitchyliquid64/golang-asm v0.15.1 // indirect + github.com/ugorji/go/codec v1.2.12 // indirect + golang.org/x/arch v0.8.0 // indirect + golang.org/x/crypto v0.23.0 // indirect + golang.org/x/mod v0.14.0 // indirect + golang.org/x/net v0.25.0 // indirect + golang.org/x/sync v0.6.0 // indirect + golang.org/x/sys v0.20.0 // indirect + golang.org/x/text v0.15.0 // indirect + golang.org/x/tools v0.17.0 // indirect + google.golang.org/protobuf v1.34.1 // indirect + gopkg.in/yaml.v3 v3.0.1 // indirect + gorm.io/datatypes v1.1.1-0.20230130040222-c43177d3cf8c // indirect + gorm.io/hints v1.1.0 // indirect + gorm.io/plugin/dbresolver v1.5.0 // indirect ) diff --git a/go.sum b/go.sum index a87c2e0..0de91a7 100644 --- a/go.sum +++ b/go.sum @@ -1,20 +1,166 @@ github.com/aws/aws-sdk-go v1.48.10 h1:0LIFG3wp2Dt6PsxKWCg1Y1xRrn2vZnW5/gWdgaBalKg= github.com/aws/aws-sdk-go v1.48.10/go.mod h1:LF8svs817+Nz+DmiMQKTO3ubZ/6IaTpq3TjupRn3Eqk= +github.com/bytedance/sonic v1.11.6 h1:oUp34TzMlL+OY1OUWxHqsdkgC/Zfc85zGqw9siXjrc0= +github.com/bytedance/sonic v1.11.6/go.mod h1:LysEHSvpvDySVdC2f87zGWf6CIKJcAvqab1ZaiQtds4= +github.com/bytedance/sonic/loader v0.1.1 h1:c+e5Pt1k/cy5wMveRDyk2X4B9hF4g7an8N3zCYjJFNM= +github.com/bytedance/sonic/loader v0.1.1/go.mod h1:ncP89zfokxS5LZrJxl5z0UJcsk4M4yY2JpfqGeCtNLU= github.com/cenkalti/backoff/v4 v4.2.1 h1:y4OZtCnogmCPw98Zjyt5a6+QwPLGkiQsYW5oUqylYbM= github.com/cenkalti/backoff/v4 v4.2.1/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE= -github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= +github.com/cloudwego/base64x v0.1.4 h1:jwCgWpFanWmN8xoIUHa2rtzmkd5J2plF/dnLS6Xd/0Y= +github.com/cloudwego/base64x v0.1.4/go.mod h1:0zlkT4Wn5C6NdauXdJRhSKRlJvmclQ1hhJgA0rcu/8w= +github.com/cloudwego/iasm v0.2.0 h1:1KNIy1I1H9hNNFEEH3DVnI4UujN+1zjpuk6gwHLTssg= +github.com/cloudwego/iasm v0.2.0/go.mod h1:8rXZaNYT2n95jn+zTI1sDr+IgcD2GVs0nlbbQPiEFhY= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/gabriel-vasile/mimetype v1.4.3 h1:in2uUcidCuFcDKtdcBxlR0rJ1+fsokWf+uqxgUFjbI0= +github.com/gabriel-vasile/mimetype v1.4.3/go.mod h1:d8uq/6HKRL6CGdk+aubisF/M5GcPfT7nKyLpA0lbSSk= +github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE= +github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI= +github.com/gin-gonic/gin v1.10.0 h1:nTuyha1TYqgedzytsKYqna+DfLos46nTv2ygFy86HFU= +github.com/gin-gonic/gin v1.10.0/go.mod h1:4PMNQiOhvDRa013RKVbsiNwoyezlm2rm0uX/T7kzp5Y= +github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s= +github.com/go-playground/assert/v2 v2.2.0/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4= +github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA= +github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY= +github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY= +github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY= +github.com/go-playground/validator/v10 v10.20.0 h1:K9ISHbSaI0lyB2eWMPJo+kOS/FBExVwjEviJTixqxL8= +github.com/go-playground/validator/v10 v10.20.0/go.mod h1:dbuPbCMFw/DrkbEynArYaCwl3amGuJotoKCe95atGMM= +github.com/go-sql-driver/mysql v1.6.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg= +github.com/go-sql-driver/mysql v1.7.0 h1:ueSltNNllEqE3qcWBTD0iQd3IpL/6U+mJxLkazJ7YPc= +github.com/go-sql-driver/mysql v1.7.0/go.mod h1:OXbVy3sEdcQ2Doequ6Z5BW6fXNQTmx+9S1MCJN5yJMI= +github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU= +github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I= +github.com/golang-sql/civil v0.0.0-20220223132316-b832511892a9 h1:au07oEsX2xN0ktxqI+Sida1w446QrXBRJ0nee3SNZlA= +github.com/golang-sql/civil v0.0.0-20220223132316-b832511892a9/go.mod h1:8vg3r2VgvsThLBIFL93Qb5yWzgyZWhEmBwUJWevAkK0= +github.com/golang-sql/sqlexp v0.1.0 h1:ZCD6MBpcuOVfGVqsEmY5/4FtYiKz6tSyUv9LPEDei6A= +github.com/golang-sql/sqlexp v0.1.0/go.mod h1:J4ad9Vo8ZCWQ2GMrC4UCQy1JpCbwU9m3EOqtpKwwwHI= +github.com/google/go-cmp v0.5.5 h1:Khx7svrCpmxxtHBq5j2mp/xVjsi8hQMfNLvJFAlrGgU= +github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= github.com/guregu/dynamo v1.23.0 h1:lKiHpT1Io3DtAxzhgM3+kyidRSk7/u6nld7kgcP6W7U= github.com/guregu/dynamo v1.23.0/go.mod h1:a0knvVZrDhT+q7eQlu1n041lf5vPi0sNfGjRh81mAnQ= +github.com/jackc/chunkreader/v2 v2.0.1 h1:i+RDz65UE+mmpjTfyz0MoVTnzeYxroil2G82ki7MGG8= +github.com/jackc/chunkreader/v2 v2.0.1/go.mod h1:odVSm741yZoC3dpHEUXIqA9tQRhFrgOHwnPIn9lDKlk= +github.com/jackc/pgconn v1.13.0 h1:3L1XMNV2Zvca/8BYhzcRFS70Lr0WlDg16Di6SFGAbys= +github.com/jackc/pgconn v1.13.0/go.mod h1:AnowpAqO4CMIIJNZl2VJp+KrkAZciAkhEl0W0JIobpI= +github.com/jackc/pgio v1.0.0 h1:g12B9UwVnzGhueNavwioyEEpAmqMe1E/BN9ES+8ovkE= +github.com/jackc/pgio v1.0.0/go.mod h1:oP+2QK2wFfUWgr+gxjoBH9KGBb31Eio69xUb0w5bYf8= +github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM= +github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg= +github.com/jackc/pgproto3/v2 v2.3.1 h1:nwj7qwf0S+Q7ISFfBndqeLwSwxs+4DPsbRFjECT1Y4Y= +github.com/jackc/pgproto3/v2 v2.3.1/go.mod h1:WfJCnwN3HIg9Ish/j3sgWXnAfK8A9Y0bwXYU5xKaEdA= +github.com/jackc/pgservicefile v0.0.0-20200714003250-2b9c44734f2b h1:C8S2+VttkHFdOOCXJe+YGfa4vHYwlt4Zx+IVXQ97jYg= +github.com/jackc/pgservicefile v0.0.0-20200714003250-2b9c44734f2b/go.mod h1:vsD4gTJCa9TptPL8sPkXrLZ+hDuNrZCnj29CQpr4X1E= +github.com/jackc/pgtype v1.12.0 h1:Dlq8Qvcch7kiehm8wPGIW0W3KsCCHJnRacKW0UM8n5w= +github.com/jackc/pgtype v1.12.0/go.mod h1:LUMuVrfsFfdKGLw+AFFVv6KtHOFMwRgDDzBt76IqCA4= +github.com/jackc/pgx/v4 v4.17.2 h1:0Ut0rpeKwvIVbMQ1KbMBU4h6wxehBI535LK6Flheh8E= +github.com/jackc/pgx/v4 v4.17.2/go.mod h1:lcxIZN44yMIrWI78a5CpucdD14hX0SBDbNRvjDBItsw= +github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E= +github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc= +github.com/jinzhu/now v1.1.2/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8= +github.com/jinzhu/now v1.1.4/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8= +github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ= +github.com/jinzhu/now v1.1.5/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8= github.com/jmespath/go-jmespath v0.4.0 h1:BEgLn5cpjn8UN1mAw4NjwDrS35OdebyEtFe+9YPoQUg= github.com/jmespath/go-jmespath v0.4.0/go.mod h1:T8mJZnbsbmF+m6zOOFylbeCJqk5+pHWvzYPziyZiYoo= github.com/jmespath/go-jmespath/internal/testify v1.5.1 h1:shLQSRRSCCPj3f2gpwzGwWFoC7ycTf1rcQZHOlsJ6N8= github.com/jmespath/go-jmespath/internal/testify v1.5.1/go.mod h1:L3OGu8Wl2/fWfCI6z80xFu9LTZmf1ZRjMHUOPmWr69U= +github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM= +github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo= +github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg= +github.com/klauspost/cpuid/v2 v2.2.7 h1:ZWSB3igEs+d0qvnxR/ZBzXVmxkgt8DdzP6m9pfuVLDM= +github.com/klauspost/cpuid/v2 v2.2.7/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws= +github.com/knz/go-libedit v1.10.1/go.mod h1:MZTVkCWyz0oBc7JOWP3wNAzd002ZbM/5hgShxwh4x8M= +github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ= +github.com/leodido/go-urn v1.4.0/go.mod h1:bvxc+MVxLKB4z00jd1z+Dvzr47oO32F/QSNjSBOlFxI= +github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= +github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= +github.com/mattn/go-sqlite3 v1.14.8/go.mod h1:NyWgC/yNuGj7Q9rpYnZvas74GogHl5/Z4A/KQRfk6bU= +github.com/mattn/go-sqlite3 v1.14.15 h1:vfoHhTN1af61xCRSWzFIWzx2YskyMTwHLrExkBOjvxI= +github.com/mattn/go-sqlite3 v1.14.15/go.mod h1:2eHXhiwb8IkHr+BDWZGa96P6+rkvnG63S2DGjv9HUNg= +github.com/microsoft/go-mssqldb v0.17.0 h1:Fto83dMZPnYv1Zwx5vHHxpNraeEaUlQ/hhHLgZiaenE= +github.com/microsoft/go-mssqldb v0.17.0/go.mod h1:OkoNGhGEs8EZqchVTtochlXruEhEOaO4S0d2sB5aeGQ= +github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= +github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg= +github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= +github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M= +github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= +github.com/pelletier/go-toml/v2 v2.2.2 h1:aYUidT7k73Pcl9nb2gScu7NSrKCSHIDE89b3+6Wq+LM= +github.com/pelletier/go-toml/v2 v2.2.2/go.mod h1:1t835xjRzz80PqgE6HHgN2JOsmgYu/h4qDAS4n929Rs= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= -golang.org/x/sync v0.5.0 h1:60k92dhOjHxJkrqnwsfl8KuaHbn/5dl0lUPUklKo3qE= -golang.org/x/sync v0.5.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= +github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= +github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= +github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= +github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= +github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= +github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= +github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= +github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI= +github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08= +github.com/ugorji/go/codec v1.2.12 h1:9LC83zGrHhuUA9l16C9AHXAqEV/2wBQ4nkvumAE65EE= +github.com/ugorji/go/codec v1.2.12/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg= +golang.org/x/arch v0.0.0-20210923205945-b76863e36670/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8= +golang.org/x/arch v0.8.0 h1:3wRIsP3pM4yUptoR96otTUOXI367OS0+c9eeRi9doIc= +golang.org/x/arch v0.8.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys= +golang.org/x/crypto v0.23.0 h1:dIJU/v2J8Mdglj/8rJ6UUOM3Zc9zLZxVZwwxMooUSAI= +golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8= +golang.org/x/mod v0.14.0 h1:dGoOF9QVLYng8IHTm7BAyWqCqSheQ5pYWGhzW00YJr0= +golang.org/x/mod v0.14.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= +golang.org/x/net v0.25.0 h1:d/OCCoBEUq33pjydKrGQhw7IlUPI2Oylr+8qLx49kac= +golang.org/x/net v0.25.0/go.mod h1:JkAGAh7GEvH74S6FOH42FLoXpXbE/aqXSrIQjXgsiwM= +golang.org/x/sync v0.6.0 h1:5BMeUDZ7vkXGfEr1x9B4bRcTH4lpkTkpdh0T/J+qjbQ= +golang.org/x/sync v0.6.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= +golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.20.0 h1:Od9JTbYCk261bKm4M/mw7AklTlFYIa0bIp9BgSm1S8Y= +golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/text v0.15.0 h1:h1V/4gjBv8v9cjcR6+AR5+/cIYK5N/WAgiv4xlsEtAk= +golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= +golang.org/x/tools v0.17.0 h1:FvmRgNOcs3kOa+T20R1uhfP9F6HgG2mfxDv1vrx1Htc= +golang.org/x/tools v0.17.0/go.mod h1:xsh6VxdV005rRVaS6SSAf9oiAqljS7UZUacMZ8Bnsps= +golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4= +golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +google.golang.org/protobuf v1.34.1 h1:9ddQBjfCyZPOHPUiPxpYESBLc+T8P3E+Vo4IbKZgFWg= +google.golang.org/protobuf v1.34.1/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/yaml.v2 v2.2.8 h1:obN1ZagJSUGI0Ek/LBmuj4SNLPfIny3KsKFopxRdj10= gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gorm.io/datatypes v1.1.1-0.20230130040222-c43177d3cf8c h1:jWdr7cHgl8c/ua5vYbR2WhSp+NQmzhsj0xoY3foTzW8= +gorm.io/datatypes v1.1.1-0.20230130040222-c43177d3cf8c/go.mod h1:SH2K9R+2RMjuX1CkCONrPwoe9JzVv2hkQvEu4bXGojE= +gorm.io/driver/mysql v1.4.3/go.mod h1:sSIebwZAVPiT+27jK9HIwvsqOGKx3YMPmrA3mBJR10c= +gorm.io/driver/mysql v1.5.7 h1:MndhOPYOfEp2rHKgkZIhJ16eVUIRf2HmzgoPmh7FCWo= +gorm.io/driver/mysql v1.5.7/go.mod h1:sEtPWMiqiN1N1cMXoXmBbd8C6/l+TESwriotuRRpkDM= +gorm.io/driver/postgres v1.4.5 h1:mTeXTTtHAgnS9PgmhN2YeUbazYpLhUI1doLnw42XUZc= +gorm.io/driver/postgres v1.4.5/go.mod h1:GKNQYSJ14qvWkvPwXljMGehpKrhlDNsqYRr5HnYGncg= +gorm.io/driver/sqlite v1.1.6/go.mod h1:W8LmC/6UvVbHKah0+QOC7Ja66EaZXHwUTjgXY8YNWX8= +gorm.io/driver/sqlite v1.4.3 h1:HBBcZSDnWi5BW3B3rwvVTc510KGkBkexlOg0QrmLUuU= +gorm.io/driver/sqlite v1.4.3/go.mod h1:0Aq3iPO+v9ZKbcdiz8gLWRw5VOPcBOPUQJFLq5e2ecI= +gorm.io/driver/sqlserver v1.4.1 h1:t4r4r6Jam5E6ejqP7N82qAJIJAht27EGT41HyPfXRw0= +gorm.io/driver/sqlserver v1.4.1/go.mod h1:DJ4P+MeZbc5rvY58PnmN1Lnyvb5gw5NPzGshHDnJLig= +gorm.io/gen v0.3.26 h1:sFf1j7vNStimPRRAtH4zz5NiHM+1dr6eA9aaRdplyhY= +gorm.io/gen v0.3.26/go.mod h1:a5lq5y3w4g5LMxBcw0wnO6tYUCdNutWODq5LrIt75LE= +gorm.io/gorm v1.21.15/go.mod h1:F+OptMscr0P2F2qU97WT1WimdH9GaQPoDW7AYd5i2Y0= +gorm.io/gorm v1.22.2/go.mod h1:F+OptMscr0P2F2qU97WT1WimdH9GaQPoDW7AYd5i2Y0= +gorm.io/gorm v1.23.8/go.mod h1:l2lP/RyAtc1ynaTjFksBde/O8v9oOGIApu2/xRitmZk= +gorm.io/gorm v1.25.2/go.mod h1:L4uxeKpfBml98NYqVqwAdmV1a2nBtAec/cf3fpucW/k= +gorm.io/gorm v1.25.7/go.mod h1:hbnx/Oo0ChWMn1BIhpy1oYozzpM15i4YPuHDmfYtwg8= +gorm.io/gorm v1.25.11 h1:/Wfyg1B/je1hnDx3sMkX+gAlxrlZpn6X0BXRlwXlvHg= +gorm.io/gorm v1.25.11/go.mod h1:xh7N7RHfYlNc5EmcI/El95gXusucDrQnHXe0+CgWcLQ= +gorm.io/hints v1.1.0 h1:Lp4z3rxREufSdxn4qmkK3TLDltrM10FLTHiuqwDPvXw= +gorm.io/hints v1.1.0/go.mod h1:lKQ0JjySsPBj3uslFzY3JhYDtqEwzm+G1hv8rWujB6Y= +gorm.io/plugin/dbresolver v1.5.0 h1:XVHLxh775eP0CqVh3vcfJtYqja3uFl5Wr3cKlY8jgDY= +gorm.io/plugin/dbresolver v1.5.0/go.mod h1:l4Cn87EHLEYuqUncpEeTC2tTJQkjngPSD+lo8hIvcT0= +nullprogram.com/x/optparse v1.0.0/go.mod h1:KdyPE+Igbe0jQUrVfMqDMeJQIJZEuyV7pjYmp6pbG50= +rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4= diff --git a/main.go b/main.go index 1414596..55b38d3 100644 --- a/main.go +++ b/main.go @@ -3,27 +3,27 @@ package main import ( "fmt" - "github.com/0311xuyang/chain-util/db" + "github.com/0311xuyang/chain-util/route" + "github.com/gin-gonic/gin" ) -func main() { - // Create a new DB object. - Store := db.New() - - // Create a new User object. - user := &db.User{ - ID: "1", - Name: "John Doe", - Email: "user1@mail.com", - } - Store.PutUser(user) - fmt.Println("User created.") +// LoadRoute defines the routes for the server. +func LoadRoute(server *gin.Engine) { + dbController := server.Group("/db") + dbController.GET("/get/:id", route.GetUser) + dbController.POST("/set", route.SetUser) +} - // Get the user by ID. - user, err := Store.GetUser("1") - if err != nil { +// StartServer a gin server +func StartServer() { + gin.SetMode(gin.DebugMode) + server := gin.Default() + LoadRoute(server) + if err := server.Run(":8080"); err != nil { fmt.Println("Error:", err) - return } - fmt.Println("User:", user) +} + +func main() { + StartServer() } diff --git a/route/controller.go b/route/controller.go new file mode 100644 index 0000000..da17b41 --- /dev/null +++ b/route/controller.go @@ -0,0 +1,80 @@ +package route + +import ( + "net/http" + + "github.com/0311xuyang/chain-util/db" + "github.com/0311xuyang/chain-util/service" + "github.com/gin-gonic/gin" +) + +// GetUser gets a user. +func GetUser(c *gin.Context) { + var request GetUserRequest + err := c.BindUri(request) + if err != nil { + formatBadResponse(c, err.Error()) + } + store := db.New() + user, err := store.GetUser(request.ID) + if err != nil { + formatBadResponse(c, err.Error()) + } + formatOKResponse(c, "success", user) +} + +// SetUser sets a user. +func SetUser(c *gin.Context) { + var request SetUserRequest + c.BindJSON(request) + store := db.New() + err := store.PutUser(&db.User{ + ID: request.ID, + Name: request.Name, + Email: request.Email, + }) + if err != nil { + formatBadResponse(c, err.Error()) + } + formatOKResponse(c, "success", nil) +} + +// GetCoinPrice gets the price of a coin. +func GetCoinPrice(c *gin.Context) { + var request GetCoinPriceRequest + err := c.BindUri(request) + if err != nil { + formatBadResponse(c, err.Error()) + } + svc := service.Service{} + coin, err := svc.GetCoin(request.Symbol) + if err != nil { + formatBadResponse(c, err.Error()) + } + formatOKResponse(c, "success", coin) +} + +// SetCoinPrice sets the price of a coin. +func SetCoinPrice(c *gin.Context) { + var request SetCoinPriceRequest + c.BindJSON(request) + svc := service.Service{} + err := svc.CreateCoin(request.Symbol, request.Price) + if err != nil { + formatBadResponse(c, err.Error()) + } + formatOKResponse(c, "success", nil) +} + +func formatOKResponse(c *gin.Context, message string, data interface{}) { + c.AbortWithStatusJSON(http.StatusOK, gin.H{ + "message": message, + "data": data, + }) +} + +func formatBadResponse(c *gin.Context, message string) { + c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{ + "message": message, + }) +} diff --git a/route/request.go b/route/request.go new file mode 100644 index 0000000..79508b2 --- /dev/null +++ b/route/request.go @@ -0,0 +1,24 @@ +package route + +// GetUserRequest is a struct that holds the request for GetUser. +type GetUserRequest struct { + ID string `url:"id"` +} + +// SetUserRequest is a struct that holds the request for SetUser. +type SetUserRequest struct { + ID string `json:"id"` + Name string `json:"name"` + Email string `json:"email"` +} + +// GetCoinPriceRequest is a struct that holds the request for GetCoinPrice. +type GetCoinPriceRequest struct { + Symbol string `url:"symbol"` +} + +// SetCoinPriceRequest is a struct that holds the request for SetCoinPrice. +type SetCoinPriceRequest struct { + Symbol string `json:"symbol"` + Price string `json:"price"` +} diff --git a/service/service.go b/service/service.go new file mode 100644 index 0000000..d7bf5b3 --- /dev/null +++ b/service/service.go @@ -0,0 +1,44 @@ +package service + +import ( + "time" + + "github.com/0311xuyang/chain-util/dal" + "github.com/0311xuyang/chain-util/dal/dao" + "github.com/0311xuyang/chain-util/dal/model" +) + +// Service is a struct that holds the service methods. +type Service struct{} + +// CreateCoin creates a coin. +func (s *Service) CreateCoin(symbol, price string) error { + coin := &model.CoinPrice{ + Date: time.Now(), + Price: price, + Symbol: symbol, + ChainName: "HSK", + } + err := dao.Use(dal.DB).CoinPrice.Create(coin) + if err != nil { + return err + } + return nil +} + +// GetCoin gets a coin by symbol. +func (s *Service) GetCoin(symbol string) (*model.CoinPrice, error) { + m := dao.Use(dal.DB).CoinPrice + coin, err := m.Select(m.ALL).Where(m.Symbol.Eq(symbol)).First() + if err != nil { + return nil, err + } + return coin, nil +} + +// DeleteCoin deletes a coin by symbol. +func (s *Service) DeleteCoin(symbol string) error { + m := dao.Use(dal.DB).CoinPrice + _, err := m.Where(m.Symbol.Eq(symbol)).Delete() + return err +} diff --git a/service/service_test.go b/service/service_test.go new file mode 100644 index 0000000..6403717 --- /dev/null +++ b/service/service_test.go @@ -0,0 +1,23 @@ +package service_test + +import ( + "testing" + + "github.com/0311xuyang/chain-util/service" +) + +func TestService(t *testing.T) { + svc := service.Service{} + svc.DeleteCoin("ATM") + err := svc.CreateCoin("ATM", "1.414") + if err != nil { + t.Error("Error creating coin:", err) + } + coin, err := svc.GetCoin("ATM") + if err != nil { + t.Error("Error getting coin:", err) + } + if coin.Symbol != "ATM" { + t.Error("Coin symbol does not match.") + } +}