admin_data 1.0.0

data/lib/admin_data/chelper.rb

@@ -0,0 +1,37 @@
+module AdminData::Chelper
+
+  def per_page
+    AdminData::Config.setting[:will_paginate_per_page]
+  end
+
+  def admin_data_is_allowed_to_view?
+    return true if Rails.env.development?
+    AdminData::Config.setting[:is_allowed_to_view].call(self)
+  end
+
+  def admin_data_is_allowed_to_view_model?
+    return true if Rails.env.development?
+    AdminData::Config.setting[:is_allowed_to_view_model].call(self)
+  end
+
+  def admin_data_is_allowed_to_update?
+    return true if Rails.env.development?
+    AdminData::Config.setting[:is_allowed_to_update].call(self)
+  end
+
+  def admin_data_is_allowed_to_update_model?
+    return true if Rails.env.development?
+    AdminData::Config.setting[:is_allowed_to_update_model].call(self)
+  end
+
+  def admin_data_invalid_record_link(klassu, id, error)
+    record = klassu.camelize.constantize.send(:find, id)
+    tmp = admin_data_on_k_path(:klass => klasss.underscore, :id => record)
+    a = []
+    a << link_to(klasss, tmp, :target => '_blank')
+    a << id
+    a << error
+    a.join(' | ')
+  end
+
+end

data/lib/admin_data/compatibility.rb

@@ -0,0 +1,7 @@
+class String
+  unless method_defined?(:html_safe)
+    def html_safe
+      self
+    end
+  end
+end

data/lib/admin_data/helpers.rb

@@ -0,0 +1,222 @@
+module AdminData::Helpers
+
+  def search_result_title(total_num_of_children, records)
+    output = []
+    if params[:base]
+      label = params[:base].camelize + ' ID ' + params[:model_id]
+      output << link_to(label, admin_data_on_k_path(:klass => params[:base], :id => params[:model_id]))
+      output << 'has'
+      output << pluralize(total_num_of_children, params[:klass])
+
+    elsif !params[:query].blank? || params[:adv_search]
+      output << 'Search result:'
+      output << pluralize(records.total_entries, 'record')
+      output << 'found'
+
+    else
+      output << 'All '
+      output << params[:klass].camelize
+      output << 'records'
+    end
+    output.join(' ').html_safe
+  end
+
+  def admin_data_column_native(klass, column)
+    klass.send(:columns).select {|r| r.instance_variable_get('@name') == column}.first
+  end
+
+  def admin_data_invalid_record_link(klassu, id, error)
+    record = klassu.camelize.constantize.send(:find, id)
+    tmp = admin_data_on_k_path(:klass => klassu, :id => record)
+    a = []
+    a << link_to(klassu.camelize, tmp, :target => '_blank')
+    a << id
+    a << error
+    a.join(' | ')
+  end
+
+  def admin_data_has_one(model, klass)
+    tmp = AdminData::Util.has_one_what(klass)
+    tmp.inject('') do |output, ho|
+      begin
+        label = ho
+        if model.send(ho)
+          has_one_klass_name = AdminData::Util.get_class_name_for_has_one_association(model, ho).name.underscore
+          output << link_to(label, admin_data_on_k_path(:klass => ho.underscore, :id => model.send(ho)))
+        else
+          output << label
+        end
+      rescue => e
+        Rails.logger.debug AdminData::Util.exception_info(e)
+      end
+      output
+    end
+  end
+
+  def admin_data_has_many_data(model, klass)
+    array = AdminData::Util.has_many_what(klass).inject([]) do |output, hm|
+      begin
+        label = hm + '(' + AdminData::Util.has_many_count(model,hm).to_s + ')'
+        if AdminData::Util.has_many_count(model,hm) > 0
+          has_many_klass_name = AdminData::Util.get_class_name_for_has_many_association(model,hm).name.underscore
+          output << link_to(label, admin_data_search_path(  :klass => has_many_klass_name,
+          :children => hm,
+          :base => klass.name.underscore,
+          :model_id => model.id))
+        else
+          output << label
+        end
+      rescue => e
+        Rails.logger.debug AdminData::Util.exception_info(e)
+      end
+      output
+    end
+    array.join(', ')
+  end
+
+  def admin_data_belongs_to_data(model, klass)
+    array = AdminData::Util.belongs_to_what(klass).inject([]) do |output, bt|
+      begin
+        t = AdminData::Util.get_class_name_for_belongs_to_class(model, bt)
+        klass_name = t[:polymorphic] ? 'Polymorphic' : t[:klass_name]
+        belongs_to_record = model.send(bt)
+
+        if belongs_to_record && t[:polymorphic]
+          output << link_to(belongs_to_record.class.name,
+          admin_data_on_k_path(:klass => belongs_to_record.class.name.underscore, :id => belongs_to_record))
+        elsif belongs_to_record
+          output << link_to(bt, admin_data_on_k_path(:klass => klass_name.underscore, :id => model.send(bt)))
+        else
+          output << bt
+        end
+      rescue => e
+        Rails.logger.info AdminData::Util.exception_info(e)
+      end
+      output
+    end
+    array.join(', ')
+  end
+
+  def admin_data_breadcrum(&block)
+    render(:partial => '/admin_data/shared/breadcrum', :locals => {:data => capture(&block)})
+  end
+
+  def admin_data_form_field(klass, model, col, f)
+    html = []
+    column_value = model.send(col.name)
+
+    if klass.serialized_attributes.has_key?(col.name)
+      return AdminData::Util.get_serialized_value(html,column_value)
+    end
+
+    if col.primary
+      html <<  model.new_record? ? '(auto)' : model.id
+
+    elsif get_reflection_for_column(klass, col) && AdminData::Config.setting[:drop_down_for_associations]
+      admin_data_form_field_for_association_records(klass, col, f, html)
+    else
+      admin_data_handle_column_type(col, html, model, column_value, f)
+    end
+  end
+
+
+  def admin_data_form_field_for_association_records(klass, col, f, html)
+    begin
+      reflection = get_reflection_for_column(klass, col)
+
+      # in some edge cases following code throws exception. investigating ..
+      options = reflection.options
+      if options.keys.include?(:polymorphic) && options.fetch(:polymorphic)
+        build_text_field(html, f, col)
+      else
+        ref_klass = reflection.klass
+        association_name = ref_klass.columns.map(&:name).include?('name') ? :name : ref_klass.primary_key
+        all_for_dropdown = ref_klass.all(:order => "#{association_name} asc")
+        html << f.collection_select(col.name, all_for_dropdown, :id, association_name, :include_blank => true)
+      end
+      html.join
+    rescue Exception => e
+      Rails.logger.info AdminData::Util.exception_info(e)
+      'could not retrieve' # returning nil
+    end
+  end
+
+  def admin_data_handle_column_type(col, html, model, column_value, f)
+    case col.type
+    when :text
+      html << f.text_area(col.name, :rows => 6, :cols => 70)
+
+    when :datetime
+      if ['created_at', 'updated_at'].include?(col.name)
+        html <<  model.new_record? ? '(auto)' : column_value
+      else
+        value = params[:action] == 'new' ? Time.now : column_value
+        year_value = value.year if value
+        datetime_selects = f.datetime_select(col.name, :include_blank => true)
+        html << datetime_selects.gsub('type="hidden"', 'type="text" size="4" class="nice-field"')
+      end
+
+    when :date
+      value = params[:action] == 'new' ? Time.now : column_value
+      year_value = value.year if value
+      date_selects = f.date_select(col.name, :discard_year => true, :include_blank => true)
+      html << date_selects.gsub('type="hidden"', 'type="text" size="4" class="nice-field"')
+
+    when :time
+      # time_select method of rails is buggy and is causing problem
+      # 1 error(s) on assignment of multiparameter attributes
+      #
+      # will try again this method with Rails 3
+      #html << f.time_select(col.name, :include_blank => true, :include_seconds => true)
+
+    when :boolean
+      html << f.select(col.name, [['True', true], ['False', false]], :include_blank => true)
+
+    else
+      build_text_field(html, f, col)
+    end
+    html.join
+  end
+
+
+  def build_text_field(html, f, col)
+    options = {:class => 'nice-field'}
+    if AdminData::Config.setting[:ignore_column_limit]
+      options[:size] = 60
+      options[:maxlength] = 255
+    else
+      options[:size] = (col && col.limit && col.limit < 60) ? col.limit : 60
+      options[:maxlength] = col.limit if col.limit
+    end
+    html << f.text_field(col.name, options)
+    html.join
+  end
+
+  # uses truncate method
+  # options supports :limit which is applied if the column type is string or text.
+  # calls the inspect method to convert to a string if the column is serialized.
+  def admin_data_get_value_for_column(column, model, options = {})
+    options.reverse_merge!(:limit => 400)
+
+    value = AdminData::Util.custom_value_for_column(column, model)
+
+    if column.type == :datetime
+      value.strftime('%d-%B-%Y %H:%M:%S %p') unless value.blank?
+    elsif column.type == :string || column.type == :text
+      value = value.inspect if model.class.serialized_attributes.keys.include?(column.name)
+      return value if options[:limit].blank?
+      begin
+        truncate(value,:length => options[:limit])
+      rescue # truncate method failed
+        '<actual data is not being shown because truncate method failed.>'
+      end
+    else
+      value
+    end
+  end
+
+  def get_reflection_for_column(klass, col)
+    klass.reflections.values.detect { |reflection| reflection.primary_key_name.to_sym == col.name.to_sym }
+  end
+
+end

data/lib/admin_data/railtie.rb

@@ -0,0 +1,21 @@
+require 'admin_data_date_validation'
+require 'admin_data/compatibility'
+require 'admin_data/settings'
+require 'admin_data/helpers'
+require 'admin_data/util'
+require 'admin_data/chelper'
+
+module AdminData
+  class Engine < Rails::Engine
+
+    initializer "admin_data.setup" do
+      AdminData::Config.initialize_defaults
+      ActionView::Base.send :include, AdminData::Helpers
+    end
+    
+    rake_tasks do
+      load 'tasks/admin_data_tasks.rake'
+      load 'tasks/validate_models_bg.rake'
+    end
+  end
+end

data/lib/admin_data/search.rb

@@ -0,0 +1,186 @@
+module Search
+
+  class Dbbase
+    def initialize(operands, table_name, field_name, operator)
+      @operands = operands
+      @table_name = table_name
+      @field_name = field_name
+      @operator = operator
+    end
+
+    def like_operator
+      'LIKE'
+    end
+
+    def sql_field_name
+      "#{@table_name}.#{@field_name}"
+    end
+
+    def operands
+      @operands
+    end
+  end
+
+  class PostgresqlSpecific < Dbbase
+    def like_operator
+      'ILIKE'
+    end
+  end
+
+  class OracleSpecific < Dbbase
+    def sql_field_name
+      result = super
+      %w(contains is_exactly does_not_contain).include?(@operator) ?  "upper(#{result})" : result
+    end
+
+    def operands
+      result = super
+      %w(contains is_exactly does_not_contain).include?(@operator) ?  result.upcase : result
+    end
+  end
+
+  class Term
+
+    attr_accessor :error, :table_name, :field, :operator, :operands, :dbbase
+
+    def initialize(klass, value, search_type)
+      @table_name = klass.table_name
+      compute_search_fields(value)
+
+      adapter = AdminData::Config.setting[:adapter_name].downcase
+      if adapter =~ /postgresql/
+        self.dbbase = PostgresqlSpecific.new(@operands, table_name, field, operator)
+      elsif adapter =~ /oracle/
+        self.dbbase = OracleSpecific.new(@operands, table_name, field, operator)
+      else
+        self.dbbase = Dbbase.new(@operands, table_name, field, operator)
+      end
+    end
+
+    def attribute_condition
+      return if valid? && operand_required? && operands.blank?
+      case operator
+      when 'contains'
+        ["#{sql_field_name} #{like_operator} ?","%#{operands}%"]
+
+      when 'is_exactly'
+        ["#{sql_field_name} = ?", operands]
+
+      when 'does_not_contain'
+        ["#{sql_field_name} IS NULL OR #{sql_field_name} NOT #{like_operator} ?","%#{operands}%"]
+
+      when 'is_false'
+        ["#{sql_field_name} = ?",false]
+
+      when 'is_true'
+        ["#{sql_field_name} = ?",true]
+
+      when 'is_null'
+        ["#{sql_field_name} IS NULL"]
+
+      when 'is_not_null'
+        ["#{sql_field_name} IS NOT NULL"]
+
+      when 'is_on'
+        ["#{sql_field_name} >= ? AND #{sql_field_name} < ?",   values_after_cast.beginning_of_day,
+        values_after_cast.end_of_day]
+
+      when 'is_on_or_before_date'
+        ["#{sql_field_name} <= ?",values_after_cast.end_of_day]
+
+      when 'is_on_or_after_date'
+        ["#{sql_field_name} >= ?",values_after_cast.beginning_of_day]
+
+      when 'is_equal_to'
+        ["#{sql_field_name} = ?",values_after_cast]
+
+      when 'greater_than'
+        ["#{sql_field_name} > ?",values_after_cast]
+
+      when 'less_than'
+        ["#{sql_field_name} < ?",values_after_cast]
+
+      else
+        # it means user did not select anything in operator. Ignore it.
+      end
+    end
+
+    def valid?
+      @error = nil
+      @error = validate
+      @error.blank?
+    end
+
+    private
+
+    def like_operator
+      dbbase.like_operator
+    end
+
+    def sql_field_name
+      dbbase.sql_field_name
+    end
+
+    def operands
+      dbbase.operands
+    end
+
+    def operand_required?
+      operator =~ /(contains|is_exactly|does_not_contain|is_on |is_on_or_before_date|is_on_or_after_date |greater_than|less_than|is_equal_to)/
+    end
+
+    def compute_search_fields(value)
+      @field, @operator, @operands = value.values_at(:col1, :col2, :col3)
+      # field value is directly used in the sql statement. So it is important to sanitize it
+      @field      = @field.gsub(/\W/,'')
+      @operands   = (@operands.blank? ? @operands : @operands.strip)
+    end
+
+    def values_after_cast
+      case operator
+      when /(is_on|is_on_or_before_date|is_on_or_after_date)/
+        AdminDataDateValidation.validate(operands)
+      when /(is_equal_to|greater_than|less_than)/
+        operands.to_i
+      else
+        operands
+      end
+    end
+
+    def validate
+      case operator
+      when /(is_on|is_on_or_before_date|is_on_or_after_date)/
+        "#{operands} is not a valid date" unless AdminDataDateValidation.validate(operands)
+      when /(is_equal_to|greater_than|less_than)/
+        unless operands.blank?
+          "#{operands} is not a valid integer" unless operands =~ /^\d+$/
+        end
+      end
+    end
+
+  end # end of Term
+
+
+  def build_quick_search_conditions( klass, search_term )
+    return nil if search_term.blank?
+    str_columns = klass.columns.select { |column| column.type.to_s =~ /(string|text)/i }
+    conditions = str_columns.collect do |column|
+      t = Term.new(klass, {:col1 => column.name, :col2 => 'contains', :col3 => search_term}, 'quick_search')
+      t.attribute_condition
+    end
+    AdminData::Util.or_merge_conditions(klass, *conditions)
+  end
+
+  def build_advance_search_conditions(klass, options)
+    values        = ( options.blank? ? [] : options.values )
+    terms         = values.collect {|value| Term.new(klass, value, 'advance_search') }
+    valid_terms   = terms.select{ |t| t.valid? }
+    errors        = (terms - valid_terms).collect { |t| t.error }
+    return {:errors => errors} if errors.any?
+
+    r = klass.unscoped
+    valid_terms.each { |t|  r = r.where(t.attribute_condition) }
+    { :cond => r }
+  end
+
+end