Revising row edit behavour

Processing data grid changes as batch per row.

Author: ddooley

lib/AppContext.js

@@ -526,29 +526,34 @@ export default class AppContext {
     const hiddenRowsPlugin = hotInstance.getPlugin('hiddenRows');
 
     // Ensure all rows are visible
-    const oldHiddenRows = hiddenRowsPlugin.getHiddenRows()
+    const oldHiddenRows = hiddenRowsPlugin.getHiddenRows();
+    // arrayRange() makes [0, ... n]
+    let rowsToHide = arrayRange(0, hotInstance.countSourceRows());
 
     //Fetch key-values to match
     const parents = this.crudGetParents(class_name);
     let [required_selections, errors] = this.crudGetForeignKeyValues(parents);
 
-    // arrayRange() makes [0, ... n]
-    let rowsToHide = arrayRange(0, hotInstance.countSourceRows()) // countSourceRows?
-    .filter((row) => {
-      for (let [slot_name, value] of Object.entries(required_selections)) {
-        const col = this.dhs[class_name].getColumnIndexByFieldName(slot_name);
-        const cellValue = hotInstance.getDataAtCell(row, col);
-        if (cellValue != value)
-          return true;
-      }
-    });
-
-    if (rowsToHide != oldHiddenRows) {
+    // FUTURE: may be able to specialize to hide display based on particular 
+    // parent(s) keys?
+    if (errors.length == 0) {
+      rowsToHide = rowsToHide.filter((row) => {
+        for (let [slot_name, value] of Object.entries(required_selections)) {
+          const col = this.dhs[class_name].getColumnIndexByFieldName(slot_name);
+          const cellValue = hotInstance.getDataAtCell(row, col);
+          // Null value test in case where parent or subordinate field is null.
+          if (cellValue != value)
+            return true;
+        }
+      });
+    }
+    // Make more efficient using Set() difference comparison?
+    //if (rowsToHide != oldHiddenRows) {
       //Future: make more efficient by switching state of show/hide deltas?
       hiddenRowsPlugin.showRows(oldHiddenRows); 
       hiddenRowsPlugin.hideRows(rowsToHide); // Hide the calculated rows
       hotInstance.render(); // Render the table to apply changes
-    }
+    //}
   }
 
   /* Here we deal with adding rows that need foreign keys.  Locate each foreign
@@ -621,7 +626,8 @@ export default class AppContext {
      *    isn't unique, then no deletions should take place in child table, and
      *    no need to report an error. 
      *    Dependent may depend on more than one table, but regarding deletion,
-     *    values of foreign keys to other tables don't matter.
+     *    values of foreign keys to other tables can be taken as a separate
+     *    deletion case to consider?
      *
      * 2) Report back how many deletions would occur (often all that are
      *    visible, since child table record visibility would be tuned to 
@@ -672,14 +678,31 @@ export default class AppContext {
     return (do_delete || found_dependent_rows == false) ? false : warning_text;
   }
 
+  /* Looks for 2nd instance of row containing keyVals, returns that row or
+   * null if not found.  PROBABLY NOT USEFUL since our work on changing or 
+   * adding unique_key fields tests for keys BEFORE user change, i.e. just
+   * finding one existing key is enough to halt operation.
+   */
+  crudFindDuplicate(dh, keyVals) {
+    let found_row = this.crudFindByKeyVals(dh, keyVals);
+    // Looking for another record besides parent being deleted.
+    //if (!found_row)
+    //  return null;
+    //console.log(found_row)
+    return this.crudFindByKeyVals(dh, keyVals, found_row+1);
+  }
 
+  /* Looks for row (starting from 0 by default) containing given keyVals.
+   * returns null if not found.
+   * ISSUE: This isn't using indexes on tables, so not very efficient.
+   */
   crudFindByKeyVals(dh, keyVals, row = 0) {
     const total_rows = dh.hot.countSourceRows(); // .countSourceRows();
     while (row < total_rows) {
       // .every() causes return on first break
       if (Object.entries(keyVals).every(([slot_name, value]) => {
-          const col = dh.getColumnIndexByFieldName(slot_name); // map to col#
-          return (value == dh.hot.getDataAtCell(row,col));
+          const col = dh.getColumnIndexByFieldName(slot_name);
+          return (value == dh.hot.getDataAtCell(row, col));
         })
       )
         break; 
@@ -719,8 +742,4 @@ export default class AppContext {
     });
   }
 
-  
-
-
-
 }

lib/DataHarmonizer.js

@@ -210,8 +210,6 @@ class DataHarmonizer {
     )
       .filter(
         ([cls_key]) =>
-          //cls_key !== 'dh_interface' &&
-          //cls_key !== 'Container' &&
           cls_key === this.class_assignment
       )
       .reduce((acc, [, spec]) => {
@@ -720,6 +718,15 @@ class DataHarmonizer {
               self.addRows('insert_row_above', 1, parseInt(self.hot.getSelected()[0][0])+1);
             },
           },
+          {
+            key: 'change_primary_key',
+            name: 'Change primary key',
+            callback: function () {
+              let entry = prompt("Enter new value for this primary key field, or press Cancel");
+              alert("Coming soon...")
+
+            },
+          },
         ],
         outsideClickDeselects: false, // for maintaining selection between tabs
         manualColumnResize: true,
@@ -743,30 +750,159 @@ class DataHarmonizer {
         // REEXAMINE ABOVE assumption now that setDataAtCell() problem solved.
         invalidCellClassName: '',
         licenseKey: 'non-commercial-and-evaluation',
-        // beforeChange source: https://handsontable.com/docs/8.1.0/tutorial-using-callbacks.html#page-source-definition
-        beforeChange: function (changes) {
-          if (!changes) {
+
+        /* Changes = array of [row, column, old value (incl. undefined), new 
+         * value (incl. null)].  NOTE: Cut & paste can include 2 or more 
+         * changes in different columns on a row, or on multiple rows, so we 
+         * need to validate 1 row at a time. Row_change data structure enables
+         * this.
+         */
+        beforeChange: function (grid_changes) {
+          // beforeChange source: https://handsontable.com/docs/8.1.0/tutorial-using-callbacks.html#page-source-definition
+
+          if (!grid_changes) { // Can this ever happen here?
             return;
           }
 
-          // When a change in one field triggers a change in another field.
-          let triggered_changes = [];
+          /* row_change is a tacitly ordered dict of row #s.
+           * {[row]: {[slot_name]: {old_value: _, value: _} } }
+           */
+          let row_change = {}; 
+          for (const change of grid_changes) {
+            let slot = self.slots[change[1]];
+            if (!(change[0] in row_change)) {
+              row_change[change[0]] = {};
+            }
+            row_change[change[0]][slot.name] = {
+              slot: slot,
+              col: change[1], 
+              old_value: change[2], 
+              value: change[3]
+            };
+          }
 
-          for (const change of changes) {
+          // Validate each row of changes
+          for (const row in row_change) {
+            let changes = row_change[row];
+
+            /* Change request cancelled (sudden death) if user tries to change
+             * an identifier (unique key) value but this would result in a 
+             * duplicate key.
+             */
+            for (const slot_name in changes) {
+              let change = changes[slot_name];
+              if (change.slot.identifier == true && change.value != null) {
+                // Look for collision with an existing row's column value.
+                // Change hasn't been implemented yet so we won't run into 
+                // change's row.
+                let search_row = self.context.crudFindByKeyVals(self, {[slot_name]: change.value});
+                if (search_row && search_row != row) {
+                  alert(`Skipping change on row ${parseInt(row)+1} because this would create a duplicate key! Check:\n\n * [${slot_name}] change to "${change.value}"\n`);
+                  return false;
+                }
+              }
+            }
+
+            /* 
+             * If a class has more than one slot in its unique_key then multiple 
+             * changes to key must be tested for duplicates as well as multiple
+             * possible impacts on dependent tables.
+             *
+             * NOTE: user can be updating one field of a primary key; neets to 
+             * be able to edit it in incomplete form.   
+             *
+             * Determine if change(s) (including cut & paste changes to more
+             * than one slot) contribute to a complete unique_key, and if so 
+             * test if there's a duplication of that key. If key slot data entry
+             * is unfinished, then no need to throw error.
+             * Requires that we iterate through class's unique_keys list,
+             * seeing if any new column (changes[0]) value (changes[3]) pertains
+             * to one. If so, test to see if key has a value.  If no value,
+             * then skip key, otherwise test new key uniqueness.
+             *
+             * Additional case: turning a component of a unique key into null
+             * in itself doesn't necessarily trigger anything other than a 
+             * validation error on that construct when user presses "Validate".
+             * Note: Validator.js validate() also has step for applying the
+             * doUniquenessValidation() method on unique_key_slots.
+             *
+             * However, any field being used as the target of a foreign key of
+             * another table, if it had a value and that changes, leaving no
+             * other key with the same value that foreign table key could use
+             * in its place, necessitates a cancel of that operation.  
+             *
+             * Only route to making a change to a unique key is in the 
+             * "change_primary_key" right-click menu option above.
+             *
+             *  [class]: {
+             *    "unique_keys": {
+             *      "grdisample_id": {
+             *        "unique_key_name": "grdisample_id",
+             *        "unique_key_slots": [
+             *          "sample_collector_sample_id"
+             *        ],
+             */
+            // FUTURE slot_ptr version of self.context.relations for efficiency.
+            let this_class = self.schema.classes[self.template_name];
+            for (let key_name in this_class?.unique_keys) {
+              var key_obj = this_class.unique_keys[key_name];
+              var keyVals = {};
+              var change_log = '';
+              // If change doesn't pertain to any index slots then keyVals remains empty.
+              if ( Object.entries(key_obj.unique_key_slots).every(([index, slot_name]) => {
+                // Key has a changed value (incl. null?), so update it.
+                if (slot_name in changes) {
+                  let change = changes[slot_name];
+                  change_log += `* [${slot_name}] change to "${change.value}"\n`
+                  keyVals[slot_name] = change.value;
+                  return true;
+                }
+                else {
+                  let col = self.getColumnIndexByFieldName(slot_name);
+                  let value = self.hot.getDataAtCell(row, col);
+                  if (value != null) {
+                    keyVals[key_name] = value;
+                    return true;
+                  }
+                }
+
+                // Key value hasn't changed, and is missing a value, so 
+                // unique_key is not established, so user's change can go
+                // through.
+                return false;
+              }) ) {
+                // Here we have complete unique_keys entry to test for duplication
+                let duplicate_row = self.context.crudFindByKeyVals(self, keyVals);
+                // There is a matching row so fail this action.
+                if (duplicate_row && duplicate_row != row) {
+                  alert(`Your change cannot be completed because it would lead to a primary key [${key_name}] duplicate on row ${parseInt(row)+1}! Check:\n\n ${change_log}`);
+                  return false;
+                };
+              } // end if of keyVals construction.
+            } // end forEach of unique_keys
+
+          } // end of row in row_change
+
+          let triggered_changes = [];
+          for (const change of grid_changes) {
+            // When a change in one field triggers a change in another field.
             // Check field change rules
-            self.fieldChangeRules(change, fields, triggered_changes);
+            self.fieldChangeRules(change, self.slots, triggered_changes);
           }
           // Add any indirect field changes onto end of existing changes.
           if (triggered_changes) {
-            changes.push(...triggered_changes);
+            grid_changes.push(...triggered_changes);
           }
         },
         afterSelection: (row, column, row2, column2) => {
           if (self.current_selection[0] != row) {
-            // Row has changed so possibly values that make up some other 
-            // table's foreign key has changed, so that table's view should
-            // be refreshed. Dependent tables determine what parent foreign 
-            // key values they need to filter view by.
+            /* ASSUMPTION: only 1st row counts for relevant row in dependent
+             * table views.
+             * Row has changed so possibly values that make up some other 
+             * table's foreign key has changed, so that table's view should
+             * be refreshed. Dependent tables determine what parent foreign 
+             * key values they need to filter view by.
+             */
             this.context.crudFilterDependentViews(this.template_name);
           };
 
@@ -2163,7 +2299,6 @@ class DataHarmonizer {
   }
 
   getInferredIndexSlot() {
-    // using the 1-m DH?
     if (this.class_assignment) {
       return this.class_assignment;
     }