carnival 0.0.59 → 0.1.0

data/app/presenters/carnival/presenter_validators/field_validator.rb

@@ -0,0 +1,39 @@
+module Carnival::PresenterValidators
+  class FieldValidator
+    EDIT_ACTIONS = [:new, :edit]
+    SHOW_ACTIONS = [:index, :show]
+
+    def initialize(presenter)
+      @presenter = presenter
+    end
+
+
+    def validates
+      fields.each do |field|
+        validates_one_to_one_associations(field)
+      end
+    end
+
+    def validates_one_to_one_associations(field)
+      if field.specified_association?
+        check_field_invalid_actions(field, EDIT_ACTIONS)
+      elsif @presenter.is_one_to_one_relation?(field)
+        check_field_invalid_actions(field, SHOW_ACTIONS)
+      end
+    end
+
+    private
+    def check_field_invalid_actions(field, actions)
+      return if field.actions.nil?
+      intersection = actions & field.actions
+      if intersection.size > 0
+        error = I18n.t("carnival.errors.invalid_field", actions: intersection, field: field.name, presenter: @presenter.presenter_name)
+        raise ArgumentError.new(error)
+      end
+    end
+
+    def fields
+      @presenter.fields.values
+    end
+  end
+end

data/app/services/carnival/klass_service.rb

@@ -0,0 +1,83 @@
+module Carnival
+  class KlassService
+
+    def initialize(klass)
+      @klass = klass
+    end
+
+    def relation? sym
+      !get_association(sym).nil?
+    end
+
+    def relation_type sym
+      return nil if !relation?(sym)
+      association = get_association(sym)
+      return association.macro if association.macro != :has_many
+      return :many_to_many if many_to_many_relation? association
+      return :has_many
+    end
+
+    def method_missing(method, *args)
+      if method.to_s.index(/^is_a_(.*)_relation\?$/)
+        result =  method.to_s.match(/^is_a_(.*)_relation\?$/)
+        relation = result[1]
+        return relation_type(args[0]) == relation.to_sym
+      end
+    end
+
+    def related_class_file_name sym
+      return nil if !relation?(sym)
+      get_related_class(sym).name.pluralize.underscore
+    end
+
+    def related_class sym
+      return nil if !relation?(sym)
+      get_related_class(sym).classify
+    end
+
+    def extract_namespace
+      namespace = ""
+      arr = @klass.to_s.split("::")
+      namespace = arr[0] if arr.size > 1
+      namespace
+    end
+
+    def is_namespaced?
+      @klass.to_s.split("::").size > 1
+    end
+
+    def table_name
+      @klass.table_name
+    end
+
+    def klass
+      @klass
+    end
+
+
+    def get_association association
+      @klass.reflect_on_association(association.to_sym)
+    end
+
+    def get_related_class sym
+      association = get_association(sym)
+      return nil if association.nil?
+      association.klass
+    end
+
+    def get_foreign_key sym
+      association = get_association(sym)
+      return nil if association.nil?
+      association.foreign_key
+    end
+    private
+
+    def many_to_many_relation? association
+      return true if association.macro == :has_and_belongs_to_many
+      return false if association.macro == :has_many
+      return true if association.options[:through].present?
+      return false
+    end
+
+  end
+end

data/app/services/carnival/presenters/advanced_search_parser.rb

@@ -0,0 +1,95 @@
+module Carnival
+  module Presenters
+    class AdvancedSearchParser
+
+      def initialize(klass_service)
+        @klass_service = klass_service
+      end
+       def get_advanced_search_fields fields
+          advanced_search_fields = {}
+          fields.each do |key, field|
+            advanced_search_fields[key] = field if field.advanced_searchable?
+          end
+          advanced_search_fields
+       end
+
+       def parse_advanced_search fields, records, search_syntax
+          search = search_syntax
+          search.each do |key, value|
+            search_field = key
+            #search_field = key.split(".").last if key.include?(".")
+            search_field = search_field.gsub("_id", "") if search_field.ends_with?("_id")
+            next if !fields.keys.include? search_field.to_sym
+            field = fields[search_field.to_sym]
+            if field.advanced_searchable? && value.present? && value.size > 0
+              field_param = {"operator" => field.advanced_search_operator.to_s, "value" => "#{value}"}
+              records =  parse_advanced_search_field(search_field, field_param, records)
+            end
+          end
+          records
+       end
+
+      private
+        def parse_advanced_search_field search_field, field_param, records
+          return records if not field_param["value"].present?
+          return records if field_param["value"] == ""
+
+          if search_field.is_a?(String) && search_field.include?('.')
+            search_field_params = search_field.split('.')
+            search_field = search_field_params[0]
+            column = search_field_params[1]
+          end
+
+          if @klass_service.relation? search_field.to_sym
+            related_model = @klass_service.get_related_class(search_field.to_sym).name.underscore
+            foreign_key = @klass_service.get_foreign_key(search_field.to_sym)
+            if @klass_service.is_a_belongs_to_relation?(search_field.to_sym)
+              records = records.joins(related_model.split("/").last.to_sym)
+            else
+              records = records.joins(related_model.split("/").last.pluralize.to_sym)
+            end
+            table = related_model.split("/").last.classify.constantize.table_name
+            column = "id" if column.nil? || field_param["operator"] == "equal"
+          else
+            table = @klass_service.table_name
+            column = search_field
+          end
+          full_column_query = "#{table}.#{column}"
+          where_clause = nil
+
+          case field_param["operator"]
+            when "equal"
+              if field_param["value"] == "nil"
+                where_clause = "#{full_column_query} is null"
+              else
+                where_clause = "lower(#{full_column_query}) = '#{advanced_search_field_value_for_query(field_param["value"])}'"
+              end
+            when "like"
+              where_clause = "lower(#{full_column_query}) like '%#{field_param["value"].downcase}%'"
+            when "greater_than"
+              where_clause = "#{full_column_query} >= '#{field_param["value"]}'"
+            when "less_than"
+              where_clause = "#{full_column_query} <= '#{field_param["value"]}'"
+            when "between"
+              where_clause = "#{full_column_query} between '#{field_param["value"]}' and '#{field_param["value2"]}'"
+            else
+              where_clause = "#{full_column_query} = #{advanced_search_field_value_for_query(field_param["value"])}"
+          end
+          records = records.where(where_clause) if where_clause.present?
+          records
+        end
+
+        def advanced_search_field_value_for_query(value)
+          if "true" == value.downcase
+            return "'t'"
+          elsif "false" == value.downcase
+            return "'f'"
+          else
+            "#{value.downcase}"
+          end
+        end
+
+
+    end
+  end
+end

data/app/services/carnival/query_form_creator.rb

@@ -0,0 +1,32 @@
+module Carnival
+  class QueryFormCreator
+
+    def self.create presenter, params
+      query_form = Carnival::QueryForm.new(params)
+
+      if query_form.sort_column.nil?
+        query_form.sort_column = presenter.default_sortable_field.name.to_sym
+      end
+
+      if query_form.sort_direction.nil?
+        query_form.sort_direction = presenter.default_sort_direction
+      end
+
+      if query_form.scope.nil?
+        scope = presenter.default_scope
+        query_form.scope = scope.name if scope.present?
+      end
+
+      date_filter_field = presenter.date_filter_field
+      if date_filter_field.present?
+        query_form.date_period_label = date_filter_field.default_date_filter if query_form.date_period_label.nil?
+        query_form.date_period_from = date_filter_field.date_filter_periods[query_form.date_period_label].first if query_form.date_period_from.nil?
+        query_form.date_period_to = date_filter_field.date_filter_periods[query_form.date_period_label].first if query_form.date_period_to.nil?
+      end
+
+      query_form
+    end
+
+
+  end
+end

data/app/services/carnival/query_service.rb

@@ -0,0 +1,106 @@
+module Carnival
+  class QueryService
+    
+    attr_accessor :total_records
+    def initialize(model, presenter, query_form)
+      @model = model
+      @presenter = presenter
+      @query_form = query_form
+      @total_records = 0
+      @should_include_relation = !@model.is_a?(ActiveRecord::Relation)
+    end
+
+    def get_query
+      records = records_without_pagination
+      records = page_query(records)
+    end
+
+    def records_without_pagination_and_scope
+      records = @model
+      records = date_period_query(records)
+      records = search_query(records)
+      records = advanced_search_query(records)
+      records = order_query(records)
+      records = includes_relations(records)
+    end
+
+    def records_without_pagination
+      records = records_without_pagination_and_scope
+      records = scope_query(records)
+    end
+
+    def total_records
+      records_without_pagination.size 
+    end
+
+    def scopes_number
+      records = records_without_pagination_and_scope 
+      scopes = {}
+      @presenter.scopes.each do |key, index|
+        rec = records
+        scopes[key] = scope_query(rec, key).size
+      end
+      scopes
+    end
+
+    def scope_query(records, scope = @query_form.scope)
+      if(scope.present? && scope.to_sym != :all)
+        records = records.send(scope)
+      end
+      records
+    end
+
+    def date_period_query(records)
+      date_filter_field = @presenter.date_filter_field
+      if(date_filter_field.present? && @query_form.date_period_from.present? && @query_form.date_period_from != "" && @query_form.date_period_to.present? && @query_form.date_period_to != "")
+        records = records.where("#{@presenter.table_name}.#{date_filter_field.name} between ? and ?", "#{@query_form.date_period_from} 00:00:00", "#{@query_form.date_period_to} 23:59:59")
+      end
+      records
+    end
+
+    def search_query(records)
+      filtros = []
+      if @query_form.search_term.present? and @presenter.searchable_fields.size > 0
+        @presenter.searchable_fields.each do |key, field|
+          filtros << "#{key.to_s} like :search"
+        end
+        records = includes_relations(records) if @should_include_relation
+        records = records.where(filtros.join(" or "), search: "%#{@query_form.search_term}%")
+      end
+      records
+    end
+
+    def advanced_search_query(records)
+      return records if !@query_form.advanced_search.present?
+      @presenter.parse_advanced_search(records, @query_form.advanced_search)
+    end
+
+    def page_query(records)
+        records = records.paginate(page: @query_form.page, per_page: @presenter.items_per_page)
+    end
+
+    def order_query(records)
+      records.order("#{sort_column} #{sort_direction}")
+    end
+
+    def includes_relations(records)
+      if @should_include_relation
+        @presenter.join_tables.each do |relation_name|
+          records = records.includes(relation_name)
+        end
+      end
+      records
+    end
+
+    def sort_column
+      column = @query_form.sort_column
+      sorter = Carnival::GenericDatatable::ColumnSorterCreator.create_sorter(@presenter, column)
+      sorter.build_sort_string
+    end
+
+    def sort_direction
+      @query_form.sort_direction
+    end
+
+  end
+end

data/app/services/carnival/renderer/html.rb

@@ -0,0 +1,15 @@
+module Carnival
+  module Renderer
+    class Html
+      attr_accessor :presenter, :query_form, :query_service
+      def initialize presenter, params
+        @presenter = presenter
+        @query_form = Carnival::QueryFormCreator.create(@presenter, params)
+        @query_service = Carnival::QueryService.new(@model, @presenter, @query_form)
+      end
+
+
+
+    end
+  end
+end

data/app/view_objects/carnival/nested_form_options.rb

@@ -18,6 +18,14 @@ module Carnival
       @field
     end
 
+    def presenter
+      @presenter 
+    end
+
+    def model
+      @model 
+    end
+
     def field_name
       @field.name
     end
@@ -38,6 +46,14 @@ module Carnival
       @model.class.name.underscore.gsub('/', '_')
     end
 
+    def field_class_file_name
+      @presenter.get_related_class @field.name.to_sym
+    end
+
+    def controller_to_field
+      @presenter.controller_to_field @field 
+    end
+
     def field_name_identifier
       self.field_name.singularize.to_sym
     end
@@ -73,6 +89,7 @@ module Carnival
         props = {}
         id = self.option_id(item)
         props[:id] = "#{id}_select_option"
+        props[:data] = {:id => item.id}
         props[:disabled] = self.model_has_this_item?(item.id)
         options << [item.to_label, id, props]
       end
@@ -85,8 +102,8 @@ module Carnival
 
     def scope_column_name
       scope = @field.nested_form_scope
-      return nil if !@model.reflections[scope]
-      fkey = @model.reflections[scope].foreign_key
+      return nil if scope.blank? or !@model.class.reflections[scope]
+      fkey = @model.class.reflections[scope].foreign_key
     end
 
     def scopeJSFunction

data/app/view_objects/carnival/paginator.rb

@@ -0,0 +1,59 @@
+module Carnival
+  class Paginator
+
+    def initialize(actual_page, last_page, max_fast_pages = 5)
+      @actual_page = actual_page 
+      @last_page = last_page >= 1 ? last_page : 1
+      @max_fast_pages = max_fast_pages
+    end
+
+    def fast_pages_links_indexes
+      fast_page_links = []
+      first_index = -(@max_fast_pages/2)
+      while fast_page_links.size < @max_fast_pages do
+        fast_page = @actual_page + first_index
+        break if fast_page > @last_page
+        fast_page_links << fast_page if fast_page > 0
+        first_index = first_index + 1
+      end
+      fast_page_links
+    end
+    
+    def fast_pages_links_html
+      htmls = []
+      fast_pages_links_indexes.each do |page| 
+        htmls << {:label => page, :css_class => get_css_class(page), :js_function => get_js_function(page)}
+      end
+      htmls
+    end
+
+    def get_js_function page
+      "javascript:Carnival.goToPage(#{page})" 
+    end
+
+    def get_css_class page
+      return 'carnival-selected-page-button' if page == @actual_page
+      return 'carnival-page-button'
+    end
+
+    def previous_page
+      return @actual_page if @actual_page - 1 < 1 
+      @actual_page - 1
+    end
+
+    def next_page
+      return @actual_page if @actual_page + 1 > @last_page 
+      @actual_page + 1
+    end
+
+    def pages
+      htmls = [] 
+      htmls << {:label => ('paginate_first'), :js_function => get_js_function(1)}
+      htmls << {:label => ('paginate_previous'), :js_function => get_js_function(previous_page)}
+      htmls = htmls + fast_pages_links_html
+      htmls << {:label => ('paginate_next'), :js_function => get_js_function(next_page)}
+      htmls << {:label => ('paginate_last'), :js_function => get_js_function(@last_page)}
+    end
+
+  end
+end