dragging multiple rows change physical data layer

Author: ddooley

lib/DataHarmonizer.js

@@ -261,36 +261,60 @@ class DataHarmonizer {
             remove_row: {
               name: 'Remove row',
               callback() {
-                // Enables removal of a row and all dependent table rows.
-                // If there are 1-many cascading deletes, verify if that's ok.
-                let selection = self.hot.getSelected()[0][0];
-                let [change_report, change_message] = self.getChangeReport(self.template_name);
-                if (!change_message.length) {
-                  self.hot.alter('remove_row', selection);
-                  return true;
+                // Collect every selected visual row from all selection ranges
+                // (user may have Ctrl-clicked non-contiguous rows or dragged a block).
+                const selectedRanges = self.hot.getSelected() || [];
+                const visualRowSet = new Set();
+                for (const [r1, , r2] of selectedRanges) {
+                  const lo = Math.min(r1, r2);
+                  const hi = Math.max(r1, r2);
+                  for (let r = lo; r <= hi; r++) visualRowSet.add(r);
                 }
-               /*
-               * For deletes: (For now, ignore duplicate root key case: If 
-               * encountering foreign key involving root_class slot, test if that has
-               * > 1 row. If so, delete ok without examining other dependents.)
-               */
-
-                // Some cascading deletes to confirm here.
-                if (
-                  confirm(
-                    'WARNING: If you proceed, this will include deletion of one\n or more dependent records, and this cannot be undone:\n' +
-                      change_message
-                  )
-                ) {
-                  // User has seen the warning and has confirmed ok to proceed.
-                  for (let [dependent_name, dependent_obj] of Object.entries(change_report)) {
-                    if (dependent_obj.rows?.length) {
-                      // rows are physical (source) indices. Delete via source-data reload
-                      // so hidden rows are also removed without needing toVisualRow().
-                      self.context.crudDeleteRowsByPhysical(dependent_name, dependent_obj.rows);
+                const visualRows = [...visualRowSet].sort((a, b) => a - b);
+                const rowsToDelete = [];
+
+                for (let i = 0; i < visualRows.length; i++) {
+                  const vRow = visualRows[i];
+
+                  // Point HOT's selection at this row so crudGetDependentKeyVals
+                  // reads its primary-key values when building the change report.
+                  self.hot.selectCell(vRow, 0, vRow, 0, false);
+                  const [change_report, change_message] = self.getChangeReport(self.template_name);
+
+                  if (!change_message.length) {
+                    // No cascading dependents — safe to delete without prompting.
+                    rowsToDelete.push(vRow);
+                  } else {
+                    /*
+                     * For deletes: (For now, ignore duplicate root key case: If
+                     * encountering foreign key involving root_class slot, test if
+                     * that has > 1 row. If so, delete ok without examining other
+                     * dependents.)
+                     */
+                    const rowLabel = visualRows.length > 1
+                      ? `row ${i + 1} of ${visualRows.length}`
+                      : 'this row';
+                    if (confirm(
+                      `WARNING: Deleting ${rowLabel} will also delete dependent records and cannot be undone:\n${change_message}`
+                    )) {
+                      // rows are physical (source) indices. Delete via source-data
+                      // reload so hidden rows are also removed without toVisualRow().
+                      for (const [dependent_name, dependent_obj] of Object.entries(change_report)) {
+                        if (dependent_obj.rows?.length) {
+                          self.context.crudDeleteRowsByPhysical(dependent_name, dependent_obj.rows);
+                        }
+                      }
+                      rowsToDelete.push(vRow);
                     }
-                  };
-                  self.hot.alter('remove_row', selection); 
+                    // If the user cancels this row it is skipped; remaining rows
+                    // in the selection continue to be processed.
+                  }
+                }
+
+                // Delete confirmed primary rows in descending visual order so
+                // earlier indices are not shifted by later removals.
+                for (const vRow of rowsToDelete.sort((a, b) => b - a)) {
+                  self.hot.alter('remove_row', vRow);
                 }
               },
             },
@@ -379,7 +403,7 @@ class DataHarmonizer {
                 // Hide if no locales
                 const current_row = schema.current_selection[0];
                 if (current_row === null || current_row === undefined || current_row < 0)
-                  return false;
+                  return true;
                 const locales = schema.hot.getCellMeta(current_row, 0).locales;
                 return !locales;
               },
@@ -688,7 +712,11 @@ class DataHarmonizer {
               if (Object.keys(self.invalid_cells).length === 0) {
                 $(`#tab-bar-${self.template_name} > a`).removeClass('tab-has-errors');
                 $('#next-error-button').hide();
-                $('#no-error-button').show().delay(5000).fadeOut('slow');
+                // Only show "No errors" if the user actually fixed a previously
+                // invalid cell — not when editing a cell that was already valid.
+                if (prevInvalidChangedCells.length > 0) {
+                  $('#no-error-button').show().delay(5000).fadeOut('slow');
+                }
               }
               // Track cells that became valid (for picker/dropdown Tab navigation in beforeKeyDown).
               const firstFixed = prevInvalidChangedCells.find(
@@ -838,6 +866,24 @@ class DataHarmonizer {
           }
         },
 
+        // Commit drag-and-drop row reordering into the underlying source data.
+        // manualRowMove only updates the visual→physical index mapping; calling
+        // loadData with the rows read in visual order resets the mapper so
+        // physical order matches what the user sees.
+        afterRowMove: (movedRows, finalIndex, dropIndex, movePossible, orderChanged) => {
+          if (!orderChanged) return;
+          const count = self.hot.countSourceRows();
+          const reordered = [];
+          for (let vRow = 0; vRow < count; vRow++) {
+            const physRow = self.hot.toPhysicalRow(vRow);
+            if (physRow !== null) {
+              reordered.push([...self.hot.getSourceDataAtRow(physRow)]);
+            }
+          }
+          self.invalid_cells = {}; // physical row indices will reset; stale cache must be cleared
+          self.hot.loadData(reordered);
+        },
+
         // Reposition the validation status bar tooltip when the table scrolls
         // so it stays aligned with the focused cell even after a column shift.
         afterScrollHorizontally: () => self._updateStatusBar(),
@@ -1718,6 +1764,16 @@ class DataHarmonizer {
       }
 
       switch (slot.datatype) {
+        case 'xsd:boolean':
+          // Only use native checkbox for pure boolean fields. Fields that also
+          // have vocabulary sources (e.g. NullValueField mixed with boolean)
+          // remain key-value-list so their picklist values are preserved.
+          if (!slot.sources) {
+            col.type = 'checkbox';
+            col.checkedTemplate = true;
+            col.uncheckedTemplate = false;
+          }
+          break;
         case 'xsd:date':
           col.type = 'dh.date';
           col.allowInvalid = true; // making a difference?
@@ -2533,6 +2589,21 @@ class DataHarmonizer {
    */
   matrixFieldChangeRules(matrix) {
     Object.entries(this.slots).forEach((field, col) => {
+      // Convert string boolean values to native JS booleans for xsd:boolean
+      // checkbox cells. Fields that also have vocabulary sources (e.g. NullValueField)
+      // remain key-value-list and store string values instead.
+      if (this.slots[col].datatype === 'xsd:boolean' && !this.slots[col].sources) {
+        for (let row = 0; row < matrix.length; row++) {
+          const val = matrix[row][col];
+          if (val === null || val === undefined || val === '') continue;
+          if (typeof val === 'string') {
+            const lower = val.toLowerCase();
+            if (lower === 'true' || lower === '1') matrix[row][col] = true;
+            else if (lower === 'false' || lower === '0') matrix[row][col] = false;
+          }
+        }
+      }
+
       // Test field against capitalization change.
       if (field.capitalize) {
         for (let row = 0; row < matrix.length; row++) {
@@ -2785,6 +2856,21 @@ class DataHarmonizer {
             cellChanges.push([row, col, cellVal, 'prevalidation']);
           }
 
+          // Normalise string booleans to JS booleans for checkbox cells only.
+          // Skip fields with vocabulary sources (e.g. NullValueField); those
+          // remain as strings handled by validateValAgainstVocab below.
+          if (datatype === 'xsd:boolean' && !field.sources && typeof cellVal === 'string' && cellVal !== '') {
+            const lower = cellVal.toLowerCase();
+            let canonical = null;
+            if (lower === 'true' || lower === '1') canonical = true;
+            else if (lower === 'false' || lower === '0') canonical = false;
+            if (canonical !== null) {
+              cellVal = canonical;
+              data[row][col] = cellVal;
+              cellChanges.push([row, col, canonical, 'prevalidation']);
+            }
+          }
+
           if (cellVal && datatype === 'xsd:token' && typeof cellVal === 'string') {
             // console.log("valdation", cellVal)
             const minimized = cellVal
@@ -2829,14 +2915,21 @@ class DataHarmonizer {
         }
       }
       if (cellChanges.length) {
-        console.log(
-          'doPreValidationRepairs: setDataAtCell and afterChange Hook'
-        );
-        this.hot.addHookOnce('afterChange', resolve);
-        this.hot.setDataAtCell(cellChanges, 'validation');
-      } else {
-        resolve();
+        // Update HOT source data directly to avoid setDataAtCell's internal
+        // rendering machinery (done/getCell callbacks), which crashes for HOT
+        // instances in hidden tabs whose viewport calculator has never been
+        // initialized. getSourceData() returns the internal reference, so
+        // modifying it updates HOT's state without triggering rendering hooks.
+        const sourceData = this.hot.getSourceData();
+        for (const [vRow, col, val] of cellChanges) {
+          const pRow = this.hot.toPhysicalRow(vRow);
+          if (pRow !== null && sourceData[pRow]) {
+            sourceData[pRow][col] = val;
+          }
+        }
+        this.hot.render();
       }
+      resolve();
     });
   }