Merge branch 'feature/cron' into 'master'

models/supported_currency.go

@@ -61,7 +61,7 @@ func GetSupportedCurrencyTotal(maps interface{}) (int, error) {
 func GetSupportedCurrencies(pageNum, pageSize int, maps interface{}) ([]*SupportedCurrency, error) {
 	var currencies []*SupportedCurrency
 
-	err := db.Preload("Currency").Where(maps).Offset(pageNum).Limit(pageSize).Find(&currencies).Error
+	err := db.Preload("Currency").Order("sort").Where(maps).Offset(pageNum).Limit(pageSize).Find(&currencies).Error
 	if err != nil && err != gorm.ErrRecordNotFound {
 		return nil, err
 	}

pkg/cron/cron.go

@@ -11,13 +11,7 @@ func Setup(){
 	c = cron.New()
 
 	c.AddFunc("* * * * * *", func() {
-		gas_service := coin_gas_service.CoinGas{}
-		gas_service.Etherscan()
-	})
-
-	c.AddFunc("* * * * * *", func() {
-		gas_service := coin_gas_service.CoinGas{}
-		gas_service.Btcscan()
+		coin_gas_service.TokenView()
 	})
 
 	c.Start()

pkg/util/util.go

@@ -100,3 +100,12 @@ func StringToMd5(str string) string {
 	md5String := hex.EncodeToString(m5.Sum(nil))
 	return md5String
 }
+
+func Contains(slice []string, val string) (int, bool) {
+	for i, item := range slice {
+		if item == val {
+			return i, true
+		}
+	}
+	return -1, false
+}

routers/api/app/fee.go

@@ -66,7 +66,7 @@ func GetTransactionGas(c *gin.Context) {
 		return
 	}
 
-	gas, err := coin_gas_service.GetCoinGas(name)
+	gas, err := coin_gas_service.GetTransactionGas(name)
 
 	if err != nil {
 		handler.SendResponse(c, errno.ErrCoinNotFound, nil)

routers/router.go

@@ -47,7 +47,7 @@ func InitRouter() *gin.Engine {
 	client.POST("/live/verify",app.VerifyStatus)
 	client.GET("/live-banners",app.GetLiveBanners)
 
-	client.GET("/coin-gas",app.GetTransactionGas)
+	client.GET("/fees/recommended",app.GetTransactionGas)
 
 	api := r.Group("/api")
 

service/coin_gas_service/coin_gas.go

 package coin_gas_service
 
 import (
+	"bwallet/pkg/errno"
 	"bwallet/pkg/gredis"
 	"bwallet/pkg/util"
 	"encoding/json"
@@ -10,24 +11,53 @@ import (
 	"strings"
 )
 
-type CoinGas struct {
-	Id       int
-	CoinName string
-	Low      float32
-	Average  float32
-	High     float32
+type Response struct {
+	Code int    `json:"code"`
+	Msg  string `json:"msg"`
+	Data []Data `json:"data"`
 }
 
-func GetCoinGas(coin string) (float32, error) {
-	gas, err := gredis.HashGet(strings.ToUpper(coin)+"_GAS", "Final", 3)
-	if err != nil {
-		return 0.0, err
+type Data struct {
+	Network  string `json:network`
+	Time     int    `json:time`
+	TxFee    string `json:txFee`
+	GasPrice string `json:gasPrice`
+}
+
+func GetTransactionGas(name string) (map[string]interface{}, error) {
+	data := make(map[string]interface{})
+	items_fee := []string{"BTC", "BCH", "LTC", "ZEC", "ZCASH", "DCR", "NEO", "TRX", "ATOM", "BTY", "ETC", "ETH"}
+
+	_, found_fee := util.Contains(items_fee, strings.ToUpper(name))
+
+	if !found_fee {
+		return nil, errno.ErrCoinNotFound
 	}
-	return util.ToFloat32(string(gas)), nil
 
+	if "ETC" == strings.ToUpper(name) {
+		fee, _ := gredis.HashGet(strings.ToUpper(name)+"_GAS", "gasPrice", 3)
+		data["name"] = strings.ToUpper(name)
+		data["low"] = util.ToFloat32(string(fee)) / 1000000000 * 21000 * 0.000000001 * 30 * (1 + 0.1)
+		data["average"] = util.ToFloat32(string(fee)) / 1000000000 * 21000 * 0.000000001 * 30 * (1 + 0.2)
+		data["high"] = util.ToFloat32(string(fee)) / 1000000000 * 21000 * 0.000000001 * 30 * (1 + 0.3)
+	} else if "ETH" == strings.ToUpper(name) {
+		fee, _ := gredis.HashGet(strings.ToUpper(name)+"_GAS", "gasPrice", 3)
+		data["name"] = strings.ToUpper(name)
+		data["low"] = util.ToFloat32(string(fee)) * 0.000000001 * (1 + 0.1)
+		data["average"] = util.ToFloat32(string(fee)) * 0.000000001 * (1 + 0.2)
+		data["high"] = util.ToFloat32(string(fee)) * 0.000000001 * (1 + 0.3)
+	} else {
+		fee, _ := gredis.HashGet(strings.ToUpper(name)+"_GAS", "txFee", 3)
+		data["name"] = strings.ToUpper(name)
+		data["low"] = util.ToFloat32(string(fee)) * (1 + 0.1)
+		data["average"] = util.ToFloat32(string(fee)) * (1 + 0.2)
+		data["high"] = util.ToFloat32(string(fee)) * (1 + 0.3)
+	}
+
+	return data, nil
 }
 
-func (a *CoinGas) Etherscan() error {
+func Etherscan() error {
 	params := make(map[string]string)
 	params["module"] = "gastracker"
 	params["action"] = "gasoracle"
@@ -66,7 +96,7 @@ func (a *CoinGas) Etherscan() error {
 	return nil
 }
 
-func (a *CoinGas) Btcscan() error {
+func Btcscan() error {
 	req, err := http.NewRequest(http.MethodGet, "https://btc.com/service/fees/recommended", nil)
 	if err != nil {
 		return err
@@ -88,8 +118,61 @@ func (a *CoinGas) Btcscan() error {
 	gredis.HashSet("BTC_GAS", "Average", btc_gas["one_block_fee"], 3)
 	gredis.HashSet("BTC_GAS", "High", btc_gas["one_block_fee"], 3)
 
-	final := util.ToFloat32(btc_gas["one_block_fee"]) * (1 + 0.1)
+	final := util.ToFloat32(btc_gas["one_block_fee"]) * (1 + 0.1) * 0.00001
 	gredis.HashSet("BTC_GAS", "Final", final, 3)
 
 	return nil
 }
+
+func TokenView() error {
+	req, err := http.NewRequest(http.MethodGet, "https://tokenview.com/api/block/latest", nil)
+	if err != nil {
+		return err
+	}
+
+	r, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return err
+	}
+	responseData, err := ioutil.ReadAll(r.Body)
+	if err != nil {
+		return err
+	}
+	var responseObject Response
+	json.Unmarshal(responseData, &responseObject)
+
+	for _, val := range responseObject.Data {
+		if "-" == val.TxFee || "-" == val.GasPrice {
+			continue
+		}
+		if "BTC" == strings.ToUpper(val.Network) {
+			gredis.HashSet("BTC_GAS", "txFee", val.TxFee, 3)
+			gredis.HashSet("BTC_GAS", "time", val.Time, 3)
+		}
+		if "BCH" == strings.ToUpper(val.Network) {
+			gredis.HashSet("BCH_GAS", "txFee", val.TxFee, 3)
+			gredis.HashSet("BCH_GAS", "time", val.Time, 3)
+		}
+		if "LTC" == strings.ToUpper(val.Network) {
+			gredis.HashSet("LTC_GAS", "txFee", val.TxFee, 3)
+			gredis.HashSet("LTC_GAS", "time", val.Time, 3)
+		}
+		if "ZCASH" == strings.ToUpper(val.Network) || "ZEC" == strings.ToUpper(val.Network) {
+			gredis.HashSet("ZEC_GAS", "txFee", val.TxFee, 3)
+			gredis.HashSet("ZEC_GAS", "time", val.Time, 3)
+		}
+		if "DCR" == strings.ToUpper(val.Network) {
+			gredis.HashSet("DCR_GAS", "txFee", val.TxFee, 3)
+			gredis.HashSet("DCR_GAS", "time", val.Time, 3)
+		}
+		if "ETC" == strings.ToUpper(val.Network) {
+			gredis.HashSet("ETC_GAS", "gasPrice", val.GasPrice, 3)
+			gredis.HashSet("ETC_GAS", "time", val.Time, 3)
+		}
+		if "ETH" == strings.ToUpper(val.Network) {
+			gredis.HashSet("ETH_GAS", "gasPrice", val.GasPrice, 3)
+			gredis.HashSet("ETH_GAS", "time", val.Time, 3)
+		}
+	}
+	return nil
+}