Set newStatus to enabled if no result are returned from credentials test.

[perso/Immae/Projets/Cryptomonnaies/Cryptoportfolio/Front.git] / markets / poloniex.go

diff --git a/markets/poloniex.go b/markets/poloniex.go
index 34ebb7eaf5e296bd9d550118d18428b18ccd4155..595d5a4890ac73001f37c2a20f9cf4ba5abe18eb 100644 (file)
--- a/markets/poloniex.go
+++ b/markets/poloniex.go
@@ -16,11 +16,13 @@ var (
        IPRestricted                          = utils.InitFlag(&ErrorFlagCounter, "IPRestricted")
 )
 
+const defaultTimeout = 10
+
 func poloniexInvalidCredentialsError(err error) bool {
        if err == nil {
                return false
        }
-       return strings.Contains(err.Error(), "Invalid API key/secret pair")
+       return strings.Contains(err.Error(), "Invalid API key/secret pair") || strings.Contains(err.Error(), "Set the API KEY and API SECRET")
 }
 
 func poloniexRestrictedIPError(err error) bool {
@@ -43,7 +45,7 @@ type Poloniex struct {
 }
 
 func NewPoloniex() *Poloniex {
-       client, _ := poloniex.NewClient("", "")
+       client, _ := poloniex.NewClient("", "", defaultTimeout)
 
        return &Poloniex{
                TickerCache:      make(map[string]CurrencyPair),
@@ -52,40 +54,91 @@ func NewPoloniex() *Poloniex {
        }
 }
 
-func (p *Poloniex) GetBalance(apiKey, apiSecret string) (map[string]decimal.Decimal, error) {
-       client, _ := poloniex.NewClient(apiKey, apiSecret)
+func (p *Poloniex) TestCredentials(apiKey, apiSecret string, timeout int32) error {
+       client, _ := poloniex.NewClient(apiKey, apiSecret, timeout)
+
+       _, err := client.TradeReturnDepositAdresses()
+
+       if poloniexInvalidCredentialsError(err) {
+               return utils.Error{InvalidCredentials, "invalid poloniex credentials"}
+       }
+
+       if poloniexRestrictedIPError(err) {
+               return utils.Error{IPRestricted, "IP restricted api key"}
+       }
+
+       return err
+}
+
+func (p *Poloniex) GetBalance(apiKey, apiSecret string, timeout int32) (Summary, error) {
+       client, _ := poloniex.NewClient(apiKey, apiSecret, timeout)
+       var summary Summary
 
        accounts, err := client.TradeReturnAvailableAccountBalances()
        if poloniexInvalidCredentialsError(err) {
-               return nil, utils.Error{InvalidCredentials, "invalid poloniex credentials"}
+               return Summary{}, utils.Error{InvalidCredentials, "invalid poloniex credentials"}
+       }
+
+       if poloniexRestrictedIPError(err) {
+               return Summary{}, utils.Error{IPRestricted, "IP restricted api key"}
        }
 
        if err != nil {
-               return nil, err
+               return Summary{}, err
        }
 
-       balances := make(map[string]decimal.Decimal)
-       for currency, balance := range accounts.Margin {
-               balances[currency] = balances[currency].Add(balance)
+       positions, err := client.TradeGetMarginPosition()
+       if err != nil {
+               return Summary{}, err
        }
 
-       for currency, balance := range accounts.Exchange {
-               balances[currency] = balances[currency].Add(balance)
+       marginAccount, err := client.TradeReturnMarginAccountSummary()
+       if err != nil {
+               return Summary{}, err
+       }
+
+       summary.Balances = make(map[string]Balance)
+       for currency, amount := range accounts.Exchange {
+               balance := summary.Balances[currency]
+               balance.Amount = balance.Amount.Add(amount)
+
+               summary.Balances[currency] = balance
+       }
+
+       summary.BTCValue, err = p.ComputeAccountBalanceValue(summary.Balances)
+       if err != nil {
+               return Summary{}, err
+       }
+
+       for currencyPair, position := range positions {
+               if position.Type == "none" {
+                       continue
+               }
+               currency := currencyPair[4:]
+               balance := summary.Balances[currency]
+               balance.Amount = balance.Amount.Add(position.Amount)
+               balance.BTCValue = balance.BTCValue.Add(position.Total.Add(position.PlusValue))
+
+               summary.Balances[currency] = balance
        }
 
-       return balances, nil
+       summary.BTCValue = summary.BTCValue.Add(marginAccount.NetValue)
+
+       return summary, nil
 }
 
-func (p *Poloniex) ComputeAccountBalanceValue(account map[string]decimal.Decimal, baseCurrency string) (decimal.Decimal, error) {
+func (p *Poloniex) ComputeAccountBalanceValue(account map[string]Balance) (decimal.Decimal, error) {
        var total decimal.Decimal
 
-       for currency, amount := range account {
-               pair, err := p.GetCurrencyPair(baseCurrency, currency)
+       for currency, balance := range account {
+               pair, err := p.GetCurrencyPair("BTC", currency)
                if err != nil {
                        return decimal.Zero, err
                }
 
-               total = total.Add(amount.Mul(pair.Rate))
+               total = total.Add(balance.Amount.Mul(pair.Rate))
+               balance.BTCValue = balance.BTCValue.Add(balance.Amount.Mul(pair.Rate))
+               account[currency] = balance
        }
 
        return total, nil