sp-excel-loader 0.3.40

data/lib/sp/excel/loader/json_to_xlsx.rb

@@ -0,0 +1,159 @@
+# encoding: utf-8
+#
+# Copyright (c) 2011-2016 Cloudware S.A. All rights reserved.
+#
+# This file is part of sp-excel-loader.
+#
+# sp-excel-loader is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# sp-excel-loader is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with sp-excel-loader.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+module Sp
+  module Excel
+    module Loader
+
+      class JsonToXlsx < WorkbookLoader
+
+        attr_accessor :json_data
+        attr_accessor :fields
+
+        def initialize (a_excel_template, a_json)
+          super(a_excel_template)
+          @json_data = a_json
+        end
+
+        def convert_to_xls ()
+          ws, tbl, ref = find_table('lines')
+
+          # Detect optional report mode
+          is_report = false
+          if !ws[0].nil? && !ws[0][0].nil?
+            ws[0][0].value.lines.each do |line|
+              directive, value = line.split(':')
+              if directive.strip == 'IsReport' and value.strip == 'true'
+                is_report = true
+              end
+            end
+          end
+
+          headers_idx = 0 .. ref.row_range.begin() - 1
+          footers_idx = ref.row_range.end() + 1 .. ws.count - 1
+
+          # Replace parameters in header and footer rows
+          (headers_idx.to_a + footers_idx.to_a).each do |row|
+            ref.col_range.each do |col|
+              next if ws[row].nil?
+              next if ws[row][col].nil?
+              value = ws[row][col].value
+              next if value.nil?
+
+              value = value.to_s
+              @json_data['data']['attributes'].each do |key, val|
+                value = value.gsub('$P{' + key +'}', val.to_s)
+              end
+              value = value.gsub('$V{PAGE_NUMBER}', '1')
+
+              unless @json_data['included'].nil? or @json_data['included'].size == 0
+                @json_data['included'][0]['attributes'].each do |key,val|
+                  value = value.gsub('$FN?{' + key +'}', val.to_s)
+                end
+              end
+              ws[row][col].change_contents(value)
+            end
+          end
+
+          # Collect mapped fields
+          header_row = ref.row_range.begin()
+          dst_row    = header_row + 1
+          fields     = Hash.new
+          null_fields = Array.new
+
+          ref.col_range.each do |col|
+            cell = ws[dst_row][col]
+            next if cell.nil?
+            next if cell.value.nil?
+            m = /\A\$(FN?){(.+)}\z/.match cell.value.strip()
+            next if m.nil?
+            null_fields[col] = m[1] == 'FN' ? true : false
+            fields[col] = m[2]
+          end
+
+          # Make space for the expanded data table, shift the merged cells down
+          if is_report && !@json_data['included'].nil? && @json_data['included'].size != 0
+            row_cnt = @json_data['included'].size
+            if row_cnt != 0
+              (row_cnt - 1).times { ws.insert_row(dst_row + 1) }
+            end
+            ws.merged_cells.each do |cell|
+              next unless cell.ref.row_range.min >= dst_row
+              cell.ref.instance_variable_set(:"@row_range", Range.new(cell.ref.row_range.min + row_cnt - 1, cell.ref.row_range.max + row_cnt - 1))
+            end
+          end
+
+          # In report mode empty the first row and column
+          if is_report
+            ws.change_row_height(0, 6)
+            ws.change_column_width(0, 1)
+            ws.each_with_index do |row, ridx|
+              ws.delete_cell(ridx, 0)
+            end
+          end
+
+          # Create the table rows
+          if @json_data['included'].nil?
+            ref.col_range.each do |col|
+              ws[dst_row][col].change_contents('')
+              ws[dst_row][col].style_index = ws[header_row + 1][col].style_index
+            end
+          else
+            @json_data['included'].each do |line|
+              fields.each do |col,field|
+
+                value = line['attributes'][field]
+                if value.nil? and false == null_fields[col]
+                  value = 0
+                end
+
+                if ws[dst_row].nil? || ws[dst_row][col].nil?
+                  ws.add_cell(dst_row, col, value)
+                else
+                  ws[dst_row][col].change_contents(value)
+                end
+                ws[dst_row][col].style_index = ws[header_row + 1][col].style_index
+              end
+              dst_row += 1
+            end
+            # Update the table size
+            tbl.ref = RubyXL::Reference.ind2ref(ref.row_range.begin(),
+                                                ref.col_range.begin()) + ":" +
+                      RubyXL::Reference.ind2ref(ref.row_range.begin() + (dst_row - header_row - 1),
+                                                ref.col_range.end())
+          end
+
+          # In report mode delete all worksheets except the one that contains the lines table and wipe comments
+          if is_report
+            @workbook.worksheets.delete_if {|sheet| sheet.sheet_name != ws.sheet_name}
+            ws.comments = Array.new
+          end
+
+        end
+
+        def workbook
+          @workbook
+        end
+
+      end
+
+    end
+  end
+end

data/lib/sp/excel/loader/model_exporter.rb

@@ -0,0 +1,249 @@
+# encoding: utf-8
+#
+# Copyright (c) 2011-2016 Cloudware S.A. All rights reserved.
+#
+# This file is part of sp-excel-loader.
+#
+# sp-excel-loader is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# sp-excel-loader is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with sp-excel-loader.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+module Sp
+  module Excel
+    module Loader
+
+      class ModelExporter < WorkbookLoader
+
+        attr_accessor  :model
+
+        def initialize (a_file, a_typed_export)
+          super(a_file)
+          @model        = Hash.new
+          @typed_export = a_typed_export
+        end
+
+        def read_model(a_sheet_name, a_table_name)
+          read_model_with_typed_option(a_sheet_name, a_table_name, @typed_export)
+        end
+
+        def read_model_with_typed_option(a_sheet_name, a_table_name, a_typed_export)
+
+          read_cell_names(a_sheet_name)
+          col_names       = Hash.new
+          header_columns  = Hash.new
+          scalar_formulas = Hash.new
+          formula_lines   = Array.new
+          scalar_values   = Hash.new
+          value_lines     = Array.new
+
+          worksheet  = @workbook[a_sheet_name]
+          ref        = nil
+
+          parse_shared_formulas(worksheet)
+
+          # Capture the columns names
+          worksheet.generic_storage.each do |tbl|
+            next unless tbl.is_a? RubyXL::Table and tbl.name == a_table_name
+
+            ref      = RubyXL::Reference.new(tbl.ref)
+            type_row = ref.row_range.first() - 1
+            i        = ref.col_range.first()
+            tbl.table_columns.each do |table_col|
+              if a_typed_export
+                col_names[i] = { 'name' => table_col.name, 'type' => get_column_type(worksheet, type_row, i) }
+              else
+                col_names[i] = table_col.name
+              end
+              i += 1
+            end
+
+            col_names.sort.map do |key, value|
+              header_columns[RubyXL::Reference.new(ref.row_range.first(),ref.col_range.first() + key - 1)] = value
+            end
+          end
+
+          # Build the formula and value arrays
+          for row in ref.row_range.begin()+1..ref.row_range.end()
+            formula   = Hash.new
+            value     = Hash.new
+            col_index = 1
+
+            ref.col_range.each do |col|
+
+              cell = worksheet[row][col]
+              if a_typed_export
+                column = col_names[col_index]['name']
+              else
+                column = col_names[col_index]
+              end
+              if cell
+                key, expression = cell_expression(cell)
+                if cell.formula
+                  formula[column] = expression
+                else
+                  value[column] = expression unless expression.nil?
+                end
+              end
+              col_index += 1
+            end
+            formula_lines << formula
+            value_lines << value
+          end
+
+          # Read scalar values and formulas, from the rows that are not part of the lines table
+          renum = Array.new
+          renum =  (0..ref.row_range.begin()).to_a
+          renum += (ref.row_range.end()+1..worksheet.dimension.ref.row_range.end()).to_a
+          for idx in renum
+            next if worksheet[idx].nil?
+            next if worksheet[idx].cells.nil?
+            worksheet[idx].cells.each do |cell|
+              if cell
+                key, expression = cell_expression(cell)
+
+                if cell.formula
+                  scalar_formulas[key] = a_typed_export ? get_typed_scalar(cell, expression, worksheet) : expression
+                else
+                  unless expression.nil?
+                    scalar_values[key] = a_typed_export ? get_typed_scalar(cell, expression, worksheet) : expression
+                  end
+                end
+              end
+            end
+          end
+
+          @model = {
+            'values'   => scalar_values,
+            'formulas' => scalar_formulas,
+            'lines'    => {
+              'header'    => header_columns,
+              'formulas'  => formula_lines,
+              'values'    => value_lines
+              },
+            }
+        end
+
+        def cell_expression (a_cell)
+
+          cell_reference = RubyXL::Reference.ind2ref(a_cell.row, a_cell.column)
+          name           = @cellnames[cell_reference]
+          formula        = read_formula_expression(a_cell)
+
+          if formula != nil
+            if name
+              expression = "#{name}=#{formula}"
+            else
+              expression = "#{cell_reference}=#{formula}"
+            end
+          elsif a_cell.value
+            if name
+              if a_cell.is_date?
+                expression = "#{name}=excel_date(#{a_cell.value})"
+              else
+                begin
+                  Float(a_cell.value)
+                  expression = "#{name}=#{a_cell.value}"
+                rescue
+                  expression = "#{name}=\"#{a_cell.value}\""
+                end
+              end
+            else
+              if a_cell.is_date?
+                expression = "#{cell_reference}=excel_date(#{a_cell.value})"
+              else
+                begin
+                  Float(a_cell.value)
+                  expression = "#{cell_reference}=#{a_cell.value}"
+                rescue
+                  expression = "#{cell_reference}=\"#{a_cell.value}\""
+                end
+              end
+            end
+          end
+          return cell_reference, expression
+        end
+
+        def read_cell_names (a_sheet_name)
+          @cellnames = {}
+          ref_regexp = a_sheet_name + '!\$*([A-Z]+)\$*(\d+)'
+          @workbook.defined_names.each do |dn|
+            next unless dn.local_sheet_id.nil?
+            match = dn.reference.match(ref_regexp)
+            if match and match.size == 3
+              matched_name = match[1].to_s + match[2].to_s
+              if @cellnames[matched_name]
+                raise "**** Fatal error:\n     duplicate cellname for #{matched_name}: #{@cellnames[matched_name]} and #{dn.name}"
+              end
+              @cellnames[matched_name] = dn.name
+            end
+          end
+        end
+
+        def get_column_type (a_worksheet, a_row_idx, a_column)
+          return 'TEXT' if a_worksheet[a_row_idx].nil? or a_worksheet[a_row_idx][a_column].nil? or a_worksheet[a_row_idx][a_column].value.nil?
+          return  a_worksheet[a_row_idx][a_column].value
+        end
+
+        def get_typed_scalar (a_cell, a_expression, a_worksheet)
+
+          type = get_type_from_comment(a_cell.row, a_cell.column, a_worksheet)
+          unless type.nil?
+            return { 'type' => type, 'value' => a_expression }
+          end
+
+          if a_cell.is_date?
+            return { 'type' => 'DATE', 'value' => a_expression }
+          end
+          case a_cell.datatype
+          when RubyXL::DataType::NUMBER, nil
+            return { 'type' => 'DECIMAL', 'value' => a_expression }
+          when RubyXL::DataType::BOOLEAN
+            return { 'type' => 'BOOLEAN', 'value' => a_expression }
+          when RubyXL::DataType::DATE # Only available in Office2010
+            return { 'type' => 'DATE', 'value' => a_expression }
+          end
+          return { 'type' => 'TEXT', 'value' => a_expression }
+        end
+
+
+        def get_type_from_comment (a_row, a_col, a_worksheet)
+
+          if a_worksheet.comments != nil && a_worksheet.comments.size > 0 && a_worksheet.comments[0].comment_list != nil
+
+            a_worksheet.comments[0].comment_list.each do |comment|
+              if comment.ref.col_range.begin == a_col && comment.ref.row_range.begin == a_row
+                comment.text.to_s.lines.each do |text|
+                  text.strip!
+                  next if text == '' or text.nil?
+                  idx = text.index(':')
+                  next if idx.nil?
+                  tag   = text[0..(idx-1)]
+                  value = text[(idx+1)..-1]
+                  next if tag.nil? or value.nil?
+                  tag.strip!
+                  value.strip!
+
+                  if tag == 'type'
+                    return value
+                  end
+                end
+              end
+            end
+          end
+          return nil
+        end
+
+      end
+    end
+  end
+end

data/lib/sp/excel/loader/payrollexporter.rb

@@ -0,0 +1,168 @@
+# encoding: utf-8
+#
+# Copyright (c) 2011-2016 Cloudware S.A. All rights reserved.
+#
+# This file is part of sp-excel-loader.
+#
+# sp-excel-loader is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# sp-excel-loader is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with sp-excel-loader.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+module Sp
+  module Excel
+    module Loader
+
+      class PayrollExporter < ModelExporter
+
+        attr_accessor  :tables
+        attr_accessor  :model
+
+        def initialize (a_file, a_typed_export)
+          super(a_file, a_typed_export)
+          @tables          = Hash.new
+          @pretty          = true
+        end
+
+        def read_untyped_table (a_worksheet, a_table, a_table_name)
+
+          tbl = Array.new
+          ref = RubyXL::Reference.new(a_table.ref)
+
+          ref.col_range.each do |col|
+
+            col_obj  = Hash.new
+            col_data = Array.new
+
+            type = 'number'
+            for row in ref.row_range.begin()+1..ref.row_range.end()
+              next if a_worksheet[row][col].nil?
+              next if a_worksheet[row][col].value.nil?
+              next if a_worksheet[row][col].value.is_a? Numeric
+              next if a_worksheet[row][col].value.is_a? String and a_worksheet[row][col].value.length() == 0
+              begin
+                Float(a_worksheet[row][col].value)
+              rescue
+                type = 'text'
+                break
+              end
+            end
+
+            col_obj['name'] = a_worksheet[ref.row_range.begin()][col].value.to_s
+            col_obj['type'] = type
+            col_obj['data'] = col_data
+
+            for row in ref.row_range.begin()+1..ref.row_range.end()
+              if type == 'number'
+                if a_worksheet[row][col].nil?
+                  col_data << 0.0
+                else
+                  col_data << a_worksheet[row][col].value.to_f
+                end
+              else
+                if a_worksheet[row][col].nil?
+                  col_data << ''
+                else
+                  col_data << a_worksheet[row][col].value.to_s
+                end
+              end
+            end
+
+            tbl << col_obj
+          end
+          @tables[a_table.name] = tbl
+
+        end
+
+        def read_see_table (a_table_name)
+          tbl = []
+
+          tbl_instances = self.send "#{a_table_name}"
+
+          # Get all columns reading all getter methods from first instance of a_table_name
+          columns = tbl_instances.first.class.instance_methods(false).select { |method| method.to_s[-1] != '=' }
+
+          columns.each do |column|
+            col_obj  = Hash.new
+            col_data = Array.new
+
+            tbl_instances.each do |line|
+              column_value = line.send(column)
+              is_numeric = column_value.class.in?([Fixnum, BigDecimal])
+
+              # We are at the first line of table, so prepare the structure
+              if col_obj.empty?
+                col_obj['name'] = column.to_s
+                col_obj['type'] = is_numeric ? 'number' : 'text'
+                col_obj['data'] = col_data
+              end
+
+              col_data << (is_numeric ? column_value.to_f : column_value.to_s)
+            end
+
+            tbl << col_obj
+          end
+
+          tbl
+        end
+
+        def read_all_untyped_tables ()
+          @workbook.worksheets.each do |ws|
+            ws.generic_storage.each do |tbl|
+              next unless tbl.is_a? RubyXL::Table
+              next if tbl.name == 'LINES'
+              read_untyped_table(ws, tbl, tbl.name)
+            end
+          end
+        end
+
+        def write_json_file (a_directory, a_name, a_object)
+          FileUtils::mkdir_p(a_directory)
+          File.open(File.join(a_directory, a_name + '.json'),"w") do |f|
+            if @pretty
+              f.write(JSON.pretty_generate(a_object))
+            else
+              f.write(a_object.to_json)
+            end
+          end
+        end
+
+        def write_json_tables (a_directory)
+          a_directory = File.join(a_directory, 'tables')
+          @tables.each do |name, table|
+            write_json_file(a_directory, name, table)
+          end
+        end
+
+        def write_typed_json_tables (a_directory)
+          a_directory = File.join(a_directory, 'tables')
+          @table_names.each do |name|
+            next if name == 'LINES'
+            next if name != 'TABELA_RETROATIVOS'
+
+            write_json_file(a_directory, name, read_see_table(name))
+          end
+        end
+
+        def export(a_directory)
+          self.read_all_untyped_tables # Legacy code when all tables of excel are typed
+          self.read_all_tables
+          self.write_json_file(a_directory, 'model',       self.read_model_with_typed_option('PROCESSAMENTO', 'LINES', false))
+          self.write_json_file(a_directory, 'model_typed', self.read_model_with_typed_option('PROCESSAMENTO', 'LINES', true))
+          self.write_json_tables(a_directory) # Legacy code when all tables of excel are typed
+          self.write_typed_json_tables(a_directory)
+          self
+        end
+      end
+    end
+  end
+end