marty 4.0.0.rc2 → 5.1.0

data/app/components/marty/extras/layout.rb

@@ -115,7 +115,7 @@ module Layout
   end
 
   def get_sorter(col)
-    lambda { |rel, dir| rel.order("#{col}::text #{dir.to_s}") }
+    lambda { |rel, dir| rel.order(Arel.sql("#{col}::text #{dir}")) }
   end
 
   ######################################################################

data/app/components/marty/grid.rb

@@ -52,7 +52,7 @@ class Marty::Grid < ::Netzke::Grid::Base
 
   def get_json_sorter(json_col, field)
     lambda do |r, dir|
-      r.order("#{json_col} ->> '#{field}' " + dir.to_s)
+      r.order(Arel.sql("#{json_col} ->> '#{field}' " + dir.to_s))
     end
   end
 

data/app/components/marty/grid/client/grid.js

@@ -1,13 +1,13 @@
 {
-  getComponent: function (name) {
+  getComponent: function(name) {
     return Ext.getCmp(name);
   },
 
-  findComponent: function (name) {
+  findComponent: function(name) {
     return Ext.ComponentQuery.query(`[name=${name}]`)[0];
   },
 
-  setDisableComponentActions: function (prefix, flag) {
+  setDisableComponentActions: function(prefix, flag) {
     for (var key in this.actions) {
       if (key.substring(0, prefix.length) == prefix) {
         this.actions[key].setDisabled(flag);
@@ -15,7 +15,7 @@
     }
   },
 
-  initComponent: function () {
+  initComponent: function() {
     this.dockedItems = this.dockedItems || [];
     if (this.paging == 'pagination') {
       this.dockedItems.push({
@@ -57,7 +57,7 @@
 
     var children = me.serverConfig.child_components || [];
     me.onSelectionChange(
-      function (m) {
+      function(m) {
         var has_sel = m.hasSelection();
 
         var rid = null;
@@ -92,7 +92,7 @@
     var store = me.getStore();
     var linked = me.serverConfig.linked_components || [];
     for (var event of ['update', 'netzkerefresh']) {
-      store.on(event, function () {
+      store.on(event, function() {
         for (var link of linked) {
           var comp = me.findComponent(link);
           if (comp && comp.reload) {
@@ -103,19 +103,30 @@
     }
   },
 
-  onSelectionChange: function (f) {
+  onSelectionChange: function(f) {
     var me = this;
     me.getSelectionModel().on('selectionchange', f);
   },
 
-  doViewInForm: function (record) {
+  // override netzkeReloadStore to allow option passthrough
+  // reference: http://api.netzke.org/client/files/doc_client_netzke-basepack_javascripts_grid_event_handlers.js.html
+  netzkeReloadStore: function(opts = {}) {
+    var store = this.getStore();
+
+    // HACK to work around buffered store's buggy reload()
+    if (!store.lastRequestStart) {
+      store.load(opts);
+    } else store.reload(opts);
+  },
+
+  doViewInForm: function(record) {
     this.netzkeLoadComponent("view_window", {
       serverConfig: {
         record_id: record.id
       },
-      callback: function (w) {
+      callback: function(w) {
         w.show();
-        w.on('close', function () {
+        w.on('close', function() {
           if (w.closeRes === "ok") {
             this.netzkeReloadStore();
           }
@@ -124,11 +135,16 @@
     });
   },
 
-  reload: function (opts = {}) {
+  // always reset store to first page on reload
+  // to avoid load bug when moving from a higher page count
+  // to a grid with a lower page count
+  reload: function(opts = {
+    start: 0
+  }) {
     this.netzkeReloadStore(opts);
   },
 
-  reloadAll: function () {
+  reloadAll: function() {
     var me = this;
     var children = me.serverConfig.child_components || [];
     this.store.reload();
@@ -140,7 +156,7 @@
     }
   },
 
-  clearFilters: function () {
+  clearFilters: function() {
     this.filters.clearFilters();
   },
 }

data/app/components/marty/import_view.rb

@@ -84,10 +84,10 @@ class Marty::ImportView < Marty::Form
       result << messages if messages
 
       client.set_result result.join('<br/>')
-    rescue Marty::DataImporter::Error => exc
+    rescue Marty::DataImporter::Error => e
       result = [
-        "Import failed on line(s): #{exc.lines.join(', ')}",
-        "Error: #{exc.to_s}",
+        "Import failed on line(s): #{e.lines.join(', ')}",
+        "Error: #{e.to_s}",
       ]
 
       client.set_result '<font color="red">' + result.join('<br/>') + '</font>'

data/app/components/marty/main_auth_app.rb

@@ -4,6 +4,7 @@ require 'marty/api_log_view'
 require 'marty/config_view'
 require 'marty/data_grid_view'
 require 'marty/schedule_jobs_dashboard'
+require 'marty/data_grid_user_view'
 require 'marty/event_view'
 require 'marty/import_type_view'
 require 'marty/new_posting_window'
@@ -96,6 +97,7 @@ class Marty::MainAuthApp < Marty::AuthApp
         icon_cls: 'fa fa-window-restore glyph',
       menu: [
         :data_grid_view,
+        :data_grid_user_view,
         :reporting,
         :scripting,
         :promise_view,
@@ -237,7 +239,14 @@ class Marty::MainAuthApp < Marty::AuthApp
   end
 
   action :data_grid_view do |a|
-    a.text      = I18n.t('data_grid_view', default: 'Data Grids')
+    a.text      = I18n.t('data_grid_view')
+    a.handler   = :netzke_load_component_by_action
+    a.icon_cls = 'fa fa-table glyph'
+    a.disabled = !self.class.has_any_perm?
+  end
+
+  action :data_grid_user_view do |a|
+    a.text      = I18n.t('data_grid_user_view')
     a.handler   = :netzke_load_component_by_action
     a.icon_cls = 'fa fa-table glyph'
     a.disabled = !self.class.has_any_perm?
@@ -388,6 +397,7 @@ class Marty::MainAuthApp < Marty::AuthApp
   component :config_view
 
   component :data_grid_view
+  component :data_grid_user_view
 
   component :event_view
 

data/app/components/marty/report_form.rb

@@ -61,10 +61,10 @@ class Marty::ReportForm < Marty::Form
 
     begin
       engine.evaluate(node, 'result', d_params)
-    rescue StandardError => exc
-      Marty::Util.logger.error "run_eval failed: #{exc.backtrace}"
+    rescue StandardError => e
+      Marty::Util.logger.error "run_eval failed: #{e.backtrace}"
 
-      res = Delorean::Engine.grok_runtime_exception(exc)
+      res = Delorean::Engine.grok_runtime_exception(e)
       res['backtrace'] =
         res['backtrace'].map { |m, line, fn| "#{m}:#{line} #{fn}" }.join('\n')
       res
@@ -156,15 +156,15 @@ class Marty::ReportForm < Marty::Form
       raise 'bad form items' unless items.is_a?(Array)
       raise 'bad format' unless
         Marty::ContentHandler::GEN_FORMATS.member?(format)
-    rescue StandardError => exc
+    rescue StandardError => e
       c.title = 'ERROR'
       c.items =
         [
           {
-            field_label: 'Exception',
+            field_label: 'exception',
             xtype:       :displayfield,
             name:        'displayfield1',
-            value:       "<span style=\"color:red;\">#{exc}</span>"
+            value:       "<span style=\"color:red;\">#{e}</span>"
           },
         ]
       return

data/app/components/marty/script_form.rb

@@ -83,10 +83,10 @@ class Marty::ScriptForm < Marty::Form
     begin
       dev = Marty::Tag.find_by_name('DEV')
       Marty::ScriptSet.new(dev).parse_check(script.name, data['body'])
-    rescue Delorean::ParseError => exc
-      client.netzke_notify exc.message
+    rescue Delorean::ParseError => e
+      client.netzke_notify e.message
       client.netzke_apply_form_errors({})
-      client.set_line_error(exc.line)
+      client.set_line_error(e.line)
       return
     end
 
@@ -120,8 +120,8 @@ class Marty::ScriptForm < Marty::Form
                                          'PrettyScript',
                                          rep_params)
       client.get_report(path)
-    rescue StandardError => exc
-      return client.netzke_notify "ERROR: #{exc}"
+    rescue StandardError => e
+      return client.netzke_notify "ERROR: #{e}"
     end
   end
 

data/app/components/marty/script_tester.rb

@@ -75,8 +75,8 @@ class Marty::ScriptTester < Marty::Form
       client.set_result result.join('<br/>')
     rescue SystemStackError
       return client.netzke_notify 'System Stack Error'
-    rescue StandardError => exc
-      res = Delorean::Engine.grok_runtime_exception(exc)
+    rescue StandardError => e
+      res = Delorean::Engine.grok_runtime_exception(e)
 
       result = ["Error: #{res['error']}", 'Backtrace:'] +
         res['backtrace'].map { |m, line, fn| "#{m}:#{line} #{fn}" }

data/app/components/marty/user_view.rb

@@ -33,9 +33,7 @@ module Marty; class UserView < Marty::Grid
   def self.set_roles(roles, user)
     roles = [] unless roles.present?
 
-    roles = Marty::RoleType.get_all.select do |role|
-      roles.include?(I18n.t("roles.#{role}", default: role))
-    end
+    roles = ::Marty::RoleType.from_nice_names(roles)
 
     roles_in_user = user.user_roles.map(&:role)
     roles_to_delete = roles_in_user - roles
@@ -152,14 +150,10 @@ module Marty; class UserView < Marty::Grid
     c.type    = :string
 
     c.getter = lambda do |r|
-      r.user_roles.map do |ur|
-        I18n.t("roles.#{ur.role}", default: ur.role)
-      end
+      Marty::RoleType.to_nice_names(r.user_roles.map(&:role))
     end
 
-    store = ::Marty::RoleType.get_all.sort.map do |role|
-      I18n.t("roles.#{role}", default: role)
-    end
+    store = ::Marty::RoleType.to_nice_names(::Marty::RoleType::VALUES.sort)
 
     c.editor_config = {
       multi_select: true,

data/app/models/marty/base_rule.rb

@@ -53,13 +53,16 @@ class Marty::BaseRule < Marty::Base
 
   def validate
     self.class.guard_info.each { |name, h| check(name, h) }
+
     grids.each do |vn, gn|
       return errors[:grids] << "- Bad grid name '#{gn}' for '#{vn}'" unless
         gn.blank? || Marty::DataGrid.lookup('infinity', gn)
     end
+
     cg_err = computed_guards.delete('~~ERROR~~')
     errors[:computed] <<
       "- Error in rule '#{name}' field 'computed_guards': #{cg_err.capitalize}" if cg_err
+
     res_err = results.delete('~~ERROR~~')
     errors[:computed] <<
       "- Error in rule '#{name}' field 'results': #{res_err.capitalize}" if res_err
@@ -67,12 +70,14 @@ class Marty::BaseRule < Marty::Base
 
   validates_presence_of :name
   validate :validate
+  validate :validate_simple_guard_options
 
   before_validation(on: [:create, :update]) do
-    self.simple_guards     ||= {}
-    self.computed_guards   ||= {}
-    self.grids             ||= {}
-    self.results           ||= {}
+    self.simple_guards         ||= {}
+    self.simple_guards_options ||= {}
+    self.computed_guards       ||= {}
+    self.grids                 ||= {}
+    self.results               ||= {}
   end
 
   before_create do
@@ -83,38 +88,93 @@ class Marty::BaseRule < Marty::Base
     end
   end
 
-  def self.get_subq(field, subfield, multi, type, vraw)
-    arrow = multi || ![:range, :string, :date, :datetime].include?(type) ?
-              '->' : '->>'
-    op = multi || type == :range ? '@>' : '='
-    value0 = [:string, :date, :datetime].include?(type) ?
-               ActiveRecord::Base.connection.quote(vraw) :
-               type == :range ? vraw.to_f :
-                 "'#{vraw}'::jsonb"
-    value = multi ? %Q('["%s"]') % value0[1..-2] : value0
-    fieldcast = type == :range ? '::numrange' : ''
-    "(#{field}#{arrow}'#{subfield}')#{fieldcast} #{op} #{value}"
+  private
+
+  def validate_simple_guard_options
+    simple_guards_options.each do |guard_name, value|
+      field_path = "'simple_guard_options' -> '#{guard_name}' -> 'not'"
+
+      guard_info = self.class.guard_info[guard_name.to_s]
+
+      if guard_info.blank?
+        errors[:simple_guards_options] <<
+          "- Error in rule '#{name}' #{field_path}."\
+          "Guard '#{guard_name}' doesn't exist."
+
+        next
+      end
+
+      not_is_allowed = guard_info.fetch(:allow_not, true)
+
+      not_field = value['not'] || value[:not]
+      next if not_field.nil?
+
+      if not_field.is_a?(TrueClass)
+        next if not_is_allowed
+
+        errors[:simple_guards_options] <<
+          "- Error in rule '#{name}' #{field_path}. True value is not allowed"
+        next
+      end
+
+      next if not_field.is_a?(FalseClass)
+
+      errors[:simple_guards_options] <<
+        "- Error in rule '#{name}' #{field_path} field must be a boolean"
+    end
   end
 
-  def self.get_matches_(_pt, attrs, params)
-    q = select('DISTINCT ON (name) *').where(attrs)
+  class << self
+    def get_subq(field, subfield, multi, type, vraw)
+      arrow = multi || ![:range, :string, :date, :datetime].include?(type) ?
+                '->' : '->>'
+      op = multi || type == :range ? '@>' : '='
+      value0 = [:string, :date, :datetime].include?(type) ?
+                 ActiveRecord::Base.connection.quote(vraw) :
+                 type == :range ? vraw.to_f :
+                   "'#{vraw}'::jsonb"
+      value = multi ? %Q('["%s"]') % value0[1..-2] : value0
+      fieldcast = type == :range ? '::numrange' : ''
+      "(#{field}#{arrow}'#{subfield}')#{fieldcast} #{op} #{value}"
+    end
+
+    def get_matches_(_pt, attrs, params)
+      q = select('DISTINCT ON (name) *').where(attrs)
 
-    params.each do |k, vraw|
       h = guard_info
-      use_k = (h[k] && k) ||
-              (h[k + '_array'] && k + '_array') ||
-              (h[k + '_range'] && k + '_range')
-      next unless use_k
-
-      multi, type = h[use_k].values_at(:multi, :type)
-      filts = [vraw].flatten.map do |v|
-        qstr = get_subq('simple_guards', use_k, multi, type, v)
-      end.join(' OR ')
-      isn = "simple_guards->'#{use_k}' IS NULL OR"
-
-      q = q.where("(#{isn} #{filts})")
+
+      params.each do |k, vraw|
+        use_k = (h[k] && k) ||
+                (h[k + '_array'] && k + '_array') ||
+                (h[k + '_range'] && k + '_range')
+
+        next unless use_k
+
+        param_guard_info = h[use_k]
+
+        multi = param_guard_info[:multi]
+        type = param_guard_info[:type]
+        with_not = param_guard_info.fetch(:allow_not, true)
+
+        filts = [vraw].flatten.map do |v|
+          qstr = get_subq('simple_guards', use_k, multi, type, v)
+        end.join(' OR ')
+
+        condition = if with_not
+                      "CASE
+                       WHEN (simple_guards_options->'#{use_k}'->>'not')::boolean
+                       THEN simple_guards->'#{use_k}' IS NULL OR NOT #{filts}
+                       ELSE simple_guards->'#{use_k}' IS NULL OR #{filts}
+                       END
+                      "
+                    else
+                      "simple_guards->'#{use_k}' IS NULL OR #{filts}"
+                    end
+
+        q = q.where(condition)
+      end
+      # print q.to_sql
+      q.order(:name)
     end
-    # print q.to_sql
-    q.order(:name)
   end
 end

data/app/models/marty/data_grid.rb

@@ -8,9 +8,11 @@ class Marty::DataGrid < Marty::Base
     'integer'   => Marty::GridIndexInteger,
     'string'    => Marty::GridIndexString,
     'boolean'   => Marty::GridIndexBoolean,
-  }
+  }.freeze
 
-  ARRSEP = '|'
+  ARRSEP = '|'.freeze
+  NOT_STRING_START = 'NOT ('.freeze
+  NOT_STRING_END = ')'.freeze
 
   class DataGridValidator < ActiveModel::Validator
     def validate(dg)
@@ -253,8 +255,7 @@ class Marty::DataGrid < Marty::Base
 
   # private method used to cache lookup_grid_distinct_entry_h result
   delorean_fn :lookup_grid_h_priv,
-              to_hash: false, private: true, cache: true, sig: 4 do |pt, dgh, h, distinct|
-
+              private: true, cache: true, sig: 4 do |pt, dgh, h, distinct|
     lookup_grid_distinct_entry_h(
       pt, h, dgh, nil, true, false, distinct)['result']
   end
@@ -271,9 +272,9 @@ class Marty::DataGrid < Marty::Base
   end
 
   def self.lookup_grid_distinct_entry_h(
-        pt, h, dgh, visited = nil, follow = true,
-        return_grid_data = false, distinct = true
-      )
+    pt, h, dgh, visited = nil, follow = true,
+    return_grid_data = false, distinct = true
+  )
 
     # Perform grid lookup, if result is another data_grid, and follow is true,
     # then perform lookup on the resulting grid.  Allows grids to be nested
@@ -327,9 +328,10 @@ class Marty::DataGrid < Marty::Base
     # should unify this with Marty::DataConversion.convert
 
     type = inf['type']
+    nots = inf.fetch('nots', [])
     klass = type.constantize unless INDEX_MAP[type]
 
-    inf['keys'].map do |v|
+    keys = inf['keys'].map do |v|
       case type
       when 'numrange', 'int4range'
         Marty::Util.pg_range_to_human(v)
@@ -351,6 +353,12 @@ class Marty::DataGrid < Marty::Base
         v.join(ARRSEP) if v
       end
     end
+
+    keys.each_with_index.map do |v, index|
+      next v unless nots[index]
+
+      add_not(v)
+    end
   end
 
   # FIXME: this is only here to appease Netzke add_in_form
@@ -360,13 +368,19 @@ class Marty::DataGrid < Marty::Base
   def export_array
     # add data type metadata row if not default
     lenstr = 'lenient' if lenient
-    typestr = data_type unless [nil, DEFAULT_DATA_TYPE].member?(data_type) &&
-                               !constraint.present?
 
-    len_dt = [lenstr, typestr].compact.join(' ')
+    typestr = data_type unless [nil, DEFAULT_DATA_TYPE].member?(data_type)
+    len_type = [lenstr, typestr].compact.join(' ')
 
-    meta_rows = len_dt.present? || constraint.present? ?
-                  [[len_dt, constraint]] : []
+    meta_rows = if (lenient || typestr) && constraint
+                  [[len_type, constraint]]
+                elsif lenient || typestr
+                  [[len_type]]
+                elsif constraint
+                  [['', constraint]]
+                else
+                  []
+                end
 
     meta_rows += metadata.map do |inf|
       [inf['attr'], inf['type'], inf['dir'], inf['rs_keep'] || '']
@@ -409,6 +423,8 @@ class Marty::DataGrid < Marty::Base
   def self.parse_fvalue(pt, v, type, klass)
     return unless v
 
+    v = remove_not(v)
+
     case type
     when 'numrange', 'int4range'
       Marty::Util.human_to_pg_range(v)
@@ -461,11 +477,20 @@ class Marty::DataGrid < Marty::Base
 
   def self.parse_keys(pt, keys, type)
     klass = maybe_get_klass(type)
+
     keys.map do |v|
       parse_fvalue(pt, v, type, klass)
     end
   end
 
+  def self.parse_nots(_pt, keys)
+    keys.map do |v|
+      next false unless v
+
+      v.starts_with?(NOT_STRING_START) && v.ends_with?(NOT_STRING_END)
+    end
+  end
+
   # parse grid external representation into metadata/data
   def self.parse(pt, grid_text, options)
     options[:headers] ||= false
@@ -506,11 +531,15 @@ class Marty::DataGrid < Marty::Base
       raise "unknown metadata type #{type}" unless
         Marty::DataGrid.type_to_index(type)
 
+      keys = key && parse_keys(pt, [key], type)
+      nots = key && parse_nots(pt, [key])
+
       res = {
         'attr' => attr,
         'type' => type,
         'dir'  => dir,
-        'keys' => key && parse_keys(pt, [key], type),
+        'keys' => keys,
+        'nots' => nots,
       }
       res['rs_keep'] = rs_keep if rs_keep
       res
@@ -530,6 +559,7 @@ class Marty::DataGrid < Marty::Base
         row[0, v_infos.count].any?
 
       inf['keys'] = parse_keys(pt, row[v_infos.count, row.count], inf['type'])
+      inf['nots'] = parse_nots(pt, row[v_infos.count, row.count])
     end
 
     raise 'horiz. info keys length mismatch!' unless
@@ -542,6 +572,7 @@ class Marty::DataGrid < Marty::Base
 
     v_infos.each_with_index do |inf, i|
       inf['keys'] = parse_keys(pt, v_key_cols[i], inf['type'])
+      inf['nots'] = parse_nots(pt, v_key_cols[i])
     end
 
     raise 'vert. info keys length mismatch!' unless
@@ -553,18 +584,23 @@ class Marty::DataGrid < Marty::Base
 
     # based on data type, decide to check using convert or instance
     # lookup.  FIXME: DRY.
+
     if String === c_data_type
       tsym = c_data_type.to_sym
 
       data = data_rows.map do |r|
         r[v_infos.count, r.count].map do |v|
-          Marty::DataConversion.convert(v, tsym) if v
+          next v unless v
+
+          Marty::DataConversion.convert(v, tsym)
         end
       end
     else
       data = data_rows.map do |r|
         r[v_infos.count, r.count].map do |v|
-          next v if !v || Marty::DataGrid.
+          next v unless v
+
+          next v if Marty::DataGrid.
                          find_class_instance(pt, c_data_type, v)
 
           raise "can't find key '#{v}' for class #{data_type}"
@@ -572,12 +608,24 @@ class Marty::DataGrid < Marty::Base
       end
     end
 
-    [metadata, data, data_type, lenient, constraint]
+    {
+      metadata: metadata,
+      data: data,
+      data_type: data_type,
+      lenient: lenient,
+      constraint: constraint,
+    }
   end
 
   def self.create_from_import(name, import_text, created_dt = nil)
-    metadata, data, data_type, lenient, constraint = parse(created_dt,
-                                                           import_text, {})
+    parsed_result = parse(created_dt, import_text, {})
+
+    metadata = parsed_result[:metadata]
+    data = parsed_result[:data]
+    data_type = parsed_result[:data_type]
+    lenient = parsed_result[:lenient]
+    constraint = parsed_result[:constraint]
+
     dg            = new
     dg.name       = name
     dg.data       = data
@@ -591,8 +639,13 @@ class Marty::DataGrid < Marty::Base
   end
 
   def update_from_import(name, import_text, created_dt = nil)
-    new_metadata, data, data_type, lenient, constraint =
-      self.class.parse(created_dt, import_text, {})
+    parsed_result = self.class.parse(created_dt, import_text, {})
+
+    new_metadata = parsed_result[:metadata]
+    data = parsed_result[:data]
+    data_type = parsed_result[:data_type]
+    lenient = parsed_result[:lenient]
+    constraint = parsed_result[:constraint]
 
     self.name       = name
     self.data       = data
@@ -609,7 +662,10 @@ class Marty::DataGrid < Marty::Base
   def build_index
     # create indices for the metadata
     metadata.each do |inf|
-      attr, type, keys = inf['attr'], inf['type'], inf['keys']
+      attr = inf['attr']
+      type = inf['type']
+      keys = inf['keys']
+      nots = inf.fetch('nots', [])
 
       # find index class
       idx_class = Marty::DataGrid.type_to_index(type)
@@ -621,6 +677,7 @@ class Marty::DataGrid < Marty::Base
         gi.created_dt   = created_dt
         gi.data_grid_id = group_id
         gi.index        = index
+        gi.not          = nots[index] || false
         gi.save!
       end
     end
@@ -796,4 +853,17 @@ class Marty::DataGrid < Marty::Base
     # we convert to the opposite (what to prune)
     [opposite_sign(opstr.to_sym), ident]
   end
+
+  def self.remove_not(string)
+    return string unless string.starts_with?(NOT_STRING_START)
+    return string unless string.ends_with?(NOT_STRING_END)
+
+    remove_from_left = NOT_STRING_START.size
+    remove_from_right = NOT_STRING_END.size
+    string.slice(remove_from_left...-remove_from_right)
+  end
+
+  def self.add_not(string)
+    "#{NOT_STRING_START}#{string}#{NOT_STRING_END}"
+  end
 end