github.com/condensat/bank-core@v0.1.0/database/query/asset.go (about)

     1  // Copyright 2020 Condensat Tech. All rights reserved.
     2  // Use of this source code is governed by a MIT
     3  // license that can be found in the LICENSE file.
     4  
     5  package query
     6  
     7  import (
     8  	"errors"
     9  	"strings"
    10  
    11  	"github.com/condensat/bank-core/database"
    12  	"github.com/condensat/bank-core/database/model"
    13  	"github.com/condensat/bank-core/database/utils"
    14  
    15  	"github.com/jinzhu/gorm"
    16  )
    17  
    18  var (
    19  	ErrInvalidAssetID   = errors.New("Invalid AssetID")
    20  	ErrInvalidAssetHash = errors.New("Invalid AssetHash")
    21  )
    22  
    23  func AddAsset(db database.Context, assetHash model.AssetHash, currencyName model.CurrencyName) (model.Asset, error) {
    24  	gdb := db.DB().(*gorm.DB)
    25  	if db == nil {
    26  		return model.Asset{}, database.ErrInvalidDatabase
    27  	}
    28  
    29  	if len(assetHash) == 0 {
    30  		return model.Asset{}, ErrInvalidAssetHash
    31  	}
    32  
    33  	if len(currencyName) == 0 {
    34  		return model.Asset{}, ErrInvalidCurrencyName
    35  	}
    36  
    37  	result := model.Asset{
    38  		Hash:         assetHash,
    39  		CurrencyName: currencyName,
    40  	}
    41  	err := gdb.Create(&result).Error
    42  	if err != nil {
    43  		return model.Asset{}, err
    44  	}
    45  
    46  	return result, nil
    47  
    48  }
    49  
    50  func AssetCount(db database.Context) (int64, error) {
    51  	gdb := db.DB().(*gorm.DB)
    52  	if db == nil {
    53  		return 0, database.ErrInvalidDatabase
    54  	}
    55  
    56  	var count int64
    57  	err := gdb.Model(&model.Asset{}).Count(&count).Error
    58  	if err != nil {
    59  		return 0, err
    60  	}
    61  
    62  	return count, nil
    63  }
    64  
    65  func GetAsset(db database.Context, assetID model.AssetID) (model.Asset, error) {
    66  	gdb := db.DB().(*gorm.DB)
    67  	if db == nil {
    68  		return model.Asset{}, database.ErrInvalidDatabase
    69  	}
    70  
    71  	if assetID == 0 {
    72  		return model.Asset{}, ErrInvalidAssetID
    73  	}
    74  
    75  	var result model.Asset
    76  	err := gdb.
    77  		Where(&model.Asset{ID: assetID}).
    78  		First(&result).Error
    79  	if err != nil {
    80  		return model.Asset{}, err
    81  	}
    82  
    83  	return result, nil
    84  }
    85  
    86  func GetAssetByHash(db database.Context, assetHash model.AssetHash) (model.Asset, error) {
    87  	gdb := db.DB().(*gorm.DB)
    88  	if db == nil {
    89  		return model.Asset{}, database.ErrInvalidDatabase
    90  	}
    91  
    92  	if len(assetHash) == 0 {
    93  		return model.Asset{}, ErrInvalidAssetHash
    94  	}
    95  
    96  	if utils.ContainEllipsis(string(assetHash)) {
    97  		assetHash = getFullAssetHash(gdb, assetHash)
    98  	}
    99  
   100  	var result model.Asset
   101  	err := gdb.
   102  		Where(&model.Asset{Hash: assetHash}).
   103  		First(&result).Error
   104  	if err != nil {
   105  		return model.Asset{}, err
   106  	}
   107  
   108  	return result, nil
   109  }
   110  
   111  func GetAssetByCurrencyName(db database.Context, currencyName model.CurrencyName) (model.Asset, error) {
   112  	gdb := db.DB().(*gorm.DB)
   113  	if db == nil {
   114  		return model.Asset{}, database.ErrInvalidDatabase
   115  	}
   116  
   117  	if len(currencyName) == 0 {
   118  		return model.Asset{}, ErrInvalidCurrencyName
   119  	}
   120  
   121  	var result model.Asset
   122  	err := gdb.
   123  		Where(&model.Asset{CurrencyName: currencyName}).
   124  		First(&result).Error
   125  	if err != nil {
   126  		return model.Asset{}, err
   127  	}
   128  
   129  	return result, nil
   130  }
   131  
   132  func AssetHashExists(db database.Context, assetHash model.AssetHash) bool {
   133  	gdb := db.DB().(*gorm.DB)
   134  	if db == nil {
   135  		return false
   136  	}
   137  
   138  	if len(assetHash) == 0 {
   139  		return false
   140  	}
   141  
   142  	var result model.Asset
   143  	err := gdb.
   144  		Where(&model.Asset{Hash: assetHash}).
   145  		First(&result).Error
   146  	if err != nil && err == gorm.ErrRecordNotFound {
   147  		return false
   148  	}
   149  
   150  	return true
   151  }
   152  
   153  func getFullAssetHash(gdb *gorm.DB, assetHash model.AssetHash) model.AssetHash {
   154  	tips := utils.SplitEllipsis(string(assetHash))
   155  	if len(tips) != 2 {
   156  		return assetHash
   157  	}
   158  
   159  	var result model.Asset
   160  	err := gdb.
   161  		Where("asset LIKE ?", strings.Join(tips, "%")).
   162  		Where(&model.Asset{Hash: assetHash}).
   163  		First(&result).Error
   164  	if err != nil {
   165  		return assetHash
   166  	}
   167  
   168  	return result.Hash
   169  }