marty 2.9.3 → 3.0.0

data/app/models/marty/user.rb

@@ -8,7 +8,6 @@ class Marty::User < Marty::Base
   MARTY_IMPORT_UNIQUENESS = [:login]
 
   has_many :user_roles, dependent: :destroy
-  has_many :roles, through: :user_roles
 
   scope :active, -> { where(active: true) }
 
@@ -23,6 +22,10 @@ class Marty::User < Marty::Base
     name
   end
 
+  def roles
+    user_roles.map(&:role)
+  end
+
   # Returns the user who matches the given autologin +key+ or nil
   def self.try_to_autologin(key)
     tokens = Marty::Token.find_all_by_action_and_value('autologin', key.to_s)
@@ -95,8 +98,8 @@ class Marty::User < Marty::Base
   end
 
   def self.has_role(role)
-     mr = Mcfly.whodunnit.roles rescue []
-     mr.any? { |attr| attr.name == role }
+     mr = Mcfly.whodunnit.user_roles rescue []
+     mr.any? { |ur| ur.role == role }
   end
 
   private
@@ -110,8 +113,10 @@ class Marty::User < Marty::Base
         Rails.configuration.marty.system_account.to_s)
       system_id = system_user.id if system_user
 
+      roles = user_roles.map(&:role)
+
       if id == Mcfly.whodunnit.id
-        roles.each { |r| roles.delete r unless r.name == 'user_manager' }
+        roles.each { |r| roles.delete r unless r == 'user_manager' }
         errors.add :base, 'User Managers cannot edit '\
           'or add additional roles to their own accounts'
       elsif id == system_id

data/app/models/marty/user_role.rb

@@ -1,7 +1,6 @@
 class Marty::UserRole < Marty::Base
-  validates_uniqueness_of :user_id, scope: [:role_id]
-  validates_presence_of :user_id, :role_id
+  validates_uniqueness_of :user_id, scope: [:role]
+  validates_presence_of :user_id, :role
 
   belongs_to :user
-  belongs_to :role
 end

data/app/models/marty/vw_promise.rb

@@ -60,12 +60,12 @@ class Marty::VwPromise < Marty::Base
       'marty_users.login ILIKE ?',
       'marty_users.firstname ILIKE ?',
       'marty_users.lastname ILIKE ?',
-      'marty_roles.name ILIKE ?',
+      'marty_user_roles.role::text ILIKE ?',
     ].join(' OR ')
 
     st = "%#{search_text}%"
     # Convert "Role Name" or "Role name" to "role_name" (underscore is key)
     st2 = "%#{search_text.titleize.gsub(/\s/, '').underscore}%"
-    joins(user: :roles).where(query, st, st, st, st2).distinct
+    joins(user: :user_roles).where(query, st, st, st, st2).distinct
   }
 end

data/app/services/marty/data_grid/constraint.rb

@@ -0,0 +1,73 @@
+module Marty
+  class DataGrid
+    class Constraint
+      def self.parse(data_type, constraint)
+        return [] unless constraint
+
+        dt = DataGrid.convert_data_type(data_type)
+        if constraint =~ /[><]/
+          raise "range constraint not allowed for type #{dt}" unless
+            ['integer', 'float'].include?(dt)
+
+          pgr = Marty::Util.human_to_pg_range(constraint)
+          r = DataGrid.parse_range(pgr)
+          [r[0, 2], r[2..-1].reverse]
+        else
+          raw_vals = constraint.split('|')
+          return unless raw_vals.present?
+          raise 'list constraint not allowed for type Float' if dt == 'float'
+
+          pt = 'infinity'
+          vals = raw_vals.map do |v|
+            DataGrid.parse_fvalue(pt, v, data_type, dt)
+          end
+          [[:in?, vals.flatten]]
+        end
+      end
+
+      def self.real_type(data_type)
+        types = case data_type
+                when nil
+                  [DEFAULT_DATA_TYPE.capitalize.constantize]
+                when 'string', 'integer', 'float'
+                  [data_type.capitalize.constantize]
+                when 'boolean'
+                  [TrueClass, FalseClass]
+                else
+                  [data_type]
+                end
+        types << Integer if types.include?(Float)
+      end
+
+      # if check_data is called from validation, data has already been converted
+      # if called directly from DataGridView, it is still array of array of
+      # string.
+      def self.check_data(data_type, data, chks, cvt: false)
+        dt = Marty::DataGrid.convert_data_type(data_type)
+        klass = dt.class == Class ? dt : DataGrid.maybe_get_klass(dt)
+        rt = real_type(data_type) # get real type for string, trueclass etc
+        res = []
+        pt = 'infinity'
+        (0...data.first.length).each do |x|
+          (0...data.length).each do |y|
+            data_v = data[y][x]
+            cvt_val = nil
+            err = nil
+            begin
+              cvt_val = cvt && !data_v.class.in?(rt) ?
+                          DataGrid.parse_fvalue(pt, data_v, dt, klass).first :
+                          data_v
+            rescue StandardError => e
+              err = e.message
+            end
+            next res << [:type, x, y] if err
+
+            res << [:constraint, x, y] unless
+              chks.map { |op, chk_val| cvt_val.send(op, chk_val) }.all? { |v| v }
+          end
+        end
+        res
+      end
+    end
+  end
+end

data/app/services/marty/data_grid_view/save_grid.rb

@@ -0,0 +1,63 @@
+module Marty
+  class DataGridView
+    class SaveGrid
+      class GridError < StandardError
+        attr_reader :data, :id
+        def initialize(msg, data, id)
+          @msg = msg
+          @data = data
+          @id = id
+        end
+
+        def message
+          "save_grid: #{@msg}"
+        end
+      end
+
+      def self.call(params)
+        user_perm = Marty::DataGridView.get_edit_save_permission
+        rec_id = params['record_id']
+        data = params['data']
+        raise GridError.new('entered with view permissions', data, rec_id) if
+          user_perm == 'view'
+
+        data_as_array = data.map do |row|
+          row.keys.map { |key| row[key] }
+        end
+        dg = Marty::DataGrid.mcfly_pt('infinity').find_by(group_id: rec_id)
+        vcnt = dg.metadata.select { |md| md['dir'] == 'v' }.count
+        hcnt = dg.metadata.select { |md| md['dir'] == 'h' }.count
+        cur_data_dim = [dg.data.length, dg.data[0].length]
+        exported = dg.export.lines
+        sep = exported.each_with_index.detect { |l, _i| /^\s*$/.match(l) }.last
+        new_data = data_as_array.map do |line|
+          line.join("\t") + "\r\n"
+        end.compact
+        new_data_dim = [data_as_array.count - hcnt,
+                        data_as_array[0].count - vcnt]
+        if cur_data_dim != new_data_dim && user_perm != 'edit_all'
+          raise GridError.new('grid modification not allowed', data_as_array,
+                              rec_id)
+        end
+        data_only = data_as_array[hcnt..-1].map do |a|
+          a[vcnt..-1]
+        end
+        chks = Marty::DataGrid::Constraint.parse(dg.data_type, dg.constraint)
+        probs = Marty::DataGrid::Constraint.check_data(dg.data_type, data_only,
+                                                       chks, cvt: true)
+        return { 'problem_array' => probs } if probs.present?
+
+        to_import = (exported[0..sep] + new_data).join
+        dg.update_from_import(dg.name, to_import)
+        false
+      rescue GridError => e
+        Marty::Logger.error(e.message, rec_id: e.id,
+                            data: e.data,
+                            perm: user_perm)
+        { 'error_message' => e.message }
+      rescue StandardError => e
+        { 'error_message' => e.message }
+      end
+    end
+  end
+end

data/config/locales/en.yml

@@ -8,6 +8,7 @@ en:
   fields: Fields
   updated_at: Updated At
   user_view: User Management
+  roles_view: Roles Management
   config_view: Configuration
   reports: Reports
   import_synonym: Import Synonyms

data/db/migrate/107_add_data_grid_constraint.rb

@@ -0,0 +1,8 @@
+class AddDataGridConstraint < ActiveRecord::Migration[4.2]
+  def self.up
+    add_column :marty_data_grids, :constraint, :string, null: true
+  end
+  def self.down
+    remove_column :marty_data_grids, :constraint
+  end
+end

data/db/migrate/507_migrate_marty_roles_to_enum.rb

@@ -0,0 +1,72 @@
+class MigrateMartyRolesToEnum < ActiveRecord::Migration[5.1]
+  include Marty::Migrations
+
+  def up
+    new_enum(Marty::RoleType, 'keep_marty_prefix_here')
+
+    add_column :marty_user_roles, :role, :marty_role_types
+    add_column :marty_import_types, :role, :marty_role_types
+
+    execute <<-SQL
+      UPDATE marty_user_roles AS ur
+      SET role = roles.name::marty_role_types
+      FROM marty_roles AS roles
+      WHERE ur.role_id = roles.id
+    SQL
+
+    execute <<-SQL
+      UPDATE marty_import_types AS it
+      SET role = roles.name::marty_role_types
+      FROM marty_roles AS roles
+      WHERE it.role_id = roles.id
+    SQL
+
+    remove_column :marty_user_roles, :role_id
+    remove_column :marty_import_types, :role_id
+
+    drop_table :marty_roles
+
+    change_column_null :marty_user_roles, :role, false
+    change_column_null :marty_import_types, :role, false
+  end
+
+  def down
+    create_table :marty_roles do |t|
+      t.string :name, null: false, limit: 255
+    end
+
+    add_column :marty_user_roles, :role_id, :integer
+    add_column :marty_import_types, :role_id, :integer
+
+    Marty::RoleType::VALUES.each do |role|
+      Marty::Role.create!(name: role)
+    end
+
+    execute <<-SQL
+      UPDATE marty_user_roles AS ur
+      SET role_id = roles.id
+      FROM marty_roles AS roles
+      WHERE ur.role::text = roles.name
+    SQL
+
+    execute <<-SQL
+      UPDATE marty_import_types AS ur
+      SET role_id = roles.id
+      FROM marty_roles AS roles
+      WHERE ur.role::text = roles.name
+    SQL
+
+    remove_column :marty_user_roles, :role
+    remove_column :marty_import_types, :role
+
+    execute <<-SQL
+      DROP TYPE marty_role_types
+    SQL
+
+    change_column_null :marty_user_roles, :role_id, false
+    change_column_null :marty_import_types, :role_id, false
+
+    add_fk :marty_user_roles, :marty_roles, column: :role_id
+    add_fk :marty_import_types, :marty_roles, column: :role_id
+  end
+end

data/db/seeds.rb

@@ -12,13 +12,8 @@ end
 # FIXME: hacky -- globally changes whodunnit
 Mcfly.whodunnit = Marty::User.find_by_login(system_login)
 
-# Create all Marty roles from configuration
-(Rails.configuration.marty.roles || []).each do |role|
-  Marty::Role.create(name: role.to_s)
-end
-
 # Give system account all roles
-Marty::Role.all.map { |role|
+Marty::RoleType.get_all.map { |role|
   ur = Marty::UserRole.new
   ur.user = Mcfly.whodunnit
   ur.role = role

data/lib/marty/permissions.rb

@@ -1,9 +1,4 @@
 module Marty::Permissions
-  # Make sure there are admin and user_manager roles,
-  # even if hosting app doesn't define them
-  REQ_ROLES = [:admin, :user_manager]
-  ALL_ROLES = Rails.configuration.marty.roles.to_set.merge(REQ_ROLES)
-
   # Call using following format
   #   has_marty_permissions   create: [:dev, :admin],
   #                           read: :any,
@@ -13,15 +8,13 @@ module Marty::Permissions
   # :any gives permission to the action if user belongs to at least 1 role
   def has_marty_permissions(attrs)
     raise 'bad attrs' unless attrs.is_a?(Hash)
-    raise 'unknown role' unless
-      attrs.values.flatten.to_set.subset? (ALL_ROLES << :any)
 
     define_singleton_method(:marty_permissions) { attrs }
   end
 
   def current_user_roles
-    roles = Mcfly.whodunnit.roles rescue []
-    roles.map { |r| r.name.to_sym }.to_set
+    user_roles = Mcfly.whodunnit.user_roles rescue []
+    user_roles.map { |r| r.role.to_sym }.to_set
   end
 
   def can_perform_action?(action)
@@ -49,15 +42,12 @@ module Marty::Permissions
     end.compact
   end
 
-  # generate has_xxx_perm? methods for all permissions.
-  Rails.configuration.marty.roles.each do |role|
-    define_method("has_#{role}_perm?") do
-      current_user_roles.member? role
-    end
+  def has_any_perm?
+    current_user_roles.any?
   end
 
-  def has_any_perm?
-    !(current_user_roles & ALL_ROLES).empty?
+  def has_perm?(role)
+    current_user_roles.member? role.to_sym
   end
 
   # FIXME: for backwards compatibility returns true

data/lib/marty/version.rb

@@ -1,3 +1,3 @@
 module Marty
-  VERSION = '2.9.3'
+  VERSION = '3.0.0'
 end

data/spec/dummy/config/locales/en.yml

@@ -18,3 +18,4 @@ en:
     other_flag: "Other"
     g_bool_def: "Bool def Guard"
     g_nbool_def: "NBool def Guard"
+    project_legal_structure_type: "PLST"

data/spec/features/data_grid_spec.rb

@@ -0,0 +1,499 @@
+require 'spec_helper'
+require 'marty_rspec'
+
+feature 'data grid view', js: true do
+  before(:each) do
+    marty_whodunnit
+    Marty::Script.load_scripts
+    dt = DateTime.parse('2017-1-1')
+    p = File.expand_path('../../fixtures/misc', __FILE__)
+    Dir.glob(p + '/data_grid_*.txt').each do |path|
+      n = File.basename(path, '.txt').camelize
+      Marty::DataGrid.create_from_import(n, File.read(path), dt)
+    end
+  end
+
+  def go_to_data_grids
+    press('Applications')
+    press('Data Grids')
+    expect(page).to have_content 'Data Grids'
+  end
+
+  # setup the info for the ext grid
+  def grid_setup
+    widths, rows = get_grid_info
+    @grid = page.all(:xpath,
+                     ".//div[contains(@class, 'x-grid-item-container')]").
+              reject { |e| e.text.include?('2016-12-31') }.first
+    @gridx = @grid.native.rect.x
+    @gridy = @grid.native.rect.y
+    height = @grid.native.size.height
+    @perr = (height / rows).to_i
+    col_preh = widths.each_with_index.map do |c, i|
+      [i, [c[:x] + @gridx, c[:width]]]
+    end
+    @colh = Hash[col_preh]
+  end
+
+  def context_click(col, row, menuidx, click: false)
+    colx = @colh[col][0]
+    colw = @colh[col][1]
+    xpos = (colx + colw / 2).to_i - @gridx
+    ypos = (@perr * row + @perr / 2).to_i
+    mxpos = xpos + 20
+    mypos = ypos + (@perr * menuidx + @perr / 2).to_i
+    page.driver.browser.action.
+      move_to(@grid.native, xpos, ypos).context_click.perform
+
+    if click
+      page.driver.browser.action.move_to(@grid.native, mxpos, mypos).click.
+        release.perform
+    else
+      ret = get_menu
+      page.driver.browser.action.move_to(@grid.native, 0, 0).click.perform
+      ret
+    end
+  end
+
+  def get_menu
+    m_en = page.all(:xpath,
+                    ".//div[contains(@class, 'x-menu-item-default')]").to_a
+    m_dis = page.all(:xpath,
+                     ".//div[contains(@class, 'x-menu-item-disabled')]").to_a
+    labels = ['Insert Row Above', 'Insert Row Below',
+              'Insert Column Left', 'Insert Column Right',
+              'Delete Row', 'Delete Column']
+    en = m_en.select { |m| labels.include?(m.text) }.
+           map { |m| [m.text, :enabled] }
+    dis = m_dis.select { |m| labels.include?(m.text) }.
+            map { |m| [m.text, :disabled] }
+    Hash[en + dis]
+  end
+
+  def cell_edit(col, row, text)
+    colx = @colh[col][0]
+    colw = @colh[col][1]
+    xpos = (colx + colw / 2).to_i - @gridx
+    ypos = (@perr * row + @perr / 2).to_i
+    page.driver.browser.action.move_to(@grid.native, xpos, ypos).double_click.
+        send_keys("\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08\x08").perform
+    sleep 0.1
+    page.driver.browser.action.
+      move_to(@grid.native, xpos, ypos).double_click.
+      send_keys(text.to_s).perform
+  end
+
+  def get_grid(to_get: :values)
+    get_expr = case to_get
+               when :values
+                 'value'
+               when :colors
+                 'cell.style.backgroundColor'
+               when :qtips
+                 "('data-qtip' in cell.attributes) && "\
+                 "cell.attributes['data-qtip'].value"
+               end
+    db = 'debugger;' if to_get == :qtips
+    ret = run_js <<-JS
+         var grid = Ext.ComponentQuery.query('grid').find(function(v) {
+                return v.name=='data_grid_edit_grid'
+            });
+         var store = grid.getStore().data.items;
+         var view = grid.getView();
+         var ret = [];
+         for (var i = 0; i < store.length; ++i) {
+             var row = [];
+             var j = 0;
+             for (const [key, value] of Object.entries(store[i].data)) {
+                 if (key != 'id') {
+                    var cell = view.getCell(i, j);
+                    row.push(#{get_expr});
+                 }
+                 j++;
+             }
+             ret.push(row);
+         }
+         return ret;
+    JS
+    ret
+  end
+
+  def get_grid_info
+    cwraw, rc = run_js <<-JS
+         var grid = Ext.ComponentQuery.query('grid').find(function(v) {
+                return v.name=='data_grid_edit_grid'
+            });
+         var cols = grid.getColumnManager().getColumns();
+         var ret = [];
+         for (col of cols)
+            ret.push(col.lastBox);
+         return [ret, grid.getStore().data.items.length];
+    JS
+    cw = cwraw.map do |cwr|
+      h = {}
+      h[:x] = cwr['x']
+      h[:width] = cwr['width']
+      h
+    end
+    [cw, rc]
+  end
+
+  def iterate_area(rect, a_of_a)
+    ulx, uly, lrx, lry = rect.values
+    sub = []
+    a_of_a[uly...lry].each_with_index do |row, row_idx|
+      subrow = []
+      row[ulx...lrx].each_with_index do |cell, col_idx|
+        subrow << cell
+        yield(cell, row_idx, col_idx) if block_given?
+      end
+      sub << subrow
+    end
+    sub
+  end
+
+  def check_dim(dim, dim_size, dim_area, ui_colors, ui_data, by_col: true)
+    return unless dim.count > 0
+
+    color_sets = Array.new(dim_size) { Set.new }
+    iterate_area(dim_area, ui_colors) do |cell, row_idx, col_idx|
+      idx = by_col ? col_idx : row_idx
+      color_sets[idx] << cell
+    end
+    color_sets.each do |the_set|
+      expect(the_set.length).to eq(1)
+      expect(the_set.to_a[0]).to match(/^rgb/)
+    end
+    all_set = color_sets.map(&:to_a).reduce(&:+).to_set
+    expect(all_set.length).to eq(color_sets.length)
+
+    dim_data = iterate_area(dim_area, ui_data)
+    keys = dim.map { |d| Marty::DataGrid.export_keys(d) }
+    piv = by_col ?
+            keys.each_with_object([]) do |key_array, piv_array|
+              key_array.each_with_index do |v, idx|
+                (piv_array[idx] ||= []) << v
+              end
+            end : keys
+    expect(piv.map(&:flatten)).to eq(dim_data)
+  end
+
+  def check_grid(grid_name, perm, all_cells)
+    grid = Marty::DataGrid.mcfly_pt('infinity').find_by(name: grid_name)
+    hdim = grid.metadata.select { |md| md['dir'] == 'h' }
+    vdim = grid.metadata.select { |md| md['dir'] == 'v' }
+    data = grid.data
+    ui_data = get_grid
+    row_cnt = ui_data.length
+    col_cnt = ui_data[0].length
+    ui_colors = get_grid(to_get: :colors)
+
+    vdim_size = vdim.count
+    hdim_size = hdim.count
+    vdim_area =  { ulx: 0, uly: hdim_size, lrx: vdim_size, lry: row_cnt }
+    hdim_area =  { ulx: vdim_size, uly: 0, lrx: col_cnt, lry: hdim_size }
+    data_area =  { ulx: vdim_size, uly: hdim_size, lrx: col_cnt,
+                   lry: row_cnt }
+    # check the dim areas
+    check_dim(vdim, vdim_size, vdim_area, ui_colors, ui_data) if vdim_size > 0
+    check_dim(hdim, hdim_size, hdim_area, ui_colors, ui_data, by_col: false) if
+      hdim_size > 0
+
+    # data section color check
+    colors = Set.new
+    iterate_area(data_area, ui_colors) do |cell, _row_idx, _col_idx|
+      colors << cell
+    end
+    expect(colors.length).to eq(1)
+    expect(colors.to_a[0]).to eq('')
+
+    # check that data section matches actual grid data
+    data_data = iterate_area(data_area, ui_data)
+    expect(struct_compare(data_data, grid.data)).to be_falsey
+
+    grid_setup
+    all_disabled = {
+      'Insert Row Above'    => :disabled,
+      'Insert Row Below'    => :disabled,
+      'Insert Column Left'  => :disabled,
+      'Insert Column Right' => :disabled,
+      'Delete Row'          => :disabled,
+      'Delete Column'       => :disabled
+    }
+    col_disabled = all_disabled + {
+      'Insert Row Above'    => :enabled,
+      'Insert Row Below'    => :enabled,
+      'Delete Row'          => :enabled
+    }
+    row_disabled = all_disabled + {
+      'Insert Column Left'  => :enabled,
+      'Insert Column Right' => :enabled,
+      'Delete Column'       => :enabled
+    }
+    all_enabled = Hash[all_disabled.map { |k, _v| [k, :enabled] }]
+
+    # in the data area, what is allowed depends on whether there
+    # are only vdims, hdims, or both
+    data_menu = if ['view', 'edit_data'].include?(perm)
+                then all_disabled
+                elsif hdim.count == 0
+                  col_disabled
+                elsif vdim.count == 0
+                  row_disabled
+                else
+                  all_enabled
+                end
+    areas = [[data_area, data_menu],
+             [vdim_area, perm == 'edit_all' && vdim.count > 0 ? col_disabled :
+                           all_disabled],
+             [hdim_area, perm == 'edit_all' && hdim.count > 0 ? row_disabled :
+                           all_disabled]]
+    areas.each do |area, menu_exp|
+      xrangefull = (area[:ulx]...area[:lrx]).to_a
+      yrangefull = (area[:uly]...area[:lry]).to_a
+
+      # grid has only v or h dims
+      next if xrangefull.empty? || yrangefull.empty?
+
+      xrange = all_cells ? xrangefull : [xrangefull[0], xrangefull[-1]].uniq
+      yrange = all_cells ? yrangefull : [yrangefull[0], yrangefull[-1]].uniq
+      xrange.each do |x|
+        yrange.each do |y|
+          m = context_click(x, y, 0)
+          expect(m).to eq(menu_exp)
+        end
+      end
+    end
+  end
+
+  def validate_grid(gn)
+    grid = Marty::DataGrid.mcfly_pt('infinity').find_by(name: 'DataGrid' + gn)
+    fix = 'spec/fixtures/misc'
+    exp_data = JSON.parse(File.read("#{fix}/grid#{gn}_final_data.json"))
+    expect(grid.data).to eq(exp_data)
+    exp_meta = JSON.parse(File.read("#{fix}/grid#{gn}_final_meta.json"))
+    grid_meta = grid.metadata.map do |md|
+      [md['dir'], md['attr'], md['keys']]
+    end.sort
+    expect(grid_meta).to eq(exp_meta)
+  end
+
+  it 'dg editor' do
+    log_in_as('marty')
+    go_to_data_grids
+    dgv = netzke_find('data_grid_view')
+    grids = dgv.get_col_vals('name', 5)
+    context_test_all = ENV['DG_FEATURE_QUICK'] != 'true'
+    [['edit_all', context_test_all],
+     ['edit_data', false],
+     ['view', false]].each do |perm, all_cells|
+      grids.each do |grid|
+        Marty::Config['grid_edit_edit_perm'] = perm
+        Marty::Config['grid_edit_save_perm'] = perm
+        pos = grids.index(grid) + 1
+        dgv.select_row(pos)
+        press('Edit Grid')
+        wait_for_ajax
+        check_grid(grid, perm, all_cells)
+        expect(page).not_to have_content('Save') if perm == 'view'
+        press('Cancel')
+        wait_for_ajax
+      end
+    end
+    Marty::Config['grid_edit_edit_perm'] = 'edit_all'
+    Marty::Config['grid_edit_save_perm'] = 'edit_all'
+
+    # now test some editing, saving, and cancel logic
+    get_latest = lambda do
+      Marty::DataGrid.mcfly_pt('infinity').find_by(name: 'DataGrid5')
+    end
+    grid = get_latest.call
+    grid.constraint = '>=0<200'
+    grid.save!
+    pos = grids.index('DataGrid5') + 1
+    dgv.select_row(pos)
+    press('Edit Grid')
+    wait_for_ajax
+    # test saving and validation etc
+    grid_setup
+    cell_edit(2, 3, 'abc')
+    cell_edit(3, 3, '250')
+    press('Save')
+    expect(page).to have_content('error: some entries failed constraint or '\
+                                 'data type check')
+    press('OK')
+    colors = get_grid(to_get: :colors)
+    qtips = get_grid(to_get: :qtips)
+    expect(colors[3][2]).to eq('rgb(255, 177, 129)')
+    expect(colors[3][3]).to eq('rgb(255, 129, 129)')
+    expect(qtips[3][2]).to eq('failed type check')
+    expect(qtips[3][3]).to eq('failed constraint check')
+    expect(qtips[0][0]).to eq(false)
+    expect(qtips[0][2]).to eq('mortgage_type')
+    expect(qtips[1][2]).to eq('PLST')
+    expect(qtips[3][0]).to eq('property_state')
+    expect(qtips[3][1]).to eq('property_county_name')
+
+    grid_setup
+    cell_edit(2, 3, '123.456')
+    cell_edit(3, 3, '1.1')
+
+    cell_edit(2, 2, 'yo')
+    press('Save')
+    expect(page).to have_content('error: bad range yo')
+    press('OK')
+    cell_edit(2, 2, '>=1')
+
+    cell_edit(2, 0, 'xyz')
+    press('Save')
+    expect(page).to have_content('error: instance xyz of Gemini::MortgageType'\
+                                 ' not found')
+    press('OK')
+    cell_edit(2, 0, 'Conventional')
+
+    cell_edit(0, 3, 'xyz')
+    press('Save')
+    expect(page).to have_content("error: no such Gemini::EnumState: 'xyz'")
+    press('OK')
+    cell_edit(0, 3, 'AK')
+
+    press('Save')
+    wait_for_ajax
+    grid = get_latest.call
+    expect(grid.data[0][0]).to eq(123.456)
+    press('Edit Grid')
+    wait_for_ajax
+
+    colors = get_grid(to_get: :colors)
+    qtips = get_grid(to_get: :qtips)
+    expect(colors[3][2]).to eq('')
+    expect(colors[3][3]).to eq('')
+    expect(qtips[3][2]).to eq(false)
+    expect(qtips[3][2]).to eq(false)
+
+    # each time we change the grid, grid_setup needs to ask
+    # JS for the updated grid info
+    grid_setup
+    cell_edit(2, 3, '0.0')
+    press('Cancel')
+    exp = 'You are closing a window that has unsaved changes'
+    expect(page).to have_content(exp)
+    press('No')
+    find(:xpath, ".//div[contains(@class,'x-tool-close')]").click
+    exp = 'You are closing a window that has unsaved changes'
+    expect(page).to have_content(exp)
+    press('No')
+    press('Cancel')
+    exp = 'You are closing a window that has unsaved changes'
+    expect(page).to have_content(exp)
+    press('Yes')
+    grid = get_latest.call
+    expect(grid.data[0][0]).to eq(123.456)
+
+    press('Edit Grid')
+    wait_for_ajax
+    grid_setup
+    context_click(1, 9, 1, click: true)
+    grid_setup
+    ['AR', 'Abc', 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11].each_with_index do |v, idx|
+      cell_edit(idx, 10, v)
+    end
+    context_click(5, 12, 0, click: true)
+    grid_setup
+    ['TN', 'Xyz', 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1].each_with_index do |v, idx|
+      cell_edit(idx, 12, v)
+    end
+    context_click(5, 5, 2, click: true)
+    grid_setup
+    (['FHA', nil, '<1'] + [100] * 11).each_with_index do |v, idx|
+      cell_edit(5, idx, v) if v
+    end
+    context_click(13, 1, 3, click: true)
+    grid_setup
+    (['VA', nil, '>5'] + [100] * 11).each_with_index do |v, idx|
+      cell_edit(14, idx, v)
+    end
+    grid_setup
+    context_click(2, 4, 4, click: true)
+    grid_setup
+    context_click(2, 1, 5, click: true)
+    wait_for_ajax
+    press('Save')
+    wait_for_ajax
+    sleep 1
+    validate_grid('5')
+
+    pos = grids.index('DataGrid2') + 1
+    dgv.select_row(pos)
+    begin
+      press('Edit Grid')
+      press('Edit Grid')
+    rescue StandardError => e # rubocop:disable Lint/HandleExceptions
+    end
+    wait_for_ajax
+    grid_setup
+    context_click(2, 3, 2, click: true)
+    grid_setup
+    ['99', 'StrNew', 'StrNew2', 'Strnew3', 'StrNew4', 'StrNew5',
+     '>10000000<11000000', '12345'].each_with_index do |v, idx|
+      cell_edit(2, idx, v)
+    end
+    press('Save')
+    sleep 1
+    validate_grid('2')
+
+    pos = grids.index('DataGrid1') + 1
+    dgv.select_row(pos)
+    begin
+      press('Edit Grid')
+      press('Edit Grid')
+    rescue StandardError => e # rubocop:disable Lint/HandleExceptions
+    end
+    wait_for_ajax
+    grid_setup
+    cell_edit(7, 2, '11111')
+    context_click(3, 4, 1, click: true)
+    ['5|4', 'Abc', 'Def', 'QQQ', 'ZZZ', 'AAA', '>5000011<6000000', 765].
+      each_with_index do |v, idx|
+      cell_edit(idx, 5, v)
+    end
+    press('Save')
+    sleep 1
+    validate_grid('1')
+
+    Marty::Config['grid_edit_save_perm'] = 'view'
+    pos = grids.index('DataGrid5') + 1
+    dgv.select_row(pos)
+    count = 1
+    begin
+      press('Edit Grid')
+      wait_for_ajax
+      grid_setup
+      cell_edit(2, 3, '123.456')
+    rescue StandardError => e
+      if count > 0
+        sleep 1
+        retry
+      end
+      count -= 1
+    end
+    press('Save')
+    errexp = 'error: save_grid: entered with view permissions'
+    expect(page).to have_content(errexp)
+    press('OK')
+    wait_for_ajax
+    context_click(2, 4, 4, click: true)
+    Marty::Config['grid_edit_save_perm'] = 'edit_data'
+    press('Save')
+    errexp = 'error: save_grid: grid modification not allowed'
+    expect(page).to have_content(errexp)
+    exp_log = JSON.parse(File.read('spec/fixtures/misc/grid_log_errs.json'))
+    got = Marty::Log.all.select(:message, :details).attributes.map do |l|
+      newl = l.except('id')
+      newl['details'].delete('rec_id')
+      newl
+    end
+    cmp = struct_compare(got, exp_log)
+    expect(cmp).to be_falsey
+  end
+end