cex 0.1.5 → 0.1.7

data/lib/cex/bigquery2.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+# @author Hernani Rodrigues Vaz
+module Cex
+  # (see Bigquery)
+  class Bigquery
+    # @return [String] comando insert SQL formatado ust (trades)
+    def ust_ins
+      "insert #{BD}.ust(txid,ordertxid,pair,time,type,ordertype,price,cost,fee,vol,margin,misc,ledgers,dias) " \
+      "VALUES#{apius.trades.map { |k, v| ust_val1(k, v) }.join(',')}"
+    end
+
+    # @return [String] comando insert SQL formatado usl (ledger)
+    def usl_ins
+      "insert #{BD}.usl(txid,refid,time,type,aclass,asset,amount,fee) " \
+      "VALUES#{apius.ledger.map { |k, v| usl_val(k, v) }.join(',')}"
+    end
+
+    # @return [String] comando insert SQL formatado det (trades)
+    def det_ins
+      "insert #{BD}.det(tp,btc,eur,time,user,id,dtc,dias) VALUES#{apide.trades.map { |h| det_val1(h) }.join(',')}"
+    end
+
+    # @return [String] comando insert SQL formatado del (ledger)
+    def del_ins
+      "insert #{BD}.del(time,tp,qtxt,id,qt,fee,lgid) VALUES#{apide.ledger.map { |h| del_val(h) }.join(',')}"
+    end
+
+    # @return [String] comando insert SQL formatado fr (ledger)
+    def frl_ins
+      "insert #{BD}.fr(uuid,tipo,valor,moe,time,dias) VALUES#{apifr.ledger.map { |h| frl_val(h) }.join(',')}"
+    end
+
+    # @return [String] comando insert SQL formatado fr (ledger)
+    def mtl_ins
+      "insert #{BD}.mt(id,time,type,valor,moe,pair,note,trade_id,dias) " \
+      "VALUES#{apimt.ledger.map { |h| mtl_val1(h) }.join(',')}"
+    end
+
+    # @example (see Apide#trades)
+    # @param [Hash] htx transacao trade apide
+    # @return [String] valores formatados det (trades parte1)
+    def det_val1(htx)
+      "('#{htx[:type]}'," \
+      'cast(' \
+      "#{htx[:type] == 'buy' ? htx[:amount_currency_to_trade_after_fee] : "-#{htx[:amount_currency_to_trade]}"}" \
+      ' as numeric),' \
+      "cast(#{htx[:volume_currency_to_pay_after_fee]} as numeric)," \
+      "DATETIME(TIMESTAMP('#{htx[:successfully_finished_at]}'))," \
+      "'#{htx[:trading_partner_information][:username]}'," \
+      "#{det_val2(htx)}"
+    end
+
+    # @param (see #det_val1)
+    # @return [String] valores formatados det (trades parte2)
+    def det_val2(htx)
+      "'#{htx[:trade_id]}'," \
+        "DATETIME(TIMESTAMP('#{htx[:trade_marked_as_paid_at]}'))," \
+      "#{Integer(ops[:h][htx[:trade_id]] || 0)})"
+    end
+
+    # @example (see Apius#trades)
+    # @param [String] idx identificador transacao
+    # @param [Hash] htx transacao trade apius
+    # @return [String] valores formatados ust (trades parte1)
+    def ust_val1(idx, htx)
+      "('#{idx}'," \
+      "'#{htx[:ordertxid]}'," \
+      "'#{htx[:pair]}'," \
+      "PARSE_DATETIME('%s', '#{String(htx[:time].round)}')," \
+      "'#{htx[:type]}'," \
+      "'#{htx[:ordertype]}'," \
+      "cast(#{htx[:price]} as numeric)," \
+      "cast(#{htx[:cost]} as numeric)," \
+      "cast(#{htx[:fee]} as numeric)," \
+      "#{ust_val2(idx, htx)}"
+    end
+
+    # @param (see #ust_val1)
+    # @return [String] valores formatados ust (trades parte2)
+    def ust_val2(idx, htx)
+      "cast(#{htx[:vol]} as numeric)," \
+      "cast(#{htx[:margin]} as numeric)," \
+      "#{htx[:misc].to_s.empty? ? 'null' : "'#{htx[:misc]}'"}," \
+      "'#{apius.ledger.select { |_, v| v[:refid] == idx }.keys.join(',') || ''}'," \
+      "#{Integer(ops[:h][idx] || 0)})"
+    end
+
+    # @example (see Apide#deposit_hash)
+    # @example (see Apide#withdrawal_hash)
+    # @param [Hash] hlx transacao uniformizada deposits + withdrawals apide
+    # @return [String] valores formatados del (ledger)
+    def del_val(hlx)
+      "(DATETIME(TIMESTAMP('#{hlx[:time].iso8601}'))," \
+      "'#{hlx[:tp]}'," \
+      "'#{hlx[:qtxt]}'," \
+      "'#{hlx[:id]}'," \
+      "cast(#{hlx[:tp] == 'out' ? '-' : ''}#{hlx[:qt]} as numeric)," \
+      "cast(#{hlx[:fee]} as numeric)," \
+      "#{hlx[:lgid]})"
+    end
+
+    # @example (see Apius#ledger)
+    # @param idx (see #ust_val1)
+    # @param [Hash] hlx transacao ledger apius
+    # @return [String] valores formatados usl (ledger)
+    def usl_val(idx, hlx)
+      "('#{idx}'," \
+      "'#{hlx[:refid]}'," \
+      "PARSE_DATETIME('%s', '#{String(hlx[:time].round)}')," \
+      "'#{hlx[:type]}'," \
+      "#{hlx[:aclass].to_s.empty? ? 'null' : "'#{hlx[:aclass]}'"}," \
+      "'#{hlx[:asset]}'," \
+      "cast(#{hlx[:amount]} as numeric)," \
+      "cast(#{hlx[:fee]} as numeric))"
+    end
+
+    # @example (see Apifr#ledger)
+    # @param [Hash] hlx transacao ledger apifr
+    # @return [String] valores formatados frl (ledger)
+    def frl_val(hlx)
+      "('#{hlx[:uuid]}'," \
+      "'#{hlx[:name]}'," \
+      "cast(#{hlx[:amount]} as numeric)," \
+      "'#{hlx[:currency]}'," \
+      "PARSE_DATETIME('%s', '#{hlx[:created_at_int]}')," \
+      "#{Integer(ops[:h][hlx[:uuid]] || 0)})"
+    end
+
+    # @example (see Apimt#ledger)
+    # @param [Hash] hlx transacao ledger apimt
+    # @return [String] valores formatados mtl (ledger parte1)
+    def mtl_val1(hlx)
+      "(#{hlx[:id]}," \
+      "DATETIME(TIMESTAMP('#{hlx[:date]}'))," \
+      "'#{hlx[:type]}'," \
+      "cast(#{hlx[:price]} as numeric)," \
+      "'#{hlx[:currency]}'," \
+      "#{hlx[:fund_id].to_s.empty? ? 'null' : "'#{hlx[:fund_id]}'"}," \
+      "#{mtl_val2(hlx)}"
+    end
+
+    # @param hlx (see #mtl_val1)
+    # @return [String] valores formatados mtl (ledger parte2)
+    def mtl_val2(hlx)
+      "#{hlx[:note].to_s.empty? ? 'null' : "'#{hlx[:note]}'"}," \
+      "#{hlx[:trade_id].to_s.empty? ? 'null' : (hlx[:trade_id]).to_s}," \
+      "#{Integer(ops[:h][String(hlx[:id])] || 0)})"
+    end
+  end
+end

data/lib/cex/bitcoinde.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require('bigdecimal/util')
+
+# @author Hernani Rodrigues Vaz
+module Cex
+  # classe para processar saldos & transacoes trades e ledger do bitcoinde
+  class Bitcoinde
+    # @return [Apius] API bitcoinde
+    attr_reader :api
+    # @return [Array<Hash>] todos os dados bigquery
+    attr_reader :dbq
+    # @return [Thor::CoreExt::HashWithIndifferentAccess] opcoes trabalho
+    attr_reader :ops
+
+    # @param [Hash] dad todos os dados bigquery
+    # @param [Thor::CoreExt::HashWithIndifferentAccess] pop opcoes trabalho
+    # @option pop [Hash] :h ({}) configuracao dias ajuste reposicionamento temporal
+    # @option pop [Boolean] :v (false) mostra dados transacoes trades & ledger?
+    # @option pop [Boolean] :t (false) mostra transacoes todas ou somente novas?
+    # @return [Bitcoinde] API bitcoinde - obter saldos & transacoes trades e ledger
+    def initialize(dad, pop)
+      # API bitcoinde base
+      @api = Apide.new
+      @dbq = dad
+      @ops = pop
+    end
+
+    # @return [Hash] dados exchange bitcoinde - saldos & transacoes trades e ledger
+    def exd
+      @exd ||= {
+        sl: api.account,
+        tt: api.trades,
+        tl: api.deposits + api.withdrawals
+      }
+    end
+
+    # @return [Array<String>] lista txid de transacoes trades
+    def kyt
+      @kyt ||= exd[:tt].map { |h| h[:trade_id] }.flatten - (ops[:t] ? [] : dbq[:nt].map { |e| e[:txid] })
+    end
+
+    # @return [Array<Integer>] lista txid de transacoes ledger
+    def kyl
+      @kyl ||= exd[:tl].map { |h| h[:lgid] }.flatten - (ops[:t] ? [] : dbq[:nl].map { |e| e[:txid] })
+    end
+
+    # @return [Hash] transacoes trades
+    def trades
+      @trades ||= exd[:tt].select { |h| kyt.include?(h[:trade_id]) }
+    end
+
+    # @return [Hash] transacoes ledger
+    def ledger
+      @ledger ||= exd[:tl].select { |h| kyl.include?(h[:lgid]) }
+    end
+
+    # @example (see Apide#account)
+    # @param [String] moe codigo bitcoinde da moeda
+    # @param [Hash] hsx saldo bitcoinde da moeda
+    # @return [String] texto formatado saldos (bitcoinde)
+    def formata_saldos(moe, hsx)
+      b = dbq[:sl][moe.downcase.to_sym].to_d
+      e = hsx[:total_amount].to_d
+      format(
+        '%<mo>-5.5s %<ex>21.9f %<bq>21.9f %<ok>3.3s',
+        mo: moe.upcase,
+        ex: e,
+        bq: b,
+        ok: e == b ? 'OK' : 'NOK'
+      )
+    end
+
+    # @example (see Apide#trades)
+    # @param (see Bigquery#det_val1)
+    # @return [String] texto formatado transacao trade
+    def formata_trades(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],
+        dt: Time.parse(htx[:successfully_finished_at]),
+        dp: Time.parse(htx[:trade_marked_as_paid_at]),
+        ty: htx[:type],
+        mo: htx[:trading_pair].upcase,
+        vl: htx[:amount_currency_to_trade].to_d,
+        co: htx[:volume_currency_to_pay].to_d
+      )
+    end
+
+    # @example (see Apide#deposit_hash)
+    # @example (see Apide#withdrawal_hash)
+    # @param (see Bigquery#del_val)
+    # @return [String] texto formatado transacao ledger
+    def formata_ledger(hlx)
+      format(
+        '%<ky>6i %<dt>19.19s %<ty>-10.10s %<mo>-3.3s %<pr>19.8f %<vl>18.8f',
+        ky: hlx[:lgid],
+        dt: hlx[:time],
+        ty: hlx[:tp],
+        mo: hlx[:qtxt].upcase,
+        pr: hlx[:qt].to_d,
+        vl: hlx[:fee].to_d
+      )
+    end
+
+    # @return [String] texto saldos & transacoes & ajuste dias
+    def mostra_resumo
+      puts("\nBITCOINDE\nmoeda       saldo bitcoinde        saldo bigquery")
+      exd[:sl].each { |k, v| puts(formata_saldos(k, v)) }
+
+      mostra_trades
+      mostra_ledger
+      return unless trades.count.positive?
+
+      puts("\nstring ajuste dias dos trades\n-h=#{kyt.map { |e| "#{e}:0" }.join(' ')}")
+    end
+
+    # @return [String] texto transacoes trades
+    def mostra_trades
+      return unless ops[:v] && trades.count.positive?
+
+      puts("\ntrades data       hora     dt criacao tipo  par      ---------------qtd -----eur")
+      trades.sort { |a, b| Time.parse(b[:successfully_finished_at]) <=> Time.parse(a[:successfully_finished_at]) }
+            .each { |h| puts(formata_trades(h)) }
+    end
+
+    # @return [String] texto transacoes ledger
+    def mostra_ledger
+      return unless ops[:v] && ledger.count.positive?
+
+      puts("\nledger data       hora     tipo       moe ---------quantidade -------------custo")
+      ledger.sort { |a, b| b[:time] <=> a[:time] }.each { |h| puts(formata_ledger(h)) }
+    end
+  end
+end

data/lib/cex/kraken.rb

@@ -6,7 +6,7 @@ require('bigdecimal/util')
 module Cex
   # classe para processar saldos & transacoes trades e ledger
   class Kraken
-    # @return [Client] API kraken
+    # @return [Apius] API kraken
     attr_reader :api
     # @return [Array<Hash>] todos os dados bigquery
     attr_reader :dbq
@@ -21,89 +21,90 @@ module Cex
     # @return [Kraken] API kraken - obter saldos & transacoes trades e ledger
     def initialize(dad, pop)
       # API kraken base
-      @api = Client.new
+      @api = Apius.new
       @dbq = dad
       @ops = pop
     end
 
-    # @return [Hash] dados kraken - saldos & transacoes trades e ledger
-    def dkr
-      @dkr ||= {
-        sl: api.balance,
-        kt: api.trades_history,
+    # @return [Hash] dados exchange kraken - saldos & transacoes trades e ledger
+    def exd
+      @exd ||= {
+        sl: api.account,
+        kt: api.trades,
         kl: api.ledger
       }
     end
 
     # @return [Array<String>] lista txid de transacoes trades
     def kyt
-      @kyt ||= dkr[:kt]['trades'].keys - (ops[:t] ? [] : dbq[:nt].map { |e| e[:txid] })
+      @kyt ||= exd[:kt].keys - (ops[:t] ? [] : dbq[:nt].map { |e| e[:txid].to_sym })
     end
 
     # @return [Array<String>] lista txid de transacoes ledger
     def kyl
-      @kyl ||= dkr[:kl]['ledger'].keys - (ops[:t] ? [] : dbq[:nl].map { |e| e[:txid] })
+      @kyl ||= exd[:kl].keys - (ops[:t] ? [] : dbq[:nl].map { |e| e[:txid].to_sym })
     end
 
     # @return [Hash] transacoes trades
     def trades
-      @trades ||= dkr[:kt]['trades'].select { |k, _| kyt.include?(k) }
+      @trades ||= exd[:kt].select { |k, _| kyt.include?(k) }
     end
 
     # @return [Hash] transacoes ledger
     def ledger
-      @ledger ||= dkr[:kl]['ledger'].select { |k, _| kyl.include?(k) }
+      @ledger ||= exd[:kl].select { |k, _| kyl.include?(k) }
     end
 
-    # @parm [String] moe codigo kraken da moeda
-    # @parm [String] moe saldo kraken da moeda
+    # @example (see Apius#account)
+    # @param [String] moe codigo kraken da moeda
+    # @param [BigDecimal] sal saldo kraken da moeda
     # @return [String] texto formatado saldos (kraken/bigquery) & iguais/ok/nok?
     def formata_saldos(moe, sal)
       t = dbq[:sl][moe.downcase.to_sym].to_d
       format(
         '%<mo>-5.5s %<kr>21.9f %<bq>21.9f %<ok>3.3s',
-        mo: moe,
+        mo: moe.upcase,
         kr: sal,
         bq: t,
         ok: t == sal ? 'OK' : 'NOK'
       )
     end
 
-    # @parm [String] idx codigo transacao
-    # @parm [Hash] htx transacao trade
+    # @example (see Apius#trades)
+    # @param (see Bigquery#ust_val1)
     # @return [String] texto formatado transacao trade
-    def formata_transacao_trades(idx, htx)
+    def formata_trades(idx, htx)
       format(
         '%<ky>-6.6s %<dt>19.19s %<ty>-10.10s %<mo>-8.8s %<pr>8.2f %<vl>15.7f %<co>8.2f',
         ky: idx,
-        dt: Time.at(htx['time']),
-        ty: "#{htx['type']}/#{htx['ordertype']}",
-        mo: htx['pair'],
-        pr: htx['price'].to_d,
-        vl: htx['vol'].to_d,
-        co: htx['cost'].to_d
+        dt: Time.at(htx[:time]),
+        ty: "#{htx[:type]}/#{htx[:ordertype]}",
+        mo: htx[:pair].upcase,
+        pr: htx[:price].to_d,
+        vl: htx[:vol].to_d,
+        co: htx[:cost].to_d
       )
     end
 
-    # @parm idx (see formata_transacao_trades)
-    # @parm [Hash] hlx transacao ledger
+    # @example (see Apius#ledger)
+    # @param (see Bigquery#usl_val)
     # @return [String] texto formatado transacao ledger
-    def formata_transacao_ledger(idx, hlx)
+    def formata_ledger(idx, hlx)
       format(
         '%<ky>-6.6s %<dt>19.19s %<ty>-10.10s %<mo>-4.4s %<pr>18.7f %<vl>18.7f',
         ky: idx,
-        dt: Time.at(hlx['time']),
-        ty: hlx['type'],
-        mo: hlx['asset'],
-        pr: hlx['amount'].to_d,
-        vl: hlx['fee'].to_d
+        dt: Time.at(hlx[:time]),
+        ty: hlx[:type],
+        mo: hlx[:asset].upcase,
+        pr: hlx[:amount].to_d,
+        vl: hlx[:fee].to_d
       )
     end
 
     # @return [String] texto saldos & transacoes & ajuste dias
     def mostra_resumo
-      puts("\nmoeda          saldo kraken        saldo bigquery")
-      dkr[:sl].each { |k, v| puts(formata_saldos(k, v.to_d)) }
+      puts("\nKRAKEN\nmoeda          saldo kraken        saldo bigquery")
+      exd[:sl].each { |k, v| puts(formata_saldos(k, v.to_d)) }
 
       mostra_trades
       mostra_ledger
@@ -117,7 +118,7 @@ module Cex
       return unless ops[:v] && trades.count.positive?
 
       puts("\ntrade  data       hora     tipo       par      ---preco ---------volume ---custo")
-      trades.each { |k, v| puts(formata_transacao_trades(k, v)) }
+      trades.sort { |a, b| b[1][:time] <=> a[1][:time] }.each { |k, v| puts(formata_trades(k, v)) }
     end
 
     # @return [String] texto transacoes ledger
@@ -125,7 +126,7 @@ module Cex
       return unless ops[:v] && ledger.count.positive?
 
       puts("\nledger data       hora     tipo       moeda -------quantidade -------------custo")
-      ledger.each { |k, v| puts(formata_transacao_ledger(k, v)) }
+      ledger.sort { |a, b| b[1][:time] <=> a[1][:time] }.each { |k, v| puts(formata_ledger(k, v)) }
     end
   end
 end

data/lib/cex/paymium.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require('bigdecimal/util')
+
+# @author Hernani Rodrigues Vaz
+module Cex
+  # classe para processar saldos & transacoes ledger
+  class Paymium
+    # @return [Apius] API paymium
+    attr_reader :api
+    # @return [Array<Hash>] todos os dados bigquery
+    attr_reader :dbq
+    # @return [Thor::CoreExt::HashWithIndifferentAccess] opcoes trabalho
+    attr_reader :ops
+
+    # @param [Hash] dad todos os dados bigquery
+    # @param [Thor::CoreExt::HashWithIndifferentAccess] pop opcoes trabalho
+    # @option pop [Hash] :h ({}) configuracao dias ajuste reposicionamento temporal
+    # @option pop [Boolean] :v (false) mostra dados transacoes trades & ledger?
+    # @option pop [Boolean] :t (false) mostra transacoes todas ou somente novas?
+    # @return [Paymium] API paymium - obter saldos & transacoes ledger
+    def initialize(dad, pop)
+      # API paymium base
+      @api = Apifr.new
+      @dbq = dad
+      @ops = pop
+    end
+
+    # @return [Hash] dados exchange paymium - saldos & transacoes ledger
+    def exd
+      @exd ||= {
+        sl: api.account,
+        kl: api.ledger
+      }
+    end
+
+    # @return [Array<String>] lista txid de transacoes ledger
+    def kyl
+      @kyl ||= exd[:kl].map { |h| h[:account_operations].map { |o| o[:uuid] } }.flatten -
+               (ops[:t] ? [] : dbq[:nl].map { |e| e[:txid] })
+    end
+
+    # @return [Hash] transacoes ledger
+    def ledger
+      @ledger ||= exd[:kl].map { |h| h[:account_operations].select { |o| kyl.include?(o[:uuid]) } }.flatten
+    end
+
+    # @example (see Apifr#account)
+    # @param [Symbol] bqm symbol paymium da moeda
+    # @return [String] texto formatado saldos (paymium/bigquery) & iguais/ok/nok?
+    def formata_saldos(bqm)
+      b = dbq[:sl][bqm].to_d
+      t = exd[:sl]["balance_#{bqm}".to_sym].to_d
+      format(
+        '%<mo>-5.5s %<kr>21.9f %<bq>21.9f %<ok>3.3s',
+        mo: bqm.upcase,
+        kr: t,
+        bq: b,
+        ok: t == b ? 'OK' : 'NOK'
+      )
+    end
+
+    # @example (see Apifr#ledger)
+    # @param (see Bigquery#frl_val)
+    # @return [String] texto formatado transacao ledger
+    def formata_ledger(hlx)
+      format(
+        '%<ky>-18.18s %<dt>19.19s %<ty>-17.17s %<mo>-4.4s %<vl>18.7f',
+        ky: formata_uuid(hlx[:uuid], 18),
+        dt: Time.at(hlx[:created_at_int]),
+        ty: hlx[:name],
+        mo: hlx[:currency].upcase,
+        vl: hlx[:amount].to_d
+      )
+    end
+
+    # @example (see Apifr#ledger)
+    # @param [String] uid identificacor da ledger apifr
+    # @param [Integer] max chars a mostrar
+    # @return [String] texto formatado identificacor da ledger apifr
+    def formata_uuid(uid, max)
+      i = Integer(max / 2)
+      max < 7 ? 'erro' : "#{uid[0, i]}#{uid[-i..]}"
+    end
+
+    # @return [String] texto saldos & transacoes & ajuste dias
+    def mostra_resumo
+      puts("\nPAYMIUM\nmoeda         saldo paymium        saldo bigquery")
+      puts(formata_saldos(:btc))
+      puts(formata_saldos(:eur))
+
+      mostra_ledger
+      return unless ledger.count.positive?
+
+      puts("\nstring ajuste dias da ledger\n-h=#{kyl.map { |e| "#{e}:0" }.join(' ')}")
+    end
+
+    # @return [String] texto transacoes ledger
+    def mostra_ledger
+      return unless ops[:v] && ledger.count.positive?
+
+      puts("\nledger             data       hora     tipo              moeda -------quantidade")
+      ledger.sort { |a, b| b[:created_at_int] <=> a[:created_at_int] }.each { |o| puts(formata_ledger(o)) }
+    end
+  end
+end