erp_app 4.0.0 → 4.2.0

data/lib/active_ext/core.rb

@@ -1,105 +0,0 @@
-module ActiveExt
-  class Core
-    attr :model_id
-    attr_accessor :columns
-    attr_accessor :association_names
-
-    #rails generated columns.  Do not remove these
-    RAILS_COLUMNS = [:id, :created_at, :updated_at]
-    BETTER_NESTED_SET_COLUMNS = [:parent_id, :lft, :rgt]
-
-    def initialize(model_id, options)
-      @model_id = model_id.to_s.pluralize.singularize
-      @options = options
-
-      #get all attribute columns
-      attribute_names = self.model.columns.collect { |c| c.name.to_sym }.sort_by { |c| c.to_s }
-
-      #only include attribute columns we care about, do not remove rails generated columns
-      if options[:only]
-        valid_columns = []
-        options[:only].each do |option|
-          if option.is_a?(Hash)
-            valid_columns << option.keys.first
-          else
-            valid_columns << option
-          end
-        end
-        valid_columns = valid_columns | RAILS_COLUMNS
-        attribute_names.delete_if { |item| !valid_columns.include?(item.to_sym) }
-      end
-
-      #if we are including associations get them
-      unless options[:ignore_associations]
-        @association_names = self.model.reflect_on_all_associations.collect { |a| a.name.to_sym }
-        association_column_names = @association_names.sort_by { |c| c.to_s }
-        attribute_names += association_column_names
-      end
-
-      @columns = ActiveExt::DataStructures::Columns.new(self.model, attribute_names)
-
-      #exclude id columns and count columns and better nested set columns
-      @columns.exclude(*@columns.find_all { |c| c.column and (c.column.primary or c.column.name =~ /(_id|_count)$/) }.collect { |c| c.name })
-      #exclude nested set columns
-      @columns.exclude(*@columns.find_all { |c| c.column and (BETTER_NESTED_SET_COLUMNS.include?(c.column.name.to_sym)) }.collect { |c| c.name })
-      #exclude associations columns
-      @columns.exclude(*self.model.reflect_on_all_associations.collect { |a| :"#{a.name}_type" if a.options[:polymorphic] }.compact)
-
-      set_column_options
-    end
-
-    def model_id
-      @model_id
-    end
-
-    def model
-      @model ||= @model_id.to_s.camelize.constantize
-    end
-
-    def options
-      @options
-    end
-
-    def non_excluded_columns
-      columns = []
-
-      #add id column if showing it
-      if self.options[:show_id]
-        columns << core.columns[:id]
-      end
-
-      #build ext columns
-      self.columns.each do |column|
-        next if column.name.to_s =~ /(^id|created_at|updated_at)$/ || self.columns.exclude_column?(column.name)
-        columns << column
-      end
-
-      #add timestamp columns if showing them
-      if self.options[:show_timestamps]
-        columns << self.columns[:created_at]
-        columns << self.columns[:updated_at]
-      end
-
-      columns
-    end
-
-    private
-
-    def set_column_options
-      all_column_options = self.options[:only]
-      self.columns.each do |column|
-        if RAILS_COLUMNS.include?(column.name)
-          column.options = {:readonly => true, :required => false}
-        else
-          unless all_column_options.nil?
-            column_options = all_column_options.find { |item| item.is_a?(Hash) && item.has_key?(column.name) }
-            unless column_options.nil?
-              column.options = column_options[column.name]
-            end
-          end
-        end
-      end
-    end
-
-  end
-end

data/lib/active_ext/data_structures/column.rb

@@ -1,21 +0,0 @@
-module ActiveExt
-  module DataStructures
-    class Column
-      attr_accessor :name, :association, :column, :options
-
-      def initialize(name, active_record_class)
-        @name = name.to_sym
-        @column = active_record_class.columns_hash[self.name.to_s]
-        @association = active_record_class.reflect_on_association(self.name)
-        @active_record_class = active_record_class
-        @table = active_record_class.table_name
-        #set default options
-        @options = {:required => false, :readonly => false}
-      end
-
-      def sql_type
-        @column.type
-      end
-    end
-  end
-end

data/lib/active_ext/data_structures/columns.rb

@@ -1,69 +0,0 @@
-module ActiveExt
-  module DataStructures
-    class Columns
-      include Enumerable
-
-      # This collection is referenced by other parts of ActiveExt and by methods within this DataStructure.
-      # IT IS NOT MEANT FOR PUBLIC USE (but if you know what you're doing, go ahead)
-      def _inheritable=(value)
-        @sorted = true
-        @_inheritable = value
-      end
-
-      # This accessor is used by ActionColumns to create new Column objects without adding them to this set
-      attr_reader :active_record_class
-
-      def initialize(active_record_class, *args)
-        @active_record_class = active_record_class
-        @_inheritable = []
-        @excluded_columns = []
-        @set = []
-
-        self.add *args
-      end
-
-      # the way to add columns to the set. this is primarily useful for virtual columns.
-      # note that this also makes columns inheritable
-      def add(*args)
-        args.flatten! # allow [] as a param
-        args = args.collect { |a| a.to_sym }
-
-        # make the columns inheritable
-        @_inheritable.concat(args)
-        # then add columns to @set (unless they already exist)
-        args.each { |a| @set << ActiveExt::DataStructures::Column.new(a.to_sym, @active_record_class) unless find_by_name(a) }
-      end
-
-      alias_method :<<, :add
-
-      def exclude(*args)
-        # only remove columns from _inheritable. we never want to completely forget about a column.
-        args.each { |a| @_inheritable.delete a }
-        @excluded_columns.concat(args)
-      end
-
-      # returns an array of columns with the provided names
-      def find_by_names(*names)
-        @set.find_all { |column| names.include? column.name }
-      end
-
-      # returns the column of the given name.
-      def find_by_name(name)
-        # this works because of `def column.=='
-        column = @set.find { |c| c.name == name }
-        column
-      end
-
-      alias_method :[], :find_by_name
-
-      def each
-        @set.each { |i| yield i }
-      end
-
-      def exclude_column?(name)
-        @excluded_columns.include?(name)
-      end
-
-    end
-  end
-end

data/lib/active_ext/data_structures/data_structures.rb

@@ -1,2 +0,0 @@
-require 'active_ext/data_structures/column'
-require 'active_ext/data_structures/columns'

data/lib/active_ext/ext_helpers/column_builder.rb

@@ -1,136 +0,0 @@
-module ActiveExt
-  module ExtHelpers
-    module ColumnBuilder
-
-      def self.build_column(column)
-        column_hash = nil
-
-        #if this is an association sql_type will be blank, use string column
-        if column.sql_type.blank? || column.sql_type == NilClass
-          column_hash = self.send("build_string_column", column.name, column.options)
-        else
-          column_hash = self.send("build_#{column.sql_type.to_s}_column", column.name, column.options)
-        end
-
-        column_hash
-      end
-
-      private
-
-      def self.build_boolean_column(column_name, options={})
-        column = {
-            :header => column_name,
-            :type => 'date',
-            :dataIndex => column_name,
-            :width => options[:width].nil? ? 150 : options[:width],
-            :renderer => NonEscapeJsonString.new('function(v) {
-        result = "False";
-        
-        if(v == 1){
-          result = "True";
-        }
-        return result;
-      }')
-        }
-
-        column[:editor] = {:xtype => "booleancolumneditor", :readOnly => options[:readonly].blank? ? false : options[:readonly]}
-
-        column
-      end
-
-      def self.build_date_column(column_name, options={})
-        column = {
-            :header => column_name,
-            :type => 'date',
-            :dataIndex => column_name,
-            :width => options[:width].nil? ? 200 : options[:width],
-            :renderer => NonEscapeJsonString.new("Ext.util.Format.dateRenderer('m/d/Y')")
-        }
-
-        column[:editor] = {:xtype => "datefield", :readOnly => options[:readonly].blank? ? false : options[:readonly]}
-
-        column
-      end
-
-      def self.build_datetime_column(column_name, options={})
-        column = {
-            :header => column_name,
-            :type => 'date',
-            :dataIndex => column_name,
-            :width => options[:width].nil? ? 200 : options[:width],
-            :renderer => NonEscapeJsonString.new("Ext.util.Format.dateRenderer('m/d/Y')")
-        }
-
-        column[:editor] = {:xtype => "datefield", :readOnly => options[:readonly].blank? ? false : options[:readonly]}
-
-        column
-      end
-
-      def self.build_string_column(column_name, options={})
-        column = {
-            :header => column_name,
-            :type => 'string',
-            :dataIndex => column_name,
-            :width => options[:width].nil? ? 150 : options[:width],
-        }
-
-        column[:editor] = {:xtype => "textfield", :readOnly => options[:readonly].blank? ? false : options[:readonly]}
-
-        column
-      end
-
-      def self.build_integer_column(column_name, options={})
-        column = {
-            :header => column_name,
-            :type => 'number',
-            :dataIndex => column_name,
-            :width => options[:width].nil? ? 150 : options[:width],
-        }
-
-        column[:editor] = {:xtype => "numberfield", :readOnly => options[:readonly].blank? ? false : options[:readonly]}
-
-        column
-      end
-
-      def self.build_decimal_column(column_name, options={})
-        column = {
-            :header => column_name,
-            :type => 'float',
-            :dataIndex => column_name,
-            :width => options[:width].nil? ? 150 : options[:width],
-        }
-
-        column[:editor] = {:xtype => "numberfield", :readOnly => options[:readonly].blank? ? false : options[:readonly]}
-
-        column
-      end
-
-      def self.build_float_column(column_name, options={})
-        column = {
-            :header => column_name,
-            :type => 'float',
-            :dataIndex => column_name,
-            :width => options[:width].nil? ? 150 : options[:width],
-        }
-
-        column[:editor] = {:xtype => "numberfield", :readOnly => options[:readonly].blank? ? false : options[:readonly]}
-
-        column
-      end
-
-      def self.build_text_column(column_name, options={})
-        column = {
-            :header => column_name,
-            :type => 'string',
-            :dataIndex => column_name,
-            :width => options[:width].nil? ? 150 : options[:width],
-        }
-
-        column[:editor] = {:xtype => "textarea", :readOnly => options[:readonly].blank? ? false : options[:readonly]}
-
-        column
-      end
-
-    end
-  end
-end

data/lib/active_ext/ext_helpers/data_helper.rb

@@ -1,67 +0,0 @@
-module ActiveExt
-  module ExtHelpers
-    module DataHelper
-      
-      def self.build_json_data(core, options={})
-        result = {:total => 0, :data => []}
-        klass = get_klass(core.model)
-    
-        klass.include_root_in_json = false
-        
-        records = klass.all(options)
-        result[:total] = klass.count
-        result[:data] = records
-    
-        result.to_json(:include => core.association_names)
-      end
-    
-      def self.create_record(core, options={})
-        ignored_columns = %w{id created_at updated_at}
-    
-        klass = get_klass(core.model)
-    
-        options[:data].delete_if{|k,v| k.blank? || ignored_columns.include?(k)}
-        obj = klass.create
-        options[:data].each do |k,v|
-          obj.send("#{k.to_s}=", v)
-        end
-        obj.save
-    
-        result = {:success => true, :data => []}
-        result[:data] = obj
-    
-        result.to_json
-      end
-    
-      def self.update_record(core, options={})
-        klass = get_klass(core.model)
-        
-        obj = klass.find(options[:id])
-        options[:data].each do |k,v|
-          obj.send("#{k.to_s}=", v)
-        end
-        obj.save
-    
-        result = {:success => true, :data => []}
-        result[:data] = obj
-        result.to_json
-      end
-    
-      def self.delete_record(core, options={})
-        klass = get_klass(core.model)
-    
-        klass.destroy(options[:id])
-    
-        result = {:success => true, :data => []}
-        result.to_json
-      end
-    
-      private
-    
-      def self.get_klass(model)
-        model.to_s.constantize
-      end
-      
-    end #DataHelper
-  end #ExtHelpers
-end #ActiveExt

data/lib/active_ext/ext_helpers/ext_helpers.rb

@@ -1,5 +0,0 @@
-require 'active_ext/ext_helpers/column_builder'
-require 'active_ext/ext_helpers/data_helper'
-require 'active_ext/ext_helpers/field_builder'
-require 'active_ext/ext_helpers/form_builder'
-require 'active_ext/ext_helpers/table_builder'

data/lib/active_ext/ext_helpers/field_builder.rb

@@ -1,146 +0,0 @@
-module ActiveExt
-  module ExtHelpers
-    module FieldBuilder
-      class << self
-
-        def build_field(column, value, display_only = false, hidden = false)
-          if display_only
-            field_json = display_field(column.options)
-          elsif hidden
-            field_json = hidden_field(column.options)
-          elsif column.options[:readonly]
-            field_json = display_field(column.options)
-          else
-            field_json = self.send("build_#{column.sql_type.to_s}_field", column.options)
-          end
-
-          field_json[:fieldLabel] = column.name.to_s.humanize
-          field_json[:name] = column.name.to_s
-          field_json[:allowBlank] = !column.options[:required]
-
-          if display_only
-            value = format_display_value(column, value)
-          elsif column.options[:readonly]
-            value = format_display_value(column, value)
-          end
-
-          field_json[:value] = value
-
-          field_json
-        end
-
-        def format_display_value(column, value)
-          if column.sql_type.to_s == 'date'
-            value = value.strfdate('%m/%d/%Y') unless value.nil?
-          elsif column.sql_type.to_s == 'datetime'
-            value = value.strftime('%m/%d/%Y') unless value.nil?
-          end
-
-          value
-        end
-
-        def hidden_field(options={})
-          field_json = {
-              :xtype => 'hidden'
-          }
-
-          field_json
-        end
-
-        def display_field(options={})
-          field_json = {
-              :width => 250,
-              :xtype => 'displayfield',
-              :labelWidth => 140
-          }
-
-          field_json
-        end
-
-        def build_boolean_field(options={})
-          field_json = {
-              :width => 250,
-              :xtype => 'combo',
-              :labelWidth => 140,
-              :forceSelection => true,
-              :store => [['true', 'True'], ['false', 'False']],
-              :triggerAction => 'all'
-          }
-
-          field_json
-        end
-
-        def build_date_field(options={})
-          field_json = {
-              :width => 250,
-              :xtype => 'datefield',
-              :labelWidth => 140
-          }
-
-          field_json
-        end
-
-        def build_datetime_field(options={})
-          field_json = {
-              :width => 150,
-              :xtype => 'datefield',
-              :labelWidth => 140
-          }
-
-          field_json
-        end
-
-        def build_string_field(options={})
-          field_json = {
-              :width => 250,
-              :xtype => 'textfield',
-              :labelWidth => 140
-          }
-
-          field_json
-        end
-
-        def build_integer_field(options={})
-          field_json = {
-              :width => 250,
-              :xtype => 'numberfield',
-              :labelWidth => 140
-          }
-
-          field_json
-        end
-
-        def build_decimal_field(options={})
-          field_json = {
-              :width => 250,
-              :xtype => 'numberfield',
-              :labelWidth => 140
-          }
-
-          field_json
-        end
-
-        def build_float_field(options={})
-          field_json = {
-              :width => 250,
-              :xtype => 'numberfield',
-              :labelWidth => 140
-          }
-
-          field_json
-        end
-
-        def build_text_field(options={})
-          field_json = {
-              :width => 150,
-              :xtype => 'textarea',
-              :labelWidth => 140
-          }
-
-          field_json
-        end
-
-      end
-    end
-  end
-end