dbm 1.4.7 → 1.4.9

package/commands/IncreaseProperty.js

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

package/commands/index.js

@@ -3,6 +3,7 @@ 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 IncreaseProperty} from "./IncreaseProperty.js";
 export {default as ResolvePromise} from "./ResolvePromise.js";
 export {default as TrackEvent} from "./TrackEvent.js";
 
@@ -39,6 +40,14 @@ export const setProperty = function(aProperty, aValue) {
     return newCommand;
 }
 
+export const increaseProperty = function(aProperty, aValue = 1) {
+    let newCommand = new Dbm.commands.SetProperty();
+    newCommand.item.setValue("property", aProperty);
+    newCommand.item.setValue("value", aValue);
+
+    return newCommand;
+}
+
 export const trackEvent = function(aEventName, aAdditionalData = {}) {
     let newCommand = new Dbm.commands.TrackEvent();
     newCommand.item.setValue("eventName", aEventName);

package/core/BaseObject.js

@@ -33,20 +33,19 @@ export default class BaseObject extends Dbm.core.LifeCycleObject {
 
     _propertyOrName(aPropertyOrName) {
         if(typeof(aPropertyOrName) === "string") {
-            return this.item[aPropertyOrName];
+            return this.item.properties[aPropertyOrName];
         }
 
         return aPropertyOrName;
     }
 
     addUpdateCall(aPropertyOrName, aFunction, aArguments = []) {
-        let addUpdateCommand = Dbm.objectPath(Dbm.getRepositoryItem("library"), "Dbm/flow/addUpdateCommand");
-        addUpdateCommand(this._propertyOrName(aPropertyOrName), aMatchValue, this._getScopedCallFunctionCommand(aFunction, aArguments));
+        this._propertyOrName(aPropertyOrName).addUpdate(this._getScopedCallFunctionCommand(aFunction, aArguments));
     }
 
     addUpdateCallWhenMatched(aPropertyOrName, aMatchValue, aFunction, aArguments = []) {
-        let addUpdateCommandWhenMatched = Dbm.objectPath(Dbm.getRepositoryItem("library"), "Dbm/flow/addUpdateCommandWhenMatched");
-        addUpdateCommandWhenMatched(this._propertyOrName(aPropertyOrName), aMatchValue, this._getScopedCallFunctionCommand(aFunction, aArguments));
+        console.log(this._propertyOrName(aPropertyOrName), aPropertyOrName, this);
+        this._propertyOrName(aPropertyOrName).addUpdateWhenMatched(aMatchValue, this._getScopedCallFunctionCommand(aFunction, aArguments));
     }
 
     destroy() {

package/core/LifeCycleObject.js

@@ -19,7 +19,19 @@ export default class LifeCycleObject {
 
     }
 
-    destroy() {
+    retain() {
+        //METODO
+
+        return this;
+    }
+
+    release() {
         //METODO
     }
+
+    destroy() {
+        if(process.env.NODE_ENV === "development") {
+            this._debugId = null;
+        }
+    }
 }

package/dbm.js

@@ -113,4 +113,5 @@ export * as startup from "./startup/index.js";
 export * as site from "./site/index.js";
 export * as tracking from "./tracking/index.js";
 export * as ecommerce from "./ecommerce/index.js";
-export * as node from "./node/index.js";
+export * as node from "./node/index.js";
+export * as form from "./form/index.js";

package/ecommerce/Cart.js

@@ -12,48 +12,54 @@ export default class Cart extends Dbm.core.BaseObject {
         this.item.setValue("numberOfLines", 0);
 
         this.item.setValue("changeCount", 0);
+    }
+
+    createLineItem(aType, aQuantity = 0, aMeta = null) {
+        
+        let id = "lineItem" + Dbm.getInstance().getNextId();
+        let lineItem = new Dbm.ecommerce.CartLineItem();
+        lineItem.item.setId(id);
+        lineItem.item.type = aType;
+        lineItem.setQuantity(aQuantity);
+        lineItem.setCart(this.item);
+
+        if(aMeta) {
+            for(let objectName in aMeta) {
+                lineItem.setMeta(objectName, aMeta[objectName]);
+            }
+        }
 
-        //METODO: integrate local storage
+        Dbm.flow.addUpdateCommand(lineItem.item.properties.quantity, this._changeCommand);
+
+        this.item.addToArray("lineItems", lineItem.item);
+
+        return lineItem;
     }
 
     addProduct(aProduct, aQuantity = 1, aMeta = null) {
         //console.log("addProduct");
         //console.log(aQuantity);
 
-        let lineItems = this.item.lineItems;
-        let lineItem;
-        let index = Dbm.utils.ArrayFunctions.getItemIndexByIfExists(lineItems, "product", aProduct);
+        let lineItem = Dbm.utils.ArrayFunctions.getItemBy(this.item.lineItems, "product", aProduct);
         
-        if(index !== -1) {
-            lineItem = lineItems[index].controller;
+        if(lineItem) {
             lineItem.increaseQuantity(aQuantity);
-            //METODO: support items with different meta
+            
             if(aMeta) {
                 for(let objectName in aMeta) {
                     lineItem.setMeta(objectName, aMeta[objectName]);
                 }
             }
-        }
-        else {
-            let id = "lineItem" + Dbm.getInstance().getNextId();
-            lineItem = new Dbm.ecommerce.CartLineItem();
-            lineItem.item.setId(id);
-            lineItem.setProduct(aProduct);
-            lineItem.setQuantity(aQuantity);
-            lineItem.setCart(this.item);
 
-            if(aMeta) {
-                for(let objectName in aMeta) {
-                    lineItem.setMeta(objectName, aMeta[objectName]);
-                }
-            }
+            return lineItem;
+        }
 
-            Dbm.flow.addUpdateCommand(lineItem.item.properties.quantity, this._changeCommand);
+        return this.addProductAsSeparateLineItem(aProduct, aQuantity, aMeta);
+    }
 
-            let newLineItems = [].concat(lineItems);
-            newLineItems.push(lineItem.item);
-            this.item.lineItems = newLineItems;
-        }
+    addProductAsSeparateLineItem(aProduct, aQuantity = 1, aMeta = null) {
+        let lineItem = this.createLineItem("product", aQuantity, aMeta);
+        lineItem.setProduct(aProduct);
 
         return lineItem;
     }

package/ecommerce/CartLineItem.js

@@ -5,9 +5,13 @@ export default class CartLineItem extends Dbm.core.BaseObject {
         super._construct();
 
         this.item.setValue("cart", null);
+
+        this.item.setValue("type", null);
         this.item.setValue("product", null);
         this.item.setValue("quantity", 0);
-        this.item.setValue("meta", {});
+
+        let meta = new Dbm.utils.NamedArray();
+        this.item.setValue("meta", meta.item);
     }
 
     setCart(aItem) {
@@ -32,7 +36,9 @@ export default class CartLineItem extends Dbm.core.BaseObject {
     }
 
     setMeta(aKey, aValue) {
-        this.item.meta[aKey] = aValue;
+        //console.log("setMeta");
+        //console.log(aKey, aValue);
+        this.item.meta.controller.setValue(aKey, aValue);
 
         return this;
     }
@@ -48,4 +54,18 @@ export default class CartLineItem extends Dbm.core.BaseObject {
 
         return this;
     }
+
+    getAsObject() {
+        let returnObject = {
+            "type": this.item.type,
+            "quantity": this.item.quantity,
+            "meta": this.item.meta.controller.getAsObject()
+        }
+
+        if(this.item.product) {
+            returnObject["product"] = this.item.product.id;
+        }
+
+        return returnObject;
+    }
 }

package/ecommerce/LocalStorageCartLoader.js

@@ -33,7 +33,21 @@ export default class LocalStorageCartLoader extends Dbm.core.BaseObject {
                 for(let i = 0; i < currentArrayLength; i++) {
                     let currentData = currentArray[i];
 
-                    this.item.cart.controller.addProduct(repository.getItem(currentData["product"]), currentData["quantity"], currentData["meta"]);
+                    if(!currentData["type"]) {
+                        continue;
+                    }
+
+                    let product = null;
+                    if(currentData["product"]) {
+                        product = repository.getItem(currentData["product"]);
+                    }
+
+                    //METODO: encode links in meta
+                    let lineItem = this.item.cart.controller.createLineItem(currentData["type"], currentData["quantity"], currentData["meta"]);
+
+                    if(product) {
+                        lineItem.setProduct(product);
+                    }
                 }
             }
         }
@@ -58,10 +72,17 @@ export default class LocalStorageCartLoader extends Dbm.core.BaseObject {
         for(let i = 0; i < currentArrayLength; i++) {
             let currentData = currentArray[i];
 
-            let encodedData = {"product": currentData.product.id, "quantity": currentData.quantity, "meta": currentData.meta};
+            let meta = currentData.meta.controller.getAsObject();
+            //METODO: links in meta
+            let encodedData = {"type": currentData.type, "quantity": currentData.quantity, "meta": meta};
+            if(currentData.product) {
+                encodedData["product"] = currentData.product.id;
+            }
             encodedLineItems.push(encodedData);
         }
 
+        console.log(encodedLineItems);
+
         try {
             let cartDataString = localStorage.setItem(this.item.storageKey, JSON.stringify({"lineItems": encodedLineItems}));
         }

package/flow/FlowProperty.js

@@ -155,4 +155,42 @@ export default class FlowProperty extends Dbm.flow.FlowBaseObject {
             this._upstreamConnection = null;
         }
     }
+
+    addUpdate(aCommand) {
+        let addUpdateCommand = Dbm.objectPath(Dbm.getRepositoryItem("library"), "Dbm/flow/addUpdateCommand");
+        addUpdateCommand(this, aCommand);
+
+        return this;
+    }
+
+    addUpdateWhenMatched(aMatchValue, aCommand) {
+        let addUpdateCommandWhenMatched = Dbm.objectPath(Dbm.getRepositoryItem("library"), "Dbm/flow/addUpdateCommandWhenMatched");
+        addUpdateCommandWhenMatched(this, aMatchValue, aCommand);
+
+        return this;
+    }
+
+    createCondition(aMatchValue, aCompareType = "===") {
+        let UpdateFunctionClass = Dbm.objectPath(Dbm.getRepositoryItem("library"), "Dbm/flow/updatefunctions/logic/Condition");
+        let updateFunction = new UpdateFunctionClass();
+        updateFunction.input.properties.input1.connectInput(this);
+        updateFunction.input.input2 = aMatchValue;
+        updateFunction.input.operation = aCompareType;
+
+        return updateFunction.output.properties.result;
+    }
+
+    createSwitch(aDefaultValue, aValues) {
+        let UpdateFunctionClass = Dbm.objectPath(Dbm.getRepositoryItem("library"), "Dbm/flow/updatefunctions/logic/Switch");
+        let updateFunction = new UpdateFunctionClass();
+        updateFunction.input.properties.value.connectInput(this);
+        updateFunction.setDefaultValue(aDefaultValue);
+
+        //METODO: do better normalization
+        for(let objectName in aValues) {
+            updateFunction.addCase(objectName, aValues[objectName]);
+        }
+
+        return updateFunction.output.properties.value;
+    }
 }

package/flow/index.js

@@ -18,7 +18,7 @@ export const addUpdateCommand = function(aProperty, aCommand) {
     updateFunction.input.command = aCommand;
     updateFunction.noFirstTriggger();
     
-    let updatePropertyCommand = Dbm.commands.callFunction(Dbm.getInstance().repository.getItem("propertyUpdater").controller.addSinglePropertyUpdateBound, [Dbm.core.source.staticObject(updateFunction.output.properties.value)]);
+    let updatePropertyCommand = Dbm.commands.callFunction(Dbm.repository.getControllerIfExists("propertyUpdater").addSinglePropertyUpdateBound, [Dbm.core.source.staticObject(updateFunction.output.properties.value)]);
 
     let dirtyCommands = new Dbm.flow.DirtyCommands();
     updateFunction.output.properties.value.connectOutput(dirtyCommands);
@@ -43,11 +43,11 @@ export const addDirectUpdateCommand = function(aProperty, aCommand) {
 }
 
 export const addUpdateCommandWhenMatched = function(aProperty, aMatchValue, aCommand) {
-	let whenMatched = Dbm.flow.updatefunctions.logic.whenMatched(aProperty, aMatchValue);
+	let matchUpdateFunction = Dbm.flow.updatefunctions.logic.whenMatched(aProperty, aMatchValue);
 	
-	let updateData = Dbm.flow.addUpdateCommand(whenMatched.output.properties.value, aCommand);
+	let updateData = Dbm.flow.addUpdateCommand(matchUpdateFunction.output.properties.value, aCommand);
 	
-	updateData["whenMatched"] = whenMatched;
+	updateData["matchUpdateFunction"] = matchUpdateFunction;
 	
 	return updateData;
 }

package/form/Field.js

@@ -0,0 +1,76 @@
+import Dbm from "../index.js";
+
+export default class Field extends Dbm.core.BaseObject {
+    _construct() {
+        super._construct();
+
+        let changeCommand = this._getScopedCallFunctionCommand(this._changed);
+        let focusChangedCommand = this._getScopedCallFunctionCommand(this._focusChanged);
+        let validationChangedCommand = this._getScopedCallFunctionCommand(this._validationActiveChange);
+
+        this.item.requireProperty("value", null).addUpdate(changeCommand);
+
+        let validation = new Dbm.form.validation.Validation();
+        validation.item.field = this.item;
+        validation.item.properties.active.addUpdate(validationChangedCommand);
+        validation.item.properties.validationFunction.addUpdate(validationChangedCommand);
+
+        this.item.requireProperty("validation", validation.item);
+        this.item.requireProperty("editing", false).addUpdate(focusChangedCommand);
+        this.item.requireProperty("valid", true);
+        this.item.requireProperty("validationState", "notValidated");
+        this.item.requireProperty("validationMode", null);
+        this.item.requireProperty("focusMode", "reset");
+    }
+
+    validate() {
+        if(this.item.validation.active) {
+            let newState = this.item.valid ? "valid" : "invalid";
+            this.item.validationState = newState;
+        }
+        else {
+            this.item.valid = true;
+            this.item.validationState = "notValidated";
+        }
+
+        return this.item.valid;
+    }
+
+    getValue() {
+        return this.item.value;
+    }
+
+    _validationActiveChange() {
+        //console.log("_validationActiveChange");
+        if(this.item.validation.active) {
+            this._changed();
+        }
+        else {
+            this.item.valid = true;
+            this.item.validationState = "notValidated";
+        }
+    }
+
+    _changed() {
+        //console.log("_changed");
+        this.item.valid = this.item.validation.controller.validate();
+
+        if(this.item.validationMode === "onChange") {
+            this.validate();
+        }
+    }
+
+    _focusChanged() {
+        //console.log("_focus");
+        if(this.item.editing) {
+            if(this.item.focusMode === "reset") {
+                this.item.validationState = "notValidated";
+            }
+        }
+        else {
+            if(this.item.validationMode === "onBlur") {
+                this.validate();
+            }
+        }
+    }
+}

package/form/Form.js

@@ -0,0 +1,87 @@
+import Dbm from "../index.js";
+
+export default class Form extends Dbm.core.BaseObject {
+    _construct() {
+        super._construct();
+
+        let all = Dbm.flow.updatefunctions.logic.all();
+        this.item.requireProperty("all", all);
+
+        this.item.requireProperty("valid", true).connectInput(all.output.properties.value);
+        this.item.requireProperty("fields", new Dbm.repository.Item());
+        this.item.requireProperty("fieldNames", []);
+        this.item.requireProperty("defaultValidationMode", "onBlur");
+    }
+
+    addExistingField(aName, aField) {
+        this.item.fields.setValue(aName, aField.item);
+        this.item.all.addCheck(aField.item.properties.valid);
+        this.item.addToArray("fieldNames", aName);
+
+        return this;
+    }
+
+    createField(aName, aValue = null, aValidationFunction = null, aValidationActive = null) {
+
+        if(this.item.fields[aName]) {
+            console.error("Field " + aName + " already exists");
+            return this.item.fields[aName].controller;
+        }
+
+        let newField = new Dbm.form.Field();
+        newField.item.value = aValue;
+        newField.item.validationMode = this.item.defaultValidationMode;
+        if(aValidationFunction) {
+            newField.item.validation.validationFunction = aValidationFunction;
+        }
+        if(aValidationActive) {
+            newField.item.validation.properties.active.setOrConnect(aValidationActive);
+        }
+
+        this.addExistingField(aName, newField);
+
+        return newField;
+    }
+
+    createGroup(aName) {
+        let newForm = new Dbm.form.Form();
+        newForm.item.defaultValidationMode = this.item.defaultValidationMode;
+
+        this.addExistingField(aName, newForm);
+
+        return newForm;
+    }
+
+    validate() {
+        console.log("validate");
+
+        let currentArray = this.item.fieldNames;
+        let currentArrayLength = currentArray.length;
+        for(let i = 0; i < currentArrayLength; i++) {
+            let currentName = currentArray[i];
+
+            let result = this.item.fields[currentName].controller.validate();
+
+            if(!result) {
+                console.log("Field " + currentName + " is not valid.", this.item.fields[currentName]);
+            }
+            //METODO: return the result in some format
+        }
+
+        return this.item.valid;
+    }
+
+    getValue() {
+        let returnObject = {};
+
+        let currentArray = this.item.fieldNames;
+        let currentArrayLength = currentArray.length;
+        for(let i = 0; i < currentArrayLength; i++) {
+            let currentName = currentArray[i];
+
+            returnObject[currentName] = this.item.fields[currentName].controller.getValue();
+        }
+
+        return returnObject;
+    }
+}

package/form/index.js

@@ -0,0 +1,6 @@
+import Dbm from "../index.js";
+
+export * as validation from "./validation/index.js";
+
+export {default as Form} from "./Form.js";
+export {default as Field} from "./Field.js";

package/form/validation/Validation.js

@@ -0,0 +1,23 @@
+import Dbm from "../../index.js";
+
+export default class Validation extends Dbm.core.BaseObject {
+    _construct() {
+        super._construct();
+
+        this.item.requireProperty("field", null);
+        this.item.requireProperty("active", true);
+        this.item.requireProperty("validationFunction", Dbm.form.validation.ValidationFunctions.noValidation);
+    }
+
+    validate() {
+        if(!this.item.active) {
+            return true;
+        }
+        let validationFunction = this.item.validationFunction;
+        return validationFunction(this.item);
+    }
+
+    static noValidation(aValidation) {
+        return true;
+    }
+}

package/form/validation/ValidationFunctions.js

@@ -0,0 +1,23 @@
+import Dbm from "../../index.js";
+
+export const noValidation = function(aValidation) {
+    return true;
+}
+
+export const notEmpty = function(aValidation) {
+    //console.log("notEmpty");
+
+    if(aValidation.field.value && aValidation.field.value.length > 0) {
+        return true;
+    }
+    return false;
+}
+
+export const checked = function(aValidation) {
+    //console.log("notEmpty");
+
+    if(aValidation.field.value) {
+        return true;
+    }
+    return false;
+}

package/form/validation/index.js

@@ -0,0 +1,4 @@
+import Dbm from "../../index.js";
+
+export {default as Validation} from "./Validation.js";
+export * as ValidationFunctions from "./ValidationFunctions.js";

package/graphapi/webclient/WebSocketConnection.js

@@ -294,7 +294,9 @@ export default class WebSocketConnection extends Dbm.core.BaseObject {
                 {
                     let item = repository.getItem(data["requestId"]);
                     if(data["id"]) {
-                        item.setValue("user", repository.getItem(data["id"]));
+                        let userItem = repository.getItem(data["user"]);
+                        userItem.setValue("roles", data["roles"]);
+                        item.setValue("user", userItem);
                     }
                     else {
                         item.setValue("user", null);
@@ -307,7 +309,9 @@ export default class WebSocketConnection extends Dbm.core.BaseObject {
             case "connectionReady": 
                 {
                     if(data["user"]) {
-                        repository.getItem("site").currentUser = repository.getItem(data["user"]);
+                        let userItem = repository.getItem(data["user"]);
+                        userItem.setValue("roles", data["roles"]);
+                        repository.getItem("site").currentUser = userItem;
                     }
                     else {
                         repository.getItem("site").currentUser = null;

package/graphapi/webclient/admin/ItemEditor.js

@@ -160,7 +160,7 @@ export default class ItemEditor extends Dbm.core.BaseObject {
         let name = "out_" + aType + "_" + aObjectType;
         let valueEditor = this.item["editor_multipleRelations_" + name];
         if(!valueEditor) {
-            let relations = Dbm.utils.ArrayFunctions.filterByField(Dbm.objectPath(this.item.editedItem, "relations/in." + aType + ".objects"), "objectTypes", aObjectType, "arrayContains");
+            let relations = Dbm.utils.ArrayFunctions.filterByField(Dbm.objectPath(this.item.editedItem, "relations/out." + aType + ".objects"), "objectTypes", aObjectType, "arrayContains");
             let ids = Dbm.utils.ArrayFunctions.mapField(relations, "id");
 
             valueEditor = this.addMultipleOutgoingRelationsEditor(aType, aObjectType, ids, "relations");

package/loading/FontLoader.js

@@ -0,0 +1,47 @@
+import Dbm from "../index.js";
+
+export default class FontLoader extends Dbm.core.BaseObject {
+    constructor() {
+        super();
+
+        this._url = null;
+        this._fontName = null;
+        this._element = null;
+        this._promise = null;
+
+        this.item.setValue("status", Dbm.loading.LoadingStatus.NOT_STARTED);
+    }
+
+    setUrl(aUrl) {
+        this._url = aUrl;
+        return this;
+    }
+
+    setFontName(aFontName) {
+        this._fontName = aFontName;
+        return this;
+    }
+
+    load() {
+
+        if(!this._element) {
+            this.item.setValue("status", Dbm.loading.LoadingStatus.LOADING);
+
+            let element = document.createElement("link");
+            element.href = this._url;
+            element.rel = "stylesheet";
+
+            this._element = element;
+
+            document.head.appendChild(element);
+
+            this._promise = document.fonts.load("16px " + JSON.stringify(this._fontName));
+            this._promise.then(() => {
+                this.item.setValue("status", Dbm.loading.LoadingStatus.LOADED);
+            });
+            
+        }
+        
+        return this;
+    }
+}