spotlight_search 0.1.8 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3e9cd4941331e8c05faf205f5e88b871d70281e28b537ff8884a873c4c039c01
-  data.tar.gz: 65588a311e3dd0ca07e73064f65eb38dd92eaf21c525da71866a4621edf419bc
+  metadata.gz: 0d8c71e34af7024e41f5d6767ce6b9cc6a4466aed6882997d97b4f45e57c2500
+  data.tar.gz: bd7d756c813e0a0572dd4973e8f795ce5195740811460bd91fa595aafa556080
 SHA512:
-  metadata.gz: e4e0877a70a4340f373fbcb5cad506bdb70311db3f04cb57a9ff8985f1b1321388e9e37f9109c2a262b798b450b233449b0401f1a8799ff76808733f8ec39499
-  data.tar.gz: b7a088d2af85d00e71663cc50a37cacc149432f188e84907c33d138a2380ed705f0fb5fad8252c841d3f33d9736e0891c1b90f8e3d310ef05bb6c62a6e8d837b
+  metadata.gz: 9e83a3b01980d9d3fa0fea02ee9f9f226ec882dfbaaff6b13bf69748b9e37ef8e7cc6b8487cba6a27a4d2d1681864ae06d490628cf01d4746a6fce1c63cc9bf4
+  data.tar.gz: 1fca5cef1d8ced80eb3c9a040152277002758b592b34af18674ba205737fecba884de3f397ac4a4edf74b4104178dcdd1f75b4ae219f52b9b10e0a776adc8907

data/README.md

@@ -20,6 +20,8 @@ Or install it manually:
 
     $ gem install spotlight_search
 
+Include the spotlight_search javascript by adding the line `//= require spotlight_search` to your `app/assets/javascripts/application.js`
+
 ## Usage
 
 1. [Filtering, Sorting and Pagination](#filtering-sorting-and-pagination)
@@ -169,7 +171,7 @@ Add `exportable email, model_object` in your view to display the export button.
   </td>
 </table>
 
-<%= exportable(current_user.email, current_user.class) %>
+<%= exportable(current_user.email, Person) %>
 ```
 
 This will first show a popup where an option to select the export enabled columns will be listed. This will also apply any filters that has been selected along with a sorting if applied. It then pushes the export to a background job which will send an excel file of the contents to the specified email. You can edit the style of the button using the class `export-to-file-btn`.

data/app/jobs/spotlight_search/export_job.rb

@@ -5,7 +5,13 @@ module SpotlightSearch
     def perform(email, klass, columns = [], filters = {})
       klass = klass.constantize
       records = get_records(klass, filters, columns)
-      file_path = create_excel(records, klass.name, columns)
+      file_path =
+        case SpotlightSearch.exportable_columns_version
+        when :v1
+          create_excel(records, klass.name, columns)
+        when :v2
+          create_excel_v2(records, klass.name)
+        end
       subject = "#{klass.name} export at #{Time.now}"
       ExportMailer.send_excel_file(email, file_path, subject).deliver_now
       File.delete(file_path)
@@ -13,7 +19,7 @@ module SpotlightSearch
 
     def get_records(klass, filters, columns)
       records = klass
-      if filters
+      if !filters.empty?
         if filters['filters'].present?
           filters['filters'].each do |scope, scope_args|
             if scope_args.is_a?(Array)
@@ -26,9 +32,16 @@ module SpotlightSearch
         if filters['sort'].present?
           records = records.order("#{filters['sort']['sort_column']} #{filters['sort']['sort_direction']}")
         end
+      else
+        records = records.all
+      end
+      case SpotlightSearch.exportable_columns_version
+      when :v1
+        columns = columns.map(&:to_sym)
+        records.select(*columns)
+      when :v2
+        records.as_json(SpotlightSearch::Utils.deserialize_csv_columns(columns, :as_json_params))
       end
-      columns = columns.map(&:to_sym)
-      records.select(*columns)
     end
 
     # Creating excel with the passed records
@@ -48,5 +61,23 @@ module SpotlightSearch
       xl.serialize(file_location)
       file_location
     end
+
+    def create_excel_v2(records, class_name)
+      flattened_records = records.map { |record| SpotlightSearch::Utils.flatten_hash(record) }
+      columns = flattened_records[0].keys
+      size_arr = []
+      columns.size.times { size_arr << 22 }
+      xl = Axlsx::Package.new
+      xl.workbook.add_worksheet do |sheet|
+        sheet.add_row columns, b: true
+        flattened_records.each do |record|
+          sheet.add_row(columns.map { |column| record[column] })
+        end
+        sheet.column_widths(*size_arr)
+      end
+      file_location = "#{Rails.root}/public/export_#{class_name}_#{Time.now.to_s}.xls"
+      xl.serialize(file_location)
+      file_location
+    end
   end
 end

data/lib/spotlight_search.rb

@@ -1,6 +1,8 @@
 require 'spotlight_search/engine'
 require 'spotlight_search/version'
 require 'spotlight_search/exportable_columns'
+require 'spotlight_search/exportable_columns_v2'
+require 'spotlight_search/utils'
 require 'spotlight_search/railtie' if defined?(Rails)
 require 'active_support'
 require 'active_support/rails'
@@ -10,6 +12,13 @@ module SpotlightSearch
 
   autoload :Exceptions, 'spotlight_search/exceptions'
 
+  def self.setup
+    yield self
+  end
+
+  mattr_accessor :exportable_columns_version
+  @@exportable_columns_version = :v1
+
   module ClassMethods
     def filter_by(page, filter_params = {}, sort_params = {})
       filtered_result = OpenStruct.new

data/lib/spotlight_search/exceptions.rb

@@ -1,7 +1,7 @@
 module SpotlightSearch
   module Exceptions
     class InvalidColumns < StandardError
-      def initialize(columns: [])
+      def initialize(columns = [])
         message = 'Invalid columns found: ' + columns.map(&:to_s).join(', ')
         super(message)
       end

data/lib/spotlight_search/exportable_columns.rb

@@ -28,35 +28,30 @@ module SpotlightSearch
       #     export_columns enabled: true, except: [:created_at, :updated_at]
       #   end
       #
-      def export_columns(enabled: false, only: nil, except: nil)
-        begin
-          unless ActiveRecord::Base.connection.migration_context.needs_migration?
-            if enabled
-              self.export_enabled = true
-              all_columns = self.column_names.map(&:to_sym)
-              if only.present?
-                unless (valid_columns = only & all_columns).size == only.size
-                  invalid_columns = only - valid_columns
-                  raise SpotlightSearch::Exceptions::InvalidColumns.new(nil, invalid_columns)
-                end
-                self.enabled_columns = only
-              else
-                self.enabled_columns = all_columns
-              end
-              if except.present?
-                unless (valid_columns = except & all_columns).size == except.size
-                  invalid_columns = except - valid_columns
-                  raise SpotlightSearch::Exceptions::InvalidColumns.new(nil, invalid_columns)
-                end
-                self.enabled_columns = self.enabled_columns - except
-              end
-            else
-              self.export_enabled = false
-              self.enabled_columns = nil
-            end
+      def export_columns(enabled: false, only: nil, except: nil, associated: nil)
+        ActiveRecord::Base.connection.migration_context.needs_migration? && return
+        return unless enabled
+
+        self.export_enabled = true
+        all_columns = self.column_names.map(&:to_sym)
+        if only.present?
+          unless (valid_columns = only & all_columns).size == only.size
+            invalid_columns = only - valid_columns
+            raise SpotlightSearch::Exceptions::InvalidColumns, invalid_columns
+          end
+          self.enabled_columns = only
+        else
+          self.enabled_columns = all_columns
+        end
+        if except.present?
+          unless (valid_columns = except & all_columns).size == except.size
+            invalid_columns = except - valid_columns
+            raise SpotlightSearch::Exceptions::InvalidColumns, invalid_columns
           end
-        rescue ActiveRecord::NoDatabaseError
+          self.enabled_columns = self.enabled_columns - except
         end
+      rescue ActiveRecord::NoDatabaseError
+        Rails.logger.info("No database error")
       end
 
       # Validates whether the selected columns are allowed for export
@@ -72,8 +67,8 @@ module SpotlightSearch
     end
 
     included do
-      class_attribute :enabled_columns, instance_accessor: false
-      class_attribute :export_enabled, instance_accessor: false
+      class_attribute :enabled_columns, instance_accessor: false, default: nil
+      class_attribute :export_enabled, instance_accessor: false, default: false
     end
   end
 end

data/lib/spotlight_search/exportable_columns_v2.rb

@@ -0,0 +1,102 @@
+module SpotlightSearch
+  module ExportableColumnsV2
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # Enables or disables export and specifies which all columns can be
+      # exported. For enabling export for all columns in all models
+      #
+      #   class ApplicationRecord < ActiveRecord::Base
+      #     export_columns enabled: true
+      #   end
+      #
+      # For disabling export for only specific models
+      #
+      #   class Person < ActiveRecord::Base
+      #     export_columns enabled: false
+      #   end
+      #
+      # For allowing export for only specific columns in a model
+      #
+      #   class Person < ActiveRecord::Base
+      #     export_columns enabled: true, only: [:created_at, :updated_at]
+      #   end
+      #
+      # For excluding only specific columns and allowing all others
+      #
+      #   class Person < ActiveRecord::Base
+      #     export_columns enabled: true, except: [:created_at, :updated_at]
+      #   end
+      #
+      def export_columns(*record_fields, **associated_fields)
+        ActiveRecord::Base.connection.migration_context.needs_migration? && return
+
+        # Check that all record fields are valid accessible. Error if it doesn't.
+        # for each association, check that if its a valid association, and take the recursive step with that association
+        # End result is setting up in self, enabled columns and enabled associated columns
+        columns_hash = _model_exportable_columns(self, *record_fields, **associated_fields)
+
+        raise SpotlightSearch::Exceptions::InvalidColumns, columns_hash[:invalid_columns] if columns_hash[:invalid_columns].size.positive?
+        self.enabled_columns = [*record_fields, **associated_fields]
+      rescue ActiveRecord::NoDatabaseError
+        Rails.logger.info("No database error")
+      end
+
+      def _model_exportable_columns(klass, *record_fields, **associated_fields)
+        # Gets all the valid columns of a model
+        # If any column is invalid, it also returns it
+        raise SpotlightSearch::Exceptions::InvalidValue, "Expected ActiveRecord::Base, Received #{klass}" unless klass < ActiveRecord::Base
+
+        valid_columns = []
+        invalid_columns = []
+
+        # Base case: verify all the columns that belong to this record
+        record_fields.each do |field|
+          klass.new.respond_to?(field) ? valid_columns << field : invalid_columns << field
+        end
+
+        # Recursive case: check all associations and verify that they are all valid too
+        associated_fields.each do |association, association_record_fields|
+          reflection = klass.reflect_on_association(association)
+          invalid_columns << association && next unless reflection # Add whole association to invalid columns if it doesn't exist
+
+          case reflection
+          when ActiveRecord::Reflection::BelongsToReflection, ActiveRecord::Reflection::HasOneReflection
+            if reflection.polymorphic?
+              # We cannot process them further, so we'll assume it works and call it a day
+              valid_columns << { association => association_record_fields }
+            else
+              columns_hash = _model_exportable_columns(reflection.klass, *association_record_fields)
+              valid_columns << { association => columns_hash[:valid_columns] }
+              invalid_columns << { association => columns_hash[:invalid_columns] } if columns_hash[:invalid_columns].size.positive?
+            end
+          else
+            # one to many relationshops cannot be supported
+            invalid_columns << association
+            next
+          end
+        end
+
+        # return all the valid and invalid columns in a hash
+        {
+          valid_columns: valid_columns,
+          invalid_columns: invalid_columns
+        }
+      end
+
+      # Validates whether the selected columns are allowed for export
+      def validate_exportable_columns(columns)
+        unless columns.is_a?(Array)
+          raise SpotlightSearch::Exceptions::InvalidValue, 'Expected Array. Invalid type received'
+        end
+
+        true
+      end
+    end
+
+    included do
+      class_attribute :enabled_columns, instance_accessor: false, default: nil
+      class_attribute :enabled_associated_columns, instance_accessor: false, default: nil
+    end
+  end
+end

data/lib/spotlight_search/helpers.rb

@@ -48,9 +48,14 @@ module SpotlightSearch
       tag.div class: "modal-body" do
         form_tag '/spotlight_search/export_to_file', id: 'export-to-file-form', style: "width: 100%;" do
           concat hidden_field_tag 'email', email, id: 'export-to-file-email'
-          concat hidden_field_tag 'filters', nil, id: 'export-to-file-filters'
+          concat hidden_field_tag 'filters', nil, id: 'export-to-file-filters' # Filters are not being sent
           concat hidden_field_tag 'klass', klass.to_s, id: 'export-to-file-klass'
-          concat checkbox_row(klass)
+          case SpotlightSearch.exportable_columns_version
+          when :v1
+            concat checkbox_row(klass)
+          when :v2
+            concat checkbox_row_v2(klass)
+          end
           concat submit_tag 'Export as excel', class: 'btn btn-bordered export-to-file-btn'
         end
       end
@@ -67,7 +72,22 @@ module SpotlightSearch
     def create_checkbox(column_name)
       tag.div class: "col-md-4" do
         concat check_box_tag "columns[]", column_name.to_s
-        concat column_name.to_s
+        concat column_name.to_s.humanize
+      end
+    end
+
+    def checkbox_row_v2(klass)
+      tag.div class: "row" do
+        SpotlightSearch::Utils.serialize_csv_columns(*klass.enabled_columns).each do |column_path|
+          concat create_checkbox_v2(column_path)
+        end
+      end
+    end
+
+    def create_checkbox_v2(column_path)
+      tag.div class: "col-md-4" do
+        concat check_box_tag "columns[]", column_path
+        concat column_path.to_s.split('/').join('_').humanize
       end
     end
 

data/lib/spotlight_search/utils.rb

@@ -0,0 +1,69 @@
+
+
+module SpotlightSearch::Utils
+  class << self
+    def serialize_csv_columns(*columns, **hashes)
+      # Turns an arbitrary list of args and kwargs into a list of params to be used in a form
+      # For example, turns SpotlightSearch::Utils.serialize_csv_columns(:a, :b, c: [:d, e: :h], f: :g)
+      # into [:a, :b, "c/d", "c/e/h", "f/g"]
+      columns + hashes.map do |key, value|
+        serialize_csv_columns(*value).map do |column|
+          "#{key}/#{column}"
+        end
+      end.reduce([], :+)
+    end
+
+    def deserialize_csv_columns(list, method)
+      # Does the opposite operation of the above
+      list.reduce(recursive_hash) do |acc, item|
+        tokens = item.to_s.split('/')
+        send(method, acc, tokens.shift, tokens)
+      end
+    end
+
+    def base(hash, key, tokens) # recursive
+      hash.empty? && hash = { columns: [], associations: recursive_hash }
+      if tokens.empty?
+        # base case
+        hash[:columns] << key
+      else
+        # recursive case
+        # hash[:associations] ||= {}
+        hash[:associations][key] = base(hash[:associations][key], tokens.shift, tokens)
+      end
+      hash
+    end
+
+    def as_json_params(hash, key, tokens)
+      hash.empty? && hash = { only: [], methods: [], include: recursive_hash }
+      if tokens.empty?
+        # base case
+        hash[:methods] << key
+      else
+        # recursive case
+        # hash[:associations] ||= {}
+        hash[:include][key] = as_json_params(hash[:include][key], tokens.shift, tokens)
+      end
+      hash
+    end
+
+    def recursive_hash
+      func = ->(h, k) { h[k] = Hash.new(&func) }
+      # This hash creates a new hash, infinitely deep, whenever a value is not found
+      # recursive_hash[:a][:b][:c][:d] will never fail
+      Hash.new(&func)
+    end
+
+    def flatten_hash(hash, prefix="", separator="_")
+      hash.reduce({}) do |acc, item|
+        case item[1]
+        when Hash
+          acc.merge(flatten_hash(item[1], "#{prefix}#{item[0]}#{separator}"))
+        else
+          acc.merge("#{prefix}#{item[0]}" => item[1])
+        end
+      end
+    end
+
+  end
+end

data/lib/spotlight_search/version.rb

@@ -1,3 +1,3 @@
 module SpotlightSearch
-  VERSION = "0.1.8"
+  VERSION = "0.1.9"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: spotlight_search
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.9
 platform: ruby
 authors:
 - Anbazhagan Palani
@@ -123,8 +123,10 @@ files:
 - lib/spotlight_search/engine.rb
 - lib/spotlight_search/exceptions.rb
 - lib/spotlight_search/exportable_columns.rb
+- lib/spotlight_search/exportable_columns_v2.rb
 - lib/spotlight_search/helpers.rb
 - lib/spotlight_search/railtie.rb
+- lib/spotlight_search/utils.rb
 - lib/spotlight_search/version.rb
 - spotlight_search.gemspec
 homepage: https://github.com/commutatus/spotlight-search