card 1.93.5 → 1.93.6

data/mod/pointer/lib/javascript/script_pointer_config.js.coffee

@@ -11,10 +11,13 @@ $.extend decko.editorContentFunctionMap,
       pointerContent @find('input:checked').map( -> $(this).val() )
     '.pointer-select-list': ->
       pointerContent @find('.pointer-select select').map( -> $(this).val() )
-    '.pointer-mixed': ->
-      element = '.pointer-checkbox-sublist input:checked,\
-                .pointer-sublist-ul input'
-      pointerContent @find(element).map( -> $(this).val() )
+    '._pointer-filtered-list': ->
+      pointerContent @find('._filtered-list-item').map( -> $(this).data('cardName') )
+    # can't find evidence that the following is in use: #efm
+    # '.pointer-mixed': ->
+    #   element = '.pointer-checkbox-sublist input:checked,\
+    #             .pointer-sublist-ul input'
+    #   pointerContent @find(element).map( -> $(this).val() )
     # must happen after pointer-list-ul, I think
     '.perm-editor': -> permissionsContent this
 
@@ -22,6 +25,9 @@ decko.editorInitFunctionMap['.pointer-list-editor'] = ->
   @sortable({handle: '.handle', cancel: ''})
   decko.initPointerList @find('input')
 
+decko.editorInitFunctionMap['._pointer-filtered-list'] = ->
+  @sortable({handle: '._handle', cancel: ''})
+
 $.extend decko,
   initPointerList: (input) ->
     decko.initAutoCardPlete input
@@ -32,9 +38,13 @@ $.extend decko,
     url = decko.rootPath + '/' + optionsCard + '.json?view=name_complete'
     input.autocomplete { source: decko.prepUrl(url) }
 
+  pointerContent: (vals) ->
+    list = $.map $.makeArray(vals), (v) -> if v then '[[' + v + ']]'
+    $.makeArray(list).join "\n"
+
 pointerContent = (vals) ->
-  list = $.map $.makeArray(vals), (v) -> if v then '[[' + v + ']]'
-  $.makeArray(list).join "\n"
+  decko.pointerContent vals
+  # deprecated. backwards compatibility
 
 permissionsContent = (ed) ->
   return '_left' if ed.find('#inherit').is(':checked')

data/mod/pointer/set/abstract/00_paging_params.rb

@@ -1,11 +1,24 @@
 format do
   def limit_param
-    @limit ||=
-      Env.params[:limit].present? ? Env.params.delete(:limit).to_i : default_limit
+    @limit ||= contextual_param(:limit) || default_limit
   end
 
   def offset_param
-    @offset ||=
-      Env.params[:offset].present? ? Env.params.delete(:offset).to_i : 0
+    @offset ||= contextual_param(:offset) || 0
+  end
+
+  def contextual_param param
+    env_search_param(param) || voo_search_param(param)
+  end
+
+  def env_search_param param
+    return unless focal?
+    val = Env.params[param]
+    val.present? && val.to_i
+  end
+
+  def voo_search_param param
+    return unless voo&.wql
+    voo.wql[param]
   end
 end

data/mod/pointer/set/abstract/02_pointer/filtered.rb

@@ -0,0 +1,48 @@
+
+format :html do
+  view :filtered_list, tags: :unknown_ok do
+    with_nest_mode :normal do
+      class_up "card-slot", editor_id
+      wrap do
+        haml :filtered_list_input
+      end
+    end
+  end
+
+  def filtered_list_input
+    _render_filtered_list
+  end
+
+  def filtered_list_item item_card
+    nest_item item_card do |rendered, item_view|
+      wrap_item rendered, item_view
+    end
+  end
+
+  # for override
+  # @return [Card] search card on which filtering is based
+  def filter_card
+    filter_card_from_params || default_filter_card
+  end
+
+  def default_filter_card
+    fcard = card.options_rule_card || Card[:all]
+    return fcard if fcard.respond_to? :wql_hash
+    fcard.fetch trait: :referred_to_by, new: {}
+  end
+
+  def filter_card_from_params
+    return unless params[:filter_card]
+    Card.fetch params[:filter_card], new: {}
+  end
+
+  view :filter_items, tags: :unknown_ok do
+    haml :filter_items
+  end
+
+  # currently actually used as a class
+  # (because we don't have api to override slot's id)
+  def editor_id
+    @editor_id ||= "editor#{unique_id}"
+  end
+end

data/mod/pointer/set/self/input_options.rb

@@ -6,6 +6,7 @@ add_to_basket :options, "checkbox"
 add_to_basket :options, "select"
 add_to_basket :options, "multiselect"
 add_to_basket :options, "list"
+add_to_basket :options, "filtered list"
 
 def content
   options.to_pointer_content

data/mod/pointer/spec/set/self/input_options_spec.rb

@@ -1,7 +1,7 @@
 describe Card::Set::Self::InputOptions do
   it "loads the self set" do
     expect(Card[:input, :right, :options].item_names).to contain_exactly(
-      "radio", "checkbox", "select", "multiselect", "list", "ace editor",
+      "radio", "checkbox", "select", "multiselect", "list", "ace editor", "filtered list",
       "prosemirror editor", "tinymce editor", "text area", "text field", "calendar"
     )
   end

data/mod/pointer/template/abstract/02_pointer/filtered/filter_items.haml

@@ -0,0 +1,34 @@
+._filter-items.container-fluid
+  .row
+    = nest filter_card, view: :filter_form
+    ._unselected.col-6.border.mt-2.nopadding
+      = nest filter_card, view: :select_item,
+                          items: { view: implicit_item_view },
+                          wql: { limit: 10 }
+    ._selected.col-6.border.mt-2.nopadding
+      .selected-box
+        .card-header
+          %h5
+            Selected
+            .badge.badge-secondary
+              %span._selected-items
+                0
+        ._selected-item-list{ style: "display:none" }
+          .p-3.deselector
+            %input#deselect-all._deselect-all{ type: "checkbox", checked: true, disabled: true }
+            %label{ for: "deselect-all" }
+              deselect
+              %span._selected-items
+                0
+              following
+          ._selected-bin
+      ._filter-help.alert.alert-secondary
+        Filter and select items to add them here.
+      .form-group
+        .selected-item-buttons
+          = button_tag "Cancel", class: "cancel-modal", data: { dismiss: :modal }
+          - select_href = path item: params[:item], filter_card: params[:filter_card]
+          = button_tag "Add Selected", class: "_add-selected slotter close-modal",
+                                       disabled: true,
+                                       href: select_href,
+                                       data: { "slot-selector": ".#{params[:editor_id]}" }

data/mod/pointer/template/abstract/02_pointer/filtered/filtered_list_input.haml

@@ -0,0 +1,30 @@
+%div.filtered-list-editor
+  %ul.filtered-list-review._pointer-filtered-list.list-group.vertical.nopadding
+    - card.item_cards(context: :raw).each do |item_card|
+      %li._filtered-list-item.clearfix{ data: item_card.format.wrap_data(false) }
+        %span._handle.float-left.m-2
+          = icon_tag :reorder
+        - nest_item item_card do |rendered, view|
+          %span{ class: "item-#{view} float-left w-75"}
+            = rendered
+        %span.filtered-list-item-button
+          %button._filtered-list-item-delete.btn.btn-secondary.btn-sm.m-2{:type => "button"}
+            = icon_tag :remove
+  %br
+  .clearfix
+    - path_opts = { view: :filter_items,
+                    item: implicit_item_view,
+                    filter_card: filter_card.name,
+                    layout: :simple_modal,
+                    editor_id: editor_id,
+                    slot: { hide: :modal_footer },
+                    filter: { not_ids: card.item_ids.map(&:to_s).join(",") } }
+    = render_modal_link title: "Add Item",
+                        link_opts: { class: "btn btn-sm btn-primary",
+                                     "data-target": "#modal-filtered-list",
+                                     path: path_opts }
+= render_modal_slot modal_id: "filtered-list", dialog_class: "modal-lg"
+
+// note: passing item and filter card because in some cases (eg Project+Metric on wikirate)
+// the link was losing set-identifying information (type of left)
+// would be preferable to have a more general solution to retain set-identifying info.

data/mod/search/lib/card/filter_query.rb

@@ -0,0 +1,81 @@
+class Card
+  # Class for generating WQL based on filter params
+  class FilterQuery
+    def initialize filter_keys_with_values, extra_wql={}
+      @filter_wql = Hash.new { |h, k| h[k] = [] }
+      @rules = yield if block_given?
+      @rules ||= {}
+      @filter_keys_with_values = filter_keys_with_values
+      @extra_wql = extra_wql
+      prepare_filter_wql
+    end
+
+    def add_to_wql key, value
+      @filter_wql[key] << value
+    end
+
+    def add_rule key, value
+      return unless value.present?
+      case @rules[key]
+      when Symbol
+        send("#{@rules[key]}_rule", key, value)
+      when Proc
+        @rules[key].call(key, value).each do |wql_key, val|
+          @filter_wql[wql_key] << val
+        end
+      else
+        send("#{key}_wql", value)
+      end
+    end
+
+    def to_wql
+      @wql = {}
+      @filter_wql.each do |wql_key, values|
+        next if values.empty?
+        case wql_key
+        when :right_plus, :left_plus, :type
+          merge_using_and wql_key, values
+        else
+          merge_using_array wql_key, values
+        end
+      end
+      @wql.merge @extra_wql
+    end
+
+    private
+
+    def prepare_filter_wql
+      @filter_keys_with_values.each do |key, values|
+        add_rule key, values
+      end
+    end
+
+    def merge_using_array wql_key, values
+      @wql[wql_key] = values.one? ? values.first : values
+    end
+
+    def merge_using_and wql_key, values
+      hash = build_nested_hash wql_key, values
+      @wql.deep_merge! hash
+    end
+
+    # nest values with the same key using :and
+    def build_nested_hash key, values
+      return { key => values[0] } if values.one?
+      val = values.pop
+      { key => val,
+        and: build_nested_hash(key, values) }
+    end
+
+    def name_wql name
+      return unless name.present?
+      @filter_wql[:name] = ["match", name]
+    end
+
+    # FIXME: move to wikirate
+    def project_wql project
+      return unless project.present?
+      @filter_wql[:referred_to_by] << { left: { name: project } }
+    end
+  end
+end

data/mod/search/set/abstract/00_filter_helper.rb

@@ -0,0 +1,51 @@
+
+def sort_hash
+  { sort: sort_param }
+end
+
+def filter_param field
+  filter_hash[field.to_sym]
+end
+
+def filter_hash
+  @filter_hash ||= begin
+    filter = Env.params[:filter]
+    filter = filter.to_unsafe_h if filter&.respond_to?(:to_unsafe_h)
+    filter.is_a?(Hash) ? filter : {}
+  end
+end
+
+def sort_param
+  Env.params[:sort] if Env.params[:sort].present?
+end
+
+def filter_keys_with_values
+  (filter_keys + advanced_filter_keys).map do |key|
+    values = filter_param(key)
+    next unless values.present?
+    [key, values]
+  end.compact
+end
+
+def default_filter_option
+  {}
+end
+
+def offset
+  param_to_i :offset, 0
+end
+
+format do
+  delegate :filter_hash, :sort_hash, :filter_param, :sort_param,
+           :all_filter_keys, to: :card
+end
+
+format :html do
+  def extra_paging_path_args
+    { filter: filter_hash }.merge sort_hash
+  end
+
+  def filter_active?
+    filter_hash.present?
+  end
+end

data/mod/search/set/abstract/01_filter_form_helper.rb

@@ -0,0 +1,77 @@
+include_set Abstract::FilterHelper
+
+format :html do
+  def select_filter field, _label=nil, default=nil, options=nil
+    options ||= filter_options field
+    options.unshift(["--", ""]) unless default
+    select_filter_tag field, default, options
+  end
+
+  def multiselect_filter field, _label=nil, default=nil, options=nil
+    options ||= filter_options field
+    multiselect_filter_tag field, default, options
+  end
+
+  def text_filter field, opts={}
+    name = filter_name field
+    add_class opts, "form-control"
+    # formgroup filter_label(field), class: "filter-input" do
+    text_field_tag name, filter_param(field), opts
+    # end
+  end
+
+  def select_filter_type_based type_codename, order="asc"
+    # take the card name as default label
+    options = type_options type_codename, order
+    select_filter type_codename, nil, nil, options
+  end
+
+  def autocomplete_filter type_code, options_card=nil
+    options_card ||= Card::Name[type_code, :type, :by_name]
+    text_filter type_code, class: "#{type_code}_autocomplete",
+                           "data-options-card": options_card
+  end
+
+  def multiselect_filter_type_based type_codename
+    options = type_options type_codename
+    multiselect_filter type_codename, nil, nil, options
+  end
+
+  def multiselect_filter_tag field, default, options, html_options={}
+    html_options[:multiple] = true
+    select_filter_tag field, default, options, html_options
+  end
+
+  def select_filter_tag field, default, options, html_options={}
+    name = filter_name field, html_options[:multiple]
+    default = filter_param(field) || default
+    options = options_for_select(options, default)
+
+    css_class =
+      html_options[:multiple] ? "pointer-multiselect" : "pointer-select"
+    add_class(html_options, css_class + " filter-input #{field} _filter_input_field")
+
+    select_tag name, options, html_options
+  end
+
+  def filter_name field, multi=false
+    "filter[#{field}]#{'[]' if multi}"
+  end
+
+  def filter_options field
+    raw = send("#{field}_options")
+    raw.is_a?(Array) ? raw : option_hash_to_array(raw)
+  end
+
+  def option_hash_to_array hash
+    hash.each_with_object([]) do |(key, value), array|
+      array << [key, value.to_s.downcase]
+      array
+    end
+  end
+
+  def type_options type_codename, order="asc"
+    type_card = Card[type_codename]
+    Card.search type_id: type_card.id, return: :name, sort: "name", dir: order
+  end
+end

data/mod/search/set/abstract/01_search_params.rb

@@ -6,25 +6,17 @@ format do
   end
 
   def search_params
-    @search_params ||= begin
-      p = default_search_params.clone
-      offset_and_limit_search_params p if focal?
-      p
-    end
+    @search_params ||= default_search_params
   end
 
+  # used for override
   def default_search_params
-    { limit: default_limit }
+    { limit: limit_param, offset: offset_param }
   end
 
   def default_limit
     100
   end
-
-  def offset_and_limit_search_params hash
-    hash[:offset] = offset_param
-    hash[:limit] = limit_param
-  end
 end
 
 format :html do