admin_data 1.0.0

data/app/controllers/admin_data/main_controller.rb

@@ -0,0 +1,132 @@
+class AdminData::MainController  < AdminData::BaseController
+
+  unloadable
+
+  before_filter :get_class_from_params, :only => [ :table_structure, :show, :destroy, :del, :edit, :new, :update, :create]
+
+  before_filter :ensure_is_allowed_to_view
+
+  before_filter :get_model_and_verify_it, :only => [:destroy, :del, :edit, :update, :show]
+
+  before_filter :ensure_is_allowed_to_view_model, :except => [:all_models, :index]
+
+  before_filter :ensure_is_allowed_to_update, :only => [:destroy, :del, :edit, :update, :create]
+
+  before_filter :ensure_is_allowed_to_update_model, :only => [:destroy, :del, :edit, :update, :create]
+
+
+  def table_structure
+    @page_title = 'table_structure'
+    @indexes = []
+    if (indexes = ActiveRecord::Base.connection.indexes(@klass.table_name)).any?
+      add_index_statements = indexes.map do |index|
+        statment_parts = [ ('add_index ' + index.table.inspect) ]
+        statment_parts << index.columns.inspect
+        statment_parts << (':name => ' + index.name.inspect)
+        statment_parts << ':unique => true' if index.unique
+
+        '  ' + statment_parts.join(', ')
+      end
+      add_index_statements.sort.each { |index| @indexes << index }
+    end
+    respond_to {|format| format.html}
+  end
+
+  def all_models
+    respond_to {|format| format.html}
+  end
+
+  def show
+    @page_title = "#{@klass.name.underscore}:#{@model.id}"
+    respond_to {|format| format.html}
+  end
+
+  def destroy
+    @klass.send(:destroy, params[:id])
+    redirect_to admin_data_search_path(:klass => @klass.name.underscore)
+  end
+
+  def del
+    @klass.send(:delete, params[:id])
+    flash[:success] = 'Record was deleted'
+    redirect_to admin_data_search_path(:klass => @klass.name.underscore)
+  end
+
+  def edit
+    @page_title = "edit #{@klass.name.underscore}:#{@model.id}"
+    @columns = columns_list
+    respond_to {|format| format.html}
+  end
+
+  def new
+    @page_title = "new #{@klass.name.underscore}"
+    @model = @klass.send(:new)
+    @columns = columns_list
+    respond_to {|format| format.html}
+  end
+
+  def update
+    model_name_underscored = @klass.name.underscore
+    model_attrs = params[model_name_underscored]
+    @columns = columns_list
+    respond_to do |format|
+      if @model.update_attributes(model_attrs)
+        format.html do
+          flash[:success] = "Record was updated"
+          redirect_to admin_data_on_k_path(:id => @model, :klass => @klass.name.underscore)
+        end
+        format.js { render :json => {:success => true}}
+      else
+        format.html { render :action => 'edit' }
+        format.js { render :json => {:error => @model.errors.full_messages.join } }
+      end
+    end
+  end
+
+  def create
+    model_name_underscored = @klass.name.underscore
+    model_attrs = params[model_name_underscored]
+    @model = @klass.create(model_attrs)
+    @columns = columns_list
+
+    respond_to do |format|
+      if @model.errors.any?
+        format.html { render :action => 'new' }
+        format.js { render :json => {:error => @model.errors.full_messages.join() }}
+      else
+        format.html do
+          flash[:success] = "Record was created"
+          redirect_to admin_data_on_k_path(:id => @model, :klass => @klass.name.underscore)
+        end
+        format.js { render :json => {} }
+      end
+    end
+  end
+
+  private
+
+  def get_model_and_verify_it
+    primary_key = @klass.primary_key.intern
+    conditional_id = params[:id] =~ /^(\d+)-.*/ ? params[:id].to_i : params[:id]
+    condition = {primary_key => conditional_id}
+
+    # http://neerajdotname.github.com/admin_data/#override_find_condition
+    find_conditions_proc = AdminData::Config.setting[:find_conditions] ?  AdminData::Config.setting[:find_conditions][@klass.name] : nil
+    if find_conditions_proc && find_conditions = find_conditions_proc.call(params)
+
+      if find_conditions.has_key?(:conditions)
+        condition = find_conditions.fetch(:conditions)
+      end
+    end
+
+    @model = @klass.send('find', :first, :conditions => condition)
+    unless @model
+      render :text => "<h2>#{@klass.name} not found: #{params[:id]}</h2>", :status => :not_found
+    end
+  end
+
+  def columns_list
+    params[:attr].blank? ? @klass.columns : @klass.columns.find_all {|col| params[:attr] == col.name}
+  end
+
+end

data/app/controllers/admin_data/migration_controller.rb

@@ -0,0 +1,19 @@
+class AdminData::MigrationController < AdminData::BaseController
+
+  unloadable
+
+  before_filter :ensure_is_allowed_to_view
+
+  def index
+    @page_title = 'migration information'
+    m = 'select * from schema_migrations'
+    @data = ActiveRecord::Base.connection.select_all(m)
+    respond_to {|format| format.html}
+  end
+
+  def jstest
+    @page_title = 'jstest'
+    respond_to {|format| format.html { render :layout => false}}
+  end
+
+end

data/app/controllers/admin_data/search_controller.rb

@@ -0,0 +1,125 @@
+require File.join(File.dirname(__FILE__) , '..', '..', '..', 'lib', 'admin_data', 'search')
+
+class AdminData::SearchController  < AdminData::BaseController
+
+  include Search
+
+  unloadable
+
+  before_filter :get_class_from_params
+  before_filter :ensure_is_allowed_to_view
+  before_filter :ensure_is_allowed_to_view_model
+  before_filter :ensure_valid_children_klass, :only => [:quick_search]
+  before_filter :ensure_is_authorized_for_update_opration, :only => [:advance_search]
+  before_filter :set_collection_of_columns, :only => [:advance_search]
+
+  def quick_search
+    @page_title = "Search #{@klass.name.underscore}"
+    @order = default_order
+
+    if params[:base]
+      klass = AdminData::Util.camelize_constantize(params[:base])
+      model = klass.find(params[:model_id])
+      has_many_proxy = model.send(params[:children].intern)
+      @total_num_of_children = has_many_proxy.send(:count)
+      h = { :page => params[:page], :per_page => per_page, :order => @order }
+      @records = has_many_proxy.send(:paginate, h)
+    else
+      params[:query] = params[:query].strip unless params[:query].blank?
+      cond = build_quick_search_conditions(@klass, params[:query])
+      h = { :page => params[:page], :per_page => per_page, :order => @order, :conditions => cond }
+      @records = @klass.paginate(h)
+    end
+    respond_to {|format| format.html}
+  end
+
+
+  def advance_search
+    debugger
+    @page_title = "Advance search #{@klass.name.underscore}"
+    plugin_dir = AdminData::Config.setting[:plugin_dir]
+    hash = build_advance_search_conditions(@klass, params[:adv_search])
+    @relation = hash[:cond]
+    errors = hash[:errors]
+    @order = default_order
+
+    respond_to do |format|
+      format.html { render }
+      format.js {
+        debugger
+
+        if !hash[:errors].blank?
+          render :file =>  "#{plugin_dir}/app/views/admin_data/search/search/_errors.html.erb", :locals => {:errors => errors}
+          return
+        end
+        if params[:admin_data_advance_search_action_type] == 'destroy'
+          handle_advance_search_action_type_destroy
+        elsif params[:admin_data_advance_search_action_type] == 'delete'
+          handle_advance_search_action_type_delete
+        else
+          @records = @relation.order(@order).paginate(:page => params[:page], :per_page => per_page)
+        end
+
+        if @success_message
+          render :json => {:success => @success_message }
+        else
+          render   :file =>  "#{plugin_dir}/app/views/admin_data/search/search/_listing.html.erb", 
+                    :locals => {:klass => @klass, :records => @records}
+        end
+      }
+    end
+  end
+
+  private
+
+  def ensure_valid_children_klass
+    if params[:base]
+      begin
+        model_klass = AdminData::Util.camelize_constantize(params[:base])
+      rescue NameError => e #incase params[:base] is junk value
+        render :text => "#{params[:base]} is an invalid value", :status => :not_found
+        return
+      end
+      unless AdminData::Util.has_many_what(model_klass).include?(params[:children])
+        render :text => "<h2>#{params[:children]} is not a valid has_many association</h2>",
+        :status => :not_found
+        return
+      end
+    end
+  end
+
+  def ensure_is_authorized_for_update_opration
+    if %w(destroy delete).include? params[:admin_data_advance_search_action_type]
+      render :text => 'not authorized', :status => :unauthorized unless admin_data_is_allowed_to_update?
+    end
+  end
+
+  def handle_advance_search_action_type_delete
+    count = @relation.count
+    @relation.delete_all
+    @success_message = "#{count} #{AdminData::Util.pluralize(count, 'record')} deleted"
+  end
+
+  def handle_advance_search_action_type_destroy
+    count = @relation.count
+    @relation.find_in_batches do |group|
+      group.each {|record| record.destroy }
+    end
+    @success_message = "#{count} #{AdminData::Util.pluralize(count, 'record')} destroyed"
+  end
+
+  def default_order
+    params[:sortby] || "#{@klass.send(:table_name)}.#{@klass.send(:primary_key)} desc"
+  end
+
+  def set_collection_of_columns
+    collection_of_colums = @klass.columns.collect { |column|
+      #JSLint complains if a hash has key named boolean. So I am changing the key to booleant
+      column_type =  (column.type.to_s == 'boolean') ? 'booleant' : column.type.to_s
+      "#{column.name}:'#{column_type}'"
+    }
+    collection_of_colums = collection_of_colums.join(',')
+    @collection_of_colums = "[{#{collection_of_colums}}]"
+  end
+
+end

data/app/controllers/admin_data/validate_model_controller.rb

@@ -0,0 +1,106 @@
+require 'fileutils'
+
+class AdminData::ValidateModelController < AdminData::BaseController
+
+  unloadable
+
+  before_filter :ensure_is_allowed_to_view
+
+  def tid
+    @data = gather_data(params[:tid])
+    respond_to {|format| format.html}
+  end
+
+  def validate
+    @page_title = 'validate model'
+    @tid = Time.now.strftime('%Y%m%d%H%M%S')
+
+    dir = Rails.root.join('tmp', 'admin_data', 'validate_model')
+    FileUtils.mkdir_p(dir)
+    tids = Dir.chdir(dir) { Dir["*"] }
+    @tids = tids.sort!
+
+    respond_to {|format| format.html}
+  end
+
+  def validate_model
+    respond_to do |format|
+      format.js do
+        if params[:tid].blank?
+          render :json => {:error => 'Something went wrong. Please try again !!' }
+          return
+
+        elsif params[:model].blank? && params[:still_processing].blank?
+          render :json => {:error => 'Please select at least one model' }
+          return
+
+        elsif !params[:still_processing].blank?
+          tid = params[:tid]
+          data = gather_data(tid)
+          done_file = File.join(Rails.root, 'tmp', 'admin_data', 'validate_model', tid, 'done.txt')
+          answer = File.exists?(done_file) ? 'no' : 'yes'
+          h = {
+            :still_processing => answer,
+            :data => data,
+            :currently_processing_klass =>  AdminData::Util.read_validation_file(tid, 'processing.txt')
+          }
+          render :json => h
+          return
+        else
+          tid = params[:tid]
+          klasses = params[:model].keys.join(',')
+          start_validation_rake_task(tid, klasses)
+          base_url = request.protocol + request.host_with_port
+          render :json => {:still_processing => 'yes', :base_url => base_url }
+          return
+        end
+      end
+    end
+  end
+
+  private
+
+  def start_validation_rake_task(tid, klasses)
+    f = File.join(Rails.root, 'tmp', 'admin_data', 'validate_model', tid)
+    FileUtils.rm_rf(f) if File.directory?(f)
+    FileUtils.mkdir_p(f)
+
+    AdminData::Util.write_to_validation_file('', 'a', tid, 'processing.txt')
+    AdminData::Util.write_to_validation_file('', 'a', tid, 'bad.txt')
+    AdminData::Util.write_to_validation_file('', 'a', tid, 'good.txt')
+    AdminData::Util.write_to_validation_file('', 'a', tid, 'error.txt')
+
+    call_rake('admin_data:validate_models_bg', {:tid => tid, :klasses => klasses} )
+  end
+
+  def call_rake(task, options = {})
+    options[:rails_env] ||= Rails.env
+    args = options.map { |n, v| "#{n.to_s.upcase}='#{v}'" }
+    rake_command = AdminDataConfig.setting[:rake_command]
+    command =  "#{rake_command} #{task} #{args.join(' ')}"
+    Rails.logger.info "command: #{command}"
+    p1 = Process.fork { system(command) }
+    AdminData::Util.write_to_validation_file(p1, 'a', options[:tid], 'pid.txt')
+    Process.detach(p1)
+  end
+
+  def gather_data(tid)
+    good_file = File.join(Rails.root, 'tmp', 'admin_data', 'validate_model', tid, 'good.txt')
+    bad_file = File.join(Rails.root, 'tmp', 'admin_data', 'validate_model', tid, 'bad.txt')
+    regex = /(\w+)\s+\|\s+(\d+)\s+\|\s+(.*)/
+
+    data = []
+    File.open(bad_file, "r") do |f|
+      f.each_line do |line|
+        next if line.strip.blank?
+        data << '<p>'
+        m = regex.match(line)
+        data << render_to_string(:partial => 'bad', :locals => {:klassu => m[1], :id => m[2], :error => m[3]})
+        data << '</p>'
+      end
+    end
+    File.open(good_file, "r") { |f| f.each_line { |line| data << "<p>#{line}</p>" } }
+    data.join
+  end
+
+end

data/app/views/admin_data/diagnostic/index.html.erb

@@ -0,0 +1,17 @@
+<div id="main">
+  <div class="block" id="block-tables">
+
+    <div class="content rounded">          
+      <h2 class="title">Diagnostic test</h2>
+      <div class="inner">
+        <h2>
+          <%= link_to 'Find missing database index', admin_data_diagnostic_missing_index_url %>
+        </h2>
+        <h2>
+          <%= link_to 'Validate Models', admin_data_validate_url %>
+        </h2> 
+      </div>
+    </div>
+
+  </div>
+</div>

data/app/views/admin_data/diagnostic/missing_index.html.erb

@@ -0,0 +1,26 @@
+<div id="main">
+  <div class="block" id="block-tables">
+    <div class="content rounded">          
+      <h2 class="title">Missing Index Report</h2>
+      <div class="inner">
+        <p>It is recommended that all foreign keys be indexed.</p>  
+        <p>
+          Given below is the migration code that should be performed to create index.  
+        </p>
+        
+        <table id='missing_index'>
+          <% @indexes.each do |table, columns|
+            columns.map do |column| %>
+              <tr>
+                <td>
+                  add_index '<%=table%>', '<%=column%>'
+                </td>
+              </tr>
+            <% end %>
+          <% end %>
+        </table>  
+
+      </div>
+    </div>
+  </div>
+</div>

data/app/views/admin_data/feed/index.rss.builder

@@ -0,0 +1,24 @@
+xml.instruct! :xml, :version => "1.0"
+xml.rss(:version => "2.0" ){
+  xml.channel{
+    xml.title("Feeds from admin_data #{@klass.name}")
+    xml.link(request.host_with_port)
+    xml.description("feeds from AdminData #{@klass.name}")
+    xml.language('en-us')
+    h = {:order => "#{@klass.primary_key} desc", :limit => 100}
+    @klass.find(:all, h).each do |record|
+      xml.item do
+        xml.title("#{@klasss} id: #{record.id}")
+
+        desc = AdminData::Util.label_values_pair_for(record, self).inject([]) do |sum, a|
+          sum << "<p>#{a[0]}: #{a[1]}</p>"
+        end.join
+
+        xml.description(desc)
+        xml.pubDate(record.created_at.strftime("%a, %d %b %Y %H:%M:%S %z"))
+        xml.link(admin_data_on_k_path(:id => record, :klass => @klass.name))
+        xml.guid(admin_data_on_k_path(:id => record, :klass => @klass.name))
+      end
+    end
+  }
+}