dbm 1.1.10 → 1.1.12

package/core/source/SourceBaseObject.js

@@ -24,6 +24,14 @@ export default class SourceBaseObject extends Dbm.core.BaseObject {
 
         if(this._log) {
             console.log("Source>>>>>", baseObject, path);
+            let currentPath = "";
+            let currentArray = path.split(".");
+            let currentArrayLength = currentArray.length;
+            for(let i = 0; i < currentArrayLength; i++) {
+                currentPath += currentArray[i];
+                console.log(currentPath, Dbm.objectPath(baseObject, currentPath));
+                currentPath += ".";
+            }
         }
 
 		if(!path) {

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/flow/controllers/transform/SingleArrayValues.js

@@ -0,0 +1,125 @@
+import Dbm from "../../../index.js";
+
+export default class SingleArrayValues extends Dbm.core.BaseObject {
+    _construct() {
+        super._construct();
+
+        this.item.requireProperty("array", []);
+        this.item.requireProperty("items", []);
+
+        let arrayUpdatedCommand = Dbm.commands.callFunction(this._arrayUpdated.bind(this));
+        Dbm.flow.addUpdateCommand(this.item.properties.array, arrayUpdatedCommand);
+
+        this._valueUpdatedCommand = Dbm.commands.callFunction(this._valueUpdated.bind(this));
+        
+    }
+
+    _createItem(aInitialValue = null) {
+        let newItem = new Dbm.repository.Item();
+        newItem.setId("_dbmInternal/" + Dbm.getInstance().getNextId());
+        Dbm.flow.addUpdateCommand(newItem.requireProperty("value", aInitialValue), this._valueUpdatedCommand);
+
+        return newItem;
+    }
+
+    push(aValue = null) {
+        let item = this._createItem(aValue);
+        
+        let dataArray = [].concat(this.item.array);
+        let itemsArray = [].concat(this.item.items);
+
+        itemsArray.push(item);
+        dataArray.push(aValue);
+        
+        this.item.items = itemsArray;
+        this.item.properties.array.getMostUpstreamProperty().value = dataArray;
+    }
+
+    removeItem(aItem) {
+        //console.log("removeItem");
+        //console.log(aItem);
+
+        let dataArray = [].concat(this.item.array);
+        let itemsArray = [].concat(this.item.items);
+
+        let index = itemsArray.indexOf(aItem);
+        if(index >= 0) {
+            itemsArray.splice(index, 1);
+            dataArray.splice(index, 1);
+            
+            this.item.items = itemsArray;
+            this.item.properties.array.getMostUpstreamProperty().value = dataArray;
+        }
+    }
+
+    _movePosition(aFromIndex, aToIndex) {
+        //METODO
+    }
+
+    moveItem(aItem, aPosition) {
+        let index = this.item.items.indexOf(aItem);
+        if(index >= 0) {
+            this._movePosition(index, aPosition);
+        }
+    }
+
+    moveUpItem(aItem, aPosition) {
+
+        let index = this.item.items.indexOf(aItem);
+        if(index >= 0) {
+            if(index > 0) {
+                this._movePosition(index, index-1);
+            }
+        }
+    }
+
+    moveDownItem(aItem, aPosition) {
+        let index = this.item.items.indexOf(aItem);
+        if(index >= 0) {
+            if(index < this.item.items.length-1) {
+                this._movePosition(index, index+1);
+            }
+        }
+    }
+
+    _arrayUpdated() {
+        console.log("_arrayUpdated");
+
+        let dataArray = this.item.array;
+        let itemsArray = this.item.items;
+
+        let dataLength = dataArray.length;
+        let itemsLength = itemsArray.length;
+        let itemChange = dataLength-itemsLength;
+        if(itemChange !== 0) {
+            itemsArray = [].concat(itemsArray);
+            if(itemChange < 0) {
+                itemsArray.splice(itemsArray.length, Math.abs(itemChange));
+            }
+            else if(itemChange > 0) {
+                for(let i = 0; i < itemChange; i++) {
+                    itemsArray.push(this._createItem(dataArray[itemsLength+i]));
+                }
+            }
+        }
+        
+        let currentArray = dataArray;
+        let currentArrayLength = currentArray.length;
+        for(let i = 0; i < currentArrayLength; i++) {
+            itemsArray[i].value = currentArray[i];
+        }
+
+        if(itemChange !== 0) {
+            this.item.items = itemsArray;
+        }
+        
+    }
+
+    _valueUpdated() {
+        console.log("_valueUpdated");
+
+        let values = Dbm.utils.ArrayFunctions.mapField(this.item.items, "value");
+        console.log(values); 
+        this.item.properties.array.getMostUpstreamProperty().value = values;
+    }
+}

package/flow/controllers/transform/index.js

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

package/graphapi/webclient/GraphApi.js

@@ -21,7 +21,7 @@ export default class GraphApi extends Dbm.core.BaseObject {
 	}
 	
     requestRange(aSelect, aEncode) {
-        console.log("requestRange");
+        //console.log("requestRange");
 
         if(this._websocketConnection && this._websocketConnection.item.status === 1) {
 			return this._websocketConnection.requestRange(aSelect, aEncode);
@@ -31,7 +31,7 @@ export default class GraphApi extends Dbm.core.BaseObject {
     }
 
     requestItem(aId, aEncode) {
-        console.log("requestItem");
+        //console.log("requestItem");
 
         if(this._websocketConnection && this._websocketConnection.item.status === 1) {
             return this._websocketConnection.requestItem(aId, aEncode);

package/graphapi/webclient/admin/ImageUploader.js

@@ -0,0 +1,81 @@
+import Dbm from "../../../index.js";
+
+export default class ImageUploader extends Dbm.core.BaseObject {
+
+    _construct() {
+        super._construct();
+
+        this.item.requireProperty("file", null);
+        this.item.requireProperty("status", 0);
+        this.item.requireProperty("item", null);
+
+        this._fileUploadedBound = this._fileUploaded.bind(this);
+    }
+
+    setFile(aFile) {
+        this.item.file = aFile;
+        return this;
+    }
+
+    uploadImage() {
+        console.log("uploadImage");
+        if(this.item.status !== 0) {
+            console.warn("Image is already uploading", this);
+            return this;
+        }
+
+        let file = this.item.file;
+        if(!file) {
+            console.warn("No file set", this);
+            return this;
+        }
+
+        this.item.status = 2;
+                
+        let graphApi = Dbm.getInstance().repository.getItem("graphApi").controller;
+
+        let preSign = graphApi.requestData("fileUpload", {"fileName": file.name, "mimeType": file.type});
+
+        Dbm.flow.addDirectUpdateCommand(preSign.getProperty("status"), Dbm.commands.callFunction(this._statusChanged.bind(this), [preSign, file]));
+        
+        return this;
+    }
+        
+    _statusChanged(aPreSign, aFile) {
+        console.log("_statusChanged");
+        console.log(aPreSign, aFile);
+
+        let item = Dbm.getInstance().repository.getItem(aPreSign.data.id);
+        item.setValue("name", aPreSign.data.name);
+        item.setValue("url", aPreSign.data.publicUrl);
+        item.setValue("resizeUrl", aPreSign.data.publicResizeUrl);
+        item.setValue("identifier", aPreSign.data.identifier);
+        this.item.item = item;
+
+        if(aPreSign.status === 1) {
+            let url = aPreSign.data.url;
+            console.log(url, aPreSign.data);
+
+            let headers = {
+                'Content-Type': aFile.type,
+                'Cache-Control': 'no-cache',
+            };
+
+            let additionalHeaders = aPreSign.data.additionalHeaders;
+            for(let objectName in additionalHeaders) {
+                headers[objectName] = additionalHeaders[objectName];
+            }
+
+            fetch(url, {method: 'PUT', headers: new Headers(headers), body: aFile}).then(this._fileUploadedBound)
+
+        }
+    }
+
+    _fileUploaded() {
+        console.log("_fileUploaded");
+
+        this.item.status = 1;
+
+        console.log("Uploaded", this.item.item);
+    }
+}

package/graphapi/webclient/admin/ItemEditor.js

@@ -42,6 +42,68 @@ export default class ItemEditor extends Dbm.core.BaseObject {
         return this.addEditor(aField, aInitialValue, Dbm.graphapi.webclient.admin.SaveFunctions.setField, aUpdateEncoding);
     }
 
+    _addRelationEditor(aName, aType, aObjectType, aInitialValue, aSaveFunction, aUpdateEncoding = null) {
+        let valueEditor = this.item["editor_relation_" + aName];
+        if(!valueEditor) {
+            valueEditor = new Dbm.graphapi.webclient.admin.ValueEditor();
+            valueEditor.item.editValue.setInitialValue(aInitialValue);
+
+            valueEditor.item.setValue("itemEditor", this.item);
+            valueEditor.item.setValue("type", aType);
+            valueEditor.item.setValue("objectType", aObjectType);
+            valueEditor.item.setValue("updateEncoding", aUpdateEncoding);
+
+            this.item.anyChange.addCheck(valueEditor.item.properties.changed);
+            this.item.setValue("editor_relation_" + aName, valueEditor); 
+            this.item.editors = [].concat(this.item.editors, valueEditor);
+            
+            valueEditor.addSaveFunction(aSaveFunction);
+        }
+
+        return valueEditor;
+    }
+
+    addIncomingRelationEditor(aType, aObjectType, aInitialValue, aUpdateEncoding = null) {
+        let name = "in_" + aType + "_" + aObjectType;
+        return this._addRelationEditor(name, aType, aObjectType, aInitialValue, Dbm.graphapi.webclient.admin.SaveFunctions.incomingRelation, aUpdateEncoding);
+    }
+
+    addOutgoingRelationEditor(aType, aObjectType, aInitialValue, aUpdateEncoding = null) {
+        let name = "out_" + aType + "_" + aObjectType;
+        return this._addRelationEditor(name, aType, aObjectType, aInitialValue, Dbm.graphapi.webclient.admin.SaveFunctions.outgoingRelation, aUpdateEncoding);
+    }
+
+    _addMultipleRelationsEditor(aName, aType, aObjectType, aInitialValue, aSaveFunction, aUpdateEncoding = null) {
+        let valueEditor = this.item["editor_relation_" + aName];
+        if(!valueEditor) {
+            valueEditor = new Dbm.graphapi.webclient.admin.ValueEditor();
+            valueEditor.item.editValue.setInitialValue(aInitialValue);
+
+            valueEditor.item.setValue("itemEditor", this.item);
+            valueEditor.item.setValue("type", aType);
+            valueEditor.item.setValue("objectType", aObjectType);
+            valueEditor.item.setValue("updateEncoding", aUpdateEncoding);
+
+            this.item.anyChange.addCheck(valueEditor.item.properties.changed);
+            this.item.setValue("editor_multipleRelations_" + aName, valueEditor); 
+            this.item.editors = [].concat(this.item.editors, valueEditor);
+            
+            valueEditor.addSaveFunction(aSaveFunction);
+        }
+
+        return valueEditor;
+    }
+
+    addMultipleIncomingRelationsEditor(aType, aObjectType, aInitialValue, aUpdateEncoding = null) {
+        let name = "in_" + aType + "_" + aObjectType;
+        return this._addMultipleRelationsEditor(name, aType, aObjectType, aInitialValue, Dbm.graphapi.webclient.admin.SaveFunctions.multipleIncomingRelations, aUpdateEncoding);
+    }
+
+    addMultipleOutgoingRelationsEditor(aType, aObjectType, aInitialValue, aUpdateEncoding = null) {
+        let name = "out_" + aType + "_" + aObjectType;
+        return this._addMultipleRelationsEditor(name, aType, aObjectType, aInitialValue, Dbm.graphapi.webclient.admin.SaveFunctions.multipleOutgoingRelations, aUpdateEncoding);
+    }
+
     addCommandsToSaveData(aSaveData) {
 
         let editedItemId = Dbm.objectPath(this.item, "editedItem.id");

package/graphapi/webclient/admin/SaveFunctions.js

@@ -1,7 +1,41 @@
+import Dbm from "../../../index.js";
+
 export const setField = function(aEditor, aItemSaveData) {
     aItemSaveData.setField(aEditor.item.name, aEditor.item.editValue.getValue());
 }
 
 export const setUrl = function(aEditor, aItemSaveData) {
     aItemSaveData.createChange("setUrl", {"value": aEditor.item.editValue.getValue()});
+}
+
+export const setIdentifier = function(aEditor, aItemSaveData) {
+    aItemSaveData.createChange("setIdentifier", {"value": aEditor.item.editValue.getValue()});
+}
+
+export const setVisibility = function(aEditor, aItemSaveData) {
+    aItemSaveData.createChange("setVisibility", {"value": aEditor.item.editValue.getValue()});
+}
+
+export const incomingRelation = function(aEditor, aItemSaveData) {
+    let id = aEditor.item.editValue.getValue();
+
+    aItemSaveData.createChange("replaceIncomingRelation", {"value": id, "type": aEditor.item.type, "objectType": aEditor.item.objectType});
+}
+
+export const outgoingRelation = function(aEditor, aItemSaveData) {
+    let id = aEditor.item.editValue.getValue();
+
+    aItemSaveData.createChange("replaceOutgoingRelation", {"value": id, "type": aEditor.item.type, "objectType": aEditor.item.objectType});
+}
+
+export const multipleIncomingRelations = function(aEditor, aItemSaveData) {
+    let ids = Dbm.utils.ArrayFunctions.removeValues(aEditor.item.editValue.getValue(), [0, null, undefined]);
+
+    aItemSaveData.createChange("replaceMultipleIncomingRelations", {"value": ids, "type": aEditor.item.type, "objectType": aEditor.item.objectType});
+}
+
+export const multipleOutgoingRelations = function(aEditor, aItemSaveData) {
+    let ids = Dbm.utils.ArrayFunctions.removeValues(aEditor.item.editValue.getValue(), [0, null, undefined]);
+
+    aItemSaveData.createChange("replaceMultipleOutgoingRelations", {"value": ids, "type": aEditor.item.type, "objectType": aEditor.item.objectType});
 }

package/graphapi/webclient/admin/index.js

@@ -5,4 +5,6 @@ export {default as EditorGroup} from "./EditorGroup.js";
 export {default as ItemEditor} from "./ItemEditor.js";
 export {default as ValueEditor} from "./ValueEditor.js";
 
+export {default as ImageUploader} from "./ImageUploader.js";
+
 export * as SaveFunctions from "./SaveFunctions.js";

package/graphapi/webclient/decode/Relations.js

@@ -0,0 +1,77 @@
+import Dbm from "../../../index.js";
+
+export default class Relations extends Dbm.graphapi.webclient.decode.DecodeBaseObject {
+    _construct() {
+        super._construct();
+    }
+
+    _isRelationValid(aStartTime, aEndTime) {
+        let now = (new Date()).toISOString().split("T").join(" ").substring(0, 19);
+
+        return ((aStartTime === null || aStartTime <= now) && (aEndTime === null || aEndTime > now));
+    }
+
+    updateItem(aItem, aData) {
+        super.updateItem(aItem, aData);
+
+        let relations = aData["relations"];
+        {
+            let currentRelations = relations["in"];
+            let currentRelationsItem = aItem["relations/in"];
+            if(!currentRelationsItem) {
+                currentRelationsItem = new Dbm.repository.Item();
+                aItem.setValue("relations/in", currentRelationsItem);
+            }
+
+            let currentArray = currentRelations;
+            let currentArrayLength = currentArray.length;
+            for(let i = 0; i < currentArrayLength; i++) {
+                let currentRelationData = currentArray[i];
+                let currentType = currentRelationData["type"];
+                let typeItem = currentRelationsItem[currentType];
+                if(!typeItem) {
+                    typeItem = new Dbm.repository.Item();
+                    typeItem.setValue("objects", []);
+                    currentRelationsItem.setValue(currentType, typeItem);
+                }
+
+                if(this._isRelationValid(currentRelationData["startAt"], currentRelationData["endAt"])) {
+                    let newArray = [].concat(typeItem["objects"]);
+                    newArray.push(Dbm.getInstance().repository.getItem(currentRelationData["id"]));
+                    typeItem["objects"] = newArray;
+                    //METODO: set up relations
+                }
+                
+            }
+        }
+
+        {
+            let currentRelations = relations["out"];
+            let currentRelationsItem = aItem["relations/out"];
+            if(!currentRelationsItem) {
+                currentRelationsItem = new Dbm.repository.Item();
+                aItem.setValue("relations/out", currentRelationsItem);
+            }
+
+            let currentArray = currentRelations;
+            let currentArrayLength = currentArray.length;
+            for(let i = 0; i < currentArrayLength; i++) {
+                let currentRelationData = currentArray[i];
+                let currentType = currentRelationData["type"];
+                let typeItem = currentRelationsItem[currentType];
+                if(!typeItem) {
+                    typeItem = new Dbm.repository.Item();
+                    typeItem.setValue("objects", []);
+                    currentRelationsItem.setValue(currentType, typeItem);
+                }
+
+                if(this._isRelationValid(currentRelationData["startAt"], currentRelationData["endAt"])) {
+                    let newArray = [].concat(typeItem["objects"]);
+                    newArray.push(Dbm.getInstance().repository.getItem(currentRelationData["id"]));
+                    typeItem["objects"] = newArray;
+                    //METODO: set up relations
+                }
+            }
+        }
+    }
+}