rails-importer 0.0.9 → 0.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f3635e5ee04bb01d660a84c489f677c293fd9a2e
-  data.tar.gz: 2dac3d5fd9b21739a18bb9dd89b600709792a631
+  metadata.gz: 1bea8cb112642a3e3695ba97fefcbe5637e685f6
+  data.tar.gz: d1df31e5b7cef7266dafc0c0d556ab135349bb9e
 SHA512:
-  metadata.gz: aa1341f372d03468fa320b8b77a919472abffc0ac68593d927f2270b90e1f899432ed3e0b107b517a66bfc70b8387da7f5c6e46e9066e2574c3d8acf85a97f74
-  data.tar.gz: e9133c2a604f506e05b59864db75c0e5d6cd9bdbd675dae991d6ef0e38316f72772505f4ba2c97610baf20986f6bea9811b80aca7a334c7593d5a952f5d3cdb6
+  metadata.gz: de85def8d858626a261969cb6b62a53353ac8e1fbd7d5c6ec06b306c3a97509adab58f2bac405e354e5ed208a6f8c32170748c4c22b5e77aa21dd04d42db01a2
+  data.tar.gz: 1f87419a56c6b27b455181e5f294a92e855ad64bf2ca00ddddc0cfcd652346e97fa31ce3377f9f0282220831ea6925db2bc4450f42363caaee9968ec5375c979

data/README.md

@@ -53,14 +53,68 @@ end
 ### How to use
 
 You can call `import` from **Importers** objects: 
-```erb
+**file param** must be an object that responds to `.path` method
+```ruby
     file = params[:import][:file]
-    records = ExampleImporter.import(file, extra_param: 'Extra')
+    records = ExampleImporter.import(file)
 ```
 
 Or with context:
+```ruby
+    file = params[:import][:file]
+    records = ExampleImporter.import(file, context: :simple)
+```
+
+Overwrite default fields (called in the block `importer do`):
+```ruby
+    file = params[:import][:file]
+    records = ExampleImporter.import(file, fields: [:name, :email, :age])
+```
 
-```erb
+With extra params:
+```ruby
     file = params[:import][:file]
-    records = ExampleImporter.import(file, context: :simple, extra_param: 'Extra')
-```
+    records = ExampleImporter.import(file, {user: 'john@mail.com'})
+```
+Then inside each record you can get params:
+```ruby
+class ExampleImporter < RailsImporter::Base
+  importer do
+    # ...
+    each_record do |record, params|
+      # ...
+      params[:user]
+      # ...
+    end
+    # ...
+  end
+end
+```
+
+With full options:
+```ruby
+    file = params[:import][:file]
+    records = ExampleImporter.import(file,
+      context: :simple,
+      fields: [:name, :email, :age],
+      {user: 'john@mail.com', account: '1'})
+```
+
+To return imported values, you need to return values inside of `each_record`:
+```ruby
+class ExampleImporter < RailsImporter::Base
+  importer do
+    # ...
+    each_record do |record, params|
+      # ...
+      u = Model.new(record)
+      u.created_by = params[:user]
+      ok = !!u.save
+      return {record: u, success: ok}
+    end
+    # ...
+  end
+end
+records = ExampleImporter.import(file, {user: 'john@mail.com'})
+# [{record: ..., success: true}, {record: ..., success: false}]
+```

data/config/locales/importers.en.yml

@@ -1,4 +1,7 @@
 en:
   importer:
     error:
-      invalid_file_type: "Invalid file type allowed: %{file_types}"
+      invalid_file: "Invalid File instance."
+      invalid_file_type: "Invalid file type allowed: %{file_types}"
+      convert_number_to_text: "Error when convert number to text"
+      

data/lib/rails_importer/base.rb

@@ -8,18 +8,23 @@ module RailsImporter
     class << self
       def import(file, *args)
         context = args.try(:context) || :default
+        custom_fields = args.try(:fields) || nil
         result = []
         begin
-          ext = (File.extname(file.path)[1..-1] rescue nil)
-          if file.respond_to?(:path) and self.file_types.include?(ext.to_sym)
-            rows = self.send("import_from_#{ext}", file)
-            if rows.present? and rows.is_a?(Array)
-              result = rows.map do |record|
-                self.importers[context][:each_record].call(record, *args) if self.importers[context][:each_record].is_a?(Proc)
-              end.compact
+          if file.respond_to?(:path)
+            ext = (File.extname(file.path)[1..-1] rescue '')
+            if self.file_types.include?(ext.to_sym)
+              rows = self.send('import_from_%s' % ext, file, context, custom_fields)
+              if rows.present? && rows.is_a?(Array)
+                result = rows.map do |record|
+                  self.importers[context][:each_record].call(record, *args) if self.importers[context][:each_record].is_a?(Proc)
+                end.compact
+              end
+            else
+              result = I18n.t(:invalid_file_type, file_types: self.file_types.join(', '), scope: [:importer, :error])
             end
           else
-            I18n.t(:invalid_file_type, file_types: self.file_types.join(', '), scope: [:importer, :error])
+            result = I18n.t(:invalid_file, scope: [:importer, :error])
           end
         rescue Exception => e
           result = e.message
@@ -57,19 +62,19 @@ module RailsImporter
       end
 
       private
-      def import_from_csv(file, context = :default)
+      def import_from_csv(file, context = :default, custom_fields = :nil)
         records = []
         line = 0
         CSV.foreach(file.path, {:headers => false, :col_sep => ';', :force_quotes => true}) do |row|
           if line > 0
-            records << object_values(row, context) unless array_blank?(row)
+            records << object_values(row, context, custom_fields) unless array_blank?(row)
           end
           line += 1
         end
         records
       end
 
-      def import_from_xml(file, context = :default)
+      def import_from_xml(file, context = :default, custom_fields = :nil)
         records = []
         xml_structure = self.importers[context][:xml_structure]
         xml = Hash.from_xml(file.read)
@@ -77,33 +82,33 @@ module RailsImporter
           xml = xml[node.to_s]
         end
         xml.each do |elem|
-          records << object_values(elem.values, context) unless array_blank?(elem.values)
+          records << object_values(elem.values, context, custom_fields) unless array_blank?(elem.values)
         end
         records
       end
 
-      def import_from_xls(file, context = :default)
+      def import_from_xls(file, context = :default, custom_fields = :nil)
         records = []
         Spreadsheet.client_encoding = 'UTF-8'
         document = Spreadsheet.open(file.path)
         spreadsheet = document.worksheet 0
         spreadsheet.each_with_index do |row, i|
           next if i.zero?
-          records << object_values(row, context) unless array_blank?(row)
+          records << object_values(row, context, custom_fields) unless array_blank?(row)
         end
         records
       end
 
-      def object_values(array, context = :default)
-        attributes = self.importers[context][:fields]
+      def object_values(array, context = :default, custom_fields = nil)
+        attributes = custom_fields || self.importers[context][:fields]
         attributes = attributes.keys if attributes.is_a?(Hash)
-        args = array[0...attributes.size]
-        hash_values = Hash[attributes.zip(args)]
+        values = equalize_columns_of_values(attributes, array)
+        hash_values = Hash[attributes.zip(values)]
         attributes.each do |attr|
           if hash_values[attr].present?
             if hash_values[attr].is_a?(Numeric)
               hash_values[attr] = hash_values[attr].to_i if hash_values[attr].modulo(1).zero?
-              hash_values[attr] = (hash_values[attr].to_s.strip rescue '#ERRO AO CONVERTER NUMERO PARA TEXTO')
+              hash_values[attr] = (hash_values[attr].to_s.strip rescue I18n.t(:convert_number_to_text, scope: [:importer, :error]))
             elsif hash_values[attr].is_a?(Date)
               hash_values[attr] = (I18n.l(hash_values[attr], format: '%d/%m/%Y') rescue hash_values[attr]).to_s
             elsif hash_values[attr].is_a?(DateTime)
@@ -126,7 +131,7 @@ module RailsImporter
       def importer_value(key, attributes)
         if attributes.present?
           if key == :fields
-            self.importers[@importer_name][key] = (attributes.first.is_a?(Hash) ? attributes.inject(:merge) : attributes)
+            self.importers[@importer_name][key] = normalize_fields(attributes)
           else
             self.importers[@importer_name][key] = attributes
           end
@@ -134,6 +139,28 @@ module RailsImporter
           self.importers[@importer_name][key]
         end
       end
+
+      def normalize_fields(attributes)
+        if attributes.first.is_a?(Hash)
+          attributes.inject(:merge)
+        elsif attributes.first.is_a?(Array)
+          attributes.flatten
+        else
+          attributes
+        end
+      end
+
+      def equalize_columns_of_values(attributes, values=[])
+        if attributes.size > values.size
+          diff_size = (attributes.size - values.size).abs
+          values + Array.new(diff_size, nil)
+        elsif attributes.size < values.size
+          values[0...attributes.size]
+        else
+          values
+        end
+      end
+
     end
 
   end

data/lib/rails_importer/version.rb

@@ -1,3 +1,3 @@
 module RailsImporter
-  VERSION = "0.0.9"
+  VERSION = "0.0.10"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails-importer
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.0.10
 platform: ruby
 authors:
 - Bruno Porto
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-01-17 00:00:00.000000000 Z
+date: 2018-03-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -67,7 +67,6 @@ files:
 - lib/generators/templates/generic_importer.erb
 - lib/rails-importer.rb
 - lib/rails_importer.rb
-- lib/rails_importer/_importer.rb
 - lib/rails_importer/base.rb
 - lib/rails_importer/engine.rb
 - lib/rails_importer/version.rb
@@ -91,7 +90,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.12
+rubygems_version: 2.6.14
 signing_key: 
 specification_version: 4
 summary: Rails Importer

data/lib/rails_importer/_importer.rb

@@ -1,138 +0,0 @@
-require 'ostruct'
-
-module RailsImporter
-
-  def self.included(base)
-    base.extend ClassMethods
-
-    base.define_singleton_method 'colunas' do |*args|
-      @importacao_colunas = nil unless @importacao_colunas.present?
-      if args.present?
-        @importacao_colunas = (args.first.is_a?(Hash) ? args.inject(:merge) : args)
-      else
-        @importacao_colunas
-      end
-    end
-
-    base.define_singleton_method 'estrutura_xml' do |*args|
-      @importacao_estrutura_xml = nil unless @importacao_estrutura_xml.present?
-      if args.present?
-        @importacao_estrutura_xml = args
-      else
-        @importacao_estrutura_xml
-      end
-    end
-
-    base.define_singleton_method 'para_cada_linha' do |&block|
-      define_singleton_method('importar_registro') do |registro, *args|
-        block.call(registro, *args)
-      end
-    end
-
-  end
-
-  def self.tipos_de_arquivos
-    [:csv, :xls, :xml]
-  end
-
-  module ClassMethods
-
-    def importacao(&block)
-      block.call if block_given?
-      self.class.class_eval do
-        define_method :importar do |arquivo, *args|
-          retorno = []
-          begin
-            ext = (File.extname(arquivo.path)[1..-1] rescue nil)
-            if arquivo.respond_to?(:path) and RailsImporter.tipos_de_arquivos.include?(ext.to_sym)
-              registros = self.send("#{ext}_para_array", arquivo)
-              if registros.present? and registros.is_a?(Array)
-                retorno = registros.map do |registro|
-                  importar_registro(registro, *args)
-                end
-              end
-            else
-              raise "Tipo de arquivo inválido. Arquivos permitidos: #{RailsImporter.tipos_de_arquivos.join(', ')}"
-            end
-          rescue Exception => e
-            retorno = e.message
-          end
-          retorno
-        end
-      end
-    end
-
-    private
-    def csv_para_array(arquivo)
-      registros = []
-      linha=0
-      CSV.foreach(arquivo.path, {:headers => false, :col_sep => ';', :force_quotes => true}) do |row|
-        if linha>0
-          registros << object_values(row) unless array_blank?(row)
-        end
-        linha+=1
-      end
-      registros
-    end
-
-    def xml_para_array(arquivo)
-      registros = []
-      estrutura_xml = self.send(:estrutura_xml)
-      if estrutura_xml.present? and estrutura_xml.is_a?(Array) and estrutura_xml.count > 0
-        xml = Hash.from_xml(arquivo.read)
-        estrutura_xml.each do |node|
-          xml = xml[node.to_s]
-        end
-        xml.each do |elem|
-          registros << object_values(elem.values) unless array_blank?(elem.values)
-        end
-      else
-        raise 'Você precisa informar a estrutura_xml no seu Model'
-      end
-      registros
-    end
-
-    def xls_para_array(arquivo)
-      registros = []
-      Spreadsheet.client_encoding = 'UTF-8'
-      documento = Spreadsheet.open(arquivo.path)
-      planilha = documento.worksheet 0
-      planilha.each_with_index do |row, i|
-        next unless i>0
-        registros << object_values(row) unless array_blank?(row)
-      end
-      registros
-    end
-
-    def object_values(array)
-      atributos = self.send(:colunas)
-      atributos = atributos.keys if atributos.is_a?(Hash)
-      args = array[0...atributos.size]
-      hValores = Hash[atributos.zip(args)]
-      #Ajustando valores inválidos
-      atributos.each do |atributo|
-        if hValores[atributo].present?
-          if hValores[atributo].is_a?(Numeric)
-            hValores[atributo] = hValores[atributo].to_i if hValores[atributo].modulo(1).zero?
-            hValores[atributo] = (hValores[atributo].to_s.strip rescue '#ERRO AO CONVERTER NUMERO PARA TEXTO')
-          elsif hValores[atributo].is_a?(Date)
-            hValores[atributo] = (I18n.l(hValores[atributo], format: '%d/%m/%Y') rescue hValores[atributo]).to_s
-          elsif hValores[atributo].is_a?(DateTime)
-            hValores[atributo] = (I18n.l(hValores[atributo], format: '%d/%m/%Y %H:%i:%s') rescue hValores[atributo]).to_s
-          else
-            #PARA QUALQUER OUTRO VALOR, FORÇA CONVERTER PARA STRING
-            hValores[atributo] = (hValores[atributo].to_s.strip rescue '')
-          end
-        else
-          hValores[atributo] = ''
-        end
-      end
-      OpenStruct.new(hValores)
-    end
-
-    def array_blank?(array)
-      array.all? {|i|i.nil? or i==''}
-    end
-
-  end
-end