rails_db_admin 2.0.0

data/config/initializers/rails_db_admin.rb

@@ -0,0 +1,4 @@
+Rails.application.config.rails_db_admin.configure do |config|
+  config.query_location = File.join(Rails.root, 'lib', 'rails_db_admin', 'queries')
+end
+Rails.application.config.rails_db_admin.configure!

data/config/routes.rb

@@ -0,0 +1,4 @@
+RailsDbAdmin::Engine.routes.draw do
+  match '/erp_app/desktop/base(/:action(/:table(/:id)))' => "erp_app/desktop/base"
+  match '/erp_app/desktop/queries(/:action(/:table(/:id)))' => "erp_app/desktop/queries"
+end

data/db/data_migrations/20110816005525_rails_db_admin_application.rb

@@ -0,0 +1,31 @@
+class RailsDbAdminApplication
+  
+  def self.up
+    if DesktopApplication.find_by_internal_identifier('rails_db_admin').nil?
+      rails_db_admin_app = DesktopApplication.create(
+        :description => 'RailsDbAdmin',
+        :icon => 'icon-rails_db_admin',
+        :javascript_class_name => 'Compass.ErpApp.Desktop.Applications.RailsDbAdmin',
+        :internal_identifier => 'rails_db_admin',
+        :shortcut_id => 'rails_db_admin-win'
+      )
+
+      rails_db_admin_app.preference_types << PreferenceType.iid('desktop_shortcut')
+      rails_db_admin_app.preference_types << PreferenceType.iid('autoload_application')
+      rails_db_admin_app.save
+    
+      admin_user = User.find_by_username('admin')
+      admin_user.desktop.applications << rails_db_admin_app
+      admin_user.save
+    
+      truenorth_user = User.find_by_username('truenorth')
+      truenorth_user.desktop.applications << rails_db_admin_app
+      truenorth_user.save
+    end
+  end
+  
+  def self.down
+    DesktopApplication.find_by_internal_identifier('rails_db_admin').destroy
+  end
+
+end

data/lib/rails_db_admin.rb

@@ -0,0 +1,15 @@
+#compass libraries
+require 'erp_app'
+require 'erp_forms'
+
+require 'rails_db_admin/config'
+require 'rails_db_admin/extjs'
+require 'rails_db_admin/connection_handler'
+require 'rails_db_admin/query_support'
+require 'rails_db_admin/table_support'
+require "rails_db_admin/engine"
+
+module RailsDbAdmin
+end
+
+

data/lib/rails_db_admin/config.rb

@@ -0,0 +1,27 @@
+module RailsDbAdmin
+  module Config
+    class << self
+      attr_accessor :query_location
+
+      def init!
+        @defaults = {:@query_location => nil}
+      end
+
+      def reset!
+        @defaults.each do |k,v|
+          instance_variable_set(k,v)
+        end
+      end
+
+      def configure(&blk)
+        @configure_blk = blk
+      end
+
+      def configure!
+        @configure_blk.call(self) if @configure_blk
+      end
+    end
+    init!
+    reset!
+  end
+end

data/lib/rails_db_admin/connection_handler.rb

@@ -0,0 +1,17 @@
+module RailsDbAdmin
+	class ConnectionHandler
+	  def self.create_connection_class(database)
+	      klass = nil
+	
+	      unless database.blank?
+	        klass = Class.new ActiveRecord::Base
+	        klass.establish_connection(database)
+	      else
+	        klass = ActiveRecord::Base
+	      end
+	      
+	      klass
+	  end
+  end
+end
+

data/lib/rails_db_admin/engine.rb

@@ -0,0 +1,11 @@
+module RailsDbAdmin
+  class Engine < Rails::Engine
+    isolate_namespace RailsDbAdmin
+
+    config.rails_db_admin = RailsDbAdmin::Config
+    
+    initializer "rails_db_admin.merge_public" do |app|
+      app.middleware.insert_before Rack::Lock, ::ActionDispatch::Static, "#{root}/public"
+    end
+  end
+end

data/lib/rails_db_admin/extjs.rb

@@ -0,0 +1,2 @@
+require 'rails_db_admin/extjs/json_column_builder'
+require 'rails_db_admin/extjs/json_data_builder'

data/lib/rails_db_admin/extjs/json_column_builder.rb

@@ -0,0 +1,139 @@
+module RailsDbAdmin
+  module Extjs
+    class JsonColumnBuilder
+      def self.build_column_from_column_obj(column)
+        self.send("build_#{column.type.to_s}_column", column.name)
+      end
+
+      #construct an array of column objects based on a
+      #AR connection.columns object
+      def self.build_grid_columns(columns, add_fake_id = false)
+        grid_columns = columns.collect do |column|
+          RailsDbAdmin::Extjs::JsonColumnBuilder.build_column_from_column_obj(column)
+        end
+        if add_fake_id
+          grid_columns << {:header => "fake_id",
+                             :type => "number",
+                             :dataIndex => "fake_id",
+                             :hidden => true}
+        end
+        grid_columns
+      end
+
+      def self.build_store_fields(columns, add_fake_id = false)
+        grid_fields = columns.collect do |column|
+          {:name => column.name}
+        end
+
+        if add_fake_id
+          grid_fields << {:name => "fake_id"}
+        end
+
+        grid_fields
+      end
+
+      def self.build_readonly_column(column_name)
+        {
+          :header => column_name,
+          :type => 'string',
+          :dataIndex  => column_name,
+          :width => 150
+        }
+      end
+
+
+      private
+
+      def self.build_boolean_column(column_name)
+        {
+          :header => column_name,
+          :type => 'boolean',
+          :dataIndex  => column_name,
+          :width => 150,
+          :editor => {:xtype => 'booleancolumneditor'},
+          :renderer => NonEscapeJsonString.new("Compass.ErpApp.Desktop.Applications.RailsDbAdmin.renderBooleanColumn")
+        }
+      end
+
+      def self.build_date_column(column_name)
+        hash = {
+          :header => column_name,
+          :type => 'date',
+          :dataIndex  => column_name,
+          :width => 150,
+        }
+        hash[:editor] = {:xtype => 'textfield'} if (column_name != "created_at" && column_name != "updated_at")
+
+        hash
+      end
+
+      def self.build_datetime_column(column_name)
+        hash = {
+          :header => column_name,
+          :type => 'date',
+          :dataIndex  => column_name,
+          :width => 150,
+        }
+        hash[:editor] = {:xtype => 'textfield'} if (column_name != "created_at" && column_name != "updated_at")
+
+        hash
+      end
+
+      def self.build_string_column(column_name)
+        {
+          :header => column_name,
+          :type => 'string',
+          :dataIndex  => column_name,
+          :width => 150,
+          :editor => {:xtype => 'textfield'}
+        }
+      end
+
+      def self.build_text_column(column_name)
+        {
+          :header => column_name,
+          :type => 'string',
+          :dataIndex  => column_name,
+          :width => 150,
+          :editor => {:xtype => 'textarea'}
+        }
+      end
+
+      def self.build_integer_column(column_name)
+        hash = {
+          :header => column_name,
+          :type => 'number',
+          :dataIndex  => column_name,
+          :width => 150,
+        }
+        hash[:editor] = {:xtype => 'textfield'} if column_name != "id"
+
+        hash
+      end
+
+      def self.build_decimal_column(column_name)
+        hash = {
+          :header => column_name,
+          :type => 'float',
+          :dataIndex  => column_name,
+          :width => 150,
+        }
+        hash[:editor] = {:xtype => 'textfield'} if column_name != "id"
+
+        hash
+      end
+
+      def self.build_float_column(column_name)
+        hash = {
+          :header => column_name,
+          :type => 'float',
+          :dataIndex  => column_name,
+          :width => 150,
+        }
+        hash[:editor] = {:xtype => 'textfield'} if column_name != "id"
+
+        hash
+      end
+    end
+  end
+end

data/lib/rails_db_admin/extjs/json_data_builder.rb

@@ -0,0 +1,82 @@
+module RailsDbAdmin
+  module Extjs
+    class JsonDataBuilder
+
+      def initialize(database_connection_class)
+        @connection = database_connection_class.connection
+      end
+
+      def build_json_data(options)
+        unless options[:table]
+          raise '!Error Must specify table'
+        end
+
+        total_count = self.get_total_count(options[:table])
+        arel_table = Arel::Table::new(options[:table])
+
+        if options[:limit] && options[:offset] && options[:order]
+          query = arel_table.project(Arel.sql('*')).order(options[:order]).
+            take(@connection.sanitize_limit(options[:limit])).
+            skip(options[:offset].to_i)
+        elsif options[:limit] && options[:order]
+          query = arel_table.project(Arel.sql('*')).order(options[:order]).
+            take(@connection.sanitize_limit(options[:limit]))
+        elsif options[:limit] && !options[:order]
+          query = arel_table.project(Arel.sql('*')).
+            take(@connection.sanitize_limit(options[:limit]))
+        elsif !options[:limit] && options[:order]
+          query = arel_table.project(Arel.sql('*')).order(options[:order])
+        else
+          query = arel_table.project(Arel.sql('*'))
+        end
+
+
+        rows = @connection.select_all(query.to_sql)
+        records = RailsDbAdmin::TableSupport.database_rows_to_hash(rows)
+
+        if !records.empty? && !records[0].has_key?("id")
+          records = RailsDbAdmin::TableSupport.add_fake_id_col(records)
+        end
+
+        {:totalCount => total_count, :data => records}
+      end
+
+      def get_row_data(table, id)
+        arel_table = Arel::Table::new(table)
+
+        query = arel_table.project(
+          Arel.sql('*')).where(arel_table[id[0].to_sym].eq(id[1]))
+
+        rows = @connection.select_all(query.to_sql)
+        records = RailsDbAdmin::TableSupport.database_rows_to_hash(rows)
+        records[0]
+      end
+
+      #This will retrieve data from tables without an
+      #'id' field.  Will also add a 'fake_id' so that it can
+      #be used by editable ExtJS grids.
+      def get_row_data_no_id(table, row_hash)
+
+        arel_table = Arel::Table::new(table)
+        query = arel_table.project(Arel.sql('*'))
+        row_hash.each do |k, v|
+          query = query.where(arel_table[k.to_sym].eq(v))
+        end
+
+        rows = @connection.select_all(query.to_sql)
+        records = RailsDbAdmin::TableSupport.database_rows_to_hash(rows)
+        records = RailsDbAdmin::TableSupport.add_fake_id_col(records)
+        records[0]
+      end
+
+      def get_total_count(table)
+        total_count = 0
+        rows = @connection.select_all("SELECT COUNT(*) as count FROM #{table}")
+        records = RailsDbAdmin::TableSupport.database_rows_to_hash(rows)
+        total_count = records[0][:count]
+			
+        total_count
+      end
+	end
+  end
+end

data/lib/rails_db_admin/query_support.rb

@@ -0,0 +1,72 @@
+require 'fileutils'
+
+module RailsDbAdmin
+	class QuerySupport
+    def initialize(database_connection_class, database_connection_name)
+      @path = File.join(Rails.application.config.rails_db_admin.query_location, database_connection_name)
+      @connection = database_connection_class.connection
+    end
+	
+	  def execute_sql(sql)
+	    begin
+	      rows = @connection.select_all(sql)
+	    rescue => ex
+	      return nil, nil, ex.message
+	    end
+	
+	    values = []
+	    columns = []
+	
+	    unless rows.nil? || rows.empty?
+	      columns = rows[0].keys
+	      rows.each do |row|
+	        values << row
+	      end
+	    end
+	    
+	    return columns, values, nil
+	  end
+
+    def select_top_fifty(table)
+      #Actually, sanitizing here is pretty redundent since it's a constant...
+      ar = Arel::Table::new(table)
+      query = ar.project(Arel.sql('*')).take(50)
+      #query = "SELECT * FROM #{table} LIMIT #{@connection.sanitize_limit(50)}"
+
+      rows = @connection.select_all(query.to_sql)
+      records = RailsDbAdmin::TableSupport.database_rows_to_hash(rows)
+
+      return query.to_sql, records
+    end
+
+	  def get_saved_query_names
+	    query_files = []
+	    
+	    if File.directory? @path
+	      query_files = Dir.entries(@path)
+	      query_files.delete_if{|name| name =~ /^\./}
+	      query_files.each do |file_name|
+	        file_name.gsub!('.sql', '')
+	      end
+	    end
+	    
+	    query_files
+	  end
+	  
+	  def save_query(query, name)
+	    FileUtils.mkdir_p(@path) unless File.directory? @path
+
+      file_path = File.join(@path, "#{name}.sql")
+	    File.new(file_path, 'w') unless File.exist?(File.join(file_path))
+	    File.open(file_path, 'w+'){|f| f.puts(query) }
+	  end
+	  
+	  def delete_query(name)
+	    FileUtils.rm(File.join(@path, "#{name}.sql")) if File.exist?(File.join(@path, "#{name}.sql"))
+	  end
+	  
+    def get_query(name)
+      File.open(File.join(@path, "#{name}.sql")) { |f| f.read } if File.exist?(File.join(@path, "#{name}.sql"))
+    end
+  end
+end

data/lib/rails_db_admin/table_support.rb

@@ -0,0 +1,147 @@
+module RailsDbAdmin
+  class TableSupport
+
+    def initialize(database_connection_class)
+     @connection = database_connection_class.connection
+    end
+
+    def columns(table)
+      @columns ||= @connection.columns(table)
+    end
+
+    def update_table(table, id, data)
+      arel_table = Arel::Table::new(table)
+      clean_nulls!(table, data)
+      data = RailsDbAdmin::TableSupport.arel_attr(data, arel_table)
+
+      pk = id[0].to_sym
+      query = arel_table.where(arel_table[pk].eq(id[1])).compile_update(data)
+
+      @connection.execute(query.to_sql)
+    end
+
+    def update_table_without_id(table, data)
+      #makes all values strings
+      data[0].delete('fake_id')
+      data[1].delete('fake_id')
+      data.map! do |item|
+        item.each do |k,v|
+          item[k] = v.to_s
+        end
+        item
+      end
+
+      clean_nulls!(table, data)
+      changed_values = data[0].diff(data[1])
+
+      arel_table = Arel::Table::new(table)
+      updates = RailsDbAdmin::TableSupport.arel_attr(changed_values, arel_table)
+      query = arel_table
+
+      data[1].each do |k, v|
+        query = query.where(arel_table[k.to_sym].eq(v))
+      end
+      query = query.compile_update(updates)
+
+      @connection.execute(query.to_sql)
+    end
+
+    def delete_row(table, id)
+      arel_table = Arel::Table::new(table)
+      pk = id[0].to_sym
+      query = arel_table.where(arel_table[pk].eq(id[1])).compile_delete
+
+      @connection.execute(query.to_sql)
+    end
+
+    def insert_row(table, data, no_id=false)
+      clean_nulls!(table, data)
+      arel_table = Arel::Table::new(table)
+      data = RailsDbAdmin::TableSupport.arel_attr(data, arel_table)
+
+      sql = arel_table.compile_insert(data)
+      #TODO: Test with Oracle; ActiveRecord source indicates
+      #that we may need to pass in the id to use here
+      id = @connection.insert(sql.to_sql)
+
+      if no_id
+        #need to gen a random number for fake_id...
+        id = Random.rand(500-100) + 100
+      end
+      id
+    end
+
+    def primary_key(table)
+      [@connection.primary_key(table),nil]
+    end
+
+    def primary_key?(table)
+      @connection.supports_primary_key? && @connection.primary_key(table) != nil
+    end
+
+	  
+	  def table_contains_column(table, column_name)
+	    
+	    column_names = columns(table).map{|column| column.name.to_sym}
+	    
+	    column_names.include?(column_name)
+	  end
+	
+    def clean_nulls!(table, data)
+      if data.class == Array
+        data.each {|x| clean_nulls!(table, x)}
+      end
+
+      data.collect do |k,v|
+        if v == "" || v == 0
+          column = columns(table).collect do |x|
+            if (x.name == k)
+              break x
+            end
+          end
+          if column.null
+            data[k] = nil
+          end
+        end
+      end
+    end
+
+    def self.database_rows_to_hash(rows)
+      records = []
+
+      rows.each do |row|
+        record = nil
+        row.each {|k, v|
+          record = record.nil? ? {k.to_sym => v} : record.merge({k.to_sym => v})
+        }
+        records << record
+      end
+
+      records.reverse
+    end
+
+    #Construct a hash of ARel relation objects as
+    #keys and assign with values for use in update
+    #calls
+    def self.arel_attr data, arel_table
+      cln_hsh = {}
+      data.each do |k,v|
+        cln_hsh[arel_table[k.to_sym]] = v
+      end
+      cln_hsh
+    end
+
+    #Accepts an array of table row hashes and adds a 'fake_id'
+    #field to each one with a generated number.  Useful
+    #for prepraring many-to-many data to be edited in ExtJS
+    #grids
+    def self.add_fake_id_col(rows_hash)
+      nums = (1..(rows_hash.length)).to_a
+      result = rows_hash.map do |item|
+        item[:fake_id] = nums.shift
+        item
+      end
+      return result
+    end
+  end
+end