abank 0.2.4 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f1720d3e8b1de4bc6ea635712404363e460b3550af47a665a06652fae028f917
-  data.tar.gz: eef494213d2f5bf45887a1f643ec2f1becf2d470e9cc5451c2412dd41d9696c2
+  metadata.gz: 357eabd6927351fcd006bf58dda24c7b323395749b4ab6ef4ecf6f596a126241
+  data.tar.gz: 0c3fc3b9e2ebda8bfe13b0ba072f50b0ff303668dfde4ffa7378e04f1470b81e
 SHA512:
-  metadata.gz: eb2aa5a87322b5cb27fb2fac24cd99d5288eb3be339a0976cd2d2cd12c3ee46b63c2e09e8060c16dd3f07197ba837ecf6fa612a658f86cb3c7875a5546dd16b5
-  data.tar.gz: 9498f7fa1b1a5cbdf4c56b39cd770073eb13642d669847fecdd5a1b3285dd3ffc15fb0e6437a8e2758d6223e4e128e7eb0664e6f6ffb42cc73d3d1ce46380ea9
+  metadata.gz: b11a19c0f7039ff253776441e4f7b7de443808c4bf90dfec078a65dab3342b40197017d36e69d30d09d35500afd6e187ebe7113580e36ef921737085599c26af
+  data.tar.gz: 98daf017bef2b5860fe498c9f11f6881374ebaa87451a10bf24fe1fa95006230c734a6dc1176e036983ec0e991777e59cfebaa34f2c2bc67828d3b95563163ae

data/.rubocop.yml

@@ -1,4 +1,5 @@
 AllCops:
+  TargetRubyVersion: 2.6
   EnabledByDefault: true
 
 Style/ClassAndModuleChildren:
@@ -27,3 +28,6 @@ Layout/FirstMethodParameterLineBreak:
 
 Layout/FirstHashElementLineBreak:
   Enabled: false
+
+Style/MissingElse:
+  Enabled: false

data/Gemfile

@@ -1,6 +1,8 @@
-source "https://rubygems.org"
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
 
 # Specify your gem's dependencies in abank.gemspec
 gemspec
 
-gem "rake", "~> 12.0"
+gem 'rake', '~> 12.0'

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    abank (0.2.4)
+    abank (0.2.5)
       google-cloud-bigquery
       roo
       thor
@@ -17,7 +17,7 @@ GEM
     declarative-option (0.1.0)
     faraday (1.0.1)
       multipart-post (>= 1.2, < 3)
-    google-api-client (0.39.5)
+    google-api-client (0.40.1)
       addressable (~> 2.5, >= 2.5.1)
       googleauth (~> 0.9)
       httpclient (>= 2.8.1, < 3.0)
@@ -25,7 +25,7 @@ GEM
       representable (~> 3.0)
       retriable (>= 2.0, < 4.0)
       signet (~> 0.12)
-    google-cloud-bigquery (1.21.0)
+    google-cloud-bigquery (1.21.1)
       concurrent-ruby (~> 1.0)
       google-api-client (~> 0.33)
       google-cloud-core (~> 1.2)
@@ -34,9 +34,9 @@ GEM
     google-cloud-core (1.5.0)
       google-cloud-env (~> 1.0)
       google-cloud-errors (~> 1.0)
-    google-cloud-env (1.3.1)
+    google-cloud-env (1.3.2)
       faraday (>= 0.17.3, < 2.0)
-    google-cloud-errors (1.0.0)
+    google-cloud-errors (1.0.1)
     googleauth (0.12.0)
       faraday (>= 0.17.3, < 2.0)
       jwt (>= 1.4, < 3.0)

data/README.md

@@ -1,6 +1,6 @@
 # Abank [![Build Status](https://travis-ci.com/hernanirvaz/abank.svg?branch=master)](https://travis-ci.com/hernanirvaz/abank)
 
-Arquiva movimentos conta-corrente, conta-cartao do activobank no bigquery. Permite apagar movimentos similares/existentes ja no bigquery. Permite ainda classificar movimentos ja no bigquery.
+Arquiva movimentos conta-corrente, conta-cartao do activobank no bigquery. Permite apagar/recriar movimentos/rendas ja no bigquery. Permite ainda classificar movimentos no bigquery.
 
 ## Installation
 
@@ -20,10 +20,14 @@ Or install it yourself as:
 
 ## Usage
 
-    $ abank help [COMANDO]  # ajuda aos comandos
-    $ abank mostra          # mostra dados da folha calculo
-    $ abank load            # carrega dados da folha calculo no bigquery
-    $ abank classifica      # classifica arquivo no bigquery
+    $ abank apagamv -k=KEY[,KEY...] # apaga movimentos
+    $ abank apagact  -c=CONTRATO    # apaga contrato arrendamento
+    $ abank criact   -c=CONTRATO    # cria contrato arrendamento
+    $ abank recriact -c=CONTRATO    # atualiza rendas de contrato arrendamento
+    $ abank recriare                # atualiza rendas dos contratos ativos
+    $ abank load                    # carrega dados da folha calculo
+    $ abank show                    # mostra dados da folha calculo
+    $ abank tag                     # classifica movimentos
 
 ## Development
 

data/Rakefile

@@ -1,2 +1,4 @@
-require "bundler/gem_tasks"
-task :default => :build
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+task default: :build

data/abank.gemspec

@@ -10,12 +10,9 @@ Gem::Specification.new do |spec|
   spec.homepage    = 'https://github.com/hernanirvaz/abank'
   spec.license     = 'MIT'
 
-  spec.summary     = 'Arquiva <conta-corrente>.xlsx,' \
-                     ' <conta-cartao>.xlsx no bigquery.'
-  spec.description = spec.summary +
-                     ' Pode apagar movimentos similares/existentes' \
-                     ' ja no bigquery.' \
-                     ' Pode ainda classificar movimentos ja no bigquery.'
+  spec.summary     = 'Arquiva movimentos conta-corrente, conta-cartao do activobank no bigquery.'
+  spec.description = spec.summary + ' Permite apagar/recriar movimentos/rendas ja no bigquery. ' \
+                     ' Permite ainda classificar movimentos no bigquery.'
 
   spec.metadata['homepage_uri'] = spec.homepage
   spec.metadata['yard.run'] = 'yard'
@@ -24,10 +21,10 @@ Gem::Specification.new do |spec|
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads files in RubyGem that have been added into git.
-  spec.files = Dir.chdir(File.expand_path(__dir__)) do
-    `git ls-files -z`.split("\x0")
-                     .reject { |f| f.match(%r{^(test|spec|features)/}) }
-  end
+  spec.files =
+    Dir.chdir(File.expand_path(__dir__)) do
+      `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+    end
   spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']

data/bin/console

@@ -1,7 +1,8 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
-require "bundler/setup"
-require "abank"
+require 'bundler/setup'
+require 'abank'
 
 # You can add fixtures and/or initialization code here to make experimenting
 # with your gem easier. You can also use a different console, if you like.
@@ -10,5 +11,5 @@ require "abank"
 # require "pry"
 # Pry.start
 
-require "irb"
+require 'irb'
 IRB.start(__FILE__)

data/lib/abank.rb

@@ -9,92 +9,86 @@ require 'abank/version'
 
 # @author Hernani Rodrigues Vaz
 module Abank
-  ID = `whoami`.chomp
+  DR = "/home/#{`whoami`.chomp}/Downloads"
 
   class Error < StandardError; end
 
   # CLI para carregar folhas calculo comuns no bigquery
   class CLI < Thor
-    desc 'tag', 'classifica movimentos no bigquery'
-    # classifica movimentos no bigquery
+    desc 'tag', 'classifica movimentos'
+    # classifica movimentos
     def tag
-      Big.new(i: true).mv_classifica
+      Big.new.mv_classifica
     end
 
-    desc 'rendas', 'atualiza rendas no bigquery'
-    # atualiza rendas no bigquery
-    def rendas
-      Big.new.re_atualiza
+    desc 'apagamv', 'apaga movimentos'
+    option :k, banner: 'KEY[,KEY...]', required: true, desc: 'keys movimentos a apagar'
+    # apaga movimentos
+    def apagamv
+      Big.new(k: options[:k]).mv_delete.mv_insert.re_work
     end
 
-    desc 'apaga', 'apaga movimentos no bigquery'
-    option :k, banner: 'k1[,k2,...]', required: true,
-               desc: 'Keys movimentos a apagar'
-    # apaga movimentos no bigquery
-    def apaga
-      Big.new(k: options[:k]).mv_apaga
+    desc 'criact', 'cria contrato arrendamento'
+    option :c, banner: 'CONTRATO', required: true, desc: 'Identificador contrato arrendamento'
+    option :t, type: :boolean, default: true,      desc: 'cria todas as rendas?'
+    option :d, banner: 'DATA', default: '',        desc: 'data contrato arrendamento'
+    # cria contrato arrendamento
+    def criact
+      Big.new(c: options[:c], t: options[:t], d: options[:d]).ct_cria
     end
 
-    desc 'load', 'carrega dados da folha calculo no bigquery'
-    option :d, banner: 'DIR', default: "/home/#{ID}/Downloads",
-               desc: 'Onde procurar folhas calculo'
-    option :v, banner: 'DATA', default: '',
-               desc: 'data valor para movimentos a carregar'
-    option :g, banner: 'TAG', default: '',
-               desc: 'classificacao para movimentos a carregar'
-    option :s, type: :boolean, default: false,
-               desc: 'apaga linha similar no bigquery'
-    option :e, type: :boolean, default: false,
-               desc: 'apaga linha igual no bigquery'
-    option :m, type: :boolean, default: false,
-               desc: 'apaga linhas existencia multipla no bigquery'
+    desc 'apagact', 'apaga contrato arrendamento'
+    option :c, banner: 'CONTRATO', required: true, desc: 'Identificador contrato arrendamento'
+    option :t, type: :boolean, default: false,     desc: 'apaga todas as rendas?'
+    # apaga contrato arrendamento
+    def apagact
+      Big.new(c: options[:c], t: options[:t]).ct_apaga
+    end
+
+    desc 'recriact', 'atualiza rendas de contrato arrendamento'
+    option :c, banner: 'CONTRATO', required: true, desc: 'Identificador contrato arrendamento'
+    option :t, type: :boolean, default: false,     desc: 'apaga todas as rendas?'
+    option :d, banner: 'DATA', default: '',        desc: 'data contrato arrendamento'
+    # atualiza rendas de contrato arrendamento
+    def recriact
+      Big.new(c: options[:c], t: options[:t]).ct_apaga
+      Big.new(c: options[:c], t: true, d: options[:d]).ct_cria
+    end
+
+    desc 'recriare', 'atualiza rendas dos contratos ativos'
+    option :t, type: :boolean, default: false, desc: 'atualiza todas as rendas?'
+    # atualiza rendas dos contratos ativos
+    def recriare
+      Big.new(t: options[:t]).re_atualiza
+    end
+
+    desc 'load', 'carrega dados da folha calculo'
+    option :s, type: :boolean, default: false, desc: 'apaga movimento similar'
+    option :e, type: :boolean, default: false, desc: 'apaga movimento igual'
+    option :v, banner: 'DATA', default: '',    desc: 'data valor para movimentos a carregar'
+    option :g, banner: 'TAG', default: '',     desc: 'classificacao para movimentos a carregar'
     # carrega folha calculo
     def load
-      Dir.glob("#{options[:d]}/*.xlsx").sort.each do |f|
-        Big::Folha.new(f, load_ops).processa_folha
+      Dir.glob("#{DR}/*.xlsx").sort.each do |f|
+        Big::Folha.new(load_opc.merge(f: f)).processa_xls
       end
     end
 
     desc 'show', 'mostra dados da folha calculo'
-    option :d, banner: 'DIR', default: "/home/#{ID}/Downloads",
-               desc: 'Onde procurar folhas calculo'
     # mostra folha calculo
     def show
-      Dir.glob("#{options[:d]}/*.xlsx").sort.each do |f|
-        Big::Folha.new(f).processa_folha
+      Dir.glob("#{DR}/*.xlsx").sort.each do |f|
+        Big::Folha.new(f: f).processa_xls
       end
     end
 
-    desc 'criare', 'cria contrato arrendamento/rendas no bigquery'
-    option :c, banner: 'CONTRATO', required: true,
-               desc: 'Identificador contrato arrendamento a criar'
-    option :t, type: :boolean, default: true,
-               desc: 'cria todas as rendas?'
-    option :v, banner: 'DATA', default: '',
-               desc: 'data contrato arrendamento a criar'
-    # cria contrato arrendamento/rendas no bigquery
-    def criare
-      Big::Contrato.new(options[:c], { t: options[:t], v: options[:v] }).re_cria
-    end
-
-    desc 'apagare', 'apaga contrato arrendamento/rendas no bigquery'
-    option :c, banner: 'CONTRATO', required: true,
-               desc: 'Identificador contrato arrendamento a apagar'
-    option :t, type: :boolean, default: false,
-               desc: 'apaga todas as rendas?'
-    # apaga contrato arrendamento/rendas no bigquery
-    def apagare
-      Big::Contrato.new(options[:c], { t: options[:t], v: '' }).re_apaga
-    end
-
     no_commands do
-      # @return [Hash] opcoes trabalho com linhas para load
-      def load_ops
-        { s: options[:s], e: options[:e], m: options[:m], i: true,
-          v: options[:v], g: options[:g] }
+      # @return [Hash] opcoes trabalho com movimentos para load
+      def load_opc
+        { s: options[:s], e: options[:e], i: true, v: options[:v], g: options[:g] }
       end
     end
 
-    default_task :rendas
+    default_task :show
   end
 end

data/lib/abank/big.rb

@@ -2,137 +2,133 @@
 
 require 'google/cloud/bigquery'
 
-# class Contrato
+# @see Abank::Big
 class Abank::Big
   DF = '%Y-%m-%d'
 
+  # @return [Hash] opcoes trabalho
+  attr_reader :opcao
+
   # @return [Google::Cloud::Bigquery] API bigquery
-  attr_reader :api
-  # @return [Hash] opcoes trabalho com linhas
-  attr_reader :opl
+  attr_reader :bqapi
 
   # @return [Google::Cloud::Bigquery::QueryJob] job bigquery
-  attr_reader :job
-  # @return [Google::Cloud::Bigquery::Data] lista devolvida pelo select
-  attr_reader :resultados
-
-  # @param [Hash] ops opcoes trabalho
-  # @option ops [Boolean] :s (false) apaga linha similar? (mv)
-  # @option ops [Boolean] :e (false) apaga linha igual? (mv)
-  # @option ops [Boolean] :m (false) apaga linhas existencia multipla? (mv)
-  # @option ops [Boolean] :i (false) insere linha nova? (mv)
-  # @option ops [String]  :v ('') data valor (mv)/data contrato (re)
-  # @option ops [String]  :g ('') classificacao movimentos (mv)
-  # @option ops [Boolean] :t (false) trabalha todoas as rendas? (re)
-  # @option ops [String]  :k ('') keys movimentos a apagar (mv)
-  # @return [Big] acesso bigquery dataset
-  def initialize(ops = {})
-    @opl = ops
-    @api ||= Google::Cloud::Bigquery.new
-    p ['Big', ops, api]
-  end
-
-  # (see CLI#classifica)
-  def mv_classifica
-    return unless opl[:i]
-
-    i = dml('update hernanilr.ab.mv set mv.ct=tt.nct ' \
-              'from (select * from hernanilr.ab.cl) as tt ' \
-             'where mv.dl=tt.dl and mv.dv=tt.dv ' \
-               'and mv.ds=tt.ds and mv.vl=tt.vl')
-    puts 'LINHAS CLASSIFICADAS ' + i.to_s
-    return unless i.positive?
-
-    re_atualiza
-  end
-
-  # (see CLI#atualiza)
-  def re_atualiza
-    r = re_join(lista_ativos)
-    if r.size.zero?
-      puts 'NAO EXISTEM RENDAS NOVAS'
-    else
-      puts 'RENDAS CRIADAS ' + dml('insert hernanilr.ab.re VALUES' + r).to_s
-    end
-  end
+  attr_reader :bqjob
 
-  # (see CLI#apagamv)
-  def mv_apaga
-    e = ct_envolvidos
-    i = dml(sql_apaga_mv)
-    puts 'MOVIMENTOS APAGADOS ' + i.to_s
-    return unless i.positive? && e.count.positive?
+  # @return [Google::Cloud::Bigquery::Data] resultado do select
+  attr_reader :bqres
 
-    e.map { |c| Contrato.new(c).re_apaga }
+  # @return [Integer] numero linhas afetadas pela Data Manipulation Language (DML)
+  attr_reader :bqnrs
 
-    re_atualiza
-  end
+  # @return [String] movimentos a inserir (values.mv)
+  attr_reader :mvvls
 
-  def ct_envolvidos
-    sel(sql_sel_mv).group_by { |r| r[:ct] }
-                   .delete_if { |k, _| !k || k[0] != 'r' }.keys
-  end
+  # @return [String] movimentos a apagar (keysin.mv)
+  attr_reader :mvkys
 
-  # @return [Array<Hash>] lista contratos com lista movimentos novos
-  def lista_ativos
-    sel(sql_ativos_re).map { |c| Contrato.new(c[:ct]).dados_contrato }.compact
+  # 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, '')
+    # p ['B', opcao]
+    opcao
   end
 
-  # @param [Array<Hash>] lct lista contratos com lista movimentos novos
-  # @return [String] row formatada das novas rendas para inserir bigquery
-  def re_join(lct)
-    lct.map { |c| Contrato::Rendas.new(c).rendas }.flatten(1).join(',')
+  # (see CLI#tag)
+  def mv_classifica
+    dml('update hernanilr.ab.mv set mv.ct=tt.nct ' \
+          'from (select * from hernanilr.ab.cl) as tt ' \
+         "where #{ky_mv}=tt.ky")
+    puts 'MOVIMENTOS CLASSIFICADOS ' + bqnrs.to_s
   end
 
-  def sql_ativos_re
-    'SELECT ct from hernanilr.ab.re group by 1 order by 1'
+  # 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 = sel("select ct from hernanilr.ab.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
+    end
+    self
   end
 
-  def sql_sel_mv
-    'select * ' + sql_where_mv
+  # insere & classifica movimentos no bigquery
+  #
+  # @return [Big] acesso a base dados abank no bigquery
+  def mv_insert
+    if mvvls.size.positive?
+      dml('insert hernanilr.ab.mv VALUES' + mvvls)
+      puts 'MOVIMENTOS INSERIDOS ' + bqnrs.to_s
+      mv_classifica if bqnrs.positive?
+    end
+    self
   end
 
-  # @return [String] sql apaga movimentos
-  def sql_apaga_mv
-    'delete ' + sql_where_mv
+  # 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
 
-  # @return [String] parte sql para processamento movimentos
-  def sql_where_mv
-    "from hernanilr.ab.mv where #{sql_digest_mv} in(#{opl[:k]})"
+  # apaga movimentos no bigquery
+  def mv_delete_dml
+    dml("delete from hernanilr.ab.mv where #{ky_mv} in(#{mvkys})")
+    puts 'MOVIMENTOS APAGADOS ' + bqnrs.to_s
   end
 
-  def sql_digest_mv
-    'FARM_FINGERPRINT(CONCAT(CAST(nc as STRING),' \
-      'ds,CAST(dl as STRING),CAST(vl as STRING)))'
+  # @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] sql comando sql a executar
+  # @param [String] sql comando a executar
   # @return [Boolean] job ok?
-  def job_bigquery?(sql)
-    p sql
-    @job = api.query_job(sql)
-    @job.wait_until_done!
-    puts @job.error['message'] if @job.failed?
-    @job.failed?
+  def job?(sql)
+    # p sql
+    @bqjob = bqapi.query_job(sql)
+    @bqjob.wait_until_done!
+    puts @bqjob.error['message'] if @bqjob.failed?
+    @bqjob.failed?
   end
 
-  # executa Data Manipulation Language (DML) job no bigquery
+  # executa sql & devolve resultado do bigquery
   #
-  # @param (see job_bigquery?)
-  # @return [Integer] numero linhas afetadas
-  def dml(sql)
-    job_bigquery?(sql) ? 0 : job.num_dml_affected_rows
+  # @param (see job?)
+  # @param [Array] erro quando da erro no bigquery
+  # @return [Google::Cloud::Bigquery::Data] resultado do sql
+  def sel(sql, erro = [])
+    @bqres = job?(sql) ? erro : bqjob.data
   end
 
-  # executa sql & devolve resultados do bigquery
+  # executa Data Manipulation Language (DML) no bigquery
   #
-  # @param sql (see job_bigquery?)
-  # @param [Array] arr resultado quando da erro no bigquery
-  # @return [Google::Cloud::Bigquery::Data] resultado do sql num array<hash>
-  def sel(sql, arr = [])
-    @resultados = job_bigquery?(sql) ? arr : job.data
+  # @param (see job?)
+  # @return [Integer] numero rows afetadas pelo dml
+  def dml(sql)
+    @bqnrs = job?(sql) ? 0 : bqjob.num_dml_affected_rows
   end
 end

data/lib/abank/contrato.rb

@@ -1,80 +1,107 @@
 # frozen_string_literal: true
 
-# class Big::Contrato
-class Abank::Big::Contrato < Abank::Big
-  # @return [String] identificador contrato arrendamento
-  attr_reader :rct
-
-  # {:ct=>"r03000"}
-  def initialize(con, ops = { t: false, v: '' })
-    p ['Contrato', con, ops]
-    @rct = con
-    super(ops)
-  end
+# acesso a base dados abank no bigquery
+class Abank::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#cria)
-  def re_cria
+  # (see CLI#criact)
+  def ct_cria
     if existe_contrato?
-      i = 0
-      puts 'JA EXISTE CONTRATO'
+      @bqnrs = 1
+      puts 'CONTRATO JA EXISTE'
     else
-      i = dml('insert into hernanilr.ab.re ' + sql_contrato_mv)
-      puts i.zero? ? 'NAO EXISTE CONTRATO' : "CONTRATO #{rct} INSERIDO"
+      dml('insert into hernanilr.ab.re ' + sql_contrato_mv)
+      puts "CONTRATO #{ctide} " + (bqnrs.zero? ? 'NAO EXISTE' : 'INSERIDO')
     end
-    return unless i.positive? && opl[:t]
+    return unless existem_rendas?
 
-    re_atualiza
+    # processa rendas associadas ao contrato arrendamento
+    cm_cria.vr_cria.re_insert
   end
 
-  # (see CLI#apagare)
-  def re_apaga
-    puts "RENDAS #{rct} APAGADAS " + dml(sql_apaga_re).to_s
+  # (see CLI#apagact)
+  def ct_apaga
+    @ctlct = [{ ct: ctide }]
+    lc_apaga
   end
 
-  # @return [Hash] dados contrato & movimentos novos
-  def dados_contrato
-    c = sel(sql_last_re).first
-    sel(sql_novo_mv(c[:dl]))
-    return unless resultados.count.positive?
+  # 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?
 
-    { mv: resultados }.merge(c)
+    # para nao apagar contrato arrendamento - somente as rendas
+    @opcao[:t] = false
+
+    lc_apaga
+    self
   end
 
-  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 hernanilr.ab.re where ct='#{rct}' " \
-    'order by ano desc,cnt desc limit 1'
+  # apaga rendas da lista de contratos arrendamento
+  def lc_apaga
+    dml("delete from hernanilr.ab.re where ct in(#{str_lc})#{opcao[:t] ? '' : ' and cnt>0'}")
+    puts "RENDAS #{str_lc('')} APAGADAS " + bqnrs.to_s
   end
 
-  def sql_novo_mv(mdl)
-    "select dl,vl from hernanilr.ab.mv where ct='#{rct}' " \
-       "and dl>='#{(mdl + 1).strftime(DF)}' order by dl,dv"
+  # @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]
+      sel(sql_last_re)
+      @ctlcm << bqres[0].merge({ mv: sel(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?
-    sel(sql_contrato_re).count.positive?
+    sel("select ct from hernanilr.ab.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 hernanilr.ab.re where ct='#{ctide}' order by ano desc,cnt desc limit 1"
   end
 
-  def sql_contrato_re
-    "select * from hernanilr.ab.re where ct='#{rct}' and cnt=0"
+  # @return [String] sql para obter movimentos novos (depois da ultima renda do contrato arrendamento)
+  def sql_novo_mv(mdl)
+    "select dl,vl from hernanilr.ab.mv where ct='#{ctide}' and dl>='#{(mdl + 1).strftime(DF)}' order by dl,dv"
   end
 
-  # @return [String] sql obtem dados inicio contrato arrendamento
+  # @return [String] sql para obter dados do inicio contrato arrendamento
   def sql_contrato_mv
-    if opl[:v].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 hernanilr.ab.mv where ct='#{rct}' order by dl limit 1"
+    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 hernanilr.ab.mv where ct='#{ctide}' order by dl limit 1"
     else
-      "select '#{rct}' as ct" \
-            ",EXTRACT(YEAR FROM DATE '#{opl[:v]}') as ano,0 as cnt" \
-                              ",DATE '#{opl[:v]}' as dl,0 dias "
+      "select '#{ctide}' as ct,EXTRACT(YEAR FROM DATE '#{opcao[:d]}') as ano,0 as cnt,DATE '#{opcao[:d]}' as dl,0 dias"
     end
   end
-
-  def sql_apaga_re
-    "delete from hernanilr.ab.re where ct='#{rct}'" +
-      (opl[:t] ? '' : ' and cnt>0')
-  end
 end

data/lib/abank/folha.rb

@@ -2,158 +2,153 @@
 
 require 'roo'
 
-# class Big::Contrato
+# acesso a folha calculo & base dados abank no bigquery
 class Abank::Big::Folha < Abank::Big
-  HT = ['Data Lanc.', 'Data Valor', 'Descrição', 'Valor'].freeze
-  RF = '%<v3>-34.34s %<v4>8.2f'
-  EN = ' %<v1>20d'
-  ES = ' %<v1>-20.20s'
-
   # @return [Roo::Excelx] folha calculo a processar
   attr_reader :folha
-  # @return [Integer] numero conta
+
+  # @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 :row
-
-  def initialize(xls, ops = { s: false, e: false, m: false, i: false,
-                              v: '', g: '' })
-    p ['Folha', xls, ops]
-    @folha = Roo::Spreadsheet.open(xls) if xls.size.positive?
-    @conta = xls.match?(/card/i) ? 2 : 1
-    super(ops)
-  end
+  attr_reader :rowfc
 
-  # processa linhas folha calculo & classifica bigquery
-  def processa_folha
+  # 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: HT) do |r|
+    folha.sheet(0).parse(header_search: ['Data Lanc.', 'Data Valor', 'Descrição', 'Valor']) do |r|
       n += 1
-      puts n == 1 ? "\n" + folha.info : processa_row(r)
+      puts n == 1 ? "\n" + folha.info : processa_linha(r)
     end
-    mv_classifica
+    return unless opcao[:i]
+
+    # processa movimentos & atualiza rendas
+    mv_delete.mv_insert.re_work
   end
 
-  # processa linha folha calculo para arquivo
+  # processa linha folha calculo
   #
-  # @param (see corrige_hash)
-  # @return [String] texto informativo do processamento
-  def processa_row(has)
-    corrige_hash(has)
+  # @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
-    sel(sql_sel_mv, [{}, {}])
-    if row_naoexiste? then row_str + (insert_mv == 1 ? ' NOVA' : ' ERRO')
-    elsif row_simila? then row_similar
-    elsif row_existe? then row_existente
-    else                   row_multiplas
+    sel(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
 
-  # corrige linha folha calculo para processamento
+  # inicializa variavel para processar linha folha calculo
   #
-  # @param [Hash] has da linha em processamento
-  def corrige_hash(has)
-    @row = has.values
-    @row[2] = row[2].strip
-    @row[3] = -1 * row[3] if conta > 1
-  end
-
-  # @return [String] linha folha calculo formatada
-  def row_str
-    "#{row[0].strftime(DF)} #{format(RF, v3: row[2], v4: row[3])}"
+  # @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] linha folha calculo similar
-  def row_similar
-    d = opl[:s] ? delete_mv : 0
-    row_str + ' SIMI' + str_apagadas(d) + str_extra_s(resultados.first[:ds])
+  # @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] linha folha calculo existente
-  def row_existente
-    d = opl[:e] ? delete_mv : 0
-    row_str + ' EXIS' + str_apagadas(d) + str_extra_n(resultados.first[:ky])
+  # @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
 
-  def str_extra_s(ext)
-    format(ES, v1: ext.strip)
+  # @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
 
-  def str_extra_n(ext)
-    format(EN, v1: ext)
+  # @return [String] texto linha existencia multipla formatada para display
+  def linha_multiplas
+    linha_base + ' MULT(' + bqres.count.to_s + ')'
   end
 
-  # @return [String] linha folha calculo existencia multipla
-  def row_multiplas
-    d = opl[:m] ? delete_mv : 0
-    row_str + ' M(' + resultados.count.to_s + ')' + str_apagadas(d)
-  end
-
-  # @param [Integer] numero linhas apagadas
-  # @return [String] texto formatado linhas apagadas
-  def str_apagadas(num)
-    num.positive? ? ' A(' + num.to_s + ')' : ''
+  # 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 row_naoexiste?
-    resultados.count.zero?
+  def linha_naoexiste?
+    bqres.count.zero?
   end
 
   # @return [Boolean] linha folha calculo existe no bigquery?
-  def row_existe?
-    resultados.count == 1 && resultados.first[:ds].strip == row[2]
+  def linha_existe?
+    bqres.count == 1 && bqres.first[:ds].strip == rowfc[2]
   end
 
   # @return [Boolean] linha folha calculo existe parecida no bigquery?
-  def row_simila?
-    resultados.count == 1 && resultados.first[:ds].strip != row[2]
+  def linha_simila?
+    bqres.count == 1 && bqres.first[:ds].strip != rowfc[2]
   end
 
-  def sql_sel_mv
-    "select *,#{sql_digest_mv} as ky " + sql_where_mv
+  # @return [String] sql para movimentos no bigquery
+  def sql_existe_mv
+    "select *,#{ky_mv} as ky from hernanilr.ab.mv " \
+     "where nc=#{conta} and dl='#{rowfc[0].strftime(DF)}' and vl=#{rowfc[3]}"
   end
 
-  # @return [String] parte sql para processamento movimentos
-  def sql_where_mv
-    "from hernanilr.ab.mv where nc=#{conta} " \
-     "and dl='#{row[0].strftime(DF)}' " \
-     "and vl=#{row[3]}"
+  # 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 [Integer] numero linhas inseridas
-  def insert_mv
-    return 1 unless opl[:i]
-
-    dml('insert hernanilr.ab.mv(dl,dv,ds,vl,nc,ano,mes,ct,tp) VALUES(' \
-        "'#{row[0].strftime(DF)}','#{dvc.strftime(DF)}','#{row[2]}',#{row[3]}" +
-      str_ins_pc)
+  # @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
-    opl[:v].size.zero? ? row[1] : Date.parse(opl[:v])
-  end
-
-  # @return [String] campos extra da linha bigquery
-  def str_ins_pc
-    ",#{conta},#{dvc.year},#{dvc.month},#{ctc},'#{tpc}')"
+    opcao[:v].size.zero? ? rowfc[1] : Date.parse(opcao[:v])
   end
 
+  # @return [String] classificacao do movimento (null --> classificacao automatica)
   def ctc
-    opl[:g].size.zero? ? 'null' : ("'" + opl[:g] + "'")
+    opcao[:g].size.zero? ? 'null' : ("'" + opcao[:g] + "'")
   end
 
+  # @return [String] tipo movimento c[redito] ou d[ebito]
   def tpc
-    row[3].positive? ? 'c' : 'd'
-  end
-
-  # @return [Integer] numero linhas apagadas
-  def delete_mv
-    dml('delete ' + sql_where_mv + " and ds='#{resultados.first[:ds]}'")
+    rowfc[3].positive? ? 'c' : 'd'
   end
 end

data/lib/abank/rendas.rb

@@ -1,95 +1,121 @@
 # frozen_string_literal: true
 
-# class Big::Renda
-class Abank::Big::Contrato::Rendas < Abank::Big::Contrato
-  attr_reader :ren
-
-  # @return [Integer] ano renda
-  attr_reader :ran
-  # @return [Integer] mes renda
-  attr_reader :rcn
+# @see Abank::Big
+class Abank::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 :rru
+  attr_reader :revre
+
+  # @return [String] rendas a inserir (values.re)
+  attr_reader :revls
 
-  # @return [Integer] total de movimentos novos
-  attr_reader :mcn
   # @return [Integer] movimento em tratamento
-  attr_reader :mpn
+  attr_reader :mvpos
+
   # @return [Date] data lancamento movimento em tratamento
-  attr_reader :mdl
+  attr_reader :mvdlm
+
   # @return [Float] valor movimento em tratamento
-  attr_reader :mvl
-
-  # @return [Date] data contrato arrendamento
-  # {:mv=>[{:dl=>#<Date: 2020-03-02>, :vl=>0.3e2},...]
-  # ,:ct=>"r03000"
-  # ,:dc=>#<Date: 2020-03-01>
-  # ,:ano=>2020
-  # ,:cnt=>0
-  # ,:dl=>#<Date: 2020-03-01>}
-  def initialize(ren)
-    p ['Rendas', ren]
-    @ren = ren
-    super(ren[:ct])
+  attr_reader :mvvlm
+
+  # (see CLI#recriare)
+  def re_atualiza
+    # obtem contratos ativos
+    @ctlct = sel('SELECT ct from hernanilr.ab.re group by 1')
+
+    # [re]cria rendas [novas|todas]
+    lr_apaga.cm_cria.vr_cria.re_insert
   end
 
-  # @param [Hash] con dados contrato & lista movimentos novos
-  # @return [Array<Hash>] lista rendas novas para criar
-  def rendas
-    vars_re
-    vars_mv
-    r = []
-    while mvl >= rru && mpn < mcn
-      r << nova_re
-      proximo_mv
+  # 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 hernanilr.ab.re VALUES' + revls)
+      puts "RENDAS #{str_lc('')} CRIADAS " + bqnrs.to_s
     end
-    r
   end
 
-  # @param (see rendas)
-  def vars_mv
-    @mpn = 0
-    @mcn = ren[:mv].count
-    vars_dados_mv
+  # @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
 
-  # @param (see rendas)
-  def vars_dados_mv
-    @mdl = ren[:mv][mpn][:dl]
-    @mvl = ren[:mv][mpn][:vl]
+  # 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
 
-  # @param (see rendas)
-  def vars_re
-    @ran = ren[:ano]
-    @rcn = ren[:cnt]
-    @rru = Float(ren[:ct][/\d+/]) / 100
+  # 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
 
-  # @return [Array] lista dados da renda nova
-  def nova_re
-    if rcn == 12
-      @rcn = 1
-      @ran += 1
+  # @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
-      @rcn += 1
+      @repos += 1
     end
-    # [rct, ran, rcn, mdl, mdl.mjd - vencimento.mjd]
-    "('#{rct}',#{ran},#{rcn},'#{mdl.strftime(DF)}',#{dias})"
+    "('#{cmv[:ct]}',#{reano},#{repos},'#{mvdlm.strftime(DF)}',#{dias(cmv)})"
   end
 
-  def dias
-    mdl.mjd - (Date.new(ran, rcn, 1) >> (ren[:dc].month - 1)).mjd
+  # @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
 
-  # @param (see rendas)
-  def proximo_mv
-    @mvl -= rru
-    return unless mvl < rru
+  # 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
 
-    @mpn += 1
-    return unless mpn < mcn
+    # avanca na lista de movimentos
+    @mvpos += 1
+    return unless mvpos < cmv[:mv].count
 
-    vars_dados_mv
+    vars_re_mv(cmv)
   end
 end

data/lib/abank/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Abank
-  VERSION = '0.2.4'
+  VERSION = '0.2.5'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: abank
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.2.5
 platform: ruby
 authors:
 - Hernâni Rodrigues Vaz
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-05-26 00:00:00.000000000 Z
+date: 2020-06-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -94,9 +94,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Arquiva <conta-corrente>.xlsx, <conta-cartao>.xlsx no bigquery. Pode
-  apagar movimentos similares/existentes ja no bigquery. Pode ainda classificar movimentos
-  ja no bigquery.
+description: Arquiva movimentos conta-corrente, conta-cartao do activobank no bigquery.
+  Permite apagar/recriar movimentos/rendas ja no bigquery.  Permite ainda classificar
+  movimentos no bigquery.
 email:
 - hernanirvaz@gmail.com
 executables:
@@ -143,8 +143,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.0.8
 signing_key: 
 specification_version: 4
-summary: Arquiva <conta-corrente>.xlsx, <conta-cartao>.xlsx no bigquery.
+summary: Arquiva movimentos conta-corrente, conta-cartao do activobank no bigquery.
 test_files: []