dbm 1.1.1 → 1.1.3

package/commands/CommandBaseObject.js

@@ -8,4 +8,29 @@ export default class CommandBaseObject extends Dbm.core.BaseObject {
     perform(aFromObject, aData) {
         //MENOTE: should be overridden
     }
+
+    _resolveSource(aValueOrSource) {
+        if(aValueOrSource) {
+            if(aValueOrSource.isFlowProperty) {
+                return aValueOrSource.value;
+            }
+            else if(aValueOrSource.isSource) {
+                return aValueOrSource.getSource(aFromObject, aData);
+            }
+        }
+
+        return aValueOrSource;
+    }
+
+    _resolveSourceWithoutFlow(aValueOrSource) {
+        if(aValueOrSource && aValueOrSource.isSource) {
+            return aValueOrSource.getSource(aFromObject, aData);
+        }
+
+        return aValueOrSource;
+    }
+
+    getInput(aName) {
+        return this._resolveSource(this.item[aName]);
+    }
 }

package/commands/SetProperty.js

@@ -0,0 +1,18 @@
+import Dbm from "../index.js";
+import CommandBaseObject from "./CommandBaseObject.js"
+
+export default class SetProperty extends CommandBaseObject {
+    _construct() {
+        super._construct();
+
+        this.item.setValue("property", null);
+        this.item.setValue("value", null);
+    }
+
+    perform(aFromObject, aData) {
+		
+        let value = this.getInput("value");
+        
+        this._resolveSourceWithoutFlow(this.item.property).value = value;
+    }
+}

package/commands/index.js

@@ -2,10 +2,11 @@ import Dbm from "../index.js";
 
 export {default as CommandBaseObject} from "./CommandBaseObject.js";
 export {default as CallFunction} from "./CallFunction.js";
+export {default as SetProperty} from "./SetProperty.js";
 export {default as ResolvePromise} from "./ResolvePromise.js";
 
 
-let callScopedFunction = function(aScopeObject, aFunction, aArguments = []) {
+export const callScopedFunction = function(aScopeObject, aFunction, aArguments = []) {
     let newCommand = new Dbm.commands.CallFunction();
     newCommand.item.setValue("scopeObject", aScopeObject);
     newCommand.item.setValue("callFunction", aFunction);
@@ -14,9 +15,7 @@ let callScopedFunction = function(aScopeObject, aFunction, aArguments = []) {
     return newCommand;
 }
 
-export {callScopedFunction};
-
-let callFunction = function(aFunction, aArguments = []) {
+export const callFunction = function(aFunction, aArguments = []) {
     let newCommand = new Dbm.commands.CallFunction();
     newCommand.item.setValue("callFunction", aFunction);
     newCommand.item.setValue("callArguments", aArguments);
@@ -24,13 +23,26 @@ let callFunction = function(aFunction, aArguments = []) {
     return newCommand;
 }
 
-export {callFunction};
-
-let resolvePromise = function(aValue = null) {
+export const resolvePromise = function(aValue = null) {
     let newCommand = new Dbm.commands.ResolvePromise();
     newCommand.item.setValue("value", aValue);
 
     return newCommand;
 }
 
-export {resolvePromise};
+export const setProperty = function(aProperty, aValue) {
+    let newCommand = new Dbm.commands.SetProperty();
+    newCommand.item.setValue("property", aProperty);
+    newCommand.item.setValue("value", aValue);
+
+    return newCommand;
+}
+
+export const performCommands = function(aCommands, aFromObject = null, aEventData = null) {
+    let currentArray = aCommands;
+    let currentArrayLength = currentArray.length;
+    for(let i = 0; i < currentArrayLength; i++) {
+        let currentCommand = currentArray[i];
+        currentCommand.perform(aFromObject, aEventData);
+    }
+}

package/core/source/FromObject.js

@@ -0,0 +1,8 @@
+import Dbm from "../../index.js";
+
+export default class FromObject extends Dbm.core.source.SourceBaseObject {
+	
+	getBaseObject(aFromObject, aEventData) {
+		return aFromObject;
+	}
+}

package/core/source/index.js

@@ -2,6 +2,7 @@ import Dbm from "../../index.js";
 
 export {default as SourceBaseObject} from "./SourceBaseObject.js";
 export {default as EventSource} from "./EventSource.js";
+export {default as FromObject} from "./FromObject.js";
 export {default as StaticSource} from "./StaticSource.js";
 
 export const event = function(aPath = null) {
@@ -12,6 +13,14 @@ export const event = function(aPath = null) {
 	return newSource;
 }
 
+export const fromObject = function(aPath = null) {
+	let newSource = new Dbm.core.source.FromObject();
+	
+	newSource.item.properties.path.setOrConnect(aPath);
+	
+	return newSource;
+}
+
 export const staticObject = function(aObject, aPath = null) {
 	let newSource = new Dbm.core.source.StaticSource();
 	

package/flow/controllers/edit/EditMultipleValues.js

@@ -0,0 +1,57 @@
+import Dbm from "../../../index.js";
+
+export default class EditMultipleValues extends Dbm.core.BaseObject {
+    _construct() {
+        super._construct();
+
+        this.item.requireProperty("editValues", {}); 
+
+        let anyChange = Dbm.flow.updatefunctions.logic.any();
+
+        this.item.requireProperty("anyChange", anyChange);
+        this.item.requireProperty("changed", false).connectInput(anyChange.output.properties.value);
+
+    }
+
+    get editors() {
+        return this.item.editValues;
+    }
+
+    _createEditValue(aName) {
+
+        let editValue = new Dbm.flow.controllers.edit.EditValue();
+
+        this.addEditor(aName, editValue);  
+
+        return editValue;
+    }
+
+    addEditor(aName, aEditor) {
+        let editValues = {...this.item.editValues};
+        editValues[aName] = aEditor;
+
+        this.item.anyChange.addCheck(aEditor.item.properties.changed);
+
+        this.item.editValues = editValues;
+
+        return this;
+    }
+
+    getEditorIfExists(aName) {
+        let editValues = this.item.editValues;
+        if(editValues[aName]) {
+            return editValues[aName];
+        }
+
+        return null;
+    }
+
+    getEditor(aName) {
+        let editValue = this.getEditorIfExists(aName);
+        if(!editValue) {
+            editValue = this._createEditValue(aName);
+        }
+
+        return editValue;
+    }
+}

package/flow/controllers/edit/EditValue.js

@@ -0,0 +1,52 @@
+import Dbm from "../../../index.js";
+
+export default class EditValue extends Dbm.core.BaseObject {
+    _construct() {
+        super._construct();
+
+        this.item.requireProperty("storedValue", null);
+        this.item.requireProperty("value", null);
+
+        let condition = Dbm.flow.updatefunctions.logic.condition(this.item.properties.storedValue, "!==", this.item.properties.value);
+
+        this.item.requireProperty("changed", false).connectInput(condition.output.properties.result);
+        this._setStoredValueBound = this._setStoredValue.bind(this);
+    }
+
+    get value() {
+        return this.item.properties.value;
+    }
+
+    getValue() {
+        return this.item.value;
+    }
+
+    setInitialValue(aValue) {
+        this.item.storedValue = aValue;
+        this.item.value = aValue;
+
+        return this;
+    }
+
+    _setStoredValue(aValue) {
+        this.item.storedValue = aValue;
+
+        return this;
+    }
+
+    store() {
+        this.item.properties.storedValue.getMostUpstreamProperty().storedValue = this.item.value;
+
+        return this;
+    }
+
+    undo() {
+        this.item.value = this.item.storedValue;
+
+        return this;
+    }
+
+    getStoreCommand() {
+        return Dbm.commands.callFunction(this._setStoredValueBound, [this.item.value]);
+    }
+}

package/flow/controllers/edit/index.js

@@ -0,0 +1,2 @@
+export {default as EditValue} from "./EditValue.js";
+export {default as EditMultipleValues} from "./EditMultipleValues.js";

package/flow/controllers/index.js

@@ -1 +1,2 @@
-export * as select from "./select/index.js";
+export * as select from "./select/index.js";
+export * as edit from "./edit/index.js";

package/graphapi/webclient/admin/EditorGroup.js

@@ -0,0 +1,59 @@
+import Dbm from "../../../index.js";
+
+export default class EditorGroup extends Dbm.core.BaseObject {
+
+    _construct() {
+        super._construct();
+
+        this.item.requireProperty("status", "none");
+        this.item.requireProperty("editors", []);
+
+        let anyChange = Dbm.flow.updatefunctions.logic.any();
+        
+        this.item.requireProperty("anyChange", anyChange);
+        this.item.requireProperty("changed", false).connectInput(anyChange.output.properties.value);
+    }
+
+    getItemEditor(aId) {
+        let itemEditor = this.item["editor_" + aId];
+        if(!itemEditor) {
+            itemEditor = new Dbm.graphapi.webclient.admin.ItemEditor();
+            itemEditor.item.setValue("editedItem", Dbm.getInstance().repository.getItem(aId));
+            this.item.setValue("editor_" + aId, itemEditor); 
+            this.item.editors = [].concat(this.item.editors, itemEditor);
+            this.item.anyChange.addCheck(itemEditor.item.properties.changed);
+        }
+
+        return itemEditor;
+    }
+
+    addCommandsToSaveData(aSaveData) {
+
+        aSaveData.addStartCommand(Dbm.commands.setProperty(this.item.properties.status, "loading"));
+
+        let currentArray = this.item.editors;
+        let currentArrayLength = currentArray.length;
+        for(let i = 0; i < currentArrayLength; i++) {
+            let currentEditor = currentArray[i];
+            
+            if(currentEditor.item.changed) {
+                currentEditor.addCommandsToSaveData(aSaveData);
+            }
+            
+        }
+
+        aSaveData.addSavedCommand(Dbm.commands.setProperty(this.item.properties.status, "none"));
+    }
+
+    getSaveData() {
+        let saveData = new Dbm.graphapi.webclient.admin.SaveData();
+        this.addCommandsToSaveData(saveData);
+        return saveData;
+    }
+
+    save() {
+        let saveData = this.getSaveData();
+        console.log(saveData);
+        saveData.save();
+    }
+}

package/graphapi/webclient/admin/ItemEditor.js

@@ -0,0 +1,74 @@
+import Dbm from "../../../index.js";
+
+export default class ItemEditor extends Dbm.core.BaseObject {
+
+    _construct() {
+        super._construct();
+
+        this.item.requireProperty("status", "none");
+        this.item.requireProperty("editors", []);
+
+        let anyChange = Dbm.flow.updatefunctions.logic.any();
+        
+        this.item.requireProperty("anyChange", anyChange);
+        this.item.requireProperty("changed", false).connectInput(anyChange.output.properties.value);
+    }
+
+    getEditor(aField) {
+        return this.item["editor_" + aField];
+    }
+
+    addEditor(aName, aInitialValue, aSaveFunction, aUpdateEncoding = null) {
+        let valueEditor = this.item["editor_" + aName];
+        if(!valueEditor) {
+            valueEditor = new Dbm.graphapi.webclient.admin.ValueEditor();
+            valueEditor.item.editValue.setInitialValue(aInitialValue);
+
+            valueEditor.item.setValue("itemEditor", this.item);
+            valueEditor.item.setValue("name", aName);
+            valueEditor.item.setValue("updateEncoding", aUpdateEncoding);
+
+            this.item.anyChange.addCheck(valueEditor.item.properties.changed);
+            this.item.setValue("editor_" + aName, valueEditor); 
+            this.item.editors = [].concat(this.item.editors, valueEditor);
+            
+            valueEditor.addSaveFunction(aSaveFunction);
+        }
+
+        return valueEditor;
+    }
+
+    addFieldEditor(aField, aInitialValue, aUpdateEncoding = null) {
+        return this.addEditor(aField, aInitialValue, Dbm.graphapi.webclient.admin.SaveFunctions.setField, aUpdateEncoding);
+    }
+
+    addCommandsToSaveData(aSaveData) {
+
+        let editedItemId = Dbm.objectPath(this.item, "editedItem.id");
+        let itemSaveData = aSaveData.getItemSaveData(editedItemId);
+
+        let currentArray = this.item.editors;
+        let currentArrayLength = currentArray.length;
+        for(let i = 0; i < currentArrayLength; i++) {
+            let currentEditor = currentArray[i];
+            
+            if(currentEditor.item.changed) {
+                currentEditor.addCommandsToSaveData(aSaveData);
+            }
+        }
+
+        itemSaveData.addStartCommand(Dbm.commands.setProperty(this.item.properties.status, "loading"));
+        itemSaveData.addSavedCommand(Dbm.commands.setProperty(this.item.properties.status, "none"));
+    }
+
+    getSaveData() {
+        let saveData = new Dbm.graphapi.webclient.admin.SaveData();
+        this.addCommandsToSaveData(saveData);
+        return saveData;
+    }
+
+    save() {
+        let saveData = this.getSaveData();
+        saveData.save();
+    }
+}

package/graphapi/webclient/admin/ItemSaveData.js

@@ -0,0 +1,63 @@
+import Dbm from "../../../index.js";
+
+export default class ItemSaveData extends Dbm.core.BaseObject {
+    _construct() {
+        super._construct();
+
+        this.saveData = null;
+        this.itemId = 0;
+        this._changes = [];
+        this._updateEncodings = [];
+        this._savedCommands = [];
+    }
+
+    addChange(aChange) {
+        this._changes.push(aChange);
+
+        return this;
+    }
+
+    createChange(aType, aData) {
+        this._changes.push({"type": aType, "data": aData});
+
+        return this;
+    }
+
+    setField(aField, aValue) {
+        this.createChange("setField", {"value": aValue, "field": aField});
+
+        return this;
+    }
+    
+    addUpdateEncoding(aEncoding) {
+        this._updateEncodings.push(aEncoding);
+
+        return this;
+    }
+
+    addStartCommand(aCommand) {
+        this.saveData.addStartCommand(aCommand);
+
+        return this;
+    }
+
+    addSavedCommand(aCommand) {
+        this._savedCommands.push(aCommand);
+
+        return this;
+    }
+
+    save() {
+        let graphApi = Dbm.getInstance().repository.getItem("graphApi").controller;
+
+        let request = graphApi.editItem(this.itemId, this._changes, this._updateEncodings);
+        Dbm.flow.addUpdateCommandWhenMatched(request.properties.status, 1, Dbm.commands.callFunction(this._saved.bind(this)));
+
+        return request;
+    }
+
+    _saved() {
+        console.log("_saved");
+        Dbm.commands.performCommands(this._savedCommands, this);
+    }
+}

package/graphapi/webclient/admin/SaveData.js

@@ -0,0 +1,60 @@
+import Dbm from "../../../index.js";
+
+export default class SaveData extends Dbm.core.BaseObject {
+    _construct() {
+        super._construct();
+
+        this._startCommands = [];
+        this._savedCommands = [];
+
+        this._saveOperations = [];
+        this._currentEditor = null;
+    }
+
+    getItemSaveData(aId) {
+
+        //METODO: check that it's an item save operation
+        if(this._currentEditor && this._currentEditor.itemId === aId) {
+            return this._currentEditor;
+        }
+
+        this._currentEditor = new Dbm.graphapi.webclient.admin.ItemSaveData();
+        this._currentEditor.itemId = aId;
+        this._currentEditor.saveData = this;
+        this._saveOperations.push(this._currentEditor);
+
+        return this._currentEditor;
+    }
+
+    addStartCommand(aCommand) {
+        this._startCommands.push(aCommand);
+
+        return this;
+    }
+
+    addSavedCommand(aCommand) {
+        this._savedCommands.push(aCommand);
+
+        return this;
+    }
+
+    save() {
+        Dbm.commands.performCommands(this._startCommands, this);
+
+        let saveOperations = [].concat(this._saveOperations);
+        this._performNextSaveOperation(saveOperations);
+        
+        return this;
+    }
+
+    _performNextSaveOperation(aSaveOperations) {
+        if(aSaveOperations.length === 0) {
+            Dbm.commands.performCommands(this._savedCommands, this);
+            return;
+        }
+
+        let nextOperation = aSaveOperations.shift();
+        let request = nextOperation.save();
+        Dbm.flow.addUpdateCommandWhenMatched(request.properties.status, 1, Dbm.commands.callFunction(this._performNextSaveOperation.bind(this), [aSaveOperations]));
+    }
+}

package/graphapi/webclient/admin/SaveFunctions.js

@@ -0,0 +1,7 @@
+export const setField = function(aEditor, aItemSaveData) {
+    aItemSaveData.setField(aEditor.item.name, aEditor.item.editValue.getValue());
+}
+
+export const setUrl = function(aEditor, aItemSaveData) {
+    aItemSaveData.createChange("setUrl", {"value": aEditor.item.editValue.getValue()});
+}

package/graphapi/webclient/admin/ValueEditor.js

@@ -0,0 +1,61 @@
+import Dbm from "../../../index.js";
+
+export default class ValueEditor extends Dbm.core.BaseObject {
+
+    _construct() {
+        super._construct();
+
+        this.item.requireProperty("status", "none");
+        this.item.requireProperty("saveCommands", []);
+
+        let editValue = new Dbm.flow.controllers.edit.EditValue();
+        this.item.setValue("editValue", editValue);
+
+        this.item.requireProperty("changed", false).connectInput(editValue.item.properties.changed);
+    }
+
+    addSaveCommand(aCommand) {
+
+        this.item.saveCommands = [].concat(this.item.saveCommands, aCommand);
+
+        return this;
+    }
+
+    addSaveFunction(aFunction) {
+        this.addSaveCommand(Dbm.commands.callFunction(aFunction, [Dbm.core.source.fromObject(), Dbm.core.source.event()]));
+
+        return this;
+    }
+
+    addCommandsToSaveData(aSaveData) {
+
+        let editedItemId = Dbm.objectPath(this.item, "itemEditor.editedItem.id");
+        let itemSaveData = aSaveData.getItemSaveData(editedItemId);
+
+        let currentArray = this.item.saveCommands;
+        let currentArrayLength = currentArray.length;
+        for(let i = 0; i < currentArrayLength; i++) {
+            let currentCommand = currentArray[i];
+            currentCommand.perform(this, itemSaveData);
+        }
+
+        if(this.item.updateEncoding) {
+            itemSaveData.addUpdateEncoding(this.item.updateEncoding);
+        }
+
+        itemSaveData.addSavedCommand(this.item.editValue.getStoreCommand());
+        itemSaveData.addStartCommand(Dbm.commands.setProperty(this.item.properties.status, "loading"));
+        itemSaveData.addSavedCommand(Dbm.commands.setProperty(this.item.properties.status, "none"));
+    }
+
+    getSaveData() {
+        let saveData = new Dbm.graphapi.webclient.admin.SaveData();
+        this.addCommandsToSaveData(saveData);
+        return saveData;
+    }
+
+    save() {
+        let saveData = this.getSaveData();
+        saveData.save();
+    }
+}

package/graphapi/webclient/admin/index.js

@@ -0,0 +1,8 @@
+export {default as SaveData} from "./SaveData.js";
+export {default as ItemSaveData} from "./ItemSaveData.js";
+
+export {default as EditorGroup} from "./EditorGroup.js";
+export {default as ItemEditor} from "./ItemEditor.js";
+export {default as ValueEditor} from "./ValueEditor.js";
+
+export * as SaveFunctions from "./SaveFunctions.js";

package/graphapi/webclient/decode/index.js

@@ -2,7 +2,7 @@ import Dbm from "../../../index.js";
 
 export {default as DecodeBaseObject} from "./DecodeBaseObject.js";
 
-let fullSetup = function() {
+export const fullSetup = function() {
     let decodePrefix = "graphApi/decode/";
 
     if(process.env.NODE_ENV === "development") {
@@ -78,6 +78,19 @@ let fullSetup = function() {
         currentDecoder.item.setValue("encodingType", name);
         currentDecoder.item.register(decodePrefix + name);
     }
-}
 
-export {fullSetup};
+    {
+        let name = "type";
+        let currentDecoder = new Dbm.graphapi.webclient.decode.DecodeBaseObject();
+        currentDecoder.item.setValue("encodingType", name);
+        currentDecoder.item.register(decodePrefix + name);
+    }
+
+    {
+        let name = "image";
+        let currentDecoder = new Dbm.graphapi.webclient.decode.DecodeBaseObject();
+        currentDecoder.item.setValue("copyFields", ["originalFileName", "path", "url", "resizeUrl", "altText"]);
+        currentDecoder.item.setValue("encodingType", name);
+        currentDecoder.item.register(decodePrefix + name);
+    }
+}

package/graphapi/webclient/index.js

@@ -1,7 +1,23 @@
+import Dbm from "../../index.js";
+
 export {default as WebSocketConnection} from "./WebSocketConnection.js";
 export {default as WebSocketRequest} from "./WebSocketRequest.js";
 export {default as GraphApi} from "./GraphApi.js";
 export {default as ApiConnection} from "./ApiConnection.js";
 export {default as ApiRequest} from "./ApiRequest.js";
 
-export * as decode from "./decode/index.js";
+export * as decode from "./decode/index.js";
+export * as admin from "./admin/index.js";
+
+export const setup = function(aWsPath, aApiPath) {
+    let webSocketConnection = new Dbm.graphapi.webclient.WebSocketConnection();
+    webSocketConnection.setup(aWsPath);
+    
+    let apiConnection = new Dbm.graphapi.webclient.ApiConnection();
+    apiConnection.setup(aApiPath);
+    
+    let graphApi = new Dbm.graphapi.webclient.GraphApi();
+    graphApi.setWebsocketConnection(webSocketConnection);
+    graphApi.setApiConnection(apiConnection);
+    graphApi.item.register("graphApi");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dbm",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "main": "index.js",
   "type": "module",
   "scripts": {},