dbm 1.4.7 → 1.4.8

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/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/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;
+    }
+}

package/loading/index.js

@@ -4,6 +4,7 @@ export {default as ScriptLoader} from "./ScriptLoader.js";
 export {default as JsonLoader} from "./JsonLoader.js";
 export {default as ImageLoader} from "./ImageLoader.js";
 export {default as LoadingSequence} from "./LoadingSequence.js";
+export {default as FontLoader} from "./FontLoader.js";
 
 export * as LoadingStatus from "./LoadingStatus.js";
 
@@ -52,5 +53,25 @@ export const loadImage = function(aUrl) {
     let loader = getImageLoader(aUrl);
     loader.load();
 
+    return loader;
+}
+
+export const loadFont = function(aUrl, aFontName) {
+    let loaderName = "loader-" + aUrl;
+    let loaderItem = Dbm.getInstance().repository.getItemIfExists(loaderName);
+    
+    let loader;
+    if(!loaderItem) {
+        loader = new Dbm.loading.FontLoader();
+        loader.item.register(loaderName);
+        loader.setUrl(aUrl);
+        loader.setFontName(aFontName);
+    }
+    else {
+        loader = loaderItem.controller;
+    }
+
+    loader.load();
+
     return loader;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dbm",
-  "version": "1.4.7",
+  "version": "1.4.8",
   "main": "index.js",
   "type": "module",
   "exports": {

package/react/BaseObject.js

@@ -227,6 +227,33 @@ export default class BaseObject extends Component {
 
         return createElement.apply(null, callArray);
     }
+
+    _getScopedCallFunctionCommand(aFunction, aArguments = []) {
+        let CallFunction = Dbm.objectPath(Dbm.getRepositoryItem("library"), "Dbm/commands/CallFunction");
+        let command = new CallFunction();
+        command.item.scopeObject = this;
+        command.item.callFunction = aFunction;
+        command.item.callArguments = aArguments;
+
+        return command;
+    }
+
+    _propertyOrName(aPropertyOrName) {
+        if(typeof(aPropertyOrName) === "string") {
+            return this.item.properties[aPropertyOrName];
+        }
+
+        return aPropertyOrName;
+    }
+
+    addUpdateCall(aPropertyOrName, aFunction, aArguments = []) {
+        this._propertyOrName(aPropertyOrName).addUpdate(this._getScopedCallFunctionCommand(aFunction, aArguments));
+    }
+
+    addUpdateCallWhenMatched(aPropertyOrName, aMatchValue, aFunction, aArguments = []) {
+        console.log(this._propertyOrName(aPropertyOrName), aPropertyOrName);
+        this._propertyOrName(aPropertyOrName).addUpdateWhenMatched(aMatchValue, this._getScopedCallFunctionCommand(aFunction, aArguments));
+    }
 }
 
 BaseObject.contextType = Context;

package/react/area/SwitchableArea.js

@@ -27,7 +27,7 @@ export default class SwitchableArea extends Dbm.react.BaseObject {
             slotElement = mainChildren;
         }
 
-        this.item.element = React.createElement(React.Fragment, {key: slotElement}, slotElement);
+        this.item.element = React.createElement(React.Fragment, {key: area}, slotElement);
     }
 
     _renderMainElement() {

package/react/area/index.js

@@ -29,4 +29,15 @@ export const centeredFlexDiv = function(aChildren) {
     return React.createElement("div", {className: "flex-row justify-center"}, 
         React.createElement("div", {className: "flex-row-item"}, aChildren)
     );
+}
+
+export const processStateElement = function(aState, aIdleElement, aProcessingElement, aCompletedElement) {
+    let updateFunction = Dbm.flow.updatefunctions.logic.switchValue(aState);
+    updateFunction.setDefaultValue(aIdleElement);
+    updateFunction.addCase(Dbm.loading.LoadingStatus.LOADING, aProcessingElement);
+    updateFunction.addCase(Dbm.loading.LoadingStatus.LOADED, aCompletedElement);
+
+    let element = React.createElement(Dbm.react.area.InsertElement, {"element": updateFunction.output.properties.value});
+
+    return updateFunction;
 }

package/react/form/FormField.js

@@ -6,9 +6,12 @@ export default class FormField extends Dbm.react.BaseObject {
         super._construct();
 
         this.getDynamicProp("value", "");
+        this.getDynamicPropWithoutState("editing", false);
         this.state["formUpdate"] = 0;
 
         this._callback_changeBound = this._callback_change.bind(this);
+        this._callback_focusBound = this._callback_focus.bind(this);
+        this._callback_blurBound = this._callback_blur.bind(this);
     }
 
     _callback_change(aEvent) {
@@ -21,11 +24,25 @@ export default class FormField extends Dbm.react.BaseObject {
         this.setState({"formUpdate": this.state.formUpdate}); //MENOTE: trigger change direct to not lose focus on input
     }
 
+    _callback_focus(aEvent) {
+        //console.log("_callback_focus");
+        //console.log(aEvent);
+
+        this.getDynamicProp("editing").getMostUpstreamProperty().setValue(true);
+    }
+
+    _callback_blur(aEvent) {
+        //console.log("_callback_blur");
+        //console.log(aEvent);
+
+        this.getDynamicProp("editing").getMostUpstreamProperty().setValue(false);
+    }
+
     _renderMainElement() {
 
         let value = this.getDynamicProp("value").value;
 
-        return this._createMainElement("input", {"value": value, onChange: this._callback_changeBound});
+        return this._createMainElement("input", {"value": value, onChange: this._callback_changeBound, onFocus: this._callback_focusBound, onBlur: this._callback_blurBound});
     }
 }
 

package/react/form/index.js

@@ -1,3 +1,6 @@
+import Dbm from "../../index.js";
+import React from "react";
+
 export {default as Checkbox} from "./Checkbox.js";
 export {default as FormField} from "./FormField.js";
 export {default as LabelledArea} from "./LabelledArea.js";
@@ -12,4 +15,26 @@ export {default as EditObjectProperty} from "./EditObjectProperty.js";
 export {default as Form} from "./Form.js";
 export {default as Option} from "./Option.js";
 export {default as Dropdown} from "./Dropdown.js";
-export {default as GraphApiObjectOptions} from "./GraphApiObjectOptions.js";
+export {default as GraphApiObjectOptions} from "./GraphApiObjectOptions.js";
+
+export const validationStateClassName = function(aChildren) {
+    return React.createElement(Dbm.react.AddProps, {className: Dbm.react.source.contextVariable("field.properties.validationState")},
+        aChildren
+    )
+}
+
+export const fieldWithValidation = function(aFieldName, aPlaceHolderText = null, aClasses = "standard-field standard-field-padding full-width") {
+    let returnElement = React.createElement(Dbm.react.context.AddItemToContext, {item: Dbm.react.source.contextVariable("form.fields." + aFieldName), as: "field"},
+        validationStateClassName(
+            React.createElement(Dbm.react.form.FormField, {
+                value: Dbm.react.source.contextVariable("field.properties.value"),
+                editing: Dbm.react.source.contextVariable("field.properties.editing"),
+                className: aClasses,
+                placeholder: aPlaceHolderText
+            })
+        )
+    )
+
+    return returnElement;
+}
+

package/startup/index.js

@@ -32,4 +32,7 @@ export const setupLibrary = function() {
     library.setValue("Dbm/commands/CallFunction", Dbm.commands.CallFunction);
     library.setValue("Dbm/flow/addUpdateCommand", Dbm.flow.addUpdateCommand);
     library.setValue("Dbm/flow/addUpdateCommandWhenMatched", Dbm.flow.addUpdateCommandWhenMatched);
+    library.setValue("Dbm/flow/updatefunctions/logic/Condition", Dbm.flow.updatefunctions.logic.Condition);
+    library.setValue("Dbm/flow/updatefunctions/logic/Switch", Dbm.flow.updatefunctions.logic.Switch);
+    
 }

package/tracking/Controller.js

@@ -120,7 +120,7 @@ export default class Controller extends Dbm.core.BaseObject {
         }
     }
 
-    trackEvent(aEventName, aData) {
+    trackEvent(aEventName, aData, aDataStructure = null) {
         console.log("trackEvent");
         console.log(aEventName, aData);
 
@@ -128,7 +128,7 @@ export default class Controller extends Dbm.core.BaseObject {
             let currentArray = this.item.trackers;
             let currentArrayLength = currentArray.length;
             for(let i = 0; i < currentArrayLength; i++) {
-                currentArray[i].controller.trackEvent(aEventName, aData);
+                currentArray[i].controller.trackEvent(aEventName, aData, aDataStructure);
             }
         }
 
@@ -184,7 +184,7 @@ export default class Controller extends Dbm.core.BaseObject {
             items: items
         }
 
-        this.trackEvent("Product view", data);
+        this.trackEvent("Product view", data, "ecommerce");
     }
 
     trackAddedToCart(aProductOrProducts) {
@@ -196,7 +196,7 @@ export default class Controller extends Dbm.core.BaseObject {
             items: items
         }
 
-        this.trackEvent("Added to cart", data);
+        this.trackEvent("Added to cart", data, "ecommerce");
 
     }
 
@@ -209,7 +209,7 @@ export default class Controller extends Dbm.core.BaseObject {
             items: items
         }
 
-        this.trackEvent("Checkout started", data);
+        this.trackEvent("Checkout started", data, "ecommerce");
     }
 
     trackAddShipping(aProductOrProducts) {
@@ -221,7 +221,7 @@ export default class Controller extends Dbm.core.BaseObject {
             items: items
         }
 
-        this.trackEvent("Add shipping", data);
+        this.trackEvent("Add shipping", data, "ecommerce");
     }
 
     trackAddPayment(aProductOrProducts) {
@@ -233,7 +233,7 @@ export default class Controller extends Dbm.core.BaseObject {
             items: items
         }
 
-        this.trackEvent("Add payment", data);
+        this.trackEvent("Add payment", data, "ecommerce");
     }
 
     trackPurchase(aTransactionId, aProductOrProducts) {
@@ -246,7 +246,7 @@ export default class Controller extends Dbm.core.BaseObject {
             items: items
         }
 
-        this.trackEvent("Purchase", data);
+        this.trackEvent("Purchase", data, "ecommerce");
     }
 
     createProductItemData(aId, aName, aPrice, aQuantity = 1, aAddtionalData = {}) {

package/tracking/DataLayerTracker.js

@@ -6,6 +6,9 @@ export default class DataLayerTracker extends Dbm.core.BaseObject {
 
 		this._statisticsTracking = false;
 		this._marketingTracking = false;
+
+		this.item.setValue("ecommerceDataWrapper", null);
+		this.item.setValue("eventNameMap", new Dbm.repository.Item());
     }
 
     addToDataLayer(aData) {
@@ -67,18 +70,34 @@ export default class DataLayerTracker extends Dbm.core.BaseObject {
 		return this;
 	}
 
-    trackEvent(aEventName, aData) {
+    trackEvent(aEventName, aData, aDataStructure = null) {
         console.log("trackEvent");
-        console.log(aEventName, aData);
+        console.log(aEventName, aData, aDataStructure);
+
+		let translatedEventName = this.item.eventNameMap[aEventName];
+		if(translatedEventName) {
+			aEventName = translatedEventName;
+		}
 
 		if(this._statisticsTracking) {
 			this.addToDataLayer({"event": "trackEvent", "value": {"name": aEventName, "data": aData}});
-			this._gtag("event", aEventName, aData);
+			if(aDataStructure === "ecommerce" && this.item.ecommerceDataWrapper) {
+				this.addToDataLayer({"event": aEventName, [this.item.ecommerceDataWrapper]: aData});
+			}
+			else {
+				this._gtag("event", aEventName, aData);
+			}
+			
 		}
 
         if(this._marketingTracking) {
 			this.addToDataLayer({"event": "trackMarketingEvent", "value": {"name": aEventName, "data": aData}});
-			this._gtag("event", "Marketing / " + aEventName, aData);
+			if(aDataStructure === "ecommerce" && this.item.ecommerceDataWrapper) {
+				this.addToDataLayer({"event": "Marketing / " + aEventName, [this.item.ecommerceDataWrapper]: aData});
+			}
+			else {
+				this._gtag("event", "Marketing / " + aEventName, aData);
+			}
 		}
     }
 

package/tracking/index.js

@@ -14,22 +14,24 @@ export const setup = function() {
     controller.start();
 
     let dataLayerTracker = new Dbm.tracking.DataLayerTracker();
+    dataLayerTracker.item.register("tracking/dataLayerTracker");
     controller.addTracker(dataLayerTracker.item);
 }
 
 export const addMetaPixel = function(aPixelId) {
     let tracker = new Dbm.tracking.MetaPixelTracker();
     tracker.item.pixelId = aPixelId;
-    Dbm.getInstance().repository.getItem("trackingController").controller.addTracker(tracker.item);
+    tracker.item.register("tracking/metaPixelTracker");
+    Dbm.getRepositoryItem("trackingController").controller.addTracker(tracker.item);
 }
 
 export const setCurrency = function(aCurrency) {
-    Dbm.getInstance().repository.getItem("trackingController").currency = aCurrency;
+    Dbm.getRepositoryItem("trackingController").currency = aCurrency;
 }
 
 export const addTagManagerTracking = function(aId) {
     //console.log("addTagManagerTracking");
     let tracker = new Dbm.tracking.TagManagerTracker();
     tracker.item.tagManagerId = aId;
-    Dbm.getInstance().repository.getItem("trackingController").controller.addTracker(tracker.item);
+    Dbm.getRepositoryItem("trackingController").controller.addTracker(tracker.item);
 }