marty 2.9.3 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9dcf52a2940fd4cdfa856cf82c2d77dd2ed9536b88d192addfed0d1ab3a9a9d0
-  data.tar.gz: 8becb3090ad127df9823f11f1fa4b8719a22f1401cf6e02f6121c11e650e99c2
+  metadata.gz: 46bed6f3169beec2514318a672e7b116ef0031f679f774cb51bb14dc9fa935fd
+  data.tar.gz: 74d430112df6bdf70bf9fa91d0efae7fbba4a0de08d53cb8f6cc9ab0d8029945
 SHA512:
-  metadata.gz: 50b7892041ea4f9d4ff6a63f982f29e7edeff67f313fa241b36d24fe18df79126f6d8caaa2ace032696c629f188413be9023e2582403951a5835ce83e448e7d1
-  data.tar.gz: f0fe264a2c2150ca4e85d30f2592d65c75f9fab66cad38307007361dd9b3eda7c1ca21c0cc5fa25bc70cf86d4c50182d32d150b0f37dd1f5f7cc92baf1f0f4fe
+  metadata.gz: 8ba1fa3171e1887fe79331dcb623ef1936557e16b238117c84c3b6dff4d0b519db0596f64e0dd4fa4ec08bd2703e715c3d21bcf6d5d11c8cb46d1d4e1991a46d
+  data.tar.gz: cdf887a7e66c5ce77f9c23f6467460d6b71b74f2e146fa7c7e1bfe79ad6d5534803a9930221376101683df68e360c0f30aba75072a7574c641fab4252210f818

data/.gitlab-ci.yml

@@ -36,15 +36,16 @@ cache:
     - vendor/ruby
 
 variables:
-  GIT_SSL_NO_VERIFY: "true"
   BUNDLER_VERSION: "2.0.1"
+  DOCKER_AUTH_CONFIG: '{ "credsStore": "ecr-login" }'
+  GIT_SSL_NO_VERIFY: "true"
+  HEADLESS: "true"
+  HEADLESS_WINDOW_SIZE: "1400,1400"
+  PGTZ: "America/Los_Angeles"
   POSTGRES_USER: "runner"
   POSTGRES_PASSWORD: ""
   RAILS_ENV: "test"
   RAILS_DUMP_SCHEMA: "false"
-  PGTZ: "America/Los_Angeles"
-  HEADLESS: "true"
-  HEADLESS_WINDOW_SIZE: "1400,1400"
   REPOSITORY_URL: '415596832415.dkr.ecr.us-west-2.amazonaws.com/cm_tech/docker-ruby-ci-image'
-  DOCKER_AUTH_CONFIG: '{ "credsStore": "ecr-login" }'
+  RSPEC_AUTO_RETRY_JS: "true"
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    marty (2.9.3)
+    marty (2.10.0)
       aws-sigv4 (~> 1.0, >= 1.0.2)
       axlsx (= 3.0.0pre)
       coderay

data/app/components/marty/data_grid_view.rb

@@ -62,9 +62,27 @@ module Marty; class DataGridView < McflyGridPanel
     javascript
   end
 
+  def self.edit_grid_js(options = {})
+    dg        = options[:data_grid] || 'data_grid'
+    title_str = options[:title_str] || 'Data Grid'
+
+    javascript = l(<<-JS)
+    function() {
+       var sel = this.getSelectionModel().getSelection()[0];
+       var record_id = sel && sel.getId();
+       this.server.editGrid({record_id: record_id,
+                            data_grid: "#{dg}",
+                            title_str: "#{title_str}"});
+    }
+    JS
+    javascript
+  end
+
   client_class do |c|
+    c.include :data_grid_edit
     c.netzke_show_grid        = DataGridView.show_grid_js
     c.netzke_client_show_grid = DataGridView.client_show_grid_js
+    c.netzke_edit_grid        = DataGridView.edit_grid_js
   end
 
   def configure(c)
@@ -79,6 +97,7 @@ module Marty; class DataGridView < McflyGridPanel
         :hcols,
         :lenient,
         :data_type,
+        :constraint,
         :created_dt,
       ]
 
@@ -123,6 +142,12 @@ module Marty; class DataGridView < McflyGridPanel
     a.handler  = :netzke_show_grid
   end
 
+  action :edit_grid do |a|
+    a.text     = 'Edit Grid'
+    a.icon_cls = 'fa fa-th-large glyph'
+    a.handler  = :netzke_edit_grid
+  end
+
   endpoint :show_grid do |params|
     record_id = params[:record_id]
 
@@ -143,8 +168,42 @@ module Marty; class DataGridView < McflyGridPanel
     client.netzke_client_show_grid maxcount, res, 'Data Grid'
   end
 
+  # placeholders for grid editing permission logic.
+  # for now, this allows the rspec to control the permission
+  def self.get_edit_edit_permission
+    Marty::Config['grid_edit_edit_perm'] || 'edit_all'
+  end
+
+  def self.get_edit_save_permission
+    Marty::Config['grid_edit_save_perm'] || 'edit_all'
+  end
+
+  endpoint :edit_grid do |params|
+    record_id = params[:record_id]
+
+    dg = DataGrid.find_by_id(record_id)
+
+    return client.netzke_notify('No data grid.') unless dg
+
+    meta_rows_raw, h_key_rows, data_rows = dg.export_array
+    res = h_key_rows + data_rows
+
+    md = dg.metadata
+    hdim = md.map { |m| m['dir'] == 'h' && m['attr'] }.select { |v| v }
+    vdim = md.map { |m| m['dir'] == 'v' && m['attr'] }.select { |v| v }
+    hdim_en = hdim.map { |d| I18n.t('attributes.' + d, default: d) }
+    vdim_en = vdim.map { |d| I18n.t('attributes.' + d, default: d) }
+    name = "Editing Data Grid '#{dg.name}'"
+    permission = Marty::DataGridView.get_edit_edit_permission
+    client.edit_grid(record_id, hdim_en, vdim_en, res, name, permission)
+  end
+
+  endpoint :save_grid do |params|
+    SaveGrid.call(params)
+  end
+
   def default_bbar
-    [:show_grid] + super
+    [:show_grid, :edit_grid] + super
   end
 
   def default_context_menu
@@ -172,6 +231,10 @@ module Marty; class DataGridView < McflyGridPanel
     c.width = 120
   end
 
+  attribute :constraint do |c|
+    c.width = 100
+  end
+
   attribute :hcols do |c|
     c.label  = 'Horizontal Attrs'
     c.width  = 200

data/app/components/marty/data_grid_view/client/data_grid_edit.js

@@ -0,0 +1,550 @@
+{
+    createStoreAndColumns:
+    function(data, hdim, vdim, hcol, vcol, extra_attrs) {
+        var fields = [];
+        var columns = [];
+        for (var i=0; i< data[0].length; i++) {
+            fields.push("a" + i);
+            columns.push({dataIndex: "a" + i, text: i,
+                          sortable: false,
+                          editor: 'textfield',
+                          renderer: function(value, meta) {
+                              var hlen = hdim.length,
+                                  vlen = vdim.length,
+                                  row = meta.rowIndex,
+                                  col = meta.column.fullColumnIndex;
+                              if (extra_attrs[row][col]) {
+                                  meta.tdStyle = extra_attrs[row][col][0]
+                                  meta.tdAttr = Ext.String.format('data-qtip="{0}"',
+                                                                  extra_attrs[row][col][1]);
+                              }
+                              if (row < hlen && col >= vlen)
+                              {
+                                  meta.tdStyle = hcol[row];
+                                  meta.tdAttr = Ext.String.format('data-qtip="{0}"',
+                                                                  hdim[row]);
+                              }
+                              if (col < vlen && row >= hlen)
+                              {
+                                  meta.tdStyle = vcol[col];
+                                  meta.tdAttr = Ext.String.format('data-qtip="{0}"',
+                                                                  vdim[col]);
+                              }
+
+                              return value;
+                          },
+                          autoSizeColumn: true});
+        }
+        var thestore = Ext.create('Ext.data.ArrayStore', {
+            fields: fields,
+            data: data,
+        });
+        return [columns, thestore];
+    },
+    editGrid:
+    function(record_id, hdim, vdim, data, title_str, permission) {
+        var colors = [
+
+            'background-color: #FFA1A1;',
+            'background-color: #FF9D5C;',
+            'background-color: #A1A1FF;',
+            'background-color: #FFFFA1;',
+            'background-color: #A1FFFF;',
+            'background-color: #FFA1FF;',
+            'background-color: #A1A187;',
+            'background-color: #D1FFD1;',
+            'background-color: #FFD1D1;',
+            'background-color: #FF9D7C;',
+            'background-color: #D1D1FF;',
+            'background-color: #FFFFD1;',
+            'background-color: #D1FFFF;',
+            'background-color: #FFD1FF;',
+            'background-color: #D1D1B7;',
+        ];
+        var hcol = [];
+        var vcol = [];
+        
+        var me = this;
+        // setup colors for hdims
+        for (var i=0; i<hdim.length; i++)
+            hcol[i] = colors.pop();
+        // setup colors for vdims
+        for (var i=0; i<vdim.length; i++)
+            vcol[i] = colors.pop();
+        var columns, thestore;
+
+        var createArray = function (length) {
+            var arr = new Array(length || 0),
+                i = length;
+
+            if (arguments.length > 1) {
+                var args = Array.prototype.slice.call(arguments, 1);
+                while(i--) arr[length-1 - i] = createArray.apply(this, args);
+            }
+
+            return arr;
+        };
+        
+        var extra_attrs = createArray(data.length, data[0].length);
+
+        [columns, thestore] = this.createStoreAndColumns(data, hdim, vdim, hcol, vcol, extra_attrs);
+
+        var dirty = false;
+        var setDirty = function() { dirty = true; };
+        var getDirty = function() { return dirty; };
+        var me = this;
+        var dataUpdate = function(grid, modFunc) {
+            var store_data = grid.getStore().data.items;
+            var newcolumns, newstore;
+            var mod_data = [];
+            modFunc(store_data, mod_data);
+            var extra_attrs = createArray(mod_data.length, mod_data[0].length);
+            [newcolumns, newstore] = me.createStoreAndColumns(mod_data, hdim, vdim, hcol, vcol, extra_attrs);
+            grid.reconfigure(newstore, newcolumns);
+            Ext.each(grid.getColumns(), function(column) {
+                column.autoSize();
+            });
+            setDirty();
+        };
+        var insertRow = function(inData, outData, rowIdx, up) {
+            var width = inData[0].fields.length -1
+            var newa = Array.apply(null, Array(width)).map(function () { return ""; });
+            var target = up ? rowIdx : rowIdx + 1;
+            for (var i=0; i<= inData.length; ++i) {
+                if (i == target) {
+                    outData.push(newa);
+                }
+                if (i < inData.length) {
+                    var row = [];
+                    for (const [key, value] of Object.entries(inData[i].data)) {
+                        if (key != 'id') row.push(value);
+                    }
+                    outData.push(row);
+                }
+            }
+        };
+        var insertCol = function(inData, outData, colIdx, left) {
+            var target = left ? colIdx : colIdx + 1
+            var row_width = inData[0].fields.length;
+            for (var i=0; i< inData.length; ++i) {
+                var row = [];
+                var idx = 0;
+                for (const [key, value] of Object.entries(inData[i].data)) {
+                    if (idx == target) row.push(null);
+                    if (key != 'id') row.push(value);
+                    ++idx;
+                }
+                if (target == row_width) row.push(null);
+                outData.push(row);
+            }
+        };
+        var deleteRow = function(inData, outData, rowIdx) {
+            for (var i=0; i< inData.length; ++i) {
+                if (i != rowIdx) {
+                    var row = [];
+                    for (const [key, value] of Object.entries(inData[i].data)) {
+                        if (key != 'id')
+                            row.push(value);
+                    }
+                    outData.push(row);
+                }
+            }
+        };
+        var deleteCol = function(inData, outData, colIdx) {
+            for (var i=0; i< inData.length; ++i) {
+                var row = [];
+                var idx = 0;
+                for (const [key, value] of Object.entries(inData[i].data)) {
+                    if (idx != colIdx && key != 'id')
+                        row.push(value);
+                    ++idx;
+                }
+                outData.push(row);
+            }
+        };
+        var lookup_grid = function () {
+            return Ext.ComponentQuery.query('grid').find(function(v) {
+                return v.name=='data_grid_edit_grid'
+            });
+        };
+        var lookup_win = function () {
+            return Ext.ComponentQuery.query('window').find(function(v) {
+                return v.name=='data_grid_edit_window'
+            });
+        };
+        var insertRowAboveAction = Ext.create('Ext.Action', {
+            text: 'Insert Row Above',
+            handler: function(widget , event) {
+                var grid = lookup_grid();
+                dataUpdate(grid, function(data, mod_data) {
+                    insertRow(data, mod_data, widget.position.row, true);
+                });
+            }
+        });
+        var insertRowBelowAction = Ext.create('Ext.Action', {
+            text: 'Insert Row Below',
+            handler: function(widget , event) {
+                var grid = lookup_grid();
+                dataUpdate(grid, function(data, mod_data) {
+                    insertRow(data, mod_data, widget.position.row, false);
+                });
+            }
+        });
+        var insertColLeftAction = Ext.create('Ext.Action', {
+            text: 'Insert Column Left',
+            handler: function(widget , event) {
+                var grid = lookup_grid();
+                dataUpdate(grid, function(data, mod_data) {
+                    insertCol(data, mod_data, widget.position.col, true);
+                });
+            }
+        });
+        var insertColRightAction = Ext.create('Ext.Action', {
+            text: 'Insert Column Right',
+            handler: function(widget , event) {
+                var grid = lookup_grid();
+                dataUpdate(grid, function(data, mod_data) {
+                    insertCol(data, mod_data, widget.position.col, false);
+                });
+            }
+        });
+        var deleteRowAction = Ext.create('Ext.Action', {
+            text: 'Delete Row',
+            handler: function(widget , event) {
+                var grid = lookup_grid();
+                dataUpdate(grid, function(data, mod_data) {
+                    deleteRow(data, mod_data, widget.position.row);
+                });
+            }
+        });
+        var deleteColAction = Ext.create('Ext.Action', {
+            text: 'Delete Column',
+            handler: function(widget , event) {
+                var grid = lookup_grid();
+                dataUpdate(grid, function(data, mod_data) {
+                    deleteCol(data, mod_data, widget.position.col);
+                });
+            }
+        });
+        var itemContextMenu = Ext.create('Ext.menu.Menu' , {
+            items: [insertRowAboveAction, insertRowBelowAction, insertColLeftAction,
+                    insertColRightAction, deleteRowAction, deleteColAction]
+        });
+
+        // Selection Models
+        var spSel = Ext.create("Ext.grid.selection.SpreadsheetModel", {
+            cellSelect: true,
+            columnSelect: true,
+            rowSelect: false,
+            extensible: true,
+            mode: "MULTI"
+        });
+
+        var get_area = function(row, col) {
+            var row_hdim = row < hdim.length,
+                row_vdim = col < vdim.length;
+
+            var a;
+            if (row_hdim && row_vdim)
+                a = 'blank_area';
+            else if (!row_hdim && !row_vdim)
+                a = 'data_area';
+            else if (row_hdim && !row_vdim)
+                a = 'hdim_area';
+            else a = 'vdim_area';
+            return a;
+        };
+
+        var can_edit  = function(row, col) {
+            var area = get_area(row, col);
+            if (area == 'blank_area')
+                return false;
+            if (area == 'data_area')
+                return permission != 'view';
+            if (area == 'vdim_area' || area == 'hdim_area')
+                return permission == 'edit_all';
+        }
+
+        // Plugins
+        var cellEditor = Ext.create("Ext.grid.plugin.CellEditing", {
+
+            clicksToEdit: 2,
+            listeners: {
+                beforeedit: function(editor, context, eOpts) {
+                    if (!can_edit(context.rowIdx, context.colIdx))
+                        return false;
+                },
+                afteredit: function() {
+                    setDirty();
+                }
+            }
+        });
+
+        var context_disable_fn = function(menu, label, x, y, fn) {
+            var mi = menu.items.items.find(function (mi) {
+                return mi.text == label;
+            });
+            if (fn(x, y))
+                mi.enable();
+            else
+                mi.disable();
+        };
+        // check to see if menu item should be enabled based on row, col
+        var row_menu_chk = function (row, col) {
+            var area =  get_area(row, col);
+            if (vdim.length == 0)
+                return false;
+            return (area == 'vdim_area' || area == 'data_area') &&
+                permission == 'edit_all';
+        };
+        var col_menu_chk = function (row, col) {
+            var area =  get_area(row, col);
+            if (hdim.length == 0)
+                return false;
+            return (area == 'hdim_area' || area == 'data_area') &&
+                permission == 'edit_all';
+        };
+        var disable_conds = [
+            ['Insert Row Above',    row_menu_chk],
+            ['Insert Row Below',    row_menu_chk],
+            ['Delete Row',          row_menu_chk],
+            ['Insert Column Left',  col_menu_chk],
+            ['Insert Column Right', col_menu_chk],
+            ['Delete Column',       col_menu_chk]
+        ];
+        Ext.define('DGEdit.grid.plugin.Clipboard',{
+            override: 'Ext.grid.plugin.Clipboard',
+            beforepaste: Ext.emptyFn,
+            mixins: [
+                'Ext.mixin.Observable'
+            ],
+            constructor: function(config) {
+                var me = this;
+
+                me.callParent([config]);
+                me.mixins.observable.constructor.call(me);
+            },
+            privates : {
+                onPaste: function (keyCode, event) {
+                    var me = this,
+                        sharedData = me.shared.data,
+                        source = me.getSource(),
+                        i, n, s,
+                        rowIdx = event.position.rowIdx,
+                        colIdx = event.position.colIdx;
+                    if (!can_edit(rowIdx, colIdx))  {
+                        return;
+                    }
+                    if (me.fireEvent('beforepaste',keyCode,event,me.cmp) !== false) {
+                        if (source) {
+                            for (i = 0, n = source.length; i < n; ++i) {
+                                s = source[i];
+                                if (s === 'system') {
+                                    // get the format used by the system clipboard.
+                                    s = me.getSystem();
+                                    me.pasteClipboardData(s);
+                                    break;
+                                } else if (sharedData && (s in sharedData)) {
+                                    me.doPaste(s, sharedData[s]);
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        });
+        Ext.define('DGEditController', {
+            extend : 'Ext.app.ViewController',
+            alias: 'controller.dataGridEdit',
+            onBeforePaste:function(keyCode,event,grid){
+                return false;
+            }
+        });
+        Ext.tip.Tip.prototype.minWidth = void 0;
+        Ext.tip.QuickTipManager.init();
+        var grid = {
+            xtype:       'grid',
+            name:        'data_grid_edit_grid',
+            border:      false,
+            hideHeaders: false,
+            autoEncode: true,
+            controller: 'dataGridEdit',
+            columns:     columns,
+            scrollable: true,
+            anchor: '100% 100%',
+            forceFit: true,
+            store:       thestore,
+            hideHeaders: true,
+            columnLines: true,
+            plugins: [cellEditor,
+                      {
+                          ptype: 'clipboard',
+                          system: 'raw',
+              //            listeners: {
+               //               beforepaste: 'onBeforePaste'
+                //          }
+                      }],
+            selModel: spSel,
+            listeners: {
+                containercontextmenu: function(view, e) {
+                    e.preventDefault();
+                },
+                contextmenu: function(e, element, options) {
+                    e.preventDefault();
+                },
+                itemcontextmenu: function(view, record, item, index, e) {
+                    e.stopEvent();
+                    var items = itemContextMenu.items.items;
+                    var ctn    = items.length;
+                    var y = e.position.colIdx;
+                    var x = e.position.rowIdx;
+                    for (var i=0; i<ctn; ++i) {
+                        items[i].position = {col: y, row: x};
+                    }
+                    for (const [label, fn] of disable_conds) {
+                        context_disable_fn(itemContextMenu, label, x, y, fn);
+                    }
+                    itemContextMenu.showAt(e.getXY());
+                },
+
+            }
+        };
+        var fbsave = {
+                    text: 'Save',
+                    handler: function () {
+                        this.up('window').submit();
+                    }};
+        var fbcancel = {
+                    text: 'Cancel',
+                    handler: function () {
+                        this.up('window').close();
+                    }};
+        var fbar = permission == 'view' ?
+            [fbcancel] : [fbsave, fbcancel];
+
+        Ext.create('Ext.Window', {
+            name: 'data_grid_edit_window',
+            height:        "90%",
+            width:         "90%",
+            x:             100,
+            y:             100,
+            autoWidth:     true,
+             modal:         true,
+            autoScroll:    true,
+            title:         title_str,
+            layout: 'anchor',
+            items: grid,
+            submit: function() {
+                Ext.getBody().mask('Saving data...').setZIndex(99999).setStyle('cursor', 'wait');
+                var grid = Ext.ComponentQuery.query('grid').find(function(v) {
+                    return v.name=='data_grid_edit_grid'
+                });
+                var server = me.server;
+
+                if (getDirty() || grid.getStore().getModifiedRecords().length > 0) {
+                    var store = grid.getStore().data.items;
+                    var ret = [];
+
+                    for (var i = 0; i < store.length; ++i) {
+                        var row = {};
+
+                        var col_idx = 0;
+
+                        // or remove label fields we added in top left
+                        var col_null = i < hdim.length ? vdim.length : 0;
+
+                        for (const [key, value] of Object.entries(store[i].data)) {
+                            if (key != 'id') {
+                                if (col_idx < col_null)
+                                    row[key] = "";
+                                else
+                                    row[key] = value;
+                            }
+                            col0_skip = false;
+                            col_idx++;
+                        }
+                        ret.push(row);
+                    }
+                    server.saveGrid({record_id: record_id, data: ret}, function(res) {
+                        if (res) {
+                            if (res['errorMessage']) {
+                                Ext.MessageBox.show({
+                                    title:'Error in data',
+                                    msg: 'error: ' + res['errorMessage'],
+                                    buttons: Ext.Msg.OK
+                                });
+                            } else if (res['problemArray']) {
+                                Ext.MessageBox.show({
+                                    title:'Error in data',
+                                    msg: 'error: some entries failed constraint or data type check',
+                                    buttons: Ext.Msg.OK
+                                });
+                                for (const [type, x, y] of res['problemArray']) {
+                                    var real_x = vdim.length + x,
+                                        real_y = hdim.length + y;
+                                    if (type == 'constraint')
+                                        extra_attrs[real_y][real_x] = ['background-color: #FF8181;','failed constraint check'];
+                                    else if (type == 'type')
+                                        extra_attrs[real_y][real_x] = ['background-color: #FFB181;','failed type check'];
+                                }
+                                grid.getView().refresh();
+                            }
+                        }
+                        else
+                        {
+                            var win = lookup_win();
+                            win.destroy();
+                        }
+                        Ext.getBody().unmask();
+                    });
+                }
+                else
+                {
+                    Ext.getBody().unmask();
+                    Ext.MessageBox.show({
+                        title:'Nothing to Save',
+                        msg: 'No changes made',
+                        buttons: Ext.Msg.OK
+                    });
+                }
+            },
+            closeAction: 'destroy',
+            listeners: {
+                beforeclose: function (win) {
+                    var grid = lookup_grid();
+                    if(win.closeMe) {
+                        win.closeMe = false;
+                        grid.destroy();
+                        return true;
+                    }
+                    if (getDirty() || grid.getStore().getModifiedRecords().length > 0) {
+                        Ext.MessageBox.show({
+                            title:'Discard Changes?',
+                            msg: 'You are closing a window that has unsaved changes. Are you sure?',
+                            buttons: Ext.Msg.YESNO,
+                            icon: Ext.Msg.QUESTION,
+                            callback: function(btn) {
+                                if('yes' === btn) {
+                                    win.closeMe = true;
+                                    win.close();
+                                }
+                            }
+                        });
+                        return false;
+                    }
+                    grid.destroy();
+                    return true;
+                }
+            },
+            fbar: fbar
+        }).show();
+        var gridobj = Ext.ComponentQuery.query('grid').find(function(v) {
+            return v.name=='data_grid_edit_grid'
+        });
+        Ext.each(gridobj.getColumns(), function(column) {
+            column.autoSize();
+            column.setWidth(column.getWidth()+20);
+        });
+    }
+}