forks/go-ethereum
1
0
Fork 1
mirror of https://github.com/ethereum/go-ethereum.git synced 2026-07-10 23:14:27 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Merge pull request #697 from gzliudan/fix-s1034

Browse source 
XDCxDAO: fix staticcheck warning S1034: use result of type assertion to simplify cases
This commit is contained in:
Daniel Liu 2024-10-28 15:17:01 +08:00 committed by GitHub
commit efe041a684
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
1 changed files with 29 additions and 39 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

68
XDCxDAO/mongodb.go
View file

@ -101,7 +101,7 @@ func (db *MongoDatabase) HasObject(hash common.Hash, val interface{}) (bool, err
err error err error
) )
query := bson.M{"hash": hash.Hex()} query := bson.M{"hash": hash.Hex()}
switch val.(type) { switch item := val.(type) {
case *tradingstate.OrderItem: case *tradingstate.OrderItem:
// Find key in ordersCollection collection // Find key in ordersCollection collection
count, err = sc.DB(db.dbName).C(ordersCollection).Find(query).Limit(1).Count() count, err = sc.DB(db.dbName).C(ordersCollection).Find(query).Limit(1).Count()
@ -126,7 +126,6 @@ func (db *MongoDatabase) HasObject(hash common.Hash, val interface{}) (bool, err
} }
case *lendingstate.LendingItem: case *lendingstate.LendingItem:
// Find key in lendingItemsCollection collection // Find key in lendingItemsCollection collection
item := val.(*lendingstate.LendingItem)
switch item.Type { switch item.Type {
case lendingstate.Repay: case lendingstate.Repay:
count, err = sc.DB(db.dbName).C(lendingRepayCollection).Find(query).Limit(1).Count() count, err = sc.DB(db.dbName).C(lendingRepayCollection).Find(query).Limit(1).Count()
@ -176,7 +175,7 @@ func (db *MongoDatabase) GetObject(hash common.Hash, val interface{}) (interface
query := bson.M{"hash": hash.Hex()} query := bson.M{"hash": hash.Hex()}
switch val.(type) { switch item := val.(type) {
case *tradingstate.OrderItem: case *tradingstate.OrderItem:
var oi *tradingstate.OrderItem var oi *tradingstate.OrderItem
err := sc.DB(db.dbName).C(ordersCollection).Find(query).One(&oi) err := sc.DB(db.dbName).C(ordersCollection).Find(query).One(&oi)
@ -196,7 +195,6 @@ func (db *MongoDatabase) GetObject(hash common.Hash, val interface{}) (interface
case *lendingstate.LendingItem: case *lendingstate.LendingItem:
var li *lendingstate.LendingItem var li *lendingstate.LendingItem
var err error var err error
item := val.(*lendingstate.LendingItem)
switch item.Type { switch item.Type {
case lendingstate.Repay: case lendingstate.Repay:
err = sc.DB(db.dbName).C(lendingRepayCollection).Find(query).One(&li) err = sc.DB(db.dbName).C(lendingRepayCollection).Find(query).One(&li)
@ -230,62 +228,58 @@ func (db *MongoDatabase) PutObject(hash common.Hash, val interface{}) error {
cacheKey := db.getCacheKey(hash.Bytes()) cacheKey := db.getCacheKey(hash.Bytes())
db.cacheItems.Add(cacheKey, val) db.cacheItems.Add(cacheKey, val)
switch val.(type) { switch item := val.(type) {
case *tradingstate.Trade: case *tradingstate.Trade:
// PutObject trade into tradesCollection collection // PutObject trade into tradesCollection collection
db.tradeBulk.Insert(val.(*tradingstate.Trade)) db.tradeBulk.Insert(item)
case *tradingstate.OrderItem: case *tradingstate.OrderItem:
// PutObject order into ordersCollection collection // PutObject order into ordersCollection collection
o := val.(*tradingstate.OrderItem) if item.Status == tradingstate.OrderStatusOpen {
if o.Status == tradingstate.OrderStatusOpen { db.orderBulk.Insert(item)
db.orderBulk.Insert(o)
} else { } else {
query := bson.M{"hash": o.Hash.Hex()} query := bson.M{"hash": item.Hash.Hex()}
db.orderBulk.Upsert(query, o) db.orderBulk.Upsert(query, item)
} }
return nil return nil
case *tradingstate.EpochPriceItem: case *tradingstate.EpochPriceItem:
item := val.(*tradingstate.EpochPriceItem)
query := bson.M{"hash": item.Hash.Hex()} query := bson.M{"hash": item.Hash.Hex()}
db.epochPriceBulk.Upsert(query, item) db.epochPriceBulk.Upsert(query, item)
return nil return nil
case *lendingstate.LendingTrade: case *lendingstate.LendingTrade:
lt := val.(*lendingstate.LendingTrade)
// PutObject LendingTrade into tradesCollection collection // PutObject LendingTrade into tradesCollection collection
if existed, err := db.HasObject(hash, val); err == nil && existed { if existed, err := db.HasObject(hash, val); err == nil && existed {
query := bson.M{"hash": lt.Hash.Hex()} query := bson.M{"hash": item.Hash.Hex()}
db.lendingTradeBulk.Upsert(query, lt) db.lendingTradeBulk.Upsert(query, item)
} else { } else {
db.lendingTradeBulk.Insert(lt) db.lendingTradeBulk.Insert(item)
} }
case *lendingstate.LendingItem: case *lendingstate.LendingItem:
// PutObject order into ordersCollection collection // PutObject order into ordersCollection collection
li := val.(*lendingstate.LendingItem) switch item.Type {
switch li.Type {
case lendingstate.Repay: case lendingstate.Repay:
if li.Status != lendingstate.LendingStatusReject { if item.Status != lendingstate.LendingStatusReject {
li.Status = lendingstate.Repay item.Status = lendingstate.Repay
} }
db.repayBulk.Insert(li) db.repayBulk.Insert(item)
return nil return nil
case lendingstate.TopUp: case lendingstate.TopUp:
if li.Status != lendingstate.LendingStatusReject { if item.Status != lendingstate.LendingStatusReject {
li.Status = lendingstate.TopUp item.Status = lendingstate.TopUp
} }
db.topUpBulk.Insert(li) db.topUpBulk.Insert(item)
return nil return nil
case lendingstate.Recall: case lendingstate.Recall:
if li.Status != lendingstate.LendingStatusReject { if item.Status != lendingstate.LendingStatusReject {
li.Status = lendingstate.Recall item.Status = lendingstate.Recall
} }
db.recallBulk.Insert(li) db.recallBulk.Insert(item)
return nil return nil
default: default:
if li.Status == lendingstate.LendingStatusOpen { if item.Status == lendingstate.LendingStatusOpen {
db.lendingItemBulk.Insert(li) db.lendingItemBulk.Insert(item)
} else { } else {
query := bson.M{"hash": li.Hash.Hex()} query := bson.M{"hash": item.Hash.Hex()}
db.lendingItemBulk.Upsert(query, li) db.lendingItemBulk.Upsert(query, item)
} }
return nil return nil
} }
@ -313,7 +307,7 @@ func (db *MongoDatabase) DeleteObject(hash common.Hash, val interface{}) error {
if found { if found {
var err error var err error
switch val.(type) { switch item := val.(type) {
case *tradingstate.OrderItem: case *tradingstate.OrderItem:
err = sc.DB(db.dbName).C(ordersCollection).Remove(query) err = sc.DB(db.dbName).C(ordersCollection).Remove(query)
if err != nil && err != mgo.ErrNotFound { if err != nil && err != mgo.ErrNotFound {
@ -325,7 +319,6 @@ func (db *MongoDatabase) DeleteObject(hash common.Hash, val interface{}) error {
return fmt.Errorf("failed to delete XDCx trade. Err: %v", err) return fmt.Errorf("failed to delete XDCx trade. Err: %v", err)
} }
case *lendingstate.LendingItem: case *lendingstate.LendingItem:
item := val.(*lendingstate.LendingItem)
switch item.Type { switch item.Type {
case lendingstate.Repay: case lendingstate.Repay:
err = sc.DB(db.dbName).C(lendingRepayCollection).Remove(query) err = sc.DB(db.dbName).C(lendingRepayCollection).Remove(query)
@ -424,7 +417,7 @@ func (db *MongoDatabase) DeleteItemByTxHash(txhash common.Hash, val interface{})
defer sc.Close() defer sc.Close()
query := bson.M{"txHash": txhash.Hex()} query := bson.M{"txHash": txhash.Hex()}
switch val.(type) { switch item := val.(type) {
case *tradingstate.OrderItem: case *tradingstate.OrderItem:
if err := sc.DB(db.dbName).C(ordersCollection).Remove(query); err != nil && err != mgo.ErrNotFound { if err := sc.DB(db.dbName).C(ordersCollection).Remove(query); err != nil && err != mgo.ErrNotFound {
log.Error("DeleteItemByTxHash: failed to delete order", "txhash", txhash, "err", err) log.Error("DeleteItemByTxHash: failed to delete order", "txhash", txhash, "err", err)
@ -434,7 +427,6 @@ func (db *MongoDatabase) DeleteItemByTxHash(txhash common.Hash, val interface{})
log.Error("DeleteItemByTxHash: failed to delete trade", "txhash", txhash, "err", err) log.Error("DeleteItemByTxHash: failed to delete trade", "txhash", txhash, "err", err)
} }
case *lendingstate.LendingItem: case *lendingstate.LendingItem:
item := val.(*lendingstate.LendingItem)
switch item.Type { switch item.Type {
case lendingstate.Repay: case lendingstate.Repay:
if err := sc.DB(db.dbName).C(lendingRepayCollection).Remove(query); err != nil && err != mgo.ErrNotFound { if err := sc.DB(db.dbName).C(lendingRepayCollection).Remove(query); err != nil && err != mgo.ErrNotFound {
@ -473,7 +465,7 @@ func (db *MongoDatabase) GetListItemByTxHash(txhash common.Hash, val interface{}
defer sc.Close() defer sc.Close()
query := bson.M{"txHash": txhash.Hex()} query := bson.M{"txHash": txhash.Hex()}
switch val.(type) { switch item := val.(type) {
case *tradingstate.OrderItem: case *tradingstate.OrderItem:
result := []*tradingstate.OrderItem{} result := []*tradingstate.OrderItem{}
if err := sc.DB(db.dbName).C(ordersCollection).Find(query).All(&result); err != nil && err != mgo.ErrNotFound { if err := sc.DB(db.dbName).C(ordersCollection).Find(query).All(&result); err != nil && err != mgo.ErrNotFound {
@ -487,7 +479,6 @@ func (db *MongoDatabase) GetListItemByTxHash(txhash common.Hash, val interface{}
} }
return result return result
case *lendingstate.LendingItem: case *lendingstate.LendingItem:
item := val.(*lendingstate.LendingItem)
result := []*lendingstate.LendingItem{} result := []*lendingstate.LendingItem{}
switch item.Type { switch item.Type {
case lendingstate.Repay: case lendingstate.Repay:
@ -529,7 +520,7 @@ func (db *MongoDatabase) GetListItemByHashes(hashes []string, val interface{}) i
query := bson.M{"hash": bson.M{"$in": hashes}} query := bson.M{"hash": bson.M{"$in": hashes}}
switch val.(type) { switch item := val.(type) {
case *tradingstate.OrderItem: case *tradingstate.OrderItem:
result := []*tradingstate.OrderItem{} result := []*tradingstate.OrderItem{}
if err := sc.DB(db.dbName).C(ordersCollection).Find(query).All(&result); err != nil && err != mgo.ErrNotFound { if err := sc.DB(db.dbName).C(ordersCollection).Find(query).All(&result); err != nil && err != mgo.ErrNotFound {
@ -543,7 +534,6 @@ func (db *MongoDatabase) GetListItemByHashes(hashes []string, val interface{}) i
} }
return result return result
case *lendingstate.LendingItem: case *lendingstate.LendingItem:
item := val.(*lendingstate.LendingItem)
result := []*lendingstate.LendingItem{} result := []*lendingstate.LendingItem{}
switch item.Type { switch item.Type {
case lendingstate.Repay: case lendingstate.Repay: