rails_data 0.0.1

data/app/helpers/data_records_helper.rb

@@ -0,0 +1,2 @@
+module DataRecordsHelper
+end

data/app/helpers/rails_data_helper.rb

@@ -0,0 +1,21 @@
+module RailsDataHelper
+
+  def text_field_tag(name, value = nil, options = {})
+    if options[:as]
+      type = RailsData.config.mapping[options[:as]][:input]
+
+      if type == 'textarea'
+        return text_area_tag(name, value, options)
+      end
+
+      if type == 'select'
+        opts = RailsData.config.mapping[options[:as]][:options]
+        selected = RailsData.config.mapping[options[:as]][:selected]
+        return select_tag name, options_for_select(opts, selected), options
+      end
+    end
+
+    super
+  end
+
+end

data/app/jobs/table_job.rb

@@ -0,0 +1,11 @@
+class TableJob < ActiveJob::Base
+  queue_as :default
+
+  def perform(table_list_id, user_id)
+    @table_list = TableList.find(table_list_id)
+    @table_list.run
+
+    ActionCable.server.broadcast "user:#{user_id}", body: '<i class="green checkmark icon"></i>', done_id: table_list_id
+  end
+
+end

data/app/mailers/report_finish_mailer.rb

@@ -0,0 +1,17 @@
+class ReportFinishMailer < ActionMailer::Base
+  default from: ""
+
+  def finish_notify(id)
+    @report_list = ReportList.find(id)
+    @message = @report_list.notice_body
+
+    if Rails.env == 'production'
+      @email = @report_list.notice_email
+    else
+      @email = 'mingyuan0715@foxmail.com'
+    end
+
+    mail to: @email, subject: "Generation Complete"
+  end
+
+end

data/app/models/rails_data/concerns/data_cache_service.rb

@@ -0,0 +1,26 @@
+class DataCacheService
+  include DataExportHelper
+
+  def initialize(table_list)
+    @table_list = table_list
+    @data_list = @table_list.data_list
+    @config_table = table_list.data_list.config_table
+    convert_parameters(@table_list.parameters)
+  end
+
+  def cache_table
+    @table_list.headers = header_result
+    cache_table_items
+    @table_list.footers = footer_result
+    @table_list.done = true
+    @table_list.save
+  end
+
+  def cache_table_items
+    @config_table.collection.call(@params).each_with_index do |object, index|
+      row = field_result(object, index)
+      @table_list.table_items.create(fields: row)
+    end
+  end
+
+end

data/app/models/rails_data/concerns/data_export_helper.rb

@@ -0,0 +1,55 @@
+module DataExportHelper
+
+  def convert_parameters(parameters)
+    @params = {}
+    parameters.each do |k, v|
+      @params.merge! k.to_sym => v.send(RailsData.config.mapping[@data_list.parameters[k].to_sym][:output])
+    end
+    @params
+  end
+
+  def header_result
+    results = []
+
+    @config_table.columns.each do |_, column|
+      if column[:header].respond_to?(:call)
+        results << column[:header].call
+      else
+        results << column[:header]
+      end
+    end
+    results
+  end
+
+  def field_result(object, index)
+    results = []
+    @config_table.columns.each do |_, column|
+      params = column[:field].parameters.to_combined_h
+      if Array(params[:key]).include? :index
+        results << column[:field].call(object, index)
+      elsif params[:key]
+        results << column[:field].call(object, **@params.slice(params[:key]))
+      elsif params[:key].blank? && params[:req]
+        results << column[:field].call(object)
+      else
+        results << nil
+      end
+    end
+
+    results
+  end
+
+  def footer_result
+    results = []
+
+    @config_table.columns.each do |_, column|
+      if column[:footer].respond_to?(:call)
+        results << column[:footer].call
+      else
+        results << column[:footer]
+      end
+    end
+    results
+  end
+
+end

data/app/models/rails_data/concerns/data_import_helper.rb

@@ -0,0 +1,40 @@
+module DataImportHelper
+
+  def import_to_table_list(file)
+    importer = data_list.importer(file)
+    self.headers = importer.results[0]
+    self.done = true
+    self.save
+    importer.results[1..-1].each do |row|
+      table_items.create(fields: row)
+    end
+  end
+
+  def import_columns
+    config = data_list.config_table
+    columns = {}
+    config.columns.each do |key, value|
+      columns[key] = config.columns[key].merge(index: self.headers.find_index(value[:header]))
+    end
+    columns.reject { |_, v| v[:index].nil? }
+  end
+
+  def migrate
+    config = data_list.config_table
+    columns = import_columns
+    self.table_items.each do |table_item|
+      attr = {}
+      columns.map do |key, value|
+        r = table_item.fields[value[:index]]
+        if value[:field] && value[:field].respond_to?(:call)
+          attr[key] = value[:field].call(r)
+        else
+          attr[key] = r
+        end
+      end
+      config.record.create attr
+    end
+    self.destroy
+  end
+
+end

data/app/models/rails_data/concerns/data_import_service.rb

@@ -0,0 +1,35 @@
+require 'roo'
+class DataImportService
+  attr_reader :sheet, :column_index
+
+  def initialize(config, sheet_file)
+    if File.extname(sheet_file.path) == '.xls'
+      require 'roo-xls'
+      xlsx = Roo::Excel.new(sheet_file)
+    else
+      xlsx = Roo::Excelx.new(sheet_file)
+    end
+    @sheet = xlsx.sheet(xlsx.sheets[0])
+    @config = config
+
+    @column_index = init_header.compact
+  end
+
+  def init_header
+    headers = @config.columns.map { |_, v| v[:header] }
+    file_header = @sheet.row(1)
+
+    headers.map do |header|
+      file_header.find_index(header)
+    end
+  end
+
+  def results
+    results = []
+    @sheet.each do |row|
+      results << column_index.map { |index| row[index] }
+    end
+    results
+  end
+
+end

data/app/models/rails_data/data_list.rb

@@ -0,0 +1,47 @@
+require 'rails_com/utils/setting'
+class DataList < ApplicationRecord
+  serialize :parameters, Hash
+  serialize :columns, Hash
+
+  has_many :table_lists, dependent: :destroy
+  has_many :table_items, through: :table_lists
+
+  scope :published, -> { where(published: true) }
+
+  before_create :update_parameters
+
+  def rebuild!
+    self.save
+  end
+
+  def form_parameters
+    r = parameters.map { |k, v| { key: k, value: v } }
+    if r.blank?
+      r = [{ key: nil, value: nil }]
+    end
+    Settings.new(r)
+  end
+
+  def update_parameters
+    self.parameters = config_params
+  end
+
+  def config_params
+    hash = {}
+    config_table.parameters.map { |p| hash[p] = nil }
+    hash
+  end
+
+  def config_table
+    @config_table ||= data_table.to_s.safe_constantize
+  end
+
+  def config_excel
+    @config_excel ||= export_excel.to_s.safe_constantize
+  end
+
+  def config_pdf
+    @config_pdf ||= export_pdf.to_s.safe_constantize
+  end
+
+end

data/app/models/rails_data/data_lists/data_export.rb

@@ -0,0 +1,11 @@
+class DataExport < DataList
+
+  def headers
+    config_table.columns.map { |p| p[1][:header] }
+  end
+
+  def just_run
+
+  end
+
+end

data/app/models/rails_data/data_lists/data_import.rb

@@ -0,0 +1,11 @@
+class DataImport < DataList
+
+  def importer(file)
+    @importer ||= DataImportService.new(config_table, file)
+  end
+
+
+  def config_params
+    {}
+  end
+end

data/app/models/rails_data/data_lists/data_record.rb

@@ -0,0 +1,18 @@
+class DataRecord < DataList
+  has_many :record_lists, foreign_key: 'data_list_id', dependent: :destroy
+  has_many :record_items, through: :record_lists
+
+  def rebuild!
+    self.columns = self.config_params
+    super
+  end
+
+  def update_parameters
+    self.columns = config_columns
+  end
+
+  def config_columns
+    config_table.columns.transform_values { |x| x[:as] }
+  end
+
+end

data/app/models/rails_data/export_services/csv_export_service.rb

@@ -0,0 +1,24 @@
+require 'csv'
+class CsvExportService
+  include DataExportHelper
+
+  attr_reader :sheet, :headers
+
+  def initialize
+    headers =
+    config_table
+
+
+  end
+
+
+  def to_csv
+    csv = ''
+    csv << headers.to_csv
+    self.table_items.each do |table_item|
+      csv << table_item.fields.to_csv
+    end
+    csv
+  end
+
+end

data/app/models/rails_data/export_services/pdf_export_service.rb

@@ -0,0 +1,74 @@
+require 'prawn/table'
+class PdfExportService
+  include DataExportHelper
+
+  def pdf
+    if reportable.respond_to?(:pdf_object)
+      @pdf ||= reportable.pdf_object(reportable_name)
+    else
+      @pdf ||= TablePdf.new
+    end
+  end
+
+  def remove_file_save
+    self.remove_file = true
+    self.save
+    self.remove_file = nil
+  end
+
+  def pdf_data
+    if file_id
+      file.read
+    else
+      pdf_string
+    end
+  end
+
+  def pdf_string
+    pdf_result.render
+  end
+
+  def pdf_result
+    pdf.table_data = table_lists.includes(:table_items).map { |i| i.csv_array }
+    pdf.header_data = header_data
+    pdf.ending_data = ending_data
+    pdf.run
+    pdf
+  end
+
+  def header_data
+    if reportable.respond_to? :header_info
+      reportable.header_info
+    else
+      [
+        ['', ''],
+        ['', '']
+      ]
+    end
+  end
+
+  def ending_data
+    if reportable.respond_to? :ending_data
+      reportable.try(:ending_data)
+    else
+      ''
+    end
+  end
+
+  def filename(extension = 'pdf')
+    if file_filename.present?
+      filename = file_filename
+    elsif reportable.respond_to?(:filename)
+      filename = reportable.filename
+    else
+      filename = "#{reportable_name.camelize}-#{reportable_id}"
+    end
+
+    unless filename.end_with?(extension)
+      filename << '.' << extension
+    end
+
+    filename
+  end
+
+end

data/app/models/rails_data/export_services/xlsx_export_service.rb

@@ -0,0 +1,51 @@
+require 'write_xlsx'
+class XlsxExportService
+  include DataExportHelper
+  attr_reader :sheet,
+              :table_list,
+              :params, :headers
+
+  def initialize(table_list: nil, data_list: nil, params: {}, headers: [])
+    if table_list
+      @table_list = table_list
+      @data_list = table_list.data_list
+      @headers = headers.presence || table_list.headers
+      convert_parameters(params)
+    elsif data_list
+      @data_list = data_list
+      @headers = headers
+      convert_parameters(params)
+    end
+    @config_table = @data_list.config_table
+
+    @io = StringIO.new
+    @workbook = WriteXLSX.new(@io)
+    @sheet = @workbook.add_worksheet
+  end
+
+  def direct_xlsx
+    sheet.write_row(0, 0, headers)
+
+    @config_table.collection.call(@params).each_with_index do |object, index|
+      row = field_result(object, index)
+      sheet.write_row(index + 1, 0, row)
+    end
+
+    @workbook.close
+    @io.string
+  end
+
+  def cached_xlsx
+    sheet.write_row(0, 0, table_list.headers)
+
+    table_list.table_items.each_with_index do |table_item, index|
+      sheet.write_row(index + 1, 0, table_item.fields)
+    end
+
+    sheet.write_row table_list.table_items_count + 1, 0, table_list.footers
+
+    @workbook.close
+    @io.string
+  end
+
+end

data/app/models/rails_data/record_list.rb

@@ -0,0 +1,69 @@
+class RecordList < ApplicationRecord
+  serialize :columns, Hash
+  serialize :parameters, Hash
+  belongs_to :data_list
+
+  default_scope -> { order(id: :desc) }
+
+  def run
+    to_table
+  end
+
+  def to_table
+    initialize_table
+    self.to_table_items
+    self.done = true
+    self.save
+  end
+
+  def initialize_table
+    @config_table = data_list.config_table
+    @record = @config_table.record.call(converted_parameters)
+    @config_table
+  end
+
+  def converted_parameters
+    param = {}
+    parameters.each do |k, v|
+      param.merge! k.to_sym => v.send(RailsData.config.mapping[data_list.parameters[k].to_sym][:output])
+    end
+    param
+  end
+
+  def to_table_items
+    self.columns = field_result(@record)
+  end
+
+  def field_result(object)
+    results = {}
+    @config_table.columns.each do |key, column|
+      if column[:field].arity == 1
+        results[key] = column[:field].call(object)
+      else
+        results[key] = nil
+      end
+    end
+
+    results
+  end
+
+  def to_xlsx
+    @config_excel = data_list.config_excel.new(self.columns)
+    @config_excel.render
+  end
+
+  def to_pdf
+    @config_pdf ||= data_list.config_pdf.new(self.columns)
+    @config_pdf.render
+  end
+
+  def xlsx_file_name
+    @config_excel.file_name || "#{self.id}.xlsx"
+  end
+
+  def file_name(format)
+    name = self.id || 'example'
+    "#{name}.#{format}"
+  end
+
+end

data/app/models/rails_data/table_item.rb

@@ -0,0 +1,5 @@
+class TableItem < ApplicationRecord
+  serialize :fields, Array
+  belongs_to :table_list, counter_cache: true
+
+end

data/app/models/rails_data/table_list.rb

@@ -0,0 +1,47 @@
+class TableList < ApplicationRecord
+  include DataImportHelper
+  serialize :parameters, Hash
+  serialize :headers, Array
+  serialize :footers, Array
+
+  belongs_to :data_list, optional: true
+  has_many :table_items, dependent: :delete_all
+
+  def run
+    clear_old
+    export = DataCacheService.new(self)
+    export.cache_table
+  end
+
+  def direct_xlsx
+    _headers = self.headers.presence || self.data_list.headers
+    export = XlsxExportService.new(data_list: self.data_list, params: self.parameters, headers: _headers)
+    export.direct_xlsx
+  end
+
+  def cached_xlsx
+    export = XlsxExportService.new(table_list: self)
+    export.cached_xlsx
+  end
+
+  def cached_run(_timestamp = nil)
+    unless self.timestamp.present? && self.timestamp == _timestamp.to_s
+      self.timestamp = _timestamp
+      run
+    end
+  end
+
+  def clear_old
+    self.done = false
+    self.class.transaction do
+      self.save!
+      table_items.delete_all
+    end
+  end
+
+  def file_name(format)
+    name = self.id || 'example'
+    "#{name}.#{format}"
+  end
+
+end

data/app/pdfs/concerns/pdf_page_helper.rb

@@ -0,0 +1,37 @@
+module PdfPageHelper
+
+  def repeat_header(data = nil)
+    repeat :all do
+      canvas do
+        bounding_box [bounds.left+75, bounds.top-20], :width  => bounds.width do
+          process_header(data)
+        end
+      end
+    end
+  end
+
+  def process_header(data)
+    default_options = {
+      cell_style: { borders: [] },
+      column_widths: [225, 220]
+    }
+
+    table(data, default_options) do
+      row(0).style font_style: :bold, size: 14
+      row(1..-1).style size: 10
+      column(0).style align: :left, padding: 0
+      column(1).style align: :right, padding: 0
+      cells[2, 0].style size: 12 if cells[2, 0].present?
+    end
+
+    move_down 50
+  end
+
+  def footer(data = nil, options = {})
+    text data
+    if options[:page]
+      number_pages "<page> / <total>", at: [bounds.right - 50, 0]
+    end
+  end
+
+end