basepack 0.0.2

data/lib/basepack/import/actions.rb

@@ -0,0 +1,105 @@
+module Basepack
+  module Import
+    class Actions
+      attr_reader :params
+      attr_reader :controller
+      attr_reader :current_ability
+      attr_reader :form
+
+      def initialize(controller, form)
+        @params = controller.params
+        @controller = controller
+        @current_ability = controller.current_ability
+        @form = form
+      end
+
+      def resource_class
+        @form.resource_class
+      end
+
+      def get(patch = false)
+        import_params = params[:import]
+
+        if params[:import_id].present?
+          # import selected
+          form = @form.show_form
+          import_resource = form.resource_class.find(params[:import_id])
+          current_ability.authorize!(:show, import_resource) # CanCan
+          form.resource = import_resource
+
+          if patch and import_params.present?
+            # update import
+            current_ability.authorize!(:update, import_resource) # CanCan
+            send("import_sanitize_params_#{import_resource.file_type}!", import_params, import_resource)
+            if import_resource.update_attributes(controller.edit_form_for(import_resource).permit_params(import_params))
+              yield(import_resource)
+            end
+          end
+        end
+      end
+
+      def patch(&block)
+        get(true, &block)
+      end
+
+      def post
+        import_params = params[:import]
+        if import_params.present?
+          # create import
+          form = @form.edit_form
+          form.resource.assign_attributes(current_ability.attributes_for(:new, form.resource_class))
+          form.resource.assign_attributes(form.permit_params(import_params))
+          form.resource.klass = resource_class.to_s
+          form.resource.action_name = @form.action_name
+          current_ability.authorize!(:create, form.resource) # CanCan
+          yield if form.resource.save
+        end
+      end
+
+      def delete
+        import = @form.show_form.resource_class.find(params[:delete_id])
+        current_ability.authorize!(:destroy, import) # CanCan
+        yield if import.destroy
+      end
+
+      def import_sanitize_params_csv!(import_params, import)
+        if mapping = import_params[:configuration].try(:[], :mapping)
+          options = Hash[form.fields_for_import_as_select_options.map {|o| [o[1], o[1].presence] }]
+          import_params[:configuration][:mapping] = Array.wrap(mapping).map {|n| options[n]}
+        end
+      end
+
+      def import_configuration_csv(import)
+        # separator
+        unless import.configuration[:col_sep]
+          col_sep = ','
+          import.open_file do |f|
+            col_sep = ';' if l = f.gets and l.count(';') > l.count(',')
+          end
+          import.configuration[:col_sep] = col_sep
+        end
+
+        # columns
+        row = []
+        import.open_file do |f|
+          CSV.new(f, col_sep: import.configuration[:col_sep]).each do |r|
+            if r.present?
+              row = r
+              break
+            end
+          end
+        end
+        [
+          "forms/import_configuration_csv",
+          {
+            form:           form,
+            csv_cols:       row,
+            select_options: form.fields_for_import_as_select_options,
+            configuration:  import.configuration,
+          },
+        ]
+      end
+
+    end
+  end
+end

data/lib/basepack/import/controller.rb

@@ -0,0 +1,94 @@
+module Basepack
+  module Import
+    module Controller
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :import_class
+        helper_method :import_form_for
+        self.import_class = Basepack::Settings.import.model_name.safe_constantize
+        import_action Basepack::Settings.import.default_action
+      end
+
+      module ClassMethods
+        def import_action(name, actions_class = Basepack::Import::Actions)
+          name = name.to_sym
+          self.__actions += [name] #custom_actions collection: [name] TODO - destroys URL helpers for other actions
+          name_bang = "#{name}!"
+
+          # [GET,POST,PATCH,DELETE] /resources/#{name}
+          define_method name_bang do |&block|
+            @title_params = [[resource_class, "Import"]]
+
+            authorize!(name, resource_class) # CanCan
+
+            @import_actions = actions_class.new(self, import_form)
+            if request.get?
+              @import_actions.get
+            elsif request.patch?
+              @import_actions.patch do |import_resource|
+                # run import
+                import_resource.import_data(current_ability) if import_resource.state == "not_started"
+                redirect_to polymorphic_path([name, route_prefix, association_chain, resource_class].flatten,
+                                             import_id: import_resource.id),
+                            notice: message_edit_done(import_form.show_form.label)
+              end
+            elsif request.post?
+              @import_actions.post do
+                redirect_to polymorphic_path([name, route_prefix, association_chain, resource_class].flatten,
+                                             import_id: import_form.edit_form.resource.id),
+                            notice: message_new_done(import_form.edit_form.label)
+              end
+            elsif request.delete?
+              @import_actions.delete do
+                redirect_to polymorphic_path([name, route_prefix, association_chain, resource_class].flatten),
+                            notice: message_destroy_done(import_form.edit_form.label)
+              end
+            end
+          end
+
+          define_method name do
+            send(name_bang)
+          end
+
+          protected name_bang
+
+          name_form = "#{name}_form"
+          name_form_bang = "#{name}_form!"
+          var = :"@#{name}_form"
+
+          define_method name_form_bang do |&block|
+            unless form = instance_variable_get(var)
+              form = import_form_for(chain_with_class)
+              form.configure(&block) if block
+              form.configuration_params do |frm, import|
+                import_actions = actions_class.new(self, frm)
+                method = "import_configuration_#{import.file_type}"
+                import_actions.send(method, import) if import_actions.respond_to?(method)
+              end
+              instance_variable_set(var, form)
+            end
+            form
+          end
+
+          helper_method name_form
+
+          define_method name_form do
+            send(name_form_bang)
+          end
+        end
+      end
+
+      def import_form_for(class_or_chain, options = {})
+        klass = Array.wrap(class_or_chain).last
+        form_factory_rails_admin(:import, Basepack::Forms::Import, class_or_chain,
+           action_name: options[:action_name] || Basepack::Settings.import.default_action,
+           edit_form:   edit_form_for(import_class),
+           show_form:   show_form_for(import_class),
+           list_form:   list_form_for(query_form_for(import_class, import_class.where(klass: klass))))
+      end
+
+    end
+  end
+end
+

data/lib/basepack/import/importable.rb

@@ -0,0 +1,40 @@
+module Basepack
+  module Import
+    module Importable
+      extend ActiveSupport::Concern
+
+      included do
+        association_name = Basepack::Settings.import.association_name
+        association_name_join_table = Basepack::Settings.import.association_name_join_table
+        if association_name
+          has_many association_name_join_table,
+                   as: :importable, inverse_of: :importable, dependent: :destroy, class_name: 'Basepack::ImportImportable'
+          has_many association_name, through: association_name_join_table
+        end
+      end
+
+      module ClassMethods
+        def find_or_initialize_for_import(attrs)
+          Basepack::Import::Importable.find_or_initialize_for_import(self, attrs)
+        end
+        alias :find_or_initialize_for_import! :find_or_initialize_for_import
+      end
+
+      def around_import(import, &block)
+        yield
+      end
+      alias :around_import! :around_import
+
+      def self.find_or_initialize_for_import(model, attrs, key = nil)
+        key ||= model.primary_key
+        if attrs[key]
+          object = model.where(key => attrs[key]).first_or_initialize
+          object.assign_attributes(attrs.except(key))
+          object
+        else
+          model.new(attrs)
+        end
+      end
+    end
+  end
+end

data/lib/basepack/import/model_dragonfly.rb

@@ -0,0 +1,232 @@
+module Basepack
+  module Import
+    module ModelDragonfly
+      extend ActiveSupport::Concern
+
+      included do
+        attr_accessor :current_ability
+
+        has_many :importables, inverse_of: :import, dependent: :destroy, class_name: 'Basepack::ImportImportable'
+
+        image_accessor :file
+        image_accessor :report
+
+        serialize :configuration, Hash
+
+        validates :klass,  presence: true
+        validate :validate_klass_is_model
+
+        validates :file,  presence: true
+        validates_property :mime_type, of: [:file, :report], in: Basepack::Settings.import.mime_types, case_sensitive: false
+        validates :state, presence: true, inclusion: { in: Basepack::Settings.import.state_types.map { |t| t.last } }
+        validates :action_name, :num_errors, :num_imported, presence: true
+
+        rails_admin do
+          configure :file_name do
+            pretty_value do
+              bindings[:view].link_to(value, bindings[:object].file.url)
+            end
+          end
+          configure :file_size do
+            pretty_value do
+              value.to_s(:human_size)
+            end
+          end
+          configure :report_name do
+            pretty_value do
+              bindings[:object].report ? bindings[:view].link_to(value, bindings[:object].report.url) : nil
+            end
+          end
+          configure :num_errors do
+            pretty_value do
+              bindings[:object].report ? bindings[:view].link_to(value, bindings[:object].report.url) : value.to_s
+            end
+          end
+          configure :num_imported do
+            pretty_value do
+              if bindings[:object].klass
+                klass = bindings[:object].importable_class
+                assoc_name = Basepack::Settings.import.association_name
+                if assoc_name and klass.reflect_on_association(assoc_name)
+                  bindings[:view].link_to(
+                    value,
+                    bindings[:view].main_app.polymorphic_path(klass,
+                      "f[#{assoc_name}_id_eq]" => bindings[:object].id)
+                  )
+                else
+                  value.to_s
+                end
+              else
+                value.to_s
+              end
+            end
+          end
+
+          query do
+            sort_by :created_at
+          end
+
+          show do
+            field :file_name
+            field :file_mime_type
+            field :file_size
+            field :report_name
+            field :num_errors
+            field :num_imported
+            field :state
+            field :created_at
+          end
+
+          list do
+            field :file_name
+            field :file_size
+            field :num_errors
+            field :num_imported
+            field :state
+            field :created_at
+          end
+
+          update do
+            field :state, :hidden
+            field :configuration
+          end
+
+          edit do
+            field :file
+          end
+        end
+      end
+
+      module ClassMethods
+        def state_enum
+          Basepack::Settings.import.state_types
+        end
+      end
+
+      def file_type
+        case file.try(:mime_type)
+        when "text/csv", "text/plain"
+          :csv
+        else
+          :unknown
+        end
+      end
+
+      def open_file(&block)
+        File.open(file.path, "r:utf-8", &block)
+      end
+
+      def open_report(&block)
+        File.open(report.path, "a:utf-8", &block)
+      end
+
+      def validate_klass_is_model
+        begin
+          c = klass.constantize
+          raise NameError unless c.ancestors.include? ActiveRecord::Base
+          false
+        rescue NameError
+          errors.add(:klass, "is not known model!")
+          true
+        end
+      end
+
+      def importable_class
+        klass.constantize
+      end
+
+      def start_processing(&block)
+        import = self
+        unless import.state == "finished"
+          unless import.state == "processing"
+            name = "report-#{import.id}.csv"
+            data = ""
+            data.define_singleton_method(:original_filename) { name }
+            import.report = data
+            import.state = "processing"
+            import.save!
+            import = self.class.find(import.id) # reload report path
+          end
+          yield(import)
+          import.update_attributes!(state: "finished")
+        end
+      end
+
+      def import_data(current_ability)
+        start_processing do |import|
+          import.current_ability = current_ability
+          import.send("import_data_#{import.file_type}")
+        end
+      end
+
+      def import_data_csv
+        import = self
+        ability_attributes = current_ability.attributes_for(:import, importable_class)
+        mapping = import.configuration[:mapping] || []
+        use_blanks = import.configuration[:blank_vals] == 'use'
+        skip_rows = import.num_imported + import.num_errors + 1 # 1==header, if > 1, then import failed and called repeatedly
+        idx = 0
+
+        import.open_report do |report|
+          if skip_rows == 1
+            report << CSV.generate_line(mapping + ["Chyby"], encoding: 'UTF-8')
+          end
+          import.open_file do |f|
+            CSV.new(f, col_sep: import.configuration[:col_sep] || ',').each do |row|
+              next if row.blank?
+              idx += 1
+              next if idx <= skip_rows
+
+              attrs = ability_attributes.dup
+              row.each_with_index do |data, i|
+                attr = mapping[i]
+                attrs[attr] = data if attr.present? and (data.present? or use_blanks)
+              end
+
+              import_attributes(Rack::Utils.parse_nested_query(attrs.to_query)) do |object|
+                unless save_object(object)
+                  report << CSV.generate_line(row + [object.errors.full_messages.join('; ')], encoding: 'UTF-8')
+                end
+              end
+            end
+          end
+        end
+      end
+
+      def import_attributes(attrs, &block)
+        if attrs.present?
+          transaction do
+            model = importable_class
+
+            begin
+              object = model.try(:find_or_initialize_for_import, attrs) ||
+                       Basepack::Import::Importable.find_or_initialize_for_import(model, attrs)
+            rescue ActiveRecord::RecordNotFound => e # error in finding nested attributes
+              object = model.new
+              object.errors[:base] << e.message
+            end
+
+            if object.respond_to?(:around_import)
+              object.around_import(self) { yield(object) }
+            else
+              yield(object)
+            end
+            save!
+          end
+        end
+      end
+
+      def save_object(object)
+        status = object.errors.empty? ? object.save : false
+        if status
+          self.num_imported += 1
+          self.importables.build(importable: object)
+        else
+          self.num_errors += 1
+        end
+        status
+      end
+    end
+  end
+end
+

data/lib/basepack/model.rb

@@ -0,0 +1,30 @@
+# This is the module which makes any class behave like ActiveModel.
+module Basepack
+  module Model
+    extend ActiveSupport::Concern
+
+    included do
+      extend ActiveModel::Callbacks
+      include ActiveModel::Model
+      include ActiveModel::Serialization
+      include ActiveModel::ForbiddenAttributesProtection
+      include ActiveModel::AttributeMethods
+      include ActiveModel::Dirty
+    end
+
+    # Always return true so when using form_for, the default method will be post.
+    def new_record?
+      true
+    end
+
+    # Always return nil so when using form_for, the default method will be post.
+    def id
+      nil
+    end
+
+    def destroyed?
+      true
+    end
+
+  end
+end

data/lib/basepack/renderable.rb

@@ -0,0 +1,45 @@
+module Basepack
+  module Renderable
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def render(name = nil, options = {}, &rendering_block)
+        if name.blank?
+          render = "render"
+          content = options[:content] || "content"
+        else
+          render = "render_#{name}"
+          content = options[:content] || "content_for_#{name}"
+        end
+
+        var = "@#{content}".to_sym
+        render_bang = "#{render}!"
+
+        define_method content do |&block|
+          # hack - view.capture doesn't work for Haml if not called on block with original binding
+          params = block.parameters
+          if params.present? and params.last[0] == :block
+            instance_variable_set(var, [block, eval("proc {|c, s, a, b| c.(s, *a, &b)}", block.binding)])
+          else
+            instance_variable_set(var, block)
+          end
+        end
+
+        define_method render_bang, &rendering_block
+
+        define_method render do |*args, &block|
+          if cont_block = instance_variable_get(var)
+            if cont_block.is_a? Array
+              view.capture(cont_block[0], self, args, block, &cont_block[1])
+            else
+              view.capture(self, *args, &cont_block)
+            end
+          else
+            send(render_bang, *args, &block)
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/basepack/sections/bulk_edit.rb

@@ -0,0 +1,15 @@
+require 'rails_admin/config/sections/base'
+
+module RailsAdmin
+  module Config
+      # Configuration of the bulk edit view
+    module Sections
+      class BulkEdit < RailsAdmin::Config::Sections::Edit
+      end
+    end
+  end
+end
+
+RailsAdmin::Config::Sections.included(RailsAdmin::Config::Model)
+
+

data/lib/basepack/sections/import.rb

@@ -0,0 +1,15 @@
+require 'rails_admin/config/sections/base'
+
+module RailsAdmin
+  module Config
+    module Sections
+      # Configuration of the import view
+      class Import < RailsAdmin::Config::Sections::Export
+      end
+    end
+  end
+end
+
+RailsAdmin::Config::Sections.included(RailsAdmin::Config::Model)
+
+

data/lib/basepack/sections/query.rb

@@ -0,0 +1,19 @@
+module RailsAdmin
+  module Config
+    module Sections
+      # Configuration of the query view
+      class Query < RailsAdmin::Config::Sections::Base
+        register_instance_option :sort_by do
+          nil
+        end
+
+        register_instance_option :sort_reverse? do
+          false
+        end
+      end
+    end
+  end
+end
+
+RailsAdmin::Config::Sections.included(RailsAdmin::Config::Model)
+