erp_app 3.1.1 → 3.1.2

data/app/controllers/erp_app/desktop/scaffold/base_controller.rb

@@ -6,84 +6,84 @@ module ErpApp
 		module Scaffold
 			class BaseController < ErpApp::Desktop::BaseController
 
-			  def create_model
-          name = params[:name].underscore
+			  def get_models
+          names = ActiveRecord::Base.all_subclasses.collect{|klass| klass.name}.delete_if{|item| item =~ /::/}.uniq.sort{|a,b| a <=> b}
 
-          result = create_scaffold_check(name)
-          if result[:success]
-            Rails::Generators.invoke('active_ext', [name, 'desktop','scaffold'])
-            load_files(name)
+          respond_to do |format|
+            format.json do
+              render :json => {:success => true, :names => names.collect{|name| {:name => name}}}
+            end
+            format.tree do
+              if params[:node].blank? || params[:node] == "root"
+                render :json => {:success => true, :names => names.collect{|model| {:text => model, :id => model.underscore, :model => model, :iconCls => 'icon-grid', :leaf => false}}}
+              else
+                active_ext_core = ActiveExt::Core.new(params[:node].classify, :ignore_associations => true, :include_timestamps => false)
+                non_excluded_columns = active_ext_core.non_excluded_columns.collect{|column| column.name}
+
+                render :json => {:success => true, :names => non_excluded_columns.collect{|column| {:text => column, :iconCls => 'icon-gear', :leaf => true}}}
+              end
+            end
           end
+        end
 
-          render :json => result
-			  end
+        def get_columns
+          active_ext_core = ActiveExt::Core.new(params[:model], :ignore_associations => true, :include_timestamps => false)
 
-			  def get_active_ext_models
-          render :json => find_active_ext_models.map{|model| {:text => model, :model => model.underscore, :iconCls => 'icon-grid', :leaf => true}}
-			  end
+          non_excluded_columns = active_ext_core.non_excluded_columns.collect{|column| {:name => column.name}}
 
-			  private
+          render :json => {:success => true, :columns => non_excluded_columns.sort{|a,b| a[:name] <=> b[:name]}}
+        end
 
-			  def create_scaffold_check(name)
-          result = {:success => true}
+        def setup
+          active_ext_core = setup_active_ext_core
 
-          klass_name = name.classify
-          model_names = find_active_ext_models
-          unless model_names.include?(klass_name)
-            unless class_exists?(klass_name)
-              result[:success] = false
-              result[:msg] = "Model does not exists"
-            end
-          else
-            result[:success] = false
-            result[:msg] = "Scaffold already exists"
-          end
+          columns, fields, validations = ActiveExt::ExtHelpers::TableBuilder.generate_columns_and_fields(active_ext_core)
+          result = {
+              :success => true,
+              :use_ext_forms => active_ext_core.options[:use_ext_forms].nil? ? false : active_ext_core.options[:use_ext_forms],
+              :inline_edit => active_ext_core.options[:inline_edit].nil? ? false : active_ext_core.options[:inline_edit],
+              :columns => columns,
+              :fields => fields,
+              :validations => validations
+          }
+          render :inline => result.to_json
+        end
 
-          return result
-			  end
-
-			  #get all file in root app/controllers and first level plugins app/controllers
-			  def find_active_ext_models
-          model_names = []
-
-          dirs = [Rails.root]
-          dirs = dirs | Rails::Application::Railties.engines.map{|p| p.config.root.to_s}
-
-          dirs.each do |dir|
-            if File.exists? File.join(dir,"/app/controllers/erp_app/desktop/scaffold/")
-              Dir.glob("#{dir}/app/controllers/erp_app/desktop/scaffold/*.rb") do |filename|
-                next if filename =~ /#{['svn','git'].join("|")}/
-                open(filename) do |file|
-                  if file.grep(/active_ext/).any?
-                    model = File.basename(filename).gsub("_controller.rb", "").classify
-                    if class_exists?(model)
-                      model_names << model
-                    end
-                  end
-                end
-              end
-            end
+        def data
+          active_ext_core = setup_active_ext_core
+
+          json_text = nil
+
+          if request.get?
+            json_text = ActiveExt::ExtHelpers::DataHelper.build_json_data(active_ext_core, :limit => params[:limit], :offset => params[:start])
+          elsif request.post?
+            json_text = ActiveExt::ExtHelpers::DataHelper.create_record(active_ext_core, :data => params[:data])
+          elsif request.put?
+            json_text = ActiveExt::ExtHelpers::DataHelper.update_record(active_ext_core, :data => params[:data], :id => params[:data][:id])
+          elsif request.delete?
+            json_text = ActiveExt::ExtHelpers::DataHelper.delete_record(active_ext_core, :data => params[:data], :id => params[:data][:id])
           end
-          
-          model_names
-			  end
-
-			  def class_exists?(class_name)
-          klass = Module.const_get(class_name)
-          return klass.is_a?(Class) ? klass.superclass == ActiveRecord::Base : false
-			  rescue NameError
-          return false
-			  end
-
-			  def load_files(name)
-          #reload routes file
-          load "#{Rails.root}/config/routes.rb"
-
-          #load controller
-          controller = "ErpApp::Desktop::Scaffold::#{name.classify}Controller"
-          controller.constantize unless class_exists?(controller)
-			  end
-			end
-		end
-	end
-end
+
+          render :inline => json_text
+        end
+
+        private
+
+        def setup_active_ext_core
+          model_id = params[:model_name]
+          default_options = {
+              :inline_edit => true,
+              :use_ext_forms => false,
+              :ignore_associations => true,
+              :show_id => true,
+              :show_timestamps => true,
+              :only => nil
+          }
+
+          ActiveExt::Core.new(model_id, default_options)
+        end
+
+       end #BaseController
+		end #Scaffold
+	end #Desktop
+end #ErpApp

data/app/controllers/erp_app/desktop/security_management/capabilities_controller.rb

@@ -35,9 +35,9 @@ module ErpApp
           assign_to = params[:assign_to]
           assign_to_id = params[:id]
           sort  = (params[:sort] || 'description').downcase
+          sort = 'capabilities.description' if sort == 'description'
           dir   = (params[:dir] || 'asc').downcase
           query_filter = params[:query_filter].strip rescue nil
-
           scope_type_ids = [ScopeType.find_by_internal_identifier('class').id, ScopeType.find_by_internal_identifier('query').id]
 
           ar = assign_to_id.blank? ? Capability.joins(:capability_type) : assign_to.constantize.find(assign_to_id).capabilities_not.where("scope_type_id IN (#{scope_type_ids.join(',')})")
@@ -51,6 +51,7 @@ module ErpApp
           assign_to = params[:assign_to]
           assign_to_id = params[:id]
           sort  = (params[:sort] || 'description').downcase
+          sort = 'capabilities.description' if sort == 'description'
           dir   = (params[:dir] || 'asc').downcase
           query_filter = params[:query_filter].strip rescue nil
 

data/app/controllers/erp_app/desktop/security_management/groups_controller.rb

@@ -35,6 +35,7 @@ module ErpApp
           assign_to = params[:assign_to]
           assign_to_id = params[:id]
           sort  = (params[:sort] || 'description').downcase
+          sort = 'groups.description' if sort == 'description'
           dir   = (params[:dir] || 'asc').downcase
           query_filter = params[:query_filter].strip rescue nil
 
@@ -49,6 +50,7 @@ module ErpApp
           assign_to = params[:assign_to]
           assign_to_id = params[:id]
           sort  = (params[:sort] || 'description').downcase
+          sort = 'groups.description' if sort == 'description'
           dir   = (params[:dir] || 'asc').downcase
           query_filter = params[:query_filter].strip rescue nil
 

data/app/views/erp_app/desktop/base/index.erb

@@ -2,6 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml">
   <head>
     <style type="text/css">
+
 <%@desktop.applications.each do |application|%>
         .<%=application.shortcut_id%>-shortcut{
           background-image:url("/images/icons/<%=application.icon.split('-')[1]%>/<%=application.icon.split('-')[1]%>_48x48.png");

data/config/routes.rb

@@ -42,7 +42,7 @@ ErpApp::Engine.routes.draw do
 
   #Desktop Applications
   #scaffold
-  match '/desktop/scaffold/:action' => "desktop/scaffold/base"
+  match '/desktop/scaffold/:action((/:model_name)(.:format))' => "desktop/scaffold/base"
   match '/desktop/scaffold/role/:action(/:id)' => "desktop/scaffold/role#index"
   
   #user_management

data/lib/active_ext/core.rb

@@ -1,82 +1,105 @@
 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
+  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
-      valid_columns = valid_columns | RAILS_COLUMNS
-      attribute_names.delete_if{|item| !valid_columns.include?(item.to_sym)}
+
+      @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
 
-    #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
+    def model_id
+      @model_id
     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)
+    def model
+      @model ||= @model_id.to_s.camelize.constantize
+    end
 
-    set_column_options
-  end
+    def options
+      @options
+    end
 
-  def model_id
-    @model_id
-  end
-  
-  def model
-    @model ||= @model_id.to_s.camelize.constantize
-  end
+    def non_excluded_columns
+      columns = []
 
-  def options
-    @options
-  end
+      #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
 
-  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]
+    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
+  end
 end

data/lib/active_ext/data_structures/column.rb

@@ -1,21 +1,21 @@
 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
+  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
+      def sql_type
+        @column.type
+      end
+    end
   end
-end
-end
 end

data/lib/active_ext/data_structures/columns.rb

@@ -1,66 +1,69 @@
 module ActiveExt
-module DataStructures
-class Columns
-  include Enumerable
+  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 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
+      # 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 = []
+      def initialize(active_record_class, *args)
+        @active_record_class = active_record_class
+        @_inheritable = []
+        @excluded_columns = []
+        @set = []
 
-    self.add *args
-  end
+        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 }
+      # 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
+        # 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
 
-  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
+      alias_method :<<, :add
 
-  # returns an array of columns with the provided names
-  def find_by_names(*names)
-    @set.find_all { |column| names.include? column.name }
-  end
+      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 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
+      # returns an array of columns with the provided names
+      def find_by_names(*names)
+        @set.find_all { |column| names.include? column.name }
+      end
 
-  def each
-    @set.each {|i| yield i }
-  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
 
-  def exclude_column?(name)
-    @excluded_columns.include?(name)
+    end
   end
-end
-end
 end