dbm 1.1.0 → 1.1.2

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

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

package/flow/controllers/select/SingleSelection.js

@@ -0,0 +1,65 @@
+import Dbm from "../../../index.js";
+
+export default class SingleSelection extends Dbm.core.BaseObject {
+    _construct() {
+        super._construct();
+
+        let valueUpdatedCommand = Dbm.commands.callFunction(this._valueUpdated.bind(this));
+
+        this._selectionChangedBound = this._selectionChanged.bind(this);
+
+        Dbm.flow.addUpdateCommand(this.item.requireProperty("value", null), valueUpdatedCommand);
+        Dbm.flow.addUpdateCommand(this.item.requireProperty("selections", []), valueUpdatedCommand);
+
+        this.item.requireProperty("matched", false);
+    }
+
+    addSelectionValue(aValue) {
+        let selections = [].concat(this.item.selections);
+
+        let property = new Dbm.flow.FlowProperty();
+        property.setValue(false);
+        Dbm.flow.addUpdateCommand(property, Dbm.commands.callFunction(this._selectionChangedBound, [property, aValue]));
+
+        selections.push({"value": aValue, "property": property});
+        this.item.selections = selections;
+
+        return property;
+    }
+
+    _selectionChanged(aSelected, aValue) {
+        //console.log("_selectionChanged");
+        //console.log(aSelected, aValue);
+
+        if(aSelected) {
+            this.item.properties.value.getMostUpstreamProperty().setValue(aValue);
+        }
+        else {
+            if(this.item.properties.value === aValue) {
+                this.item.properties.value.getMostUpstreamProperty().setValue(null);
+            }
+        }
+    }
+
+    _valueUpdated() {
+        //console.log("_valueUpdated");
+        let value = this.item.value;
+
+        let matched = false;
+
+        let currentArray = this.item.selections;
+        let currentArrayLength = currentArray.length;
+        for(let i = 0; i < currentArrayLength; i++) {
+            let currentSelection = currentArray[i];
+            if(currentSelection.value === value) {
+                currentSelection.property.value = true;
+                matched = true;
+            }
+            else {
+                currentSelection.property.value = false;
+            }
+        }
+
+        this.item.matched = matched;
+    }
+}

package/flow/controllers/select/index.js

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

package/flow/index.js

@@ -9,6 +9,7 @@ export {default as DirtyCommands} from "./DirtyCommands.js";
 export {default as FlowPropertyWithExternalInput} from "./FlowPropertyWithExternalInput.js";
 
 export * as updatefunctions from "./updatefunctions/index.js";
+export * as controllers from "./controllers/index.js";
 
 export let addUpdateCommand = function(aProperty, aCommand) {
     let updateFunction = new Dbm.flow.updatefunctions.basic.RunCommand();

package/flow/updatefunctions/basic/Length.js

@@ -0,0 +1,20 @@
+import Dbm from "../../../index.js";
+
+export default class Length extends Dbm.flow.FlowUpdateFunction {
+
+    _construct() {
+        super._construct();
+        
+        this.input.register("value", "");
+
+        this.output.register("length", 0);
+    }
+
+    _update() {
+        //console.log("_update");
+
+        let value = this.input.value;
+        
+        this.output.length = value ? value.length : 0;
+    }
+}

package/flow/updatefunctions/basic/PropertyOf.js

@@ -0,0 +1,21 @@
+import Dbm from "../../../index.js";
+
+export default class Length extends Dbm.flow.FlowUpdateFunction {
+
+    _construct() {
+        super._construct();
+        
+        this.input.register("value", "");
+        this.input.register("propertyName", "");
+
+        this.output.register("value", null);
+    }
+
+    _update() {
+        //console.log("_update");
+
+        let value = this.input.value;
+        
+        this.output.value = Dbm.objectPath(value, this.input.propertyName);
+    }
+}

package/flow/updatefunctions/basic/index.js

@@ -2,6 +2,8 @@ import Dbm from "../../../index.js";
 
 export {default as RunCommand} from "./RunCommand.js";
 export {default as CombineString} from "./CombineString.js";
+export {default as Length} from "./Length.js";
+export {default as PropertyOf} from "./PropertyOf.js";
 
 export const runCommand = function(aValue, aCommand) {
 	let updateFunction = new Dbm.flow.updatefunctions.basic.RunCommand();
@@ -15,4 +17,19 @@ export const transformValue = function(aValue, aFunction) {
 	let command = Dbm.commands.callFunction(aFunction, [Dbm.core.source.event()]);
 	
 	return Dbm.flow.updatefunctions.basic.runCommand(aValue, command);
+}
+
+export const length = function(aValue) {
+	let updateFunction = new Dbm.flow.updatefunctions.basic.Length();
+	updateFunction.input.properties.value.setOrConnect(aValue);
+	
+	return updateFunction;
+}
+
+export const propertyOf = function(aValue, aPropertyName) {
+	let updateFunction = new Dbm.flow.updatefunctions.basic.PropertyOf();
+	updateFunction.input.properties.value.setOrConnect(aValue);
+	updateFunction.input.properties.propertyName.setOrConnect(aPropertyName);
+	
+	return updateFunction;
 }

package/flow/updatefunctions/logic/Condition.js

@@ -15,6 +15,17 @@ export default class Condition extends Dbm.flow.FlowUpdateFunction {
     _update() {
         //console.log("_update");
 
-        this.output.result = this.input.operation.call(this, this.input.input1, this.input.input2);
+        let operation = this.input.operation;
+        if(typeof(operation) === "string") {
+            if(operation === "!==") {
+                operation = function(aA, aB) {return aA !== aB;}
+            }
+            else {
+                //METODO: add more operations
+                operation = function(aA, aB) {return aA === aB;}
+            }
+        }
+
+        this.output.result = operation.call(this, this.input.input1, this.input.input2);
     }
 }

package/flow/updatefunctions/logic/Invert.js

@@ -0,0 +1,18 @@
+import Dbm from "../../../index.js";
+
+export default class Invert extends Dbm.flow.FlowUpdateFunction {
+
+    _construct() {
+        super._construct();
+        
+        this.input.register("input", false);
+
+        this.output.register("result", true);
+    }
+
+    _update() {
+        //console.log("_update");
+
+        this.output.result = !this.input.input;
+    }
+}

package/flow/updatefunctions/logic/index.js

@@ -10,6 +10,7 @@ export {default as All} from "./All.js";
 export {default as Any} from "./Any.js";
 export {default as AllAtValue} from "./AllAtValue.js";
 export {default as WhenMatched} from "./WhenMatched.js";
+export {default as Invert} from "./Invert.js";
 
 export let subtract = function(aInput1 = 0, aInput2 = 0) {
     let updateFunction = new Dbm.flow.updatefunctions.logic.Subtraction();
@@ -19,6 +20,13 @@ export let subtract = function(aInput1 = 0, aInput2 = 0) {
     return updateFunction;
 }
 
+export let invert = function(aValue = false) {
+    let updateFunction = new Dbm.flow.updatefunctions.logic.Invert();
+    updateFunction.input.properties.input.setValue(aValue);
+
+    return updateFunction;
+}
+
 export let invertP = function(aP = 0) {
     let updateFunction = new Dbm.flow.updatefunctions.logic.Subtraction();
     updateFunction.input.properties.input1.setValue(1);

package/graphapi/webclient/GraphApi.js

@@ -32,6 +32,10 @@ export default class GraphApi extends Dbm.core.BaseObject {
         return this._websocketConnection.requestData(aFunctionName, aData);
     }
 
+    performAction(aFunctionName, aData) {
+        return this._websocketConnection.performAction(aFunctionName, aData);
+    }
+
     createItem(aTypes, aVisibility = "draft", aChanges = [], aEncode = []) {
         return this._websocketConnection.createItem(aTypes, aVisibility, aChanges, aEncode);
     }

package/graphapi/webclient/WebSocketConnection.js

@@ -87,6 +87,15 @@ export default class WebSocketConnection extends Dbm.core.BaseObject {
         return item;
     }
 
+    performAction(aFunctionName, aData) {
+        //console.log("performAction");
+        let item = this._getRequestItem();
+        item.setValue("requestData", {"type": "action", "functionName": aFunctionName, "data": aData, "requestId": item.id});
+        this._runRequest(item);
+        
+        return item;
+    }
+
     createItem(aTypes, aVisibility = "draft", aChanges = [], aEncode = []) {
         let item = this._getRequestItem();
         item.setValue("requestData", {"type": "admin/createObject", "types": aTypes, "visibility": aVisibility, "changes": aChanges, "encode": aEncode, "requestId": item.id});
@@ -212,6 +221,7 @@ export default class WebSocketConnection extends Dbm.core.BaseObject {
                 }
                 break;
             case "data/response":
+            case "action/response":
                 {
                     let item = repository.getItem(data["requestId"]);
                     item.setValue("data", data["data"]);

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();
+    }
+}