dbm 1.2.1 → 1.2.3

package/commands/CommandBaseObject.js

@@ -9,7 +9,7 @@ export default class CommandBaseObject extends Dbm.core.BaseObject {
         //MENOTE: should be overridden
     }
 
-    _resolveSource(aValueOrSource) {
+    _resolveSource(aValueOrSource, aFromObject = null, aData = null) {
         if(aValueOrSource) {
             if(aValueOrSource.isFlowProperty) {
                 return aValueOrSource.value;
@@ -22,7 +22,7 @@ export default class CommandBaseObject extends Dbm.core.BaseObject {
         return aValueOrSource;
     }
 
-    _resolveSourceWithoutFlow(aValueOrSource) {
+    _resolveSourceWithoutFlow(aValueOrSource, aFromObject = null, aData = null) {
         if(aValueOrSource && aValueOrSource.isSource) {
             return aValueOrSource.getSource(aFromObject, aData);
         }

package/commands/SetProperty.js

@@ -13,6 +13,6 @@ export default class SetProperty extends CommandBaseObject {
 		
         let value = this.getInput("value");
         
-        this._resolveSourceWithoutFlow(this.item.property).value = value;
+        this._resolveSourceWithoutFlow(this.item.property, aFromObject, aData).value = value;
     }
 }

package/core/source/SourceCommand.js

@@ -0,0 +1,17 @@
+import Dbm from "../../index.js";
+
+export default class SourceCommand extends Dbm.core.source.SourceBaseObject {
+	
+    _construct() {
+        super._construct();
+
+        this.item.setValue("object", null);
+    }
+	
+	getBaseObject(aFromObject, aEventData) {
+
+        let command = this.item.object;
+
+		return command.perform(aFromObject, aEventData);
+	}
+}

package/core/source/index.js

@@ -5,6 +5,7 @@ export {default as EventSource} from "./EventSource.js";
 export {default as FromObject} from "./FromObject.js";
 export {default as StaticSource} from "./StaticSource.js";
 export {default as FirstSource} from "./FirstSource.js";
+export {default as SourceCommand} from "./SourceCommand.js";
 
 export const event = function(aPath = null) {
 	let newSource = new Dbm.core.source.EventSource();
@@ -50,3 +51,17 @@ export const firstWithDefault = function(...aSourcesAndDefault) {
 	
 	return newSource;
 }
+
+export const command = function(aCommand) {
+	let newSource = new Dbm.core.source.SourceCommand();
+
+	newSource.item.object = aCommand;
+	
+	return newSource;
+}
+
+export const callFunction = function(aFunction, aArguments = []) {
+	let functionCommand = Dbm.commands.callFunction(aFunction, aArguments);
+
+	return command(functionCommand);
+}

package/flow/controllers/select/InArray.js

@@ -0,0 +1,67 @@
+import Dbm from "../../../index.js";
+
+export default class InArray extends Dbm.core.BaseObject {
+    _construct() {
+        super._construct();
+
+        let valuesUpdatedCommand = Dbm.commands.callFunction(this._valuesUpdated.bind(this));
+
+        this._selectionChangedBound = this._selectionChanged.bind(this);
+
+        Dbm.flow.addUpdateCommand(this.item.requireProperty("values", null), valuesUpdatedCommand);
+        this.item.requireProperty("selections", []);
+
+    }
+
+    getSelectionForValue(aValue) {
+        let selections = this.item.selections;
+        let currentSelection = Dbm.utils.ArrayFunctions.getItemBy(selections, "value", aValue);
+
+        if(!currentSelection) {
+            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]));
+
+            currentSelection = {"value": aValue, "property": property};
+            selections.push(currentSelection);
+            this.item.selections = selections;
+        }
+
+        return currentSelection.property;
+    }
+
+    _selectionChanged(aSelected, aValue) {
+        console.log("_selectionChanged");
+
+        let newValues = [].concat(this.item.values);
+        if(aSelected) {
+            newValues.push(aValue);
+        }
+        else {
+            let index = newValues.indexOf(aValue);
+            if(index >= 0) {
+                newValues.splice(index, 1);
+            }
+        }
+
+        this.item.properties.values.getMostUpstreamProperty().setValue(newValues);
+    }
+
+    _valuesUpdated() {
+        //console.log("_valuesUpdated");
+        let values = this.item.values;
+
+        let currentArray = this.item.selections;
+        let currentArrayLength = currentArray.length;
+        for(let i = 0; i < currentArrayLength; i++) {
+            let currentSelection = currentArray[i];
+            if(values.indexOf(currentSelection.value) !== -1) {
+                currentSelection.property.getMostUpstreamProperty().setValue(true);
+            }
+            else {
+                currentSelection.property.getMostUpstreamProperty().setValue(false);
+            }
+        }
+    }
+}

package/flow/controllers/select/index.js

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

package/flow/index.js

@@ -11,7 +11,7 @@ export {default as FlowPropertyWithExternalInput} from "./FlowPropertyWithExtern
 export * as updatefunctions from "./updatefunctions/index.js";
 export * as controllers from "./controllers/index.js";
 
-export let addUpdateCommand = function(aProperty, aCommand) {
+export const addUpdateCommand = function(aProperty, aCommand) {
     let updateFunction = new Dbm.flow.updatefunctions.basic.RunCommand();
     updateFunction.input.properties.value.connectInput(aProperty);
     updateFunction.input.command = aCommand;
@@ -26,7 +26,7 @@ export let addUpdateCommand = function(aProperty, aCommand) {
     return {"updateFunction": updateFunction, "dirtyCommands": dirtyCommands};
 }
 
-export let addDirectUpdateCommand = function(aProperty, aCommand) {
+export const addDirectUpdateCommand = function(aProperty, aCommand) {
     let updateFunction = new Dbm.flow.updatefunctions.basic.RunCommand();
     updateFunction.input.properties.value.connectInput(aProperty);
     updateFunction.input.command = aCommand;
@@ -41,7 +41,7 @@ export let addDirectUpdateCommand = function(aProperty, aCommand) {
     return {"updateFunction": updateFunction, "dirtyCommands": dirtyCommands};
 }
 
-export let addUpdateCommandWhenMatched = function(aProperty, aMatchValue, aCommand) {
+export const addUpdateCommandWhenMatched = function(aProperty, aMatchValue, aCommand) {
 	let whenMatched = Dbm.flow.updatefunctions.logic.whenMatched(aProperty, aMatchValue);
 	
 	let updateData = Dbm.flow.addUpdateCommand(whenMatched.output.properties.value, aCommand);
@@ -51,6 +51,16 @@ export let addUpdateCommandWhenMatched = function(aProperty, aMatchValue, aComma
 	return whenMatched;
 }
 
+export const runWhenMatched = function(aProperty, aMatchValue, aCommand) {
+    if(aProperty.value === aMatchValue) {
+        aCommand.perform(null, null);
+
+        return null;
+    }
+    
+    return addUpdateCommandWhenMatched(aProperty, aMatchValue, aCommand);
+}
+
 export const animateValue = function(aValue, aTime = 0.5, aEasing = null) {
 	
 	let returnObject = new Dbm.repository.Item();

package/flow/updatefunctions/basic/MappedList.js

@@ -0,0 +1,49 @@
+import Dbm from "../../../index.js";
+
+export default class MappedList extends Dbm.flow.FlowUpdateFunction {
+
+    _construct() {
+        super._construct();
+        
+        this.input.register("items", []);
+        this.input.register("itemReferenceName", "forItem");
+        this.input.register("newItemCommands", []);
+
+        this.output.register("items", []);
+    }
+
+    _update() {
+        console.log("MappedList::_update");
+
+        let currentArray = this.input.items;
+        let currentArrayLength = currentArray.length;
+
+        let itemReferenceName = this.input.itemReferenceName;
+        let newItemCommands = this.input.newItemCommands;
+
+        let currentMappedList = this.output.properties.items.getValueWithoutFlow();
+
+        let returnArray = new Array(currentArrayLength);
+        for(let i = 0; i < currentArrayLength; i++) {
+            let currentItem = currentArray[i];
+
+            let index = Dbm.utils.ArrayFunctions.getItemIndexByIfExists(currentMappedList, itemReferenceName, currentItem);
+
+            if(index !== -1) {
+                returnArray[i] = currentMappedList[index];
+                currentMappedList.splice(index, 1);
+            }
+            else {
+                let newItem = new Dbm.repository.Item();
+                newItem.setId("mapped_" + Dbm.getInstance().getNextId());
+                newItem.setValue(itemReferenceName, currentItem);
+                Dbm.commands.performCommands(newItemCommands, this, {"mappedItem": newItem, "item": currentItem, "itemReferenceName": itemReferenceName});
+                returnArray[i] = newItem;
+            }
+
+            //METODO: clean up unused items
+        }
+
+        this.output.items = returnArray;
+    }
+}

package/flow/updatefunctions/basic/PropertyOf.js

@@ -1,6 +1,6 @@
 import Dbm from "../../../index.js";
 
-export default class Length extends Dbm.flow.FlowUpdateFunction {
+export default class PropertyOf extends Dbm.flow.FlowUpdateFunction {
 
     _construct() {
         super._construct();

package/flow/updatefunctions/basic/PropertyOfWithDefault.js

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

package/flow/updatefunctions/basic/Translation.js

@@ -0,0 +1,71 @@
+import Dbm from "../../../index.js";
+
+export default class Translation extends Dbm.flow.FlowUpdateFunction {
+
+    _construct() {
+        super._construct();
+        
+        this.input.register("translations", {});
+        this.input.register("path", null);
+        this.input.register("additionalPath", null);
+        this.input.register("id", "");
+        this.input.register("defaultValue", null);
+
+        this.output.register("value", null);
+    }
+
+    _update() {
+        //console.log("_update");
+
+        let translations = this.input.translations;
+
+        let path = this.input.path;
+        let additionalPath = this.input.additionalPath;
+        let id = this.input.id;
+
+        while(path) {
+
+            let currentAdditionalPath = additionalPath;
+            while(currentAdditionalPath) {
+
+                let currentValue = translations[path + "/" + currentAdditionalPath + "/" + id];
+                if(currentValue) {
+                    this.output.value = currentValue;
+                    return;
+                }
+
+                let nextIndex = currentAdditionalPath.lastIndexOf("/");
+                if(nextIndex >= 0) {
+                    currentAdditionalPath = currentAdditionalPath.substring(0, nextIndex);
+                }
+                else {
+                    currentAdditionalPath = null;
+                }
+            }
+
+            let currentValue = translations[path + "/" + id];
+            if(currentValue) {
+                this.output.value = currentValue;
+                return;
+            }
+
+            let nextIndex = path.lastIndexOf("/");
+            if(nextIndex >= 0) {
+                path = path.substring(0, nextIndex);
+            }
+            else {
+                path = null;
+            }
+        }
+        
+       let currentValue = translations[id];
+        if(currentValue) {
+            this.output.value = currentValue;
+            return;
+        }
+
+        //METODO: report missing translation
+
+        this.output.value = this.input.defaultValue;
+    }
+}

package/flow/updatefunctions/basic/index.js

@@ -4,6 +4,9 @@ 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 {default as PropertyOfWithDefault} from "./PropertyOfWithDefault.js";
+export {default as MappedList} from "./MappedList.js";
+export {default as Translation} from "./Translation.js";
 
 export const runCommand = function(aValue, aCommand) {
 	let updateFunction = new Dbm.flow.updatefunctions.basic.RunCommand();
@@ -34,6 +37,15 @@ export const propertyOf = function(aValue, aPropertyName) {
 	return updateFunction;
 }
 
+export const propertyOfWithDefault = function(aValue, aPropertyName, aDefaultValue) {
+	let updateFunction = new Dbm.flow.updatefunctions.basic.PropertyOfWithDefault();
+	updateFunction.input.properties.value.setOrConnect(aValue);
+	updateFunction.input.properties.propertyName.setOrConnect(aPropertyName);
+	updateFunction.input.properties.defaultValue.setOrConnect(aDefaultValue);
+	
+	return updateFunction;
+}
+
 export const combine = function(...aValues) {
 	let updateFunction = new Dbm.flow.updatefunctions.basic.CombineString();
 	
@@ -46,4 +58,69 @@ export const combine = function(...aValues) {
 	
 	
 	return updateFunction;
+}
+
+export const mappedList = function(aItems, aNewItemCommands = []) {
+	let updateFunction = new Dbm.flow.updatefunctions.basic.MappedList();
+	updateFunction.input.properties.items.setOrConnect(aItems);
+	updateFunction.input.properties.newItemCommands.setOrConnect(aNewItemCommands);
+
+	return updateFunction;
+}
+
+export const mappedListWithFunction = function(aItems, aNewItemFunction) {
+	let command = Dbm.commands.callFunction(aNewItemFunction, [Dbm.core.source.event("mappedItem"), Dbm.core.source.fromObject()]);
+
+	return mappedList(aItems, [command]);
+}
+
+
+
+export const activeMappedList = function(aItems, aActiveFromStart = false) {
+
+	let item = new Dbm.repository.Item();
+
+	item.requireProperty("items", []).setOrConnect(aItems);
+	item.requireProperty("activeItems", []);
+	item.requireProperty("selectionItems", []);
+
+	let activeItems = new Dbm.flow.controllers.select.InArray();
+
+	let createActiveField = function(aItem, aUpdateFunction) {
+		let activeProperty = aItem.requireProperty("active", aUpdateFunction.activeFromStart);
+		let inArrayProperty = activeItems.getSelectionForValue(aItem[aUpdateFunction.input.itemReferenceName]);
+		inArrayProperty.connectInput(activeProperty);
+	}
+
+	let updateFunction = mappedListWithFunction(item.properties.items, createActiveField);
+	updateFunction.activeFromStart = aActiveFromStart;
+	item.setValue("mappedList", updateFunction);
+	item.properties.selectionItems.connectInput(updateFunction.output.properties.items);
+
+	activeItems.item.properties.values.connectInput(item.properties.activeItems);
+	item.setValue("inArray", activeItems);
+
+	return item;
+}
+
+export const translation = function(aId, aDefaultValue = null, aPath = null, aAdditionalPath = null, aTranslations = null) {
+	let updateFunction = new Dbm.flow.updatefunctions.basic.Translation();
+
+	updateFunction.input.properties.id.setOrConnect(aId);
+	updateFunction.input.properties.defaultValue.setOrConnect(aDefaultValue);
+	updateFunction.input.properties.path.setOrConnect(aPath);
+	updateFunction.input.properties.additionalPath.setOrConnect(aAdditionalPath);
+
+	if(!aTranslations) {
+		aTranslations = Dbm.getRepositoryItem("site/translations").requireProperty("data");
+	}
+	updateFunction.input.properties.translations.setOrConnect(aTranslations);
+
+	return updateFunction;
+}
+
+export const translationProperty = function(aId, aDefaultValue = null, aPath = null, aAdditionalPath = null, aTranslations = null) {
+	let updateFunction = translation(aId, aDefaultValue, aPath, aAdditionalPath, aTranslations);
+
+	return updateFunction.output.properties.value;
 }

package/flow/updatefunctions/thirdparty/google/maps/AutoComplete.js

@@ -20,13 +20,7 @@ export default class AutoComplete extends Dbm.flow.FlowUpdateFunction {
     loadScript() {
         let key = Dbm.getRepositoryItem("googleMapsApi").apiKey;
         let scriptLoader = Dbm.loading.loadScript("https://maps.googleapis.com/maps/api/js?key=" + key + "&libraries=places");
-
-        if(scriptLoader.item.properties.status === 1) {
-            this._scriptLoaded();
-        }
-        else {
-            Dbm.flow.addUpdateCommandWhenMatched(scriptLoader.item.properties.status, 1, Dbm.commands.callFunction(this._scriptLoaded.bind(this)));
-        }
+        Dbm.flow.runWhenMatched(scriptLoader.item.properties.status, Dbm.loading.LoadingStatus.LOADED, Dbm.commands.callFunction(this._scriptLoaded.bind(this)));
 
         return this;
     }
@@ -54,7 +48,6 @@ export default class AutoComplete extends Dbm.flow.FlowUpdateFunction {
     _update() {
         console.log("_update");
 
-        
         let text = this.input.text;
         this._currentText = text;
         this.output.updated = false;

package/flow/updatefunctions/thirdparty/google/maps/PlaceDetails.js

@@ -0,0 +1,73 @@
+import Dbm from "../../../../../index.js";
+
+export default class PlaceDetails extends Dbm.flow.FlowUpdateFunction {
+
+    _construct() {
+        super._construct();
+        
+        this.input.register("id", null);
+        this.input.register("fields", ["addressComponents", "location"]);
+
+        //reviews
+
+        this._loadedScript = false;
+        this._currentId = "";
+
+        this.output.register("updated", true);
+        this.output.register("data", null);
+    }
+
+    loadScript() {
+        console.log("loadScript");
+        let key = Dbm.getRepositoryItem("googleMapsApi").apiKey;
+        let scriptLoader = Dbm.loading.loadScript("https://maps.googleapis.com/maps/api/js?key=" + key + "&libraries=places");
+        Dbm.flow.runWhenMatched(scriptLoader.item.properties.status, Dbm.loading.LoadingStatus.LOADED, Dbm.commands.callFunction(this._scriptLoaded.bind(this)));
+
+        return this;
+    }
+
+    _scriptLoaded() {
+        console.log("_scriptLoaded");
+        if(!this._loadedScript) {
+            this._loadedScript = true;
+            this._update();
+        }
+    }
+
+    _update() {
+        console.log("_update");
+
+        
+        let id = this.input.id;
+        this._currentId = id;
+        this.output.updated = false;
+
+        if(id) {
+            this.output.properties.data.isDirty = false;
+            this.output.properties.updated.isDirty = false;
+
+            if(this._loadedScript) {
+
+                let place = new google.maps.places.Place({"id": this.input.id});
+                console.log(place);
+
+                let loadPromise = place.fetchFields({"fields": this.input.fields});
+
+                loadPromise.then((aResult) => {
+                    console.log(id, place, aResult);
+                    this.output.properties.data._internal_setValueInFlowOutsideOfUpdate(place);
+                })
+            }
+            else {
+                this.loadScript();
+            }
+        }
+        else {
+            this.output.data = null;
+            this.output.updated = true;
+        }
+    }
+}
+
+
+

package/flow/updatefunctions/thirdparty/google/maps/PlaceDetailsFromQuery.js

@@ -0,0 +1,71 @@
+import Dbm from "../../../../../index.js";
+
+export default class PlaceDetailsDetailsFromQuery extends Dbm.flow.FlowUpdateFunction {
+
+    _construct() {
+        super._construct();
+        
+        this.input.register("query", null);
+        this.input.register("fields", ["addressComponents", "location"]);
+
+        this._loadedScript = false;
+        this._currentId = "";
+
+        this.output.register("updated", true);
+        this.output.register("data", null);
+    }
+
+    loadScript() {
+        console.log("loadScript");
+        let key = Dbm.getRepositoryItem("googleMapsApi").apiKey;
+        let scriptLoader = Dbm.loading.loadScript("https://maps.googleapis.com/maps/api/js?key=" + key + "&libraries=places");
+        Dbm.flow.runWhenMatched(scriptLoader.item.properties.status, Dbm.loading.LoadingStatus.LOADED, Dbm.commands.callFunction(this._scriptLoaded.bind(this)));
+
+        return this;
+    }
+
+    _scriptLoaded() {
+        console.log("_scriptLoaded");
+        if(!this._loadedScript) {
+            this._loadedScript = true;
+            this._update();
+        }
+    }
+
+    _update() {
+        console.log("_update");
+
+        
+        let query = this.input.query;
+        this._currentQuery = query;
+        this.output.updated = false;
+
+        if(query) {
+            this.output.properties.data.isDirty = false;
+            this.output.properties.updated.isDirty = false;
+
+            if(this._loadedScript) {
+
+                let loadPromise = google.maps.places.Place.searchByText({
+                    textQuery: query,
+                    fields: this.input.fields,
+                });
+
+                loadPromise.then((aResponse) => {
+                    let place = aResponse.places[0];
+                    this.output.properties.data._internal_setValueInFlowOutsideOfUpdate(place);
+                })
+            }
+            else {
+                this.loadScript();
+            }
+        }
+        else {
+            this.output.data = null;
+            this.output.updated = true;
+        }
+    }
+}
+
+
+

package/flow/updatefunctions/thirdparty/google/maps/index.js

@@ -1,3 +1,5 @@
 import Dbm from "../../../../../index.js";
 
 export {default as AutoComplete} from "./AutoComplete.js";
+export {default as PlaceDetails} from "./PlaceDetails.js";
+export {default as PlaceDetailsFromQuery} from "./PlaceDetailsFromQuery.js";

package/graphapi/webclient/ApiConnection.js

@@ -77,6 +77,7 @@ export default class ApiConnection extends Dbm.core.BaseObject {
 
     requestData(aFunctionName, aData) {
         let item = this._getRequestItem();
+        item.requireProperty("data", null);
 
         let parametersArray = [];
 

package/graphapi/webclient/WebSocketConnection.js

@@ -94,6 +94,7 @@ export default class WebSocketConnection extends Dbm.core.BaseObject {
     requestData(aFunctionName, aData) {
         //console.log("requestData");
         let item = this._getRequestItem();
+        item.requireProperty("data", null);
         item.setValue("requestData", {"type": "data", "functionName": aFunctionName, "data": aData, "requestId": item.id});
         this._runRequest(item);
         

package/graphapi/webclient/admin/EditorGroup.js

@@ -18,7 +18,7 @@ export default class EditorGroup extends Dbm.core.BaseObject {
         let itemEditor = this.item["editor_" + aId];
         if(!itemEditor) {
             itemEditor = new Dbm.graphapi.webclient.admin.ItemEditor();
-            itemEditor.item.setValue("editedItem", Dbm.getInstance().repository.getItem(aId));
+            itemEditor.item.setValue("editedItem", Dbm.getRepositoryItem(aId));
             this.item.setValue("editor_" + aId, itemEditor); 
             this.item.editors = [].concat(this.item.editors, itemEditor);
             this.item.anyChange.addCheck(itemEditor.item.properties.changed);