rexport 0.4.0

data/lib/rexport/export_filter_methods.rb

@@ -0,0 +1,34 @@
+module Rexport #:nodoc:
+  module ExportFilterMethods
+    def self.included(base)
+      base.class_eval do
+        include InstanceMethods
+
+        belongs_to :export
+        validates_presence_of :filter_field
+      end
+    end
+
+    module InstanceMethods
+      def display_value
+        return value unless filter_field[/_id$/]
+        path = filter_field.split('.')
+        foreign_key = path.pop
+        association = export.get_klass_from_path(path).reflect_on_all_associations(:belongs_to).detect do |association|
+          association.foreign_key == foreign_key
+        end
+        return 'UNDEFINED ASSOCIATION' unless association
+        begin
+          object = association.klass.find(value)
+          return object.respond_to?(:name) ? object.name : object.to_s
+        rescue ActiveRecord::RecordNotFound
+          return 'ASSOCIATED OBJECT NOT FOUND'
+        end
+      end
+      
+      def attributes_for_copy
+        attributes.slice('filter_field', 'value')
+      end
+    end
+  end
+end

data/lib/rexport/export_filters_controller_methods.rb

@@ -0,0 +1,13 @@
+module Rexport
+  module ExportFiltersControllerMethods
+    # DELETE /export_filters/1
+    def destroy
+      @export_filter = ExportFilter.find(params[:id])
+      @export_filter.destroy
+
+      respond_to do |format|
+        format.html { redirect_to(@export_filter.export) }
+      end
+    end
+  end
+end

data/lib/rexport/export_item_methods.rb

@@ -0,0 +1,45 @@
+module Rexport #:nodoc:
+  module ExportItemMethods
+    def self.included(base)
+      base.extend ClassMethods
+      base.class_eval do
+        include InstanceMethods
+        
+        acts_as_list :scope => :export
+        belongs_to :export
+        before_validation :replace_blank_name_with_rexport_field
+        validates_presence_of :name, :rexport_field
+        scope :ordered, -> { order :position }
+      end
+    end
+    
+    module ClassMethods
+      def resort(export_item_ids)
+        export_item_ids.each_index do |index|
+          position = index + 1
+          export_item = find(export_item_ids[index].gsub(/[^0-9]/,''))
+          export_item.update_attribute(:position, position) if export_item.position != position
+        end
+      end
+    end
+    
+    module InstanceMethods
+      def attributes_for_copy
+        attributes.slice('position', 'name', 'rexport_field')
+      end
+      
+      #######
+      private
+      #######
+      
+      def replace_blank_name_with_rexport_field
+        return unless name.blank?
+        self.name = if rexport_field.include?('.')
+          rexport_field.split('.').values_at(-2..-1).map {|v| v.titleize}.join(' - ')
+        else
+          rexport_field.titleize
+        end
+      end
+    end
+  end
+end

data/lib/rexport/export_item_sortings_controller_methods.rb

@@ -0,0 +1,13 @@
+module Rexport
+  module ExportItemSortingsControllerMethods
+    def update
+      ExportItem.resort(params[:sorted_items])
+    
+      respond_to do |format|
+        format.js do
+          render :nothing => true
+        end
+      end
+    end
+  end
+end

data/lib/rexport/export_items_controller_methods.rb

@@ -0,0 +1,32 @@
+module Rexport
+  module ExportItemsControllerMethods
+    # GET /export_item/1/edit
+    def edit
+      @export_item = ExportItem.find(params[:id])
+    end
+    
+    # PUT /export_item/1
+    def update
+      @export_item = ExportItem.find(params[:id])
+      
+      respond_to do |format|
+        if @export_item.update_attributes(params[:export_item])
+          flash[:notice] = 'ExportItem was successfully updated.'
+          format.html { redirect_to(export_path(@export_item.export)) }
+        else
+          format.html { render :action => "edit" }
+        end
+      end
+    end
+    
+    # DELETE /export_item/1
+    def destroy
+      @export_item = ExportItem.find(params[:id])
+      @export_item.destroy
+      
+      respond_to do |format|
+        format.html { redirect_to(export_path(@export_item.export)) }
+      end
+    end
+  end
+end

data/lib/rexport/export_methods.rb

@@ -0,0 +1,272 @@
+require 'csv'
+
+module Rexport #:nodoc:
+
+  SAMPLE_SIZE = 5
+
+  class RexportModel
+    attr_accessor :klass, :path
+
+    def initialize(klass, path = nil)
+      self.klass = klass
+      self.path = path.to_s unless path.blank?
+    end
+
+    def rexport_fields_array
+      klass.rexport_fields_array
+    end
+
+    def field_path(field_name)
+      [path, field_name].compact * '.'
+    end
+
+    def collection_from_association(association)
+      return klass.send("find_#{association}_for_rexport") if klass.respond_to?("find_#{association}_for_rexport")
+      klass.reflect_on_association(association.to_sym).klass.all
+    end
+
+    def filter_column(field)
+      return field.method unless field.method.include?('.')
+      association = field.method.split('.').first
+      klass.reflect_on_association(association.to_sym).foreign_key
+    end
+
+    def name
+      klass.name
+    end
+  end
+
+  module ExportMethods
+    def self.included(base)
+      base.extend ClassMethods
+      base.class_eval do
+        include InstanceMethods
+
+        has_many :export_items, :dependent => :destroy
+        has_many :export_filters, :dependent => :destroy
+        validates_presence_of :name, :model_name
+        after_save :save_export_items
+        scope :alphabetical,  ->              { order :name }
+        scope :categorical,   ->              { order :model_name }
+        scope :by_model,      ->(model_name)  { where(model_name: model_name) }
+      end
+    end
+
+    module ClassMethods
+      def models
+        %w(override_this_method)
+      end
+
+      def enabled
+        find(:all).select {|export| export.enabled? }
+      end
+    end
+
+    module InstanceMethods
+      def full_name
+        "#{model_name.pluralize} - #{name}"
+      end
+
+      # Returns a string with the export data
+      def to_s
+        String.new.tap do |result|
+          result << header * '|' << "\n"
+          records.each do |record|
+            result << record * '|' << "\n"
+          end
+        end
+      end
+
+      # Returns a csv string with the export data
+      def to_csv(objects = nil)
+        seed_records(objects) unless objects.nil?
+        CSV.generate do |csv|
+          csv << header
+          records.each do |record|
+            csv << record
+          end
+        end
+      end
+
+      # Returns an array with the header names from the associated export_items
+      def header
+        export_items.ordered.map {|i| i.name}
+      end
+
+      # Returns the export model class
+      def export_model
+        model_name.constantize
+      end
+
+      # Returns an array of RexportModels including export_model and associated rexport capable models
+      def rexport_models
+        @rexport_models ||= get_rexport_models(export_model)
+      end
+
+      # Returns the records for the export
+      def records
+        @records ||= get_records
+      end
+
+      # Returns a limited number of records for the export
+      def sample_records
+        get_records(Rexport::SAMPLE_SIZE)
+      end
+
+      # Returns a class based on a path array
+      def get_klass_from_path(path, klass = export_model)
+        return klass unless (association_name = path.shift)
+        get_klass_from_path(path, klass.reflect_on_association(association_name.to_sym).klass)
+      end
+
+      def has_rexport_field?(rexport_field)
+        rexport_fields.include?(rexport_field)
+      end
+
+      def rexport_fields=(rexport_fields)
+        @rexport_fields = if rexport_fields.respond_to?(:keys)
+          @set_position = false
+          rexport_fields.keys
+        else
+          @set_position = true
+          rexport_fields
+        end
+      end
+
+      def export_filter_attributes=(attributes)
+        attributes.each do |field, value|
+          if value.blank?
+            filter = export_filters.find_by_filter_field(field)
+            filter.destroy if filter
+          elsif new_record?
+            export_filters.build(:filter_field => field, :value => value)
+          else
+            filter = export_filters.find_or_create_by_filter_field(field)
+            filter.update_attribute(:value, value)
+          end
+        end
+      end
+
+      def filter_value(filter_field)
+        filter = export_filters.detect {|f| f.filter_field == filter_field}
+        filter ? filter.value : nil
+      end
+
+      def copy
+        self.class.create(attributes_for_copy) do |new_export|
+          export_items.ordered.each { |item| new_export.export_items.build(item.attributes_for_copy) }
+          export_filters.each { |filter| new_export.export_filters.build(filter.attributes_for_copy) }
+        end
+      end
+
+      def modifiable?
+        # override to disable edit and destroy links for specific exports
+        true
+      end
+
+      def enabled?
+        export_model.count > 0
+      end
+
+      #########
+      protected
+      #########
+
+      def get_records(limit = nil)
+        get_export_values(export_model.where(build_conditions).includes(build_include).limit(limit))
+      end
+
+      def seed_records(objects)
+        @records = get_export_values(objects)
+      end
+
+      def get_export_values(objects)
+        objects.map { |object| object.export(rexport_methods) }
+      end
+
+      def get_rexport_models(rexport_model, result = [], path = nil)
+        return unless rexport_model.respond_to?(:rexport_fields)
+        result << RexportModel.new(rexport_model, path)
+        get_associations(rexport_model).each do |associated_model|
+          # prevent infinite loop by checking if this class is already in the result set
+          unless result.detect { |rexport_model| rexport_model.klass == associated_model.klass }
+            get_rexport_models(associated_model.klass, result, [path, associated_model.name].compact * '.')
+          end
+        end
+        return result
+      end
+
+      def get_associations(rexport_model)
+        (rexport_model.reflect_on_all_associations(:belongs_to) + rexport_model.reflect_on_all_associations(:has_one))
+      end
+
+      def build_include
+        root = Rexport::TreeNode.new('root')
+        (rexport_methods + filter_fields).select {|m| m.include?('.')}.each do |method|
+          root.add_child(method.split('.').values_at(0..-2))
+        end
+        root.to_include
+      end
+
+      def build_conditions
+        Hash.new.tap do |conditions|
+          export_filters.each do |filter|
+            conditions[get_database_field(filter.filter_field)] = filter.value
+          end
+        end
+      end
+
+      def get_database_field(field)
+        path = field.split('.')
+        field = path.pop
+        "#{get_klass_from_path(path).table_name}.#{field}"
+      end
+
+      def rexport_methods
+        @rexport_methods ||= export_model.get_rexport_methods(ordered_rexport_fields)
+      end
+
+      def rexport_fields
+        @rexport_fields ||= export_items.map {|i| i.rexport_field}
+      end
+
+      def ordered_rexport_fields
+        export_items.ordered.map {|i| i.rexport_field}
+      end
+
+      def filter_fields
+        export_filters.map {|f| f.filter_field}
+      end
+
+      def save_export_items
+        export_items.each do |export_item|
+          unless rexport_fields.include?(export_item.rexport_field)
+            export_item.destroy
+          end
+        end
+
+        export_items.reset
+
+        position = 0
+        rexport_fields.each do |rexport_field|
+          position += 1
+          export_item = export_items.detect {|i| i.rexport_field == rexport_field } || export_items.create(:rexport_field => rexport_field)
+          export_item.update_attribute(:position, position) if @set_position && export_item.position != position
+        end
+
+        export_items.reset
+        @rexport_fields = nil
+        return true
+      end
+      
+      def attributes_for_copy
+        attributes.slice('model_name', 'description').merge(name: find_unique_name(self.name))
+      end
+
+      def find_unique_name(original_name, suffix = 0)
+        new_name = suffix == 0 ? "#{original_name} Copy" : "#{original_name} Copy [#{suffix}]"
+        self.class.find_by_name(new_name) ? find_unique_name(original_name, suffix += 1) : new_name
+      end
+    end
+  end
+end

data/lib/rexport/exports_controller_methods.rb

@@ -0,0 +1,86 @@
+module Rexport
+  module ExportsControllerMethods
+    # GET /exports
+    def index
+      @exports = Export.categorical.alphabetical
+      
+      respond_to do |format|
+        format.html # index.html.erb
+      end
+    end
+    
+    # GET /exports/1
+    def show
+      @export = Export.find(params[:id])
+      
+      respond_to do |format|
+        format.html # show.html.erb
+        format.csv { send_data(@export.to_csv, :type => export_content_type, :filename => filename) }
+      end
+    end
+    
+    # GET /exports/new
+    def new
+      @export = Export.new(params[:export])
+      
+      respond_to do |format|
+        format.html # new.html.erb
+      end
+    end
+    
+    # GET /exports/1/edit
+    def edit
+      @export = Export.find(params[:id])
+    end
+    
+    # POST /exports
+    def create
+      @export = params[:original_export_id] ? Export.find(params[:original_export_id]).copy : Export.new(params[:export])
+      
+      respond_to do |format|
+        if @export.save
+          flash[:notice] = 'Export was successfully created.'
+          format.html { redirect_to(@export) }
+        else
+          format.html { render :action => "new" }
+        end
+      end
+    end
+    
+    # PUT /exports/1
+    def update
+      @export = Export.find(params[:id])
+      
+      respond_to do |format|
+        if @export.update_attributes(params[:export])
+          flash[:notice] = 'Export was successfully updated.'
+          format.html { redirect_to(@export) }
+        else
+          format.html { render :action => "edit" }
+        end
+      end
+    end
+    
+    # DELETE /exports/1
+    def destroy
+      @export = Export.find(params[:id])
+      @export.destroy
+      
+      respond_to do |format|
+        format.html { redirect_to(exports_url) }
+      end
+    end
+    
+    #######
+    private
+    #######
+    
+    def export_content_type
+      request.user_agent =~ /windows/i ? 'application/vnd.ms-excel' : 'text/csv'
+    end
+    
+    def filename
+      "#{@export.model_name}_#{@export.name.gsub(/ /, '_')}_#{Time.now.strftime('%Y%m%d')}.csv"
+    end
+  end
+end