updated ext format

app/assets/javascripts/app/frontend/controllers/header.js

@@ -49,7 +49,7 @@ angular.module('app.frontend')
 
     this.selectedAction = function(action, extension) {
       action.running = true;
-      extensionManager.executeAction(action, extension, function(response){
+      extensionManager.executeAction(action, extension, null, function(response){
         action.running = false;
         apiController.sync(null);
       })

app/assets/javascripts/app/frontend/models/app/extension.js

@@ -1,25 +1,45 @@
 class Action {
   constructor(json) {
       _.merge(this, json);
-
       this.running = false; // in case running=true was synced with server since model is uploaded nondiscriminatory
-      this.actionVerb = this.type;
+  }
 
-      var comps = this.type.split(":");
-      if(comps.length > 1) {
-
-        this.actionType = comps[0]; // 'watch', 'poll', or 'all'
-        this.repeatable = this.actionType == "watch" || this.actionType == "poll";
-        this.actionVerb = comps[1]; // http verb : "get", "post", "show"
-        this.repeatFrequency = comps[2];
+  get permissionsString() {
+    if(!this.permissions) {
+      return "";
+    }
+    var permission = this.permissions.charAt(0).toUpperCase() + this.permissions.slice(1); // capitalize first letter
+    permission += ": ";
+    for(var contentType of this.content_types) {
+      if(contentType == "*") {
+        permission += "All items";
+      } else {
+        permission += contentType;
       }
+
+      permission += " ";
+    }
+
+    return permission;
   }
 
-  structureContentTypes() {
-    return this.structures.map(function(structure){
-      return structure.type;
-    })
+  get encryptionModeString() {
+    if(this.verb != "post") {
+      return null;
+    }
+    var encryptionMode = "This action accepts data ";
+    if(this.accepts_encrypted && this.accepts_decrypted) {
+      encryptionMode += "encrypted or decrypted.";
+    } else {
+      if(this.accepts_encrypted) {
+        encryptionMode += "encrypted.";
+      } else {
+        encryptionMode += "decrypted.";
+      }
+    }
+    return encryptionMode;
   }
+
 }
 
 class Extension extends Item {
@@ -30,6 +50,12 @@ class Extension extends Item {
       this.content_type = "Extension";
   }
 
+  actionsInGlobalContext() {
+    return this.actions.filter(function(action){
+      return action.context == "global";
+    })
+  }
+
   mapContentToLocalProperties(contentObject) {
     super.mapContentToLocalProperties(contentObject)
     this.name = contentObject.name;

app/assets/javascripts/app/services/apiController.js

@@ -234,6 +234,8 @@ angular.module('app.frontend')
           return this.createRequestParamsForItem(item, options.additionalFields);
         }.bind(this));
 
+        console.log("syncing items", request.items);
+
         if(this.syncToken) {
           request.sync_token = this.syncToken;
         }
@@ -271,10 +273,14 @@ angular.module('app.frontend')
         return this.paramsForItem(item, !item.isPublic(), additionalFields, false);
       }
 
-      this.paramsForExternalUse = function(item) {
+      this.paramsForExportFile = function(item) {
         return _.omit(this.paramsForItem(item, false, ["created_at", "updated_at"], true), ["deleted"]);
       }
 
+      this.paramsForExtension = function(item, encrypted) {
+        return _.omit(this.paramsForItem(item, encrypted, ["created_at", "updated_at"], true), ["deleted"]);
+      }
+
       this.paramsForItem = function(item, encrypted, additionalFields, forExportFile) {
         var itemCopy = _.cloneDeep(item);
 
@@ -381,7 +387,7 @@ angular.module('app.frontend')
         }.bind(this);
 
         var items = _.map(modelManager.allItemsMatchingTypes(["Tag", "Note"]), function(item){
-          return this.paramsForExternalUse(item);
+          return this.paramsForExportFile(item);
         }.bind(this));
 
         var data = {

app/assets/javascripts/app/services/extensionManager.js

@@ -5,9 +5,13 @@ class ExtensionManager {
       this.modelManager = modelManager;
       this.apiController = apiController;
       this.enabledRepeatActionUrls = JSON.parse(localStorage.getItem("enabledRepeatActionUrls")) || [];
+      this.decryptedExtensions = JSON.parse(localStorage.getItem("decryptedExtensions")) || [];
 
       modelManager.addItemSyncObserver("extensionManager", "Extension", function(items){
         for (var ext of items) {
+
+          ext.encrypted = this.extensionUsesEncryptedData(ext);
+
           for (var action of ext.actions) {
             if(this.enabledRepeatActionUrls.includes(action.url)) {
               this.enableRepeatAction(action, ext);
@@ -27,6 +31,24 @@ class ExtensionManager {
     }
   }
 
+  extensionUsesEncryptedData(extension) {
+    return !this.decryptedExtensions.includes(extension.url);
+  }
+
+  changeExtensionEncryptionFormat(encrypted, extension) {
+    if(encrypted) {
+      _.pull(this.decryptedExtensions, extension.url);
+    } else {
+      this.decryptedExtensions.push(extension.url);
+    }
+
+    localStorage.setItem("decryptedExtensions", JSON.stringify(this.decryptedExtensions))
+
+    extension.encrypted = this.extensionUsesEncryptedData(extension);
+
+    console.log("ext with dec", this.decryptedExtensions);
+  }
+
   addExtension(url) {
     this.retrieveExtensionFromServer(url, null);
   }
@@ -72,28 +94,42 @@ class ExtensionManager {
     }
   }
 
-  executeAction(action, extension, callback) {
+  executeAction(action, extension, item, callback) {
 
-    if(action.type == "get") {
-      this.Restangular.oneUrl(action.url, action.url).get().then(function(response){
-        console.log("Execute action response", response);
-        var items = response.items;
-        this.modelManager.mapResponseItemsToLocalModels(items);
-        callback(items);
-      }.bind(this))
-    }
+    switch (action.verb) {
+      case "get": {
+        this.Restangular.oneUrl(action.url, action.url).get().then(function(response){
+          console.log("Execute action response", response);
+          var items = response.items;
+          this.modelManager.mapResponseItemsToLocalModels(items);
+          callback(items);
+        }.bind(this))
 
-     else if(action.type == "show") {
-      var win = window.open(action.url, '_blank');
-      win.focus();
-      callback();
-    }
+        break;
+      }
 
-     else if(action.actionType == "all") {
-      var allItems = this.modelManager.allItemsMatchingTypes(action.structureContentTypes());
-      this.performPost(action, allItems, function(items){
-        callback(items);
-      });
+      case "show": {
+        var win = window.open(action.url, '_blank');
+        win.focus();
+        callback();
+      }
+
+      case "post": {
+        var items;
+        if(action.all) {
+          items = this.modelManager.allItemsMatchingTypes(action.content_types);
+        } else {
+          items = [item];
+        }
+
+        this.performPost(action, extension, items, function(items){
+          callback(items);
+        });
+      }
+
+      default: {
+
+      }
     }
 
     action.lastExecuted = new Date();
@@ -105,8 +141,10 @@ class ExtensionManager {
 
   disableRepeatAction(action, extension) {
     console.log("Disabling action", action);
+
     _.pull(this.enabledRepeatActionUrls, action.url);
     this.modelManager.removeItemChangeObserver(action.url);
+
     console.assert(this.isRepeatActionEnabled(action) == false);
   }
 
@@ -118,16 +156,22 @@ class ExtensionManager {
       localStorage.setItem("enabledRepeatActionUrls", JSON.stringify(this.enabledRepeatActionUrls));
     }
 
-    if(action.repeatType == "watch") {
-      for(var structure of action.structures) {
-        this.modelManager.addItemChangeObserver(action.url, structure.type, function(changedItems){
-          this.triggerWatchAction(action, changedItems);
+    if(action.repeat_mode) {
+
+      if(action.repeat_mode == "watch") {
+        this.modelManager.addItemChangeObserver(action.url, action.content_types, function(changedItems){
+          this.triggerWatchAction(action, extension, changedItems);
         }.bind(this))
       }
+
+      if(action.repeat_mode == "loop") {
+        // todo
+      }
+
     }
   }
 
-  queueAction(action, delay, changedItems) {
+  queueAction(action, extension, delay, changedItems) {
     this.actionQueue = this.actionQueue || [];
     if(_.find(this.actionQueue, action)) {
       return;
@@ -137,23 +181,19 @@ class ExtensionManager {
 
     setTimeout(function () {
       console.log("Performing queued action", action);
-      this.triggerWatchAction(action, changedItems);
+      this.triggerWatchAction(action, extension, changedItems);
       _.pull(this.actionQueue, action);
     }.bind(this), delay * 1000);
   }
 
-  outgoingParamsForItem(item) {
-    return this.apiController.paramsForExternalUse(item);
-  }
-
-  triggerWatchAction(action, changedItems) {
+  triggerWatchAction(action, extension, changedItems) {
     // console.log("Watch action triggered", action, changedItems);
-    if(action.repeatFrequency > 0) {
+    if(action.repeat_timeout > 0) {
       var lastExecuted = action.lastExecuted;
       var diffInSeconds = (new Date() - lastExecuted)/1000;
       console.log("last executed", action.lastExecuted, "diff", diffInSeconds, "repeatFreq", action.repeatFrequency);
-      if(diffInSeconds < action.repeatFrequency) {
-        var delay = action.repeatFrequency - diffInSeconds;
+      if(diffInSeconds < action.repeat_timeout) {
+        var delay = action.repeat_timeout - diffInSeconds;
         console.log("delaying action by", delay);
         this.queueAction(action, delay, changedItems);
         return;
@@ -164,15 +204,21 @@ class ExtensionManager {
 
     action.lastExecuted = new Date();
 
-    if(action.repeatVerb == "post") {
-      this.performPost(action, changedItems, null);
+    if(action.verb == "post") {
+      this.performPost(action, extension, changedItems, null);
+    } else {
+      // todo
     }
   }
 
-  performPost(action, items, callback) {
+  outgoingParamsForItem(item, extension) {
+    return this.apiController.paramsForExtension(item, this.extensionUsesEncryptedData(extension));
+  }
+
+  performPost(action, extension, items, callback) {
     var request = this.Restangular.oneUrl(action.url, action.url);
     request.items = items.map(function(item){
-      var params = this.outgoingParamsForItem(item);
+      var params = this.outgoingParamsForItem(item, extension);
       return params;
     }.bind(this))
 

app/assets/javascripts/app/services/modelManager.js

@@ -10,7 +10,9 @@ class ModelManager {
   }
 
   allItemsMatchingTypes(contentTypes) {
-    return this.items.filter(function(item){return contentTypes.includes(item.content_type) && !item.dummy})
+    return this.items.filter(function(item){
+      return (contentTypes.includes(item.content_type) || contentTypes.includes("*")) && !item.dummy;
+    })
   }
 
   findItem(itemId) {
@@ -67,7 +69,10 @@ class ModelManager {
 
   notifyItemChangeObserversOfModels(models) {
     for(var observer of this.itemChangeObservers) {
-      var relevantItems = models.filter(function(item){return item.content_type == observer.type});
+      var relevantItems = models.filter(function(item){
+        return observer.content_types.includes(item.content_type) || observer.content_types.includes("*");
+      });
+
       if(relevantItems.length > 0) {
         observer.callback(relevantItems);
       }
@@ -156,8 +161,8 @@ class ModelManager {
     _.remove(this.itemSyncObservers, _.find(this.itemSyncObservers, {id: id}));
   }
 
-  addItemChangeObserver(id, type, callback) {
-    this.itemChangeObservers.push({id: id, type: type, callback: callback});
+  addItemChangeObserver(id, content_types, callback) {
+    this.itemChangeObservers.push({id: id, content_types: content_types, callback: callback});
   }
 
   removeItemChangeObserver(id) {