rails_db_admin 3.0.0 → 3.2.0

data/config/routes.rb

@@ -1,5 +1,6 @@
 Rails.application.routes.draw do
-  match '/reports/display/:iid(.:format)' => "rails_db_admin/reports/base#index"
+  match '/reports/display/:iid(.:format)' => "rails_db_admin/reports/base#show"
+  match '/reports/email/:iid' => "rails_db_admin/reports/base#email"
 end
 
 RailsDbAdmin::Engine.routes.draw do

data/db/data_migrations/20110816005525_rails_db_admin_application.rb

@@ -1,29 +1,21 @@
 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'
+        :internal_identifier => 'rails_db_admin'
       )
 
-      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.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
+
+      rails_db_admin_app.add_party_with_role(admin_user.party.dba_organization, RoleType.iid('dba_org'))
     end
   end
-  
+
   def self.down
     DesktopApplication.find_by_internal_identifier('rails_db_admin').destroy
   end

data/db/data_migrations/20151015093724_add_report_role_type.rb

@@ -0,0 +1,15 @@
+class AddReportRoleType
+  
+  def self.up
+    RoleType.create(
+      description: 'Report',
+      internal_identifier: 'report'
+    ) unless RoleType.iid('report')
+  end
+
+  def self.down
+    report_role = RoleType.iid('report')
+    report_role.destroy if report_role
+  end
+
+end

data/db/migrate/20121210160131_add_reports.rb

@@ -9,6 +9,8 @@ class AddReports < ActiveRecord::Migration
 
         t.timestamps
       end
+
+      add_index :reports, :internal_identifier, :name => 'reports_internal_identifier_idx'
     end
   end
 

data/db/migrate/20150926061259_add_meta_data_to_reports.rb

@@ -0,0 +1,9 @@
+class AddMetaDataToReports < ActiveRecord::Migration
+  def up
+    add_column :reports, :meta_data, :text unless column_exists? :reports, :meta_data
+  end
+
+  def down
+    remove_column :reports, :meta_data if column_exists? :reports, :meta_data
+  end
+end

data/lib/rails_db_admin.rb

@@ -6,10 +6,12 @@ require "rails_db_admin/version"
 require 'rails_db_admin/config'
 require 'rails_db_admin/extjs'
 require 'rails_db_admin/connection_handler'
+require 'rails_db_admin/query_params'
+require 'rails_db_admin/erp_string_parser'
 require 'rails_db_admin/query_support'
 require 'rails_db_admin/table_support'
-require 'rails_db_admin/report_support'
-require "rails_db_admin/engine"
+require 'rails_db_admin/engine'
+require 'rails_db_admin/services/report_helper'
 
 module RailsDbAdmin
 end

data/lib/rails_db_admin/engine.rb

@@ -3,13 +3,21 @@ module RailsDbAdmin
     isolate_namespace RailsDbAdmin
 
     config.rails_db_admin = RailsDbAdmin::Config
-    
-    initializer "rails_db_admin.merge_public" do |app|
-      app.middleware.insert_before Rack::Runtime, ::ActionDispatch::Static, "#{root}/public"
+
+    initializer :assets do |config|
+      Rails.application.config.assets.paths << root.join("app", "assets", "images")
+      Rails.application.config.assets.precompile += %w{ erp_app/desktop/applications/rails_db_admin/app.js }
+      Rails.application.config.assets.precompile += ['bootstrap.css']
+
+      Rails.application.config.assets.precompile += %w{ erp_app/shared/rails_db_admin_shared.js }
+      Rails.application.config.assets.precompile += %w{ erp_app/shared/rails_db_admin_shared.css }
+
+      ErpApp::Config.shared_js_assets += %w{ erp_app/shared/rails_db_admin_shared.js }
+      ErpApp::Config.shared_css_assets += %w{ erp_app/shared/rails_db_admin_shared.css }
     end
 
     ErpBaseErpSvcs.register_as_compass_ae_engine(config, self)
     ::ErpApp::Widgets::Loader.load_compass_ae_widgets(config, self)
-    
+
   end
 end

data/lib/rails_db_admin/erp_string_parser.rb

@@ -0,0 +1,26 @@
+module RailsDbAdmin
+  class ErbStringParser
+    ERB_REGEX = /\<\%\=\s*(\$|@{1,2})?[A-Za-z][A-Za-z0-9_]*\s*\%\>/
+
+    class << self
+      def render(str, options = {})
+        locals = options[:locals] || {}
+
+        # convert all variables to underscore as
+        # ERB parser has issues with capitalized variables
+        _str = str.gsub(ERB_REGEX) do |w|
+          w.delete(' ').underscore
+        end
+        # convert all to locals to underscore
+        _locals = {}
+        locals.each do |k, v|
+          _locals[k.to_s.delete(' ').underscore] = v
+        end
+
+        query_params = RailsDbAdmin::QueryParams.new(_locals)
+        ERB.new(_str).result(query_params.get_binding)
+      end
+    end
+
+  end # ErbStringParser
+end # RailsDbadmin

data/lib/rails_db_admin/extensions/railties/action_view/helpers/report_helper.rb

@@ -1,18 +1,12 @@
+require 'base64'
+
 module RailsDbAdmin
   module Extensions
     module Railties
       module ActionView
         module Helpers
           module ReportHelper
-
-            def render_report(report_iid)
-              RailsDbAdmin::ReportSupport.new.render_report(report_iid)
-            end
-
-            def get_report_data(report_iid)
-              RailsDbAdmin::ReportSupport.new.get_report_data(report_iid)
-            end
-
+            
             def report_download_url(report_iid, format)
               raw "/reports/display/#{report_iid}.#{format}"
             end
@@ -22,9 +16,172 @@ module RailsDbAdmin
               raw "<a target='_blank' href='#{report_download_url(report_iid, format)}'>#{display}</a>"
             end
 
+            def render_template(template, locals=nil)
+              if request && request.format.symbol == :html
+                locals.nil? ? (render :partial => "/#{template}") : (render :partial => "/#{template}",:locals => locals[:locals])
+              elsif request && request.format.symbol == :pdf
+                locals.nil? ? (render :partial => "/#{template}.html.erb") : (render :partial => "/#{template}.html.erb" , :locals => locals[:locals])
+              else
+                locals.nil? ? (render :partial => "/#{template}.html.erb") : (render :partial => "/#{template}.html.erb" , :locals => locals[:locals])
+              end
+            end
+
+            def report_stylesheet_link_tag(report_id, *sources)
+              report = Report.iid(report_id)
+              return("could not find report with the id #{report_id}") unless report
+              if request && request.format.symbol == :pdf
+                file_support = ErpTechSvcs::FileSupport::Base.new(:storage => ErpTechSvcs::Config.file_storage)
+                css = sources.collect do |source|
+                  css_path = report.stylesheet_path(source)
+                  css_text = "<style type='text/css'>#{file_support.get_contents(css_path).first}</style>"
+                  css_text.respond_to?(:html_safe) ? css_text.html_safe : css_text
+                end.join("\n")
+                raw css
+              else
+                options = sources.extract_options!.stringify_keys
+                cache = options.delete("cache")
+                recursive = options.delete("recursive")
+                sources = report_expand_stylesheet_sources(report, sources, recursive).collect do |source|
+                  report_stylesheet_tag(report, source, options)
+                end.join("\n")
+                raw sources
+              end
+            end
+
+            def report_javascript_include_tag(report_id, *sources)
+              report = Report.iid(report_id)
+              return("could not find report with the id #{report_id}") unless report
+              if request && request.format.symbol == :pdf
+                file_support = ErpTechSvcs::FileSupport::Base.new(:storage => ErpTechSvcs::Config.file_storage)
+                js = sources.collect do |source|
+                  js_path = report.javascript_path(source)
+                  js_text = "<script>#{file_support.get_contents(js_path).first}</script>"
+                  js_text.respond_to?(:html_safe) ? js_text.html_safe : js_text
+                end.join("\n")
+                raw js
+              else
+                options = sources.extract_options!.stringify_keys
+                cache = options.delete("cache")
+                recursive = options.delete("recursive")
+                sources = report_expand_javascript_sources(report, sources, recursive).collect do |source|
+                  report_javascript_src_tag(report, source, options)
+                end.join("\n")
+                raw sources
+              end
+            end
+
+            def report_stylesheet_path(report, source)
+              report = Report.iid(report) unless report.is_a?(Report)
+
+              name, directory = name_and_path_from_source(source, "#{report.url}/stylesheets")
+
+              file = report.files.where('name = ? and directory = ?', name, directory).first
+
+              file.nil? ? '' : file.fully_qualified_url
+            end
+
+            def report_javascript_path(report, source)
+              report = Report.iid(report) unless report.is_a?(Report)
+
+              name, directory = name_and_path_from_source(source, "#{report.url}/javascripts")
+
+              file = report.files.where('name = ? and directory = ?', name, directory).first
+
+              file.nil? ? '' : file.fully_qualified_url
+            end
+
+            def name_and_path_from_source(source, base_directory)
+              path = source.split('/')
+              name = path.last
+
+              directory = if path.length > 1
+                            #remove last element
+                            path.pop
+
+                            "#{base_directory}/#{path.join('/')}"
+                          else
+                            base_directory
+                          end
+
+              return name, directory
+            end
+
+            def report_expand_stylesheet_sources(report, sources, recursive = false)
+              if sources.include?(:all)
+                all_stylesheet_files = collect_asset_files(report.base_dir + '/stylesheets', ('**' if recursive), '*.css').uniq
+              else
+                sources.flatten
+              end
+            end
+
+            def report_expand_javascript_sources(report, sources, recursive = false)
+              if sources.include?(:all)
+                collect_asset_files(report.base_dir + '/javascripts', ('**' if recursive), '*.js').uniq
+              else
+                sources.flatten
+              end
+            end
+
+            def report_stylesheet_tag(report, source, options)
+              options = {"rel" => "stylesheet", "type" => Mime::CSS, "media" => "screen",
+                         "href" => html_escape(report_stylesheet_path(report, source))}.merge(options)
+              tag("link", options, false, false)
+            end
+
+            def report_javascript_src_tag(report, source, options)
+              options = {"type" => Mime::JS, "src" => report_javascript_path(report, source)}.merge(options)
+              content_tag("script", "", options)
+            end
+
+            def report_image_tag(report_id, source, options = {})
+              report = Report.iid(report_id)
+              return("could not find report with the id #{report_id}") unless report
+
+              if request && request.format.symbol == :pdf
+                img_path = report.image_path(source)
+
+                file_support = ErpTechSvcs::FileSupport::Base.new(:storage => ErpTechSvcs::Config.file_storage)
+
+                image_tag "data:image/png;base64,#{Base64.encode64(file_support.get_contents(img_path).first)}"
+              else
+                options.symbolize_keys!
+                options[:src] = report_image_path(report, source)
+                options[:alt] ||= File.basename(options[:src], '.*').split('.').first.to_s.capitalize
+
+                if size = options.delete(:size)
+                  options[:width], options[:height] = size.split("x") if size =~ %r{^\d+x\d+$}
+                end
+
+                if mouseover = options.delete(:mouseover)
+                  options[:onmouseover] = "this.src='#{report_image_path(report, mouseover)}'"
+                  options[:onmouseout] = "this.src='#{report_image_path(report, options[:src])}'"
+                end
+
+                tag("img", options)
+              end
+            end
+
+            def report_image_path(report, source)
+              report = Report.iid(report) unless report.is_a?(Report)
+
+              name, directory = name_and_path_from_source(source, "#{report.url}/images")
+
+              file = report.files.where('name = ? and directory = ?', name, directory).first
+
+              file.nil? ? '' : file.fully_qualified_url
+            end
+
+            def bootstrap_load
+              stylesheet_link_tag "https://maxcdn.bootstrapcdn.com/bootstrap/3.3.5/css/bootstrap.min.css"
+            end
+
+            def jquery_load
+              javascript_include_tag "https://code.jquery.com/jquery-1.10.0.min.js"
+            end
+
           end #ReportHelper
         end #Helpers
       end #ActionView
     end #Railties
   end #Extensions
-end #RailsDbAdmin
+end #RailsDbAdmin

data/lib/rails_db_admin/extjs/json_data_builder.rb

@@ -14,27 +14,43 @@ module RailsDbAdmin
         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])
+        if options[:query_filter].present?
+          table_name = options[:table].classify.constantize
+          accepted_columns = table_name.columns.select {|column| column.type == :string or column.type == :text}
+          where_clause = ""
+          accepted_columns.each_with_index do |column, index|
+            if index == 0
+              where_clause = table_name.arel_table[column.name.to_sym].matches("%#{options[:query_filter]}%")
+            else
+              where_clause = where_clause.or(table_name.arel_table[column.name.to_sym].matches("%#{options[:query_filter]}%"))
+            end
+          end
+          rows = table_name.where(where_clause)
         else
-          query = arel_table.project(Arel.sql('*'))
-        end
 
-        # This is a temporary partial fix to handle postgres boolean columns which is use activerecord when possible
-        begin
-          rows = options[:table].classify.constantize.find_by_sql(query.to_sql)
-        rescue
-          rows = @connection.select_all(query.to_sql)
+          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
+
+          # This is a temporary partial fix to handle postgres boolean columns which is use activerecord when possible
+          begin
+            rows = options[:table].classify.constantize.find_by_sql(query.to_sql)
+          rescue
+            rows = @connection.select_all(query.to_sql)
+          end
+
         end
 
         records = RailsDbAdmin::TableSupport.database_rows_to_hash(rows)
@@ -79,7 +95,7 @@ module RailsDbAdmin
         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

data/lib/rails_db_admin/query_params.rb

@@ -0,0 +1,14 @@
+module RailsDbAdmin
+  class QueryParams
+    def initialize(hash)
+      hash.each do |key, value|
+        singleton_class.send(:define_method, key) { value }
+      end 
+    end
+
+    def get_binding
+      binding
+    end
+    
+  end
+end

data/lib/rails_db_admin/query_support.rb

@@ -1,34 +1,43 @@
 require 'fileutils'
 
 module RailsDbAdmin
-	class QuerySupport
+  class QuerySupport
+
     def initialize(database_connection_class, database_connection_name)
       @path = File.join(Rails.root, 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 execute_sql(sql)
+      begin
+        result = @connection.execute(sql)
+      rescue => ex
+        return nil, nil, ex.message
+      end
+
+      values = []
+      columns = []
+ 
+      if @connection.class == ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
+        columns = result.fields
+
+        if result && result.count > 0
+          result.each do |row|
+            values << HashWithIndifferentAccess.new(row)
+          end
+        end
+      else
+        columns = result[0].keys
+        result.each do |row|
+          values << HashWithIndifferentAccess.new(row)
+        end
+      end
+
+      return columns, values, nil
+    end
 
     def select_top_fifty(table)
-      #Actually, sanitizing here is pretty redundent since it's a constant...
+      #Actually, sanitizing here is pretty redundant 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)}"
@@ -45,34 +54,35 @@ module RailsDbAdmin
       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
+    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
-	  
+      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