cns 0.9.1 → 0.9.3

data/lib/cns/bitcoinde.rb

@@ -7,11 +7,9 @@ module Cns
   # classe para processar transacoes trades/ledger do bitcoinde
   class Bitcoinde
     # @return [Apius] API bitcoinde
-    attr_reader :api
     # @return [Array<Hash>] todos os dados bigquery
-    attr_reader :bqd
     # @return [Thor::CoreExt::HashWithIndifferentAccess] opcoes trabalho
-    attr_reader :ops
+    attr_reader :api, :bqd, :ops
 
     # @param [Hash] dad todos os dados bigquery
     # @param [Thor::CoreExt::HashWithIndifferentAccess] pop opcoes trabalho
@@ -27,60 +25,55 @@ module Cns
 
     # @return [Hash] dados exchange bitcoinde - saldos & trades & deposits & withdrawals
     def exd
-      @exd ||= { sl: pdea(api.account_de), tt: pdet(api.trades_de), tl: pdel(api.deposits_de + api.withdrawals_de) }
+      @exd ||= {sl: pdea(api.account_de), tt: pdet(api.trades_de), tl: pdel(api.deposits_de + api.withdrawals_de)}
     end
 
     # @return [String] texto saldos & transacoes & ajuste dias
     def mresumo
       puts("\nBITCOINDE\ntipo              bitcoinde              bigquery")
-      exd[:sl].sort.each { |key, val| puts(formata_saldos(key, val)) }
+      exd[:sl].sort.each { |k, v| puts(fos(k, v)) }
       mtotais
 
       mtrades
       mledger
       return if novcdet.empty?
 
-      puts("\nstring ajuste dias dos trades\n-h=#{kyt.map { |obj| "#{obj}:0" }.join(' ')}")
+      puts("\nstring ajuste dias dos trades\n-h=#{novcdet.sort_by { |i| -i[:srx] }.map { |o| "#{o[:trade_id]}:0" }.join(' ')}")
     end
 
     private
 
-    def show_all?
-      ops[:t] || false
-    end
-
-    def bqkyt
-      @bqkyt ||= show_all? ? [] : (bqd[:nt]&.map { |t| t[:txid] } || [])
-    end
+    # mosta contadores transacoes
+    def mtotais
+      vtt = exd[:tt].count
+      vnt = bqd[:nt].count
+      vtl = exd[:tl].count
+      vnl = bqd[:nl].count
 
-    def bqkyl
-      @bqkyl ||= show_all? ? [] : (bqd[:nl]&.map { |l| l[:txid] } || [])
+      puts("TRADES #{format('%<a>20i %<b>21i %<o>3.3s', a: vtt, b: vnt, o: vtt == vnt ? 'OK' : 'NOK')}")
+      puts("LEDGER #{format('%<c>20i %<d>21i %<o>3.3s', c: vtl, d: vnl, o: vtl == vnl ? 'OK' : 'NOK')}")
     end
 
-    # @return [Array<String>] lista txid dos trades novos
-    def kyt
-      @kyt ||= exd[:tt].map { |oex| oex[:trade_id] } - bqkyt
-    end
+    # mosta transacoes trades
+    def mtrades
+      return unless ops[:v] && novcdet.any?
 
-    # @return [Array<Integer>] lista txid dos ledger novos
-    def kyl
-      @kyl ||= exd[:tl].map { |oex| oex[:txid] } - bqkyl
+      puts("\ntrades data       hora     dt criacao tipo  par                     btc      eur")
+      novcdet.sort_by { |i| -i[:srx] }.each { |o| puts(fot(o)) }
     end
 
-    # @return [Array<Hash>] lista trades bitcoinde novos
-    def novcdet
-      @novcdet ||= exd[:tt].select { |obj| kyt.include?(obj[:trade_id]) }
-    end
+    # mosta transacoes ledger
+    def mledger
+      return unless ops[:v] && novcdel.any?
 
-    # @return [Array<Hash>] lista ledger (deposits + withdrawals) bitcoinde novos
-    def novcdel
-      @novcdel ||= exd[:tl].select { |obj| kyl.include?(obj[:txid]) }
+      puts("\nledger data       hora     tipo       moe          quantidade              custo")
+      novcdel.sort_by { |i| -i[:srx] }.each { |o| puts(fol(o)) }
     end
 
     # @param [String] moe codigo bitcoinde da moeda
     # @param [Hash] hsx saldo bitcoinde da moeda
     # @return [String] texto formatado saldos
-    def formata_saldos(moe, hsx)
+    def fos(moe, hsx)
       vbq = bqd[:sl][moe.downcase.to_sym].to_d
       vex = hsx[:total_amount]
       format(
@@ -92,9 +85,9 @@ module Cns
       )
     end
 
-    # @param (see Bigquery#det_val1)
+    # @param [Hash] htn trades bitcoinde
     # @return [String] texto formatado trade
-    def formata_trades(htx)
+    def fot(htx)
       format(
         '%<ky>-6.6s %<dt>19.19s %<dp>10.10s %<ty>-5.5s %<mo>-8.8s %<vl>18.8f %<co>8.2f',
         ky: htx[:trade_id],
@@ -102,82 +95,96 @@ module Cns
         dp: htx[:trade_marked_as_paid_at].strftime('%F'),
         ty: htx[:type],
         mo: htx[:trading_pair],
-        vl: htx[:amount_currency_to_trade],
-        co: htx[:volume_currency_to_pay]
+        vl: htx[:btc],
+        co: htx[:eur]
       )
     end
 
-    # @param (see Bigquery#del_val)
+    # @param [Hash] htn ledger bitcoinde
     # @return [String] texto formatado ledger
-    def formata_ledger(hlx)
+    def fol(hlx)
       format(
         '%<ky>6i %<dt>19.19s %<ty>-10.10s %<mo>-3.3s %<pr>19.8f %<vl>18.8f',
         ky: hlx[:txid],
         dt: hlx[:time].strftime('%F %T'),
         ty: hlx[:tp],
         mo: hlx[:moe],
-        pr: hlx[:qt],
+        pr: hlx[:qtd],
         vl: hlx[:fee]
       )
     end
 
-    # @return [String] texto numero de transacoes
-    def mtotais
-      vtt = exd[:tt].count
-      vnt = bqd[:nt].count
-      vtl = exd[:tl].count
-      vnl = bqd[:nl].count
-
-      puts("TRADES #{format('%<a>20i %<b>21i %<o>3.3s', a: vtt, b: vnt, o: vtt == vnt ? 'OK' : 'NOK')}")
-      puts("LEDGER #{format('%<c>20i %<d>21i %<o>3.3s', c: vtl, d: vnl, o: vtl == vnl ? 'OK' : 'NOK')}")
-    end
-
-    # @return [String] texto transacoes trades
-    def mtrades
-      return unless ops[:v] && novcdet.any?
-
-      puts("\ntrades data       hora     dt criacao tipo  par                     qtd      eur")
-      novcdet.sort_by { |i| -i[:srx] }.each { |o| puts(formata_trades(o)) }
-    end
-
-    # @return [String] texto transacoes ledger
-    def mledger
-      return unless ops[:v] && novcdel.any?
-
-      puts("\nledger data       hora     tipo       moe          quantidade              custo")
-      novcdel.sort_by { |i| -i[:srx] }.each { |o| puts(formata_ledger(o)) }
+    def show_all?
+      ops[:t] || false
     end
 
-    # Processa os trades para garantir que as datas estejam no formato correto
+    # @param [Hash] itm recursos bitcoinde
+    # @return [Hash<BigDecimal>] moedas & sados
     def pdea(itm)
       itm.select { |k, _| EM.include?(k) }.transform_values { |o| o.merge(total_amount: o[:total_amount].to_d) }
     end
 
-    # Processa time field somtimes is string
-    def ptm(itm)
-      itm.is_a?(String) ? Time.parse(itm) : itm
+    # @param [Object] val time bitcoinde
+    # @return [Time] processa time (somtimes is string)
+    def ptm(val)
+      val.is_a?(String) ? Time.parse(val) : val
     end
 
+    # @param [Hash] itm transacao bitcoinde
+    # @return [Hash] transaccao filtrada
     def pdes(key, itm)
       tym = ptm(itm[key])
       itm.merge(srx: Integer(tym), key => tym)
     end
 
-    # Processa os trades para garantir que as datas estejam no formato correto
-    def pdet(itm)
-      itm.map do |t|
+    # @param [Array<Hash>] htx trade bitcoinde
+    # @return [Array<Hash>] transaccao filtrada
+    def pdet(htx)
+      htx.map do |t|
         pdes(:successfully_finished_at, t).merge(
           trade_marked_as_paid_at: ptm(t[:trade_marked_as_paid_at]),
-          amount_currency_to_trade: t[:amount_currency_to_trade].to_d,
-          volume_currency_to_pay: t[:volume_currency_to_pay].to_d,
+          username: t[:trading_partner_information][:username],
+          btc: t[:type] == 'buy' ? t[:amount_currency_to_trade_after_fee].to_d : -1 * t[:amount_currency_to_trade].to_d,
+          eur: t[:volume_currency_to_pay_after_fee].to_d,
           trading_pair: t[:trading_pair].upcase
         )
       end
     end
 
-    # Processa os ledger entries para garantir que as datas estejam no formato correto
-    def pdel(itm)
-      itm.map { |t| pdes(:time, t).merge(qt: t[:qt].to_d, fee: t[:fee].to_d, moe: t[:moe].upcase) }
+    # @param [Array<Hash>] hlx ledger bitcoinde
+    # @return [Array<Hash>] transaccao filtrada
+    def pdel(hlx)
+      hlx.map { |t| pdes(:time, t).merge(qtd: (t[:tp] == 'withdrawal' ? -1 : 1) * t[:qt].to_d, nxid: t[:txid], fee: t[:fee].to_d, moe: t[:moe].upcase) }
+    end
+
+    # @return [Array<String>] indices trades bigquery
+    def bqkyt
+      @bqkyt ||= show_all? ? [] : (bqd[:nt]&.map { |t| t[:txid] } || [])
+    end
+
+    # @return [Array<Integer>] indices ledger bigquery
+    def bqkyl
+      @bqkyl ||= show_all? ? [] : (bqd[:nl]&.map { |l| l[:txid] } || [])
+    end
+
+    # @return [Array<String>] lista txid trades novos
+    def kyt
+      @kyt ||= exd[:tt].map { |t| t[:trade_id] } - bqkyt
+    end
+
+    # @return [Array<Integer>] lista txid ledger novos
+    def kyl
+      @kyl ||= exd[:tl].map { |t| t[:txid] } - bqkyl
+    end
+
+    # @return [Array<Hash>] lista trades bitcoinde novos
+    def novcdet
+      @novcdet ||= exd[:tt].select { |obj| kyt.include?(obj[:trade_id]) }
+    end
+
+    # @return [Array<Hash>] lista ledger (deposits + withdrawals) bitcoinde novos
+    def novcdel
+      @novcdel ||= exd[:tl].select { |obj| kyl.include?(obj[:txid]) }
     end
   end
 end