dbm 1.1.9 → 1.1.11

package/core/source/SourceBaseObject.js

@@ -4,6 +4,7 @@ export default class SourceBaseObject extends Dbm.core.BaseObject {
     _construct() {
         super._construct();
 
+        this._log = false;
         this.item.setValue("path", null);
     }
 
@@ -20,10 +21,20 @@ export default class SourceBaseObject extends Dbm.core.BaseObject {
 		
 		let path = this.item.path;
 		let baseObject = this.getBaseObject(aFromObject, aEventData);
+
+        if(this._log) {
+            console.log("Source>>>>>", baseObject, path);
+        }
+
 		if(!path) {
 			return baseObject;
 		}
         
         return Dbm.objectPath(baseObject, path);
     }
+
+    addLogs() {
+        this._log = true;
+        return this;
+    }
 }

package/dbm.js

@@ -93,4 +93,5 @@ export * as flow from "./flow/index.js";
 export * as updater from "./updater/index.js";
 export * as startup from "./startup/index.js";
 export * as site from "./site/index.js";
-export * as tracking from "./tracking/index.js";
+export * as tracking from "./tracking/index.js";
+export * as ecommerce from "./ecommerce/index.js";

package/ecommerce/Cart.js

@@ -0,0 +1,79 @@
+import Dbm from "../index.js";
+
+export default class Cart extends Dbm.core.BaseObject {
+    _construct() {
+        super._construct();
+
+        this._changeCommand = Dbm.commands.callFunction(this._changed.bind(this));
+
+        this.item.setValue("lineItems", []);
+        Dbm.flow.addUpdateCommand(this.item.properties.lineItems, this._changeCommand);
+        this.item.setValue("numberOfItems", 0);
+        this.item.setValue("numberOfLines", 0);
+
+        this.item.setValue("changeCount", 0);
+
+        //METODO: integrate local storage
+    }
+
+    addProduct(aProduct, aQuantity = 1) {
+        //console.log("addProduct");
+        //console.log(aQuantity);
+
+        let lineItems = this.item.lineItems;
+        let lineItem;
+        let index = Dbm.utils.ArrayFunctions.getItemIndexByIfExists(lineItems, "product", aProduct);
+        
+        if(index !== -1) {
+            lineItem = lineItems[index];
+            lineItem.controller.increaseQuantity(aQuantity);
+        }
+        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);
+
+            Dbm.flow.addUpdateCommand(lineItem.item.properties.quantity, this._changeCommand);
+
+            let newLineItems = [].concat(lineItems);
+            newLineItems.push(lineItem.item);
+            this.item.lineItems = newLineItems;
+        }
+
+        return lineItem;
+    }
+
+    removeLineItem(aItem) {
+        let lineItems = [].concat(this.item.lineItems);
+        
+        let index = lineItems.indexOf(aItem);
+        if(index >= 0) {
+            lineItems.splice(index, 1);
+            this.item.lineItems = lineItems;
+        }
+    }
+
+    _changed() {
+        //console.log("_changed");
+        
+        let lineItems = this.item.lineItems;
+
+        this.item.numberOfLines = lineItems.length;
+
+        let itemsCount = 0;
+        let currentArray = lineItems;
+        let currentArrayLength = currentArray.length;
+        for(let i = 0; i < currentArrayLength; i++) {
+            let currentItem = currentArray[i];
+            itemsCount += currentItem.quantity;
+        }
+
+        this.item.numberOfItems = itemsCount;
+        this.item.changeCount++;
+
+        //METODO: calculate totals
+    }
+}

package/ecommerce/CartLineItem.js

@@ -0,0 +1,44 @@
+import Dbm from "../index.js";
+
+export default class CartLineItem extends Dbm.core.BaseObject {
+    _construct() {
+        super._construct();
+
+        this.item.setValue("cart", null);
+        this.item.setValue("product", null);
+        this.item.setValue("quantity", 0);
+    }
+
+    setCart(aItem) {
+        this.item.cart = aItem;
+
+        return this;
+    }
+
+    setProduct(aProduct) {
+        this.item.product = aProduct;
+
+        return this;
+    }
+
+    setQuantity(aQuantity) {
+        console.log("setQuantity");
+        console.log(aQuantity);
+
+        this.item.quantity = aQuantity;
+
+        return this;
+    }
+
+    increaseQuantity(aQuantity) {
+        this.item.quantity += aQuantity;
+
+        return this;
+    }
+
+    remove() {
+        this.item.cart.controller.removeLineItem(this.item);
+
+        return this;
+    }
+}

package/ecommerce/LocalStorageCartLoader.js

@@ -0,0 +1,74 @@
+import Dbm from "../index.js";
+
+export default class LocalStorageCartLoader extends Dbm.core.BaseObject {
+    _construct() {
+        super._construct();
+
+        this._changeCommand = Dbm.commands.callFunction(this._changed.bind(this));
+
+        this._isLoading = false;
+        this.item.requireProperty("storageKey", "cart");
+        this.item.requireProperty("cart", null);
+    }
+
+    setCart(aCart) {
+        this.item.cart = aCart;
+        Dbm.flow.addUpdateCommand(aCart.properties.changeCount, this._changeCommand);
+
+        return this;
+    }
+
+    load() {
+        //console.log("load");
+
+        let repository = Dbm.getInstance().repository;
+
+        this._isLoading = true;
+        try {
+            let cartDataString = localStorage.getItem(this.item.storageKey);
+            if(cartDataString) {
+                let cartData = JSON.parse(cartDataString);
+                console.log(cartData);
+                let currentArray = cartData.lineItems;
+                let currentArrayLength = currentArray.length;
+                for(let i = 0; i < currentArrayLength; i++) {
+                    let currentData = currentArray[i];
+
+                    console.log(">>>>>>>>", currentData["quantity"]);
+                    this.item.cart.controller.addProduct(repository.getItem(currentData["product"]), currentData["quantity"]);
+                }
+            }
+        }
+        catch(theError) {
+            console.error(theError);
+        }
+
+        this._isLoading = false;
+    }
+
+    _changed() {
+        //console.log("_changed");
+        
+        if(this._isLoading) {
+            return;
+        }
+
+        let encodedLineItems = [];
+
+        let currentArray = this.item.cart.lineItems;
+        let currentArrayLength = currentArray.length;
+        for(let i = 0; i < currentArrayLength; i++) {
+            let currentData = currentArray[i];
+
+            let encodedData = {"product": currentData.product.id, "quantity": currentData.quantity};
+            encodedLineItems.push(encodedData);
+        }
+
+        try {
+            let cartDataString = localStorage.setItem(this.item.storageKey, JSON.stringify({"lineItems": encodedLineItems}));
+        }
+        catch(theError) {
+            console.error(theError);
+        }
+    }
+}

package/ecommerce/index.js

@@ -0,0 +1,16 @@
+import Dbm from "../index.js";
+
+export {default as Cart} from "./Cart.js";
+export {default as CartLineItem} from "./CartLineItem.js";
+export {default as LocalStorageCartLoader} from "./LocalStorageCartLoader.js";
+
+export const setup = function() {
+    
+    let cart = new Dbm.ecommerce.Cart();
+    cart.item.register("cart");
+
+    let localStorageLoader = new Dbm.ecommerce.LocalStorageCartLoader();
+    localStorageLoader.setCart(cart.item);
+    localStorageLoader.load();
+
+}

package/graphapi/webclient/WebSocketConnection.js

@@ -4,6 +4,8 @@ export default class WebSocketConnection extends Dbm.core.BaseObject {
     _construct() {
         super._construct();
 
+        this._connectBound = this._connect.bind(this);
+
 		this._url = null;
         this._webSocket = null;
         this._reconnectIfDisconnected = false;
@@ -161,7 +163,7 @@ export default class WebSocketConnection extends Dbm.core.BaseObject {
 		this.item.setValue("status", 0);
 
         if(this._reconnectIfDisconnected) {
-            this._connect();
+            setTimeout(this._connectBound, 2*1000);
         }
     }
 	

package/graphapi/webclient/decode/index.js

@@ -58,7 +58,7 @@ export const fullSetup = function() {
     {
         let name = "urlRequest";
         let currentDecoder = new Dbm.graphapi.webclient.decode.DecodeBaseObject();
-        currentDecoder.item.setValue("copyFields", ["meta/description"]);
+        currentDecoder.item.setValue("copyFields", ["meta/description", "seo/noIndex", "seo/noFollow"]);
         currentDecoder.item.setValue("encodingType", name);
         currentDecoder.item.register(decodePrefix + name);
     }
@@ -117,4 +117,28 @@ export const fullSetup = function() {
         currentDecoder.item.setValue("encodingType", name);
         currentDecoder.item.register(decodePrefix + name);
     }
+
+    {
+        let name = "admin_fields";
+        let currentDecoder = new Dbm.graphapi.webclient.decode.DecodeBaseObject();
+        currentDecoder.item.setValue("copyFields", ["fields"]);
+        currentDecoder.item.setValue("encodingType", name);
+        currentDecoder.item.register(decodePrefix + name);
+    }
+
+    {
+        let name = "objectTypes";
+        let currentDecoder = new Dbm.graphapi.webclient.decode.DecodeBaseObject();
+        currentDecoder.item.setValue("copyFields", ["objectTypes"]);
+        currentDecoder.item.setValue("encodingType", name);
+        currentDecoder.item.register(decodePrefix + name);
+    }
+
+    {
+            let name = "helpSection";
+            let currentDecoder = new Dbm.graphapi.webclient.decode.DecodeBaseObject();
+            currentDecoder.item.setValue("copyFields", ["title", "link"]);
+            currentDecoder.item.setValue("encodingType", name);
+            currentDecoder.item.register(decodePrefix + name);
+        }
 }

package/package.json

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

package/react/BaseObject.js

@@ -53,8 +53,7 @@ export default class BaseObject extends Component {
 
     getDynamicProp(aName, aInitialValue = null) {
         if(!this._dynamicProps[aName]) {
-            let newProperty = new Dbm.flow.FlowProperty();
-            newProperty.value = aInitialValue;
+            let newProperty = this.item.requireProperty("props/" + aName, aInitialValue);
             this._dynamicProps[aName] = newProperty;
             let updateState = this._getStateUpdate();
             let stateProperty = updateState.input.register(aName, aInitialValue);
@@ -65,8 +64,7 @@ export default class BaseObject extends Component {
 
     getDynamicPropWithoutState(aName, aInitialValue = null) {
         if(!this._dynamicProps[aName]) {
-            let newProperty = new Dbm.flow.FlowProperty();
-            newProperty.value = aInitialValue;
+            let newProperty = this.item.requireProperty("props/" + aName, aInitialValue);
             this._dynamicProps[aName] = newProperty;
         }
         return this._dynamicProps[aName];

package/react/admin/EditPage.js

@@ -23,6 +23,9 @@ export default class EditPage extends Dbm.react.BaseObject {
         let descriptionLength = Dbm.flow.updatefunctions.basic.length(descriptionEditor.item.editValue.value);
         this.item.requireProperty("descriptionLength", 0).connectInput(descriptionLength.output.properties.length);
 
+        itemEditor.addFieldEditor("seo/noIndex", page["seo/noIndex"], "seo/noIndex");
+        itemEditor.addFieldEditor("seo/noFollow", page["seo/noFollow"], "seo/noFollow");
+
         this.item.requireProperty("importText", "");
     }
 
@@ -169,6 +172,17 @@ export default class EditPage extends Dbm.react.BaseObject {
                             " / ",
                             "155"
                         )
+                    ),
+
+                    React.createElement("div", {className: "flex-row small-item-spacing"},
+                        React.createElement("div", {className: "flex-row-item"},
+                            React.createElement(Dbm.react.form.Checkbox, {checked: itemEditor.getEditor("seo/noIndex").item.editValue.value}),
+                            "Noindex"
+                        ),
+                        React.createElement("div", {className: "flex-row-item"},
+                            React.createElement(Dbm.react.form.Checkbox, {checked: itemEditor.getEditor("seo/noFollow").item.editValue.value}),
+                            "Nofollow"
+                        ),
                     )
                 ),
                 React.createElement("div", {className: "spacing standard"}),

package/react/admin/editor/fields/SelectionField.js

@@ -0,0 +1,55 @@
+import React from "react";
+import Dbm from "../../../../index.js";
+
+export default class SelectionField extends Dbm.react.BaseObject {
+    _construct() {
+        super._construct();
+
+        this._valueChangedBound = this._valueChanged.bind(this);
+        this._objectChangedBound = this._objectChanged.bind(this);
+
+        Dbm.flow.addUpdateCommand(this.item.requireProperty("value", this._getObjectData()), Dbm.commands.callFunction(this._valueChangedBound));
+
+        let editorData = Dbm.objectPath(this.context, "moduleData.editorData");
+        Dbm.flow.addUpdateCommand(editorData.properties.data, Dbm.commands.callFunction(this._objectChangedBound));
+    }
+
+    _getObjectData() {
+        let fieldName = this.getPropValue("name");
+
+        let editorData = Dbm.objectPath(this.context, "moduleData.editorData");
+
+        let returnData = editorData.data[fieldName];
+        if(!returnData) {
+            returnData = null;
+        }
+
+        return returnData;
+    }
+
+
+    _valueChanged() {
+        //console.log("_valueChanged");
+
+        let fieldName = this.getPropValue("name");
+        let newValue = this.item.value;
+
+        let editorData = Dbm.objectPath(this.context, "moduleData.editorData");
+
+        let newData = {...editorData.data};
+        newData[fieldName] = newValue;
+
+        editorData.data = newData;
+        this.context.moduleData.editorData.editorBlock.dataUpdated();
+    }
+
+    _objectChanged() {
+        //console.log("_objectChanged");
+
+        this.item.value = this._getObjectData();
+    }
+
+    _renderMainElement() {
+        return this._createMainElement(Dbm.react.form.Selection, {value: this.item.properties.value, className: "full-width"}, this.getPropValue("children"));
+    }
+}

package/react/admin/editor/fields/index.js

@@ -2,4 +2,5 @@ export {default as TextField} from "./TextField.js";
 export {default as RichTextField} from "./RichTextField.js";
 export {default as ImageField} from "./ImageField.js";
 export {default as CheckboxField} from "./CheckboxField.js";
-export {default as SelectObjectField} from "./SelectObjectField.js";
+export {default as SelectObjectField} from "./SelectObjectField.js";
+export {default as SelectionField} from "./SelectionField.js";

package/react/admin/editorsgroup/EditField.js

@@ -0,0 +1,28 @@
+import React from "react";
+import Dbm from "../../../index.js";
+
+export default class EditField extends Dbm.react.BaseObject {
+    _construct() {
+        super._construct();
+
+        let item = this.context.item;
+        let itemEditor = this.context.itemEditor;
+        let fieldName = this.getPropValue("fieldName");
+        let initialDataPath = this.getPropValueWithDefault("initialDataPath", fieldName);
+        let initialData = Dbm.objectPath(item, initialDataPath);
+
+        console.log(">>>>>>>>>>", initialData, item, initialDataPath);
+
+        let editor = itemEditor.addFieldEditor(fieldName, initialData);
+        this.item.setValue("editor", editor.item);
+    }
+
+    _renderMainElement() {
+
+        let children = this.getPropValue("children")
+
+        return React.createElement("div", {},
+            React.createElement(Dbm.react.context.AddContextVariables, {"values": {"valueEditor": this.item.editor}}, children)
+        );
+    }
+}

package/react/admin/editorsgroup/index.js

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

package/react/admin/index.js

@@ -3,4 +3,7 @@ export {default as EditPage} from "./EditPage.js";
 export {default as SelectImageFromLibrary} from "./SelectImageFromLibrary.js";
 
 export * as editor from "./editor/index.js";
-export * as pages from "./pages/index.js";
+export * as pages from "./pages/index.js";
+export * as website from "./website/index.js";
+export * as objects from "./objects/index.js";
+export * as editorsgroup from "./editorsgroup/index.js";

package/react/admin/objects/EditObject.js

@@ -0,0 +1,50 @@
+import React from "react";
+import Dbm from "../../../index.js";
+
+export default class EditObject extends Dbm.react.BaseObject {
+    _construct() {
+        super._construct();
+
+        let graphApi = Dbm.getInstance().repository.getItem("graphApi").controller;
+
+        let id = this.getPropValue("id");
+
+        let allLoaded = Dbm.flow.updatefunctions.logic.allAtValue(Dbm.loading.LoadingStatus.LOADED);
+        this.item.requireProperty("loaded", false);
+
+        {
+            let request = graphApi.requestRange(
+                [
+                    {"type": "includePrivate"},
+                    {"type": "includeDraft"},
+                    {"type": "idSelection", "ids": [id]},
+                ],
+                ["objectTypes"]
+            );
+            allLoaded.addCheck(request.properties.status);
+        }
+
+        this.item.properties.loaded.connectInput(allLoaded.output.properties.value);
+    }
+
+   
+
+    _renderMainElement() {
+
+        let id = this.getPropValue("id");
+        let item = Dbm.getInstance().repository.getItem(id);
+        let itemEditor = this.context.editorGroup.getItemEditor(id);
+
+        return React.createElement("div", {},
+            
+            React.createElement(Dbm.react.area.HasData, {check: this.item.properties.loaded},
+                React.createElement(Dbm.react.context.AddContextVariables, {"values": {"item": item, "itemEditor": itemEditor}},
+                    React.createElement(Dbm.react.area.List, {items: Dbm.react.source.contextVariable("item.objectTypes"), "as": "objectType", "keyField": "(root)"},
+                        React.createElement(Dbm.react.admin.objects.InjectObjectTypeEditor, {type: Dbm.react.source.contextVariable("objectType")})
+                    )
+                )
+            )
+            
+        )
+    }
+}

package/react/admin/objects/InjectObjectTypeEditor.js

@@ -0,0 +1,30 @@
+import React from "react";
+import Dbm from "../../../index.js";
+
+export default class InjectObjectTypeEditor extends Dbm.react.BaseObject {
+    _construct() {
+        super._construct();
+    }
+
+   
+
+    _renderMainElement() {
+
+        let type = this.getPropValue("type");
+        let editor = Dbm.getInstance().repository.getItem("admin/objectTypeEditors/" + type);
+
+        let editors = editor.editors;
+        if(!editors) {
+            return null;
+        }
+        let elements = Dbm.utils.ArrayFunctions.mapField(editors, "element");
+
+        console.log(editors, elements);
+
+        if(!elements) {
+            return null;
+        }
+
+        return React.createElement(Dbm.react.area.InsertElement, {element: elements});
+    }
+}

package/react/admin/objects/ObjectList.js

@@ -0,0 +1,92 @@
+import React from "react";
+import Dbm from "../../../index.js";
+
+export default class ObjectList extends Dbm.react.BaseObject {
+    _construct() {
+        super._construct();
+
+        let graphApi = Dbm.getInstance().repository.getItem("graphApi").controller;
+
+        this.item.requireProperty("items", []);
+
+        let objectType = this.getPropValue("objectType");
+        let encodings = this.getPropValueWithDefault("encodings", ["name"]);
+
+        let allLoaded = Dbm.flow.updatefunctions.logic.allAtValue(Dbm.loading.LoadingStatus.LOADED);
+        this.item.requireProperty("loaded", false);
+
+        {
+            let request = graphApi.requestRange(
+                [
+                    {"type": "includePrivate"},
+                    {"type": "includeDraft"},
+                    {"type": "byObjectType", "objectType": objectType},
+                ],
+                encodings
+            );
+            Dbm.flow.addUpdateCommandWhenMatched(request.properties.status, Dbm.loading.LoadingStatus.LOADED, Dbm.commands.callFunction(this._loaded.bind(this), [request]));
+            allLoaded.addCheck(request.properties.status);
+        }
+
+        this.item.properties.loaded.connectInput(allLoaded.output.properties.value);
+    }
+
+    _loaded(aRequest) {
+        console.log("_loaded");
+
+        let currentArray = [].concat(aRequest.items);
+
+        let nameField = this.getPropValueWithDefault("nameField", "name");
+        Dbm.utils.ArrayFunctions.sortOnField(currentArray, nameField);
+        
+        this.item.items = currentArray;
+    }
+
+    _create() {
+        console.log("_create");
+        let objectType = this.getPropValue("objectType");
+        let encodings = this.getPropValueWithDefault("encodings", ["name"]);
+        let visibility = this.getPropValueWithDefault("visibility", "private");
+
+        let changes = [
+            {"type": "setField", "data": {"value": "Unnamed " + objectType, "field": "name"}}
+        ];
+
+        let request = Dbm.getInstance().repository.getItem("graphApi").controller.createItem([objectType], visibility, changes, encodings);
+
+        Dbm.flow.addUpdateCommand(request.properties.status, Dbm.commands.callFunction(this._created.bind(this), [request]));
+    }
+
+    _created(aRequest) {
+        console.log("_created");
+        console.log(aRequest);
+
+        let newItems = [].concat(this.item.items);
+        console.log(newItems);
+        newItems.push(aRequest.item);
+        this.item.items = newItems;
+    }
+
+    _renderMainElement() {
+        
+        let nameField = this.getPropValueWithDefault("nameField", "name");
+
+        let id = Dbm.react.source.contextVariable("item.id");
+        let text = Dbm.react.source.contextVariable("item." + nameField);
+
+        return React.createElement("div", {"className": "standard-alternating-rows"},
+            React.createElement(Dbm.react.area.List, {items: this.item.properties.items},
+                React.createElement(Dbm.react.admin.objects.ObjectListRow, {"id": id, "text": text})
+            ),
+            React.createElement("div", {"className": "spacing standard"}),
+            React.createElement("div", {"className": "flex-row"},
+                React.createElement("div", {"className": "flex-row-item"},
+                    React.createElement(Dbm.react.interaction.CommandButton, {"command": Dbm.commands.callFunction(this._create.bind(this))},
+                        React.createElement("div", {"className": "standard-button standard-button-padding"}, "Create")
+                    )
+                )
+            )
+            
+        )
+    }
+}