abank 0.2.9 → 0.3.4

data/lib/abank/big.rb

@@ -1,135 +0,0 @@
-# frozen_string_literal: true
-
-require('google/cloud/bigquery')
-
-module Abank
-  # @see Big
-  class Big
-    DF = '%Y-%m-%d'
-
-    # @return [Hash] opcoes trabalho
-    attr_reader :opcao
-
-    # @return [Google::Cloud::Bigquery] API bigquery
-    attr_reader :bqapi
-
-    # @return [Google::Cloud::Bigquery::QueryJob] job bigquery
-    attr_reader :bqjob
-
-    # @return [Google::Cloud::Bigquery::Data] resultado do select
-    attr_reader :bqres
-
-    # @return [Integer] numero linhas afetadas pela Data Manipulation Language (DML)
-    attr_reader :bqnrs
-
-    # @return [String] movimentos a inserir (values.mv)
-    attr_reader :mvvls
-
-    # @return [String] movimentos a apagar (keysin.mv)
-    attr_reader :mvkys
-
-    # acesso a base dados abank no bigquery
-    #
-    # @param [Hash] opc opcoes trabalho
-    # @option opc [String]  :k ('') movimentos a apagar (keysin.mv)
-    # @option opc [String]  :c ('') id contrato arrendamento (re)
-    # @option opc [String]  :d ('') data inicio contrato arrendamento (re)
-    # @option opc [Boolean] :t (false) trabalha todas as rendas? (re)
-    # @return [Hash] opcoes trabalho
-    def initialize(opc = {})
-      @opcao = opc
-      @bqapi = Google::Cloud::Bigquery.new
-      @mvvls = ''
-      @mvkys = opc.fetch(:k, '')
-      @ctide = opc.fetch(:c, '')
-      opcao
-    end
-
-    # (see CLI#tag)
-    def mv_classifica
-      dml("update #{BD}.mv set mv.ct=tt.nct from (select * from #{BD}.cl) as tt where #{ky_mv}=tt.ky")
-      puts("MOVIMENTOS CLASSIFICADOS #{bqnrs}")
-    end
-
-    # apaga movimentos & suas rendas associadas no bigquery
-    #
-    # @return [Big] acesso a base dados abank no bigquery
-    def mv_delete
-      vars_mv_work
-      if mvkys.size.positive?
-        # obtem lista contratos arrendamento associados aos movimentos a apagar
-        @ctlct = sql("select ct from #{BD}.mv where #{ky_mv} in(#{mvkys}) and substr(ct,1,1)='r' group by 1")
-
-        # apaga rendas associadas e depois movimentos
-        @opcao[:t] = true
-        lr_apaga.mv_delete_dml
-
-        # para obrigar re_work a trabalhar com lista contratos (ctlct)
-        @bqnrs = 0
-      else
-      end
-      self
-    end
-
-    # insere & classifica movimentos no bigquery
-    #
-    # @return [Big] acesso a base dados abank no bigquery
-    def mv_insert
-      if mvvls.size.positive?
-        dml("insert #{BD}.mv VALUES#{mvvls}")
-        puts("MOVIMENTOS INSERIDOS #{bqnrs}")
-        mv_classifica if bqnrs.positive?
-      else
-      end
-      self
-    end
-
-    # inicializa variaveis para delete/insert movimentos
-    def vars_mv_work
-      @bqnrs = 0
-      @ctlct = []
-      @mvkys = mvkys[1..] if mvkys[0] == ','
-      @mvvls = mvvls[1..] if mvvls[0] == ','
-    end
-
-    # apaga movimentos no bigquery
-    def mv_delete_dml
-      dml("delete from #{BD}.mv where #{ky_mv} in(#{mvkys})")
-      puts("MOVIMENTOS APAGADOS #{bqnrs}")
-    end
-
-    # @return [String] expressao sql da chave de movimentos
-    def ky_mv
-      'FARM_FINGERPRINT(CONCAT(CAST(mv.nc as STRING),mv.ds,CAST(mv.dl as STRING),CAST(mv.vl as STRING)))'
-    end
-
-    # cria job bigquery & verifica execucao
-    #
-    # @param [String] cmd comando a executar
-    # @return [Boolean] job ok?
-    def job?(cmd)
-      # p cmd
-      @bqjob = bqapi.query_job(cmd)
-      @bqjob.wait_until_done!
-      puts(@bqjob.error['message']) if @bqjob.failed?
-      @bqjob.failed?
-    end
-
-    # executa sql & devolve resultado do bigquery
-    #
-    # @param (see job?)
-    # @param [Array] erro quando da erro no bigquery
-    # @return [Google::Cloud::Bigquery::Data] resultado do sql
-    def sql(cmd, erro = [])
-      @bqres = job?(cmd) ? erro : bqjob.data
-    end
-
-    # executa Data Manipulation Language (DML) no bigquery
-    #
-    # @param (see job?)
-    # @return [Integer] numero rows afetadas pelo dml
-    def dml(cmd)
-      @bqnrs = job?(cmd) ? 0 : bqjob.num_dml_affected_rows
-    end
-  end
-end

data/lib/abank/contrato.rb

@@ -1,110 +0,0 @@
-# frozen_string_literal: true
-
-module Abank
-  # acesso a base dados abank no bigquery
-  class Big
-    # @return [String] id contrato arrendamento
-    attr_reader :ctide
-
-    # @return [Array<Hash>] lista ids contratos arrendamento
-    # @example
-    #   [{ ct: 'r03000' }, ...]
-    attr_reader :ctlct
-
-    # @return [Array<Hash>] lista dados contrato arrendamento (inclui lista movimentos novos)
-    # @example
-    #   [{ct: 'r03000', dc: '2020-03-01', ano: 2020, cnt: 0, dl: '2020-03-01', mv: [{dl: '2020-03-02', vl: 30}, ...]  }]
-    attr_reader :ctlcm
-
-    # (see CLI#criact)
-    def ct_cria
-      if existe_contrato?
-        @bqnrs = 1
-        puts('CONTRATO JA EXISTE')
-      else
-        dml("insert into #{BD}.re #{sql_contrato_mv}")
-        puts("CONTRATO #{ctide} " + (bqnrs.zero? ? 'NAO EXISTE' : 'INSERIDO'))
-      end
-      return unless existem_rendas?
-
-      # processa rendas associadas ao contrato arrendamento
-      cm_cria.vr_cria.re_insert
-    end
-
-    # (see CLI#apagact)
-    def ct_apaga
-      @ctlct = [{ ct: ctide }]
-      lc_apaga
-    end
-
-    # apaga rendas da lista de contrato arrendamento
-    #
-    # @return [Big] acesso a base dados abank no bigquery
-    def lr_apaga
-      return self unless opcao[:t] && ctlct.count.positive?
-
-      # para nao apagar contrato arrendamento - somente as rendas
-      @opcao[:t] = false
-
-      lc_apaga
-      self
-    end
-
-    # apaga rendas da lista de contratos arrendamento
-    def lc_apaga
-      dml("delete from #{BD}.re where ct in(#{str_lc})#{opcao[:t] ? '' : ' and cnt>0'}")
-      puts("RENDAS #{str_lc('')} APAGADAS " + bqnrs.to_s)
-    end
-
-    # @return [String] texto formatado que representa lista de contratos arrendamento
-    def str_lc(sep = "'")
-      ctlct.map { |c| sep + c[:ct] + sep }.join(',')
-    end
-
-    # optem lista dados contrato arrendamento (inclui lista movimentos novos)
-    #
-    # @return [Big] acesso a base dados abank no bigquery
-    def cm_cria
-      @ctlcm = []
-      ctlct.each do |c|
-        @ctide = c[:ct]
-        sql(sql_last_re)
-        @ctlcm << bqres[0].merge({ mv: sql(sql_novo_mv(bqres[0][:dl])) })
-      end
-      self
-    end
-
-    # @return [Boolean] existem rendas para processar sim/nao?
-    def existem_rendas?
-      @ctlct = [{ ct: ctide }]
-      bqnrs.positive? && opcao[:t]
-    end
-
-    # @return [Boolean] contrato arrendamento ja existe sim/nao?
-    def existe_contrato?
-      sql("select ct from #{BD}.re where ct='#{ctide}' and cnt=0").count.positive?
-    end
-
-    # @return [String] sql para obter ultima renda do contrato arrendamento
-    def sql_last_re
-      'select ct,DATE_SUB(DATE_SUB(dl,INTERVAL dias DAY),INTERVAL IF(cnt=0,0,cnt-1) MONTH) as dc,ano,cnt,dl ' \
-        "from #{BD}.re where ct='#{ctide}' order by ano desc,cnt desc limit 1"
-    end
-
-    # @return [String] sql para obter movimentos novos (depois da ultima renda do contrato arrendamento)
-    def sql_novo_mv(mdl)
-      "select dl,vl from #{BD}.mv where ct='#{ctide}' and dl>='#{(mdl + 1).strftime(DF)}' order by dl,dv"
-    end
-
-    # @return [String] sql para obter dados do inicio contrato arrendamento
-    def sql_contrato_mv
-      if opcao[:d].size.zero?
-        'select ct,EXTRACT(YEAR FROM DATE_TRUNC(dl,MONTH)) as ano,0 as cnt,DATE_TRUNC(dl,MONTH) as dl,0 dias ' \
-          "from #{BD}.mv where ct='#{ctide}' order by dl limit 1"
-      else
-        "select '#{ctide}' as ct,EXTRACT(YEAR FROM DATE '#{opcao[:d]}') as ano" \
-              ",0 as cnt,DATE '#{opcao[:d]}' as dl,0 dias"
-      end
-    end
-  end
-end

data/lib/abank/folha.rb

@@ -1,156 +0,0 @@
-# frozen_string_literal: true
-
-require('roo')
-
-module Abank
-  # acesso a folha calculo & base dados abank no bigquery
-  class Folha < Big
-    # @return [Roo::Excelx] folha calculo a processar
-    attr_reader :folha
-
-    # @return [Integer] numero conta associado a folha calculo
-    # @example
-    #   mov*.xlsx     --> 1 --> conta-corrente
-    #   movCard*.xlsx --> 2 --> conta-cartao
-    attr_reader :conta
-
-    # @return [Array] row folha calculo em processamento
-    attr_reader :rowfc
-
-    # acesso a folha calculo & base dados abank no bigquery
-    #
-    # @param [Hash] opc opcoes trabalho
-    # @option opc [String]  :f ('') folha calculo a processar
-    # @option opc [Boolean] :s (false) apaga movimento similar? (mv)
-    # @option opc [Boolean] :e (false) apaga movimento igual? (mv)
-    # @option opc [Boolean] :i (false) insere movimento novo? (mv)
-    # @option opc [String]  :v ('') data valor movimentos (mv)
-    # @option opc [String]  :g ('') classificacao movimentos (mv)
-    def initialize(opc = {})
-      @opcao = super
-      @folha = Roo::Spreadsheet.open(opc.fetch(:f))
-      @conta = opc.fetch(:f).match?(/card/i) ? 2 : 1
-      @opcao[:s] = opc.fetch(:s, false)
-      @opcao[:e] = opc.fetch(:e, false)
-      @opcao[:i] = opc.fetch(:i, false)
-      @opcao[:v] = opc.fetch(:v, '')
-      @opcao[:g] = opc.fetch(:g, '')
-    end
-
-    # carrega/mostra folha calculo
-    def processa_xls
-      n = 0
-      folha.sheet(0).parse(header_search: ['Data Lanc.', 'Data Valor', 'Descrição', 'Valor']) do |r|
-        n += 1
-        puts n == 1 ? "\n#{folha.info}" : processa_linha(r)
-      end
-      return unless opcao[:i]
-
-      # processa movimentos & atualiza rendas
-      mv_delete.mv_insert.re_work
-    end
-
-    # processa linha folha calculo
-    #
-    # @param [Hash] linha da folha calculo em processamento
-    # @return [String] texto informativo formatado da linha em processamento
-    def processa_linha(linha)
-      vars_xls(linha)
-      # pesquisa existencia linha folha calculo no bigquery
-      #  array.count = 0 ==> pode carregar esta linha
-      #  array.count = 1 ==> mais testes necessarios
-      #  array.count > 1 ==> nao pode carregar esta linha
-      sql(sql_existe_mv, [{}, {}])
-      if linha_naoexiste? then linha_base + values_mv
-      elsif linha_existe? then linha_existe
-      elsif linha_simila? then linha_similar
-      else                     linha_multiplas
-      end
-    end
-
-    # inicializa variavel para processar linha folha calculo
-    #
-    # @param (see processa_linha)
-    def vars_xls(linha)
-      @rowfc = linha.values
-      @rowfc[2] = rowfc[2].strip
-      @rowfc[3] = -1 * rowfc[3] if conta > 1
-    end
-
-    # @return [String] texto base formatado para display
-    def linha_base
-      "#{rowfc[0].strftime(DF)} #{format('%<v3>-34.34s %<v4>8.2f', v3: rowfc[2], v4: rowfc[3])}"
-    end
-
-    # @return [String] texto linha existente formatada para display
-    def linha_existe
-      add_kys if opcao[:e]
-      "#{linha_base} EXIS #{format('%<v1>20d', v1: bqres.first[:ky])}"
-    end
-
-    # @return [String] texto linha similar formatada para display
-    def linha_similar
-      add_kys if opcao[:s]
-      "#{linha_base} SIMI #{format('%<v1>-20.20s', v1: bqres.first[:ds].strip)}"
-    end
-
-    # @return [String] texto linha existencia multipla formatada para display
-    def linha_multiplas
-      "#{linha_base} MULT(#{bqres.count})"
-    end
-
-    # obtem chaves movimento (keysin.mv) para apagar
-    def add_kys
-      bqres.each { |r| @mvkys += ",#{r[:ky]}" }
-    end
-
-    # @return [Boolean] linha folha calculo nao existe no bigquery?
-    def linha_naoexiste?
-      bqres.count.zero?
-    end
-
-    # @return [Boolean] linha folha calculo existe no bigquery?
-    def linha_existe?
-      bqres.count == 1 && bqres.first[:ds].strip == rowfc[2]
-    end
-
-    # @return [Boolean] linha folha calculo existe parecida no bigquery?
-    def linha_simila?
-      bqres.count == 1 && bqres.first[:ds].strip != rowfc[2]
-    end
-
-    # @return [String] sql para movimentos no bigquery
-    def sql_existe_mv
-      "select *,#{ky_mv} as ky from #{BD}.mv " \
-       "where nc=#{conta} and dl='#{rowfc[0].strftime(DF)}' and vl=#{rowfc[3]}"
-    end
-
-    # obtem movimento (values.mv) para inserir
-    #
-    # @return [String] ' NOVO'
-    def values_mv
-      @mvvls += ",('#{rowfc[0].strftime(DF)}','#{dvc.strftime(DF)}','#{rowfc[2]}',#{rowfc[3]}" + values_mv_extra
-      ' NOVO'
-    end
-
-    # @return [String] campos extra do movimento (values.mv) para inserir
-    def values_mv_extra
-      ",#{conta},#{dvc.year},#{dvc.month},'#{tpc}',#{ctc})"
-    end
-
-    # @return [Date] data valor corrigida
-    def dvc
-      opcao[:v].size.zero? ? rowfc[1] : Date.parse(opcao[:v])
-    end
-
-    # @return [String] classificacao do movimento (null --> classificacao automatica)
-    def ctc
-      opcao[:g].size.zero? ? 'null' : "'#{opcao[:g]}'"
-    end
-
-    # @return [String] tipo movimento c[redito] ou d[ebito]
-    def tpc
-      rowfc[3].positive? ? 'c' : 'd'
-    end
-  end
-end

data/lib/abank/rendas.rb

@@ -1,123 +0,0 @@
-# frozen_string_literal: true
-
-module Abank
-  # @see Big
-  class Big
-    # @return [Integer] ano renda em tratamento
-    attr_reader :reano
-
-    # @return [Integer] mes renda em tratamento
-    attr_reader :repos
-
-    # @return [Float] valor renda mensal
-    attr_reader :revre
-
-    # @return [String] rendas a inserir (values.re)
-    attr_reader :revls
-
-    # @return [Integer] movimento em tratamento
-    attr_reader :mvpos
-
-    # @return [Date] data lancamento movimento em tratamento
-    attr_reader :mvdlm
-
-    # @return [Float] valor movimento em tratamento
-    attr_reader :mvvlm
-
-    # (see CLI#recriare)
-    def re_atualiza
-      # obtem contratos ativos
-      @ctlct = sql("SELECT ct from #{BD}.re group by 1")
-
-      # [re]cria rendas [novas|todas]
-      lr_apaga.cm_cria.vr_cria.re_insert
-    end
-
-    # cria rendas associadas a lista ids contratos arrendamento
-    def re_work
-      bqnrs.zero? || ctlct.count.positive? ? cm_cria.vr_cria.re_insert : re_atualiza
-    end
-
-    # obtem rendas a inserir (values.re)
-    #
-    # @return [Big] acesso a base dados abank no bigquery
-    def vr_cria
-      @revls = ctlcm.map { |c| rendas_novas(c) }.flatten(1).join(',')
-      self
-    end
-
-    # insere rendas no bigquery
-    def re_insert
-      if revls.size.zero?
-        puts('NAO EXISTEM RENDAS NOVAS')
-      else
-        dml("insert #{BD}.re VALUES#{revls}")
-        puts("RENDAS #{str_lc('')} CRIADAS " + bqnrs.to_s)
-      end
-    end
-
-    # @param [Hash] cmv dados contrato arrendamento (inclui lista movimentos novos)
-    # @return [Array<String>] lista rendas novas dum contrato arrendamento (values.re)
-    def rendas_novas(cmv)
-      return [] unless cmv[:mv].count.positive?
-
-      vars_re(cmv)
-      r = []
-      while mvvlm >= revre && mvpos < cmv[:mv].count
-        r << nova_re(cmv)
-        proximo_mv(cmv)
-      end
-      r
-    end
-
-    # inicializa variaveis para processar rendas do contrato arrendamento
-    # @param (see rendas_novas)
-    def vars_re(cmv)
-      @reano = cmv[:ano]
-      @repos = cmv[:cnt]
-      @revre = Float(cmv[:ct][/\d+/]) / 100
-      @mvpos = 0
-      vars_re_mv(cmv)
-    end
-
-    # inicializa variaveis para processar movimentos associados ao contrato arrendamento
-    # @param (see rendas_novas)
-    def vars_re_mv(cmv)
-      @mvdlm = cmv[:mv][mvpos][:dl]
-      @mvvlm = cmv[:mv][mvpos][:vl]
-    end
-
-    # @param (see rendas_novas)
-    # @return [String] renda formatada (values.re)
-    def nova_re(cmv)
-      # inicializa proxima renda
-      if repos == 12
-        @repos = 1
-        @reano += 1
-      else
-        @repos += 1
-      end
-      "('#{cmv[:ct]}',#{reano},#{repos},'#{mvdlm.strftime(DF)}',#{dias(cmv)})"
-    end
-
-    # @param (see rendas_novas)
-    # @return [Integer] dias atraso no pagamento da renda
-    def dias(cmv)
-      mvdlm.mjd - (Date.new(reano, repos, 1) >> (cmv[:dc].month - 1)).mjd
-    end
-
-    # inicializa variaveis para processar proximo movimento
-    # @param (see rendas_novas)
-    def proximo_mv(cmv)
-      # valor renda paga retirado do valor do movimento
-      @mvvlm -= revre
-      return unless mvvlm < revre
-
-      # avanca na lista de movimentos
-      @mvpos += 1
-      return unless mvpos < cmv[:mv].count
-
-      vars_re_mv(cmv)
-    end
-  end
-end