volt-table 0.1.0

data/app/table/config/dependencies.rb

@@ -0,0 +1 @@
+# Component dependencies

data/app/table/config/initializers/boot.rb

@@ -0,0 +1,10 @@
+# Place any code you want to run when the component is included on the client
+# or server.
+
+# To include code only on the client use:
+# if RUBY_PLATFORM == 'opal'
+#
+# To include code only on the server, use:
+# unless RUBY_PLATFORM == 'opal'
+# ^^ this will not send compile in code in the conditional to the client.
+# ^^ this include code required in the conditional.

data/app/table/config/routes.rb

@@ -0,0 +1 @@
+# Component routes

data/app/table/controllers/columns_controller.rb

@@ -0,0 +1,101 @@
+module Table
+  class ColumnsController < Volt::ModelController
+    reactive_accessor :options
+    reactive_accessor :values
+
+    ##############
+    # Actions
+    ##############
+
+    def index
+      page._column_filt = []
+    end
+
+    ##############
+    # Callbacks
+    ##############
+
+    ##############
+    # Data Sources
+    ##############
+
+    ##############
+    # Events
+    ##############
+    def sort(field)
+      if field
+        toggle_sort_direction(field)
+        params._sort_field = field
+      end
+    end
+
+    def toggle_sort_direction(field)
+      if params._sort_field == field
+        if params._sort_direction.to_i == 1
+          params._sort_direction = -1
+        else
+          params._sort_direction = 1
+        end
+      end
+    end
+
+    def apply_filters(item, event)
+      page._column_filt = page._column_filt.reject { |h| item.to_s.include? h._col }
+      unless options == nil || values == nil || options == '' || values == ''
+        page._column_filt << {col: "#{item}", option: "#{options}", value: "#{values}" }
+      end
+      `$(#{event.target}).closest('.dropdown').removeClass('open')`
+      nil
+    end
+
+    def reset(item, event)
+      options = ""
+      values = ""
+      if page._column_filt.any? { |x| x._col == item.to_s }
+        page._column_filt = page._column_filt.reject { |h| item.to_s.include? h._col }
+      end
+      `$(#{event.target}).closest('.dropdown').removeClass('open')`
+      nil
+    end
+
+    ##############
+    # Display
+    ##############
+    def header_sort_klass(label)
+      if params._sort_field == label
+        params._sort_direction.to_i == 1 ? 'headerSortDown' : 'headerSortUp'
+      end
+    end
+
+    def sort_direction(reverse)
+      if reverse
+        params._sort_direction.to_i == 1 ? 'down' : 'up'
+      else
+        params._sort_direction.to_i == 1 ? 'up' : 'down'
+      end
+    end
+
+    def filter_label(filter)
+      if page._column_filt.any? { |x| x._col == filter.to_s }
+        index = page._column_filt.index {|x| x._col == filter.to_s }
+        if page._column_filt[index]._option.to_s == '$ne'
+          "!= #{page._column_filt[index]._value}"
+        elsif page._column_filt[index]._option == '$gt'
+          "> #{page._column_filt[index]._value}"
+        elsif page._column_filt[index]._option == '$lt'
+          "< #{page._column_filt[index]._value}"
+        elsif page._column_filt[index]._option == '$lte'
+          "<= #{page._column_filt[index]._value}"
+        elsif page._column_filt[index]._option == '$gte'
+          ">= #{page._column_filt[index]._value}"
+        elsif page._column_filt[index]._option == '$eq'
+          "= #{page._column_filt[index]._value}"
+        else
+          ""
+        end
+      else
+        ""
+      end
+    end
+  end
+end

data/app/table/controllers/footers_controller.rb

@@ -0,0 +1,19 @@
+module Table
+  class FootersController < Volt::ModelController
+
+    def start_offset
+      (((params._page || 1).to_i - 1) * params._per_page.to_i)
+    end
+
+    def last_item
+      range = start_offset + params._per_page.to_i
+      attrs.table_size.then do |size|
+        if range >= size
+          size
+        else
+          range
+        end
+      end
+    end
+  end
+end

data/app/table/controllers/headers_controller.rb

@@ -0,0 +1,98 @@
+module Table
+  class HeadersController < Volt::ModelController
+    reactive_accessor :search_term
+    reactive_accessor :options
+    reactive_accessor :values
+    before_action :set_default_options
+
+    ##################
+    # Actions
+    ##################
+    def index
+      self.search_term = params._query
+    end
+
+    def modal
+      self.options = []
+      self.values = []
+    end
+
+    ######################
+    # callbacks
+    ######################
+    def set_default_options
+      params._per_page ||= 10
+    end
+
+    ######################
+    # Data Sources
+    ######################
+
+    def size
+      params._per_page.to_i
+    end
+
+    def set_table_size(size)
+      params._per_page = size
+    end
+
+    ####################
+    # Events
+    ####################
+    def toggle_popover
+      if `$('#popover').css('display') == 'none'`
+        `$('#popover').css('display', 'block')`
+      else
+        `$('#popover').css('display', 'none')`
+      end
+    end
+
+    def apply_filters
+      page._column_filt = []
+      options.each_with_index do |opt, i|
+        unless options[i] == nil || values[i] == nil
+          page._column_filt << {col: "#{search_fields[i]['field']}", option: "#{options[i]}", value: "#{values[i]}" }
+        end
+      end
+      `$('#sortModal').modal('hide');`
+    end
+
+    def search_fields
+      search_fields = []
+      page._table._columns.each do |col|
+        unless col._search_field == nil
+          search_fields << {title: col._title, field: col._field_name, search: col._search_field}
+        end
+      end
+      search_fields
+    end
+
+    def search
+      unless @last_hit.nil? || search_term.length == 1
+        if (Time.now - @last_hit) >= 0.5
+          params._query = search_term
+        else
+          timeout unless @timeout
+        end
+      end
+      @last_hit = Time.now
+    end
+
+    def timeout
+      unless @timeout
+        @timeout = true
+        `setTimeout(function(){#{timeout_search}}, 500)`
+      end
+    end
+
+    def timeout_search
+      @timeout = false
+      search
+    end
+
+    def clear_filters
+      page._column_filt = []
+    end
+
+  end
+end

data/app/table/controllers/main_controller.rb

@@ -0,0 +1,135 @@
+module Table
+  class MainController < Volt::ModelController
+
+    def body
+      params._per_page ||= 10
+      params._sort_direction ||= 1
+      page._column_filt ||= []
+    end
+
+    def trigger_row_click(item_id)
+      # event = page._table._default_e_click
+      # event ||=
+      # trigger('row_click', item_id)
+    end
+
+    def td_click(item_id, col_index)
+      event = page._table._columns[col_index]._click_event
+      event ||= page._table._default_click_event
+      trigger(event, item_id, col_index)
+    end
+
+    def start_offset
+      (((params._page || 1).to_i - 1) * params._per_page.to_i)
+    end
+
+    def searched_data
+      if params._query && !params._query.empty?
+        query = build_query
+      else
+        query = column_filters
+      end
+      attrs.source.where(query)
+    end
+
+    def build_query
+      if params._query
+        ands = []
+        # split at commas to get my array of queries (commas are AND)
+        and_pieces = params._query.split(',').map(&:strip)
+        and_pieces.each_with_index do |piece, i|
+          if piece =~ /\|/
+            or_query = []
+            or_pieces = piece.split('|').map(&:strip)
+            or_pieces.each_with_index do |p, i|
+              if /:/.match(p)
+                or_query.push(field_match(p)).flatten!
+              else
+                or_query.push(any_match(p)).flatten!
+              end
+            end
+            ands << {'$or' => or_query}
+          elsif /:/.match(piece) # if part of the query is a specific field search
+            ands << field_match(piece)
+          else
+            ands << {'$or' => any_match(piece)}
+          end
+        end
+        ands << column_filters if column_filters
+        {'$and' => ands}
+      end
+    end
+
+    def field_match(query)
+      clean_string = query.split(':').map(&:strip)
+      if search_fields.has_key?(clean_string[0])
+        {search_fields[clean_string[0]] => {"$regex"=>clean_string[1], "$options"=>"i"}}
+      else
+        {}
+      end
+    end
+
+    def any_match(query)
+      match = []
+      search_fields.values.each do |field|
+        match << {field => { '$regex' => "#{query}", '$options' => 'i' }}
+      end
+      match
+    end
+
+    def column_filters
+      ands = []
+      page._column_filt.each do |filter|
+        ands << {filter._col => {"#{filter._option}" => "#{filter._value}"}}
+      end
+      ands unless ands.empty?
+    end
+
+    def search_fields
+      fields = {}
+      page._table._columns.each do |col|
+        unless col._search_field == nil
+          fields[col._search_field] = col._field_name
+        end
+      end
+      fields
+    end
+
+    def ordered_data
+      if params._sort_direction
+        searched_data.order(params._sort_field => params._sort_direction.to_i)
+      else
+        searched_data
+      end
+    end
+
+    def current_page
+      per_page = params._per_page.to_i
+      per_page = 10 unless per_page > 0
+      ordered_data.skip(start_offset).limit(per_page)
+    end
+
+    def total_size
+      # TODO: volt-mongo loads the entire collection into memory for counts as of 9-7-15
+      #attrs.total_size || 500 #attrs.source.count
+      query = {}
+      attrs.source.path.then do |path|
+        CountTask.count(path[0], query)
+      end
+    end
+
+    def table_size
+      # TODO: volt-mongo loads the entire collection into memory for counts as of 9-7-15
+      # searched_data.count
+      if params._query && !params._query.empty?
+        query = build_query
+      else
+        query = column_filters
+      end
+      attrs.source.path.then do |path|
+        CountTask.count(path[0], query)
+      end
+    end
+
+  end
+end

data/app/table/tasks/count_task.rb

@@ -0,0 +1,15 @@
+class CountTask < Volt::Task
+  def count(data, filter)
+    puts "Volt::DataStore.fetch.db[#{data.to_s}].find(#{filter})"
+    res = Volt::DataStore.fetch.db[data.to_s].find(filter).count
+    puts res
+    res
+  end
+
+  def total_count(data, filter)
+    puts "Volt::DataStore.fetch.db[#{data.to_s}].find(#{filter})"
+    res = Volt::DataStore.fetch.db[data.to_s].find(filter).count
+    puts res
+    res
+  end
+end

data/app/table/views/columns/column_head.html

@@ -0,0 +1,4 @@
+<:Body>
+	<th e-click="sort(attrs.sort_name)" class="header {{ header_sort_klass(attrs.sort_name) }}">
+		{{ attrs.label }}
+	</th>

data/app/table/views/columns/filter_head.html

@@ -0,0 +1,36 @@
+<:Body>
+	<th>
+		<div class="filter-label dropdown">
+				{{ if page._column_filt.any? { |x| x._col == attrs.field_name.to_s } }}
+					<span data-toggle="dropdown">{{ filter_label(attrs.field_name) }}</span>
+				{{ else }}
+					<span class="fa fa-filter muted" data-toggle="dropdown"></span>
+				{{ end }}
+				<ul class="dropdown-menu">
+					<form e-submit="apply_filters(attrs.field_name, event)">
+						<li style="padding: 5px;">Filter {{ attrs.label }}</li>
+						<li style="padding: 5px;">
+							<select value="{{options}}" class="form-control">
+								<option value=""></option>
+								<option value="$eq">=</option>
+								<option value="$ne">!=</option>
+								<option value="$gt">&gt;</option>
+								<option value="$gte">&gt;=</option>
+								<option value="$lt">&lt;</option>
+								<option value="$lte">&lt;=</option>
+							</select>
+						</li>
+						<li style="padding: 5px;">
+							<input type="text" class="form-control" value="{{ values }}" label=false />
+						</li>
+						<li role="separator" class="divider"></li>
+						<li style="padding: 5px;">
+							<button type="reset" e-click="reset(attrs.field_name, event)" class="btn btn-default btn-block">Reset</button>
+						</li>
+						<li style="padding: 5px;">
+							<button type="submit" class="btn btn-default btn-block">Apply</button>
+						</li>
+					</form>
+				</ul>
+		</div>
+	</th>

data/app/table/views/columns/index.html

@@ -0,0 +1,17 @@
+<:Body>
+	<thead>
+		<tr>
+			{{ page._table._columns.each do |label| }}
+			 	{{ if label._shown }}
+					<:column_head label="{{ label._title }}" field_name="{{ label._field_name }}" sort_name="{{ label._sort_name }}" sort_reverse="{{ label._sort_reverse }}"/>
+				{{ end }}
+			{{ end }}
+		</tr>
+		<tr>
+			{{ page._table._columns.each do |label| }}
+			 	{{ if label._shown }}
+					<:filter_head label="{{ label._title }}" field_name="{{ label._field_name }}" sort_name="{{ label._sort_name }}" sort_reverse="{{ label._sort_reverse }}"/>
+				{{ end }}
+			{{ end }}
+		</tr>
+	</thead>