Merge pull request #27 from Alex-At-Home/content-trigger

[self] Split content_change into content_change and control_change

Author: Alex-At-Home

.gitignore

@@ -1,2 +1 @@
-elastic-sheets-project/*
-elastic-sheets-share/*
+elastic-sheets-*/*

src/frontend/data-models/DataExplorerTemplate.js

@@ -117,7 +117,7 @@ var DataExplorerTemplate =
          }
       }
    },
-   "trigger": "content_change",
+   "trigger": "control_change",
    "sql_table": {
       "enabled": false,
       "query": "--SHOW TABLES\n--DESCRIBE $$index\n--SELECT * FROM $$index WHERE $$query $$pagination"

src/frontend/managers/elasticsearchManager.js

@@ -56,6 +56,21 @@ var ElasticsearchManager = (function(){
     }).getElasticsearchMetadata()
   }
 
+  /** Util method to check if ES is configured to make requests */
+  function getEsReadiness(esMeta, onReadyCallback, onNotReadyCallback) {
+    var esEnabled = esMeta.hasOwnProperty("enabled") ? esMeta.enabled : true
+    esMeta.enabled = esEnabled //(ensure always present)
+    var esConfigured = esMeta.url ? true : false
+    var esUnauthorized = esEnabled &&
+      (("password" == esMeta.auth_type) && ("" == esMeta.password))
+
+    if (esEnabled && esConfigured && !esUnauthorized) {
+      onReadyCallback(esMeta)
+    } else {
+      onNotReadyCallback(esMeta)
+    }
+  }
+
   ////////////////////////////////////////////////////////
 
   // Internals
@@ -100,15 +115,32 @@ var ElasticsearchManager = (function(){
 
   /** Launches an ES client operation */
   function performGenericOperation(tableName, tableConfig, operationLogicFn, trigger, testMode) {
+     var onReady = function(obj) {
+       operationLogicFn(tableName, tableConfig, obj, ClientState_.getOrBuildClient(obj.es_meta), testMode)
+     }
      google.script.run.withSuccessHandler(function(obj) {
-        if (obj && (obj.es_meta.enabled || true)) { //(null used to return error which server has already handled)
-           //TODO: all sorts of works still to be done on auth
-           if (("password" == obj.es_meta.auth_type) && ("" == obj.es_meta.password)) {
-              google.script.run.launchElasticsearchConfig()
+       if (obj) getEsReadiness(obj.es_meta || {},
+         function(esMeta) { // ready
+           onReady(obj)
+         },
+         function(esMeta) { // not ready
+           if (testMode) { // this is fine, carry on
+             onReady(obj)
            } else {
-              operationLogicFn(tableName, tableConfig, obj, ClientState_.getOrBuildClient(obj.es_meta), testMode)
+             if ("manual" == trigger) {
+               if (esMeta.enabled) { //(password or URL missing)
+                 google.script.run.launchElasticsearchConfig()
+               } else {
+                 Util.showStatus("This table's ES connection is disabled")
+               }
+             } else {
+               delete esMeta.password //(eg if URL removed but password present)
+               //(will only happen if user unsets authentication after launching table builder)
+               console.log("Authorization not configured for ES: [" + JSON.stringify(esMeta) + "]")
+             }
            }
-        }
+         }
+       ) //(if obj is null, there's been a server-side error which has already been reported)
      }).withFailureHandler(function(obj) {
        if ("manual" == trigger) { //TODO: move this into Util.showStatus
          Util.showStatus("Failed to retrieve ES metadata: [" + JSON.stringify(obj) + "]")
@@ -385,12 +417,14 @@ var ElasticsearchManager = (function(){
   /** Checks whether a requested re-populate is desired */
   function isTriggerEnabled_(tableConfig, trigger) {
     //(copy paste from ElasticsearchService.handleContentUpdates.isTriggerEnabled)
-    var tableTrigger = tableConfig.trigger || "content_change"
+    var tableTrigger = tableConfig.trigger || "control_change"
     switch(trigger) {
       case "manual":
         return (tableTrigger != "disabled")
       case "config_change":
         return (tableTrigger != "disabled") && (tableTrigger != "manual")
+      case "control_change":
+        return (tableTrigger == "control_change") || (tableTrigger == "content_change")
       case "content_change":
         return (tableTrigger == "content_change")
       default:
@@ -404,8 +438,11 @@ var ElasticsearchManager = (function(){
     populateTable: populateTable,
     retrieveIndexPatternFields: retrieveIndexPatternFields,
 
+    getEsReadiness: getEsReadiness,
+
     TESTONLY: {
-      convertFieldFilterToSource_: convertFieldFilterToSource_
+      convertFieldFilterToSource_: convertFieldFilterToSource_,
+      isTriggerEnabled_: isTriggerEnabled_
     }
   }
 

src/frontend/managers/tableListManager.js

@@ -147,6 +147,12 @@ var TableListManager = (function() {
   /** Timer interval */
   var timerInterval_ = 5000 //(ms)
 
+  /** Latched when ES is seen to have been configured */
+  var esAuthConfigured_ = false
+
+  /** Latched first time we log that ES isn't configured */
+  var esAuthConfiguredLog_ = false
+
   /** At desired interval, checks if any tables need refreshing */
   function onTableRefresh_() {
 
@@ -157,23 +163,50 @@ var TableListManager = (function() {
     }
 
     // Get tables in need of refresh:
-    google.script.run.withSuccessHandler(function(obj) {
-      try {
-        Object.entries(obj).map(function(kv) {
-          var tableConfig = State_.getEntryByName(kv[0])
-          if (tableConfig) {
-            tableConfig = tableConfig.temp ? tableConfig.temp : tableConfig
-            ElasticsearchManager.populateTable(kv[0], tableConfig, kv[1], /*testMode*/false)
-          }
-        })
-      } catch (err) {
-        throw err
-      } finally {
+    var lookForTriggeredTables = function() {
+      google.script.run.withSuccessHandler(function(obj) {
+        try {
+          Object.entries(obj).map(function(kv) {
+            var tableConfig = State_.getEntryByName(kv[0])
+            if (tableConfig) {
+              tableConfig = tableConfig.temp ? tableConfig.temp : tableConfig
+              ElasticsearchManager.populateTable(kv[0], tableConfig, kv[1], /*testMode*/false)
+            }
+          })
+        } catch (err) {
+          throw err
+        } finally {
+          scheduleNextRefresh()
+        }
+      }).withFailureHandler(function(err) {
         scheduleNextRefresh()
-      }
-    }).withFailureHandler(function(err) {
-      scheduleNextRefresh()
-    }).listTriggeredTables()
+      }).listTriggeredTables()
+    }
+
+    if (esAuthConfigured_) {
+      lookForTriggeredTables()
+    } else {
+      // Very simple logic to stop unconfigured ES from stealing triggers
+      //(of course it's still very easy to steal triggers, just not quite as inadvertently)
+      google.script.run.withSuccessHandler(function(obj) {
+        if (obj) ElasticsearchManager.getEsReadiness(obj.es_meta || {},
+          function(esMeta) { // ready
+            esAuthConfigured_ = true //(no longer check until table builder reloaded)
+            lookForTriggeredTables()
+          },
+          function(esMeta) { // not ready
+            if (!esAuthConfiguredLog_) {
+              delete esMeta.password //(avoid leaking to logs if URL is not configured)
+              console.log(`ES not configured [${JSON.stringify(esMeta)}], will keep checking until it is`)
+              esAuthConfiguredLog_ = true
+            }
+            scheduleNextRefresh()
+          }
+        )
+      }).withFailureHandler(function(obj) {
+        console.log("Failed to retrieve ES metadata: [" + JSON.stringify(obj) + "]")
+      }).getElasticsearchMetadata()
+    }
   }
 
   var State_ = (function() {

src/frontend/view-models/sidebarAppGeneralEditor.js

@@ -32,6 +32,7 @@ var GeneralEditor = (function(){
     <option value='disabled'>Disabled</option>
     <option value='manual'>Manual</option>
     <option value='config_change'>Config Change</option>
+    <option value='control_change'>Control Change</option>
     <option value='content_change'>Content Change</option>
     </select>
     </div>
@@ -100,7 +101,7 @@ var GeneralEditor = (function(){
   function populate(index, name, json, tableType) {
 
     // Trigger:
-    var trigger = json.trigger || "content_change"
+    var trigger = json.trigger || "control_change"
     $(`#trigger_${tableType}_${index}`).val(trigger)
 
     // Query bar

src/server/Code.gs

@@ -17,7 +17,7 @@ function onInstall() { return UiService_.onOpen() }
 
 /** Edit trigger */
 function onEdit(e) {
-  return ElasticsearchService_.handleContentUpdates(e.range, /*triggerOverride*/null)
+  return ElasticsearchService_.handleContentUpdates(e, /*triggerOverride*/null)
 }
 
 /** Allows for UI to launch a full screen dialog showing the query that would be launched */
@@ -184,5 +184,6 @@ function buildEsSubTable(subTableCell, configOverride) {
 
 /** Triggers a refresh of the table that is currently "under the cursor" */
 function refreshSelectedTable() {
-  return ElasticsearchService_.handleContentUpdates(SpreadsheetApp.getActiveRange(), "manual")
+  var event = { range: SpreadsheetApp.getActiveRange() }
+  return ElasticsearchService_.handleContentUpdates(event, "manual")
 }

src/server/models/ElasticsearchMetaModel.gs

@@ -9,6 +9,6 @@ var esMetaModel_ = {
    "header_json": {}, //key, value map
    "client_options_json": {}, //(passed directly to ES client)
    "enabled": true,
-   "query_trigger": "timed_content", //"none", "timed_config", "timed_content"
+   "query_trigger": "timed_content", //"none", "timed_config", "timed_control", "timed_content"
    "query_trigger_interval_s": 5
 }

src/server/models/TableModel.gs

@@ -1,6 +1,6 @@
 /** The default table config - also using to sort-of-document the model */
 var defaultTableConfig_ = {
-  "trigger": "content_change", //OR "disabled", "manual", "config_change", content_change" - later  "timed"
+  "trigger": "control_change", //OR "disabled", "manual", "config_change", control_change", "content_change" (timed will be separate param)
   "common": {
 //     "refresh": {
 //        "on_query_change": true,

src/server/services/ElasticsearchService.gs

@@ -20,7 +20,7 @@ var ElasticsearchService_ = (function() {
   // 2] Pre-request logic
 
   /** Update the status field of tables that have changed */
-  function markTableAsPending(tableName) {
+  function markTableAsPending(tableName, message) {
     try {
       var savedObjects = ManagementService_.listSavedObjects(/*discardRange*/false)
       var tableConfig = savedObjects[tableName]
@@ -32,8 +32,11 @@ var ElasticsearchService_ = (function() {
         var tableRange = TableRangeUtils_.findTableRange(ss, tableName)
         if (tableRange) {
           var range = tableRange.getRange()
-          var statusInfo = "AWAITING REFRESH [" + TableRangeUtils_.formatDate() + "]"
-          var tableMeta = ElasticsearchRequestUtils_.buildTableOutline(tableName, tableConfig, range, statusInfo, /*testMode*/false)
+          var statusMessage = message || "AWAITING REFRESH"
+          var statusInfo = statusMessage + " [" + TableRangeUtils_.formatDate() + "]"
+          var tableMeta = ElasticsearchRequestUtils_.buildTableOutline(
+            tableName, tableConfig, range, statusInfo, /*testMode*/false
+          )
         }
       }
     } catch (err) {} //(fire and forget, just for display)
@@ -50,6 +53,11 @@ var ElasticsearchService_ = (function() {
         return { "es_meta": esInfo }
      }
 
+     // If ES is enavled we're not going to do anything to the table:
+     if ((false == esInfo.enabled) || !esInfo.url) {
+       testMode = true
+     }
+
      // Table metadata/validation
 
      // Revalidate range:
@@ -262,37 +270,88 @@ var ElasticsearchService_ = (function() {
   }
 
   /** Trigger for edit */
-  function handleContentUpdates(range, triggerOverride) {
+  function handleContentUpdates(event, triggerOverride) {
     //(copy paste from ElasticsearchManager.isTriggerEnabled_)
     var isTriggerEnabled = function(tableConfig, trigger) {
-      var tableTrigger = tableConfig.trigger || "content_change"
+      var tableTrigger = tableConfig.trigger || "control_change"
       switch(trigger) {
         case "manual":
           return (tableTrigger != "disabled")
         case "config_change":
           return (tableTrigger != "disabled") && (tableTrigger != "manual")
+        case "control_change":
+          return (tableTrigger == "control_change") || (tableTrigger == "content_change")
         case "content_change":
           return (tableTrigger == "content_change")
         default:
           return true
       }
     }
-    var trigger = triggerOverride || "content_change"
     var triggerPolicy = ManagementService_.getEsTriggerPolicy()
-    if (!triggerOverride && ("timed_content" != triggerPolicy)) {
-      return
+    var canBeTriggeredByContentChange =
+      ("timed_control" == triggerPolicy) || ("timed_content" == triggerPolicy)
+    if (!triggerOverride && !canBeTriggeredByContentChange) {
+      return -1
     }
-    var matchingTables = TableService_.findTablesIntersectingRange(range)
+    var updatedTables = 0
+    var matchingTables = TableService_.findTablesIntersectingRange(event.range, /*addRange*/true)
     Object.keys(matchingTables).forEach(function(matchingTableName) {
+      //TODO: also need to handle 2-way sync regardless of table trigger
       var tableConfig = matchingTables[matchingTableName]
-      tableConfig = tableConfig.temp ? tableConfig.temp : tableConfig
-      if (isTriggerEnabled(tableConfig, trigger)) {
+      var activeRange = tableConfig.activeRange
+      delete tableConfig.activeRange //(remove extra non-standard field)
+      tableConfig = tableConfig.temp ? tableConfig.temp : tableConfig //(use current version, not saved)
+
+      // Logic to determine if a table edit hits the control cells (query/page)
+      var isControlEvent = function() {
+        // Check metadata to see if it's a control or content change
+        var retVal = ElasticsearchRequestUtils_.buildTableOutline(
+          matchingTableName, tableConfig, activeRange, "", /*testMode*/true
+        )
+        var offsets = [ "query_offset", "page_info_offset" ]
+        var modifiedOffsets = offsets
+          .filter(function(offset) {
+            return retVal.hasOwnProperty(offset)
+          })
+          .filter(function(offset) {
+            var newRange = activeRange.offset(
+              retVal[offset].row - 1, retVal[offset].col - 1, 1, 1
+            )
+            return TableRangeUtils_.doRangesIntersect(event.range, newRange)
+          })
+
+        if (modifiedOffsets.length > 0) {
+          if (modifiedOffsets.indexOf("query_offset") >= 0) { //query has changed...
+            //...if the page is hand specified, reset to 1
+            if (retVal.page_info_offset) {
+              var pageRange = activeRange.offset(
+                retVal.page_info_offset.row - 1, retVal.page_info_offset.col - 1, 1, 1
+              )
+              if (!pageRange.getFormulaR1C1()) {
+                pageRange.setValue(1)
+              }
+            }
+          }
+          return true
+        } else {
+          return false
+        }
+      }
+      var triggerToUse = triggerOverride ?
+        triggerOverride :
+        (isControlEvent() ? "control_change" : "content_change")
+
+      if (isTriggerEnabled(tableConfig, triggerToUse)) {
         markTableAsPending(matchingTableName)
         ManagementService_.setSavedObjectTrigger(
-          matchingTableName, trigger
+          matchingTableName, triggerToUse
         )
-      }
-    })
+        updatedTables++
+      } else if ("disabled" != tableConfig.trigger) { // Just note the table has been changed
+        markTableAsPending(matchingTableName, "HAND EDITED")
+      }//(if the table is disabled, do nothing)
+    })//(end loop over intersecting tables)
+    return updatedTables
   }
 
   ////////////////////////////////////////////////////////

src/server/services/ManagementService.gs

@@ -164,7 +164,12 @@ var ManagementService_ = (function(){
             case "manual":
               trigger = "manual" //nothing can overwrite manual (except "")
               break
-            case "config_change": //(everything except data_change overwrites)
+            case "config_change": //(everything except control/content_change overwrites)
+              trigger =
+                (("control_change" == trigger) || ("content_change" == trigger))
+                  ? curr : trigger
+              break
+            case "control_change": //(everything except content_change overwrites)
               trigger = ("content_change" == trigger) ? curr : trigger
               break
             default: //("" or "content_change" - always update)