dbm 1.4.12 → 1.4.14

package/commands/index.js

@@ -61,6 +61,12 @@ export const performCommands = function(aCommands, aFromObject = null, aEventDat
     let currentArrayLength = currentArray.length;
     for(let i = 0; i < currentArrayLength; i++) {
         let currentCommand = currentArray[i];
+
+        if(currentCommand && currentCommand.isSource) {
+            currentCommand = currentCommand.getSource(aFromObject);
+        }
+        //METODO: add flow property
+
         try {
             currentCommand.perform(aFromObject, aEventData);
         }

package/css/all.css

@@ -5,4 +5,5 @@
 @import './rows.css';
 @import './icons.css';
 @import './tags.css';
-@import './elements.css';
+@import './elements.css';
+@import './text.css';

package/css/tags.css

@@ -107,8 +107,17 @@
     overflow: hidden;
 }
 
-.standard-tag-list .standard-tag-list-item{
+.standard-tag-list .standard-tag-list-item {
     float: left;
     margin-right: var(--standard-tag-list-horizontal-margin, 10px);
     margin-bottom: var(--standard-tag-list-vertical-margin, 5px);
+}
+
+.option {
+    cursor: pointer;
+}
+
+.option.selected {
+    background-color: var(--standard-tag-option-selected-background-color, #555555);
+    color: var(--standard-tag-option-selected-text-color, #ffffff);
 }

package/css/text.css

@@ -0,0 +1,4 @@
+.small-description {
+    font-size: 12px;
+    color: #828282;
+}

package/flow/updatefunctions/basic/GetItemBy.js

@@ -0,0 +1,20 @@
+import Dbm from "../../../index.js";
+
+export default class GetItemBy extends Dbm.flow.FlowUpdateFunction {
+
+    _construct() {
+        super._construct();
+        
+        this.input.register("value", null);
+        this.input.register("items", []);
+        this.input.register("path", "id");
+
+        this.output.register("value", null);
+    }
+
+    _update() {
+        //console.log("GetItemBy::_update");
+        
+        this.output.value = Dbm.utils.ArrayFunctions.getItemBy(this.input.items, this.input.path, this.input.value);
+    }
+}

package/flow/updatefunctions/basic/index.js

@@ -8,6 +8,7 @@ export {default as PropertyOfWithDefault} from "./PropertyOfWithDefault.js";
 export {default as MappedList} from "./MappedList.js";
 export {default as Translation} from "./Translation.js";
 export {default as SetProperty} from "./SetProperty.js";
+export {default as GetItemBy} from "./GetItemBy.js";
 
 export const runCommand = function(aValue, aCommand) {
 	let updateFunction = new Dbm.flow.updatefunctions.basic.RunCommand();
@@ -134,5 +135,16 @@ export const setProperty = function(aObject, aPropertyName, aValue = null) {
 	properties.object.setOrConnect(aObject);
 	properties.propertyName.setOrConnect(aPropertyName);
 
+	return updateFunction;
+}
+
+export const getItemBy = function(aItems, aValue, aPath = "id") {
+	let updateFunction = new Dbm.flow.updatefunctions.basic.GetItemBy();
+
+	let properties = updateFunction.input.properties;
+	properties.value.setOrConnect(aValue);
+	properties.items.setOrConnect(aItems);
+	properties.path.setOrConnect(aPath);
+
 	return updateFunction;
 }

package/flow/updatefunctions/logic/Condition.js

@@ -17,13 +17,13 @@ export default class Condition extends Dbm.flow.FlowUpdateFunction {
 
         let operation = this.input.operation;
         if(typeof(operation) === "string") {
-            if(operation === "!==") {
-                operation = function(aA, aB) {return aA !== aB;}
-            }
-            else {
-                //METODO: add more operations
-                operation = function(aA, aB) {return aA === aB;}
+            let compareFunction = Dbm.getInstance().repository.getItem("compareFunctions/" + operation).compare;
+            if(!compareFunction) {
+                console.warn("No copmare function registered for: " + operation + ". Using ==", this);
+                compareFunction = Dbm.utils.CompareFunctions.equals;
             }
+
+            operation = compareFunction
         }
 
         this.output.result = operation.call(this, this.input.input1, this.input.input2);

package/graphapi/webclient/admin/ItemEditor.js

@@ -134,6 +134,7 @@ export default class ItemEditor extends Dbm.core.BaseObject {
     }
 
     addMultipleIncomingRelationsEditor(aType, aObjectType, aInitialValue, aUpdateEncoding = null) {
+        //console.log("addMultipleIncomingRelationsEditor");
         let name = "in_" + aType + "_" + aObjectType;
         return this._addMultipleRelationsEditor(name, aType, aObjectType, aInitialValue, Dbm.graphapi.webclient.admin.SaveFunctions.multipleIncomingRelations, aUpdateEncoding);
     }
@@ -144,6 +145,7 @@ export default class ItemEditor extends Dbm.core.BaseObject {
     }
 
     getAdminMultipleIncomingRelationsEditor(aType, aObjectType) {
+        //console.log("getAdminMultipleIncomingRelationsEditor");
         let name = "in_" + aType + "_" + aObjectType;
         let valueEditor = this.item["editor_multipleRelations_" + name];
         if(!valueEditor) {

package/graphapi/webclient/decode/Relations.js

@@ -39,7 +39,12 @@ export default class Relations extends Dbm.graphapi.webclient.decode.DecodeBaseO
                 let relation = Dbm.getRepositoryItem(currentRelationData["relationId"]);
                 if(typeItem.relations.indexOf(relation) === -1) {
                     let linkedItem = Dbm.getRepositoryItem(currentRelationData["id"]);
-                    //METODO: add data to relation
+
+                    relation.setValue("from", linkedItem);
+                    relation.setValue("to", aItem);
+                    relation.setValue("startAt", currentRelationData["startAt"]);
+                    relation.setValue("endAt", currentRelationData["endAt"]);
+
                     if(this._isRelationValid(currentRelationData["startAt"], currentRelationData["endAt"])) {
                         typeItem.addToArray("objects", linkedItem);
                         typeItem.addToArray("relations", relation);
@@ -72,7 +77,12 @@ export default class Relations extends Dbm.graphapi.webclient.decode.DecodeBaseO
                 let relation = Dbm.getRepositoryItem(currentRelationData["relationId"]);
                 if(typeItem.relations.indexOf(relation) === -1) {
                     let linkedItem = Dbm.getRepositoryItem(currentRelationData["id"]);
-                    //METODO: add data to relation
+                    
+                    relation.setValue("from", aItem);
+                    relation.setValue("to", linkedItem);
+                    relation.setValue("startAt", currentRelationData["startAt"]);
+                    relation.setValue("endAt", currentRelationData["endAt"]);
+
                     if(this._isRelationValid(currentRelationData["startAt"], currentRelationData["endAt"])) {
                         typeItem.addToArray("objects", linkedItem);
                         typeItem.addToArray("relations", relation);

package/graphapi/webclient/index.js

@@ -65,4 +65,16 @@ export const performAction = function(aType, aData, aCallback = null) {
     }
     
     return request.properties.data;
+}
+
+export const loadRange = function(aSelects, aEncodings, aCommand) {
+    let graphApi = Dbm.getRepositoryItem("cachedGraphApi").controller;
+        
+    let request = graphApi.requestRange(aSelects, aEncodings);
+    
+    if(aCommand) {
+        Dbm.flow.runWhenMatched(request.properties.status, Dbm.loading.LoadingStatus.LOADED, aCommand);
+    }
+
+    return request.properties.items;
 }

package/package.json

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

package/react/admin/objects/EditObject.js

@@ -19,7 +19,7 @@ export default class EditObject extends Dbm.react.BaseObject {
                     {"type": "includeDraft"},
                     {"type": "idSelection", "ids": [id]},
                 ],
-                ["objectTypes"]
+                ["objectTypes", "name", "identifier"]
             );
             allLoaded.addCheck(request.properties.status);
         }
@@ -38,11 +38,23 @@ export default class EditObject extends Dbm.react.BaseObject {
             
             React.createElement(Dbm.react.area.HasData, {check: this.item.properties.loaded},
                 React.createElement(Dbm.react.context.AddContextVariables, {"values": {"item": item}},
-                    React.createElement(Dbm.react.admin.editorsgroup.EditItem, {}, 
-                        React.createElement(Dbm.react.area.List, {items: Dbm.react.source.contextVariable("item.objectTypes"), "as": "objectType", "keyField": "(root)"},
-                            Dbm.react.text.text(Dbm.react.source.contextVariable("objectType"))
+                    React.createElement(Dbm.react.admin.editorsgroup.EditItem, {},
+                        React.createElement("h2", {"className": "no-margins"},
+                            Dbm.react.text.text(Dbm.react.source.item("id")),
+                            " - ",
+                            Dbm.react.text.text(Dbm.react.source.item("name")),
                         ),
-                        React.createElement(Dbm.react.area.List, {items: Dbm.react.source.contextVariable("item.objectTypes"), "as": "objectType", "keyField": "(root)"},
+                        React.createElement("div", {"className": "small-description"},
+                            Dbm.react.text.text(Dbm.react.source.item("identifier"))
+                        ),
+                        React.createElement("div", {"className": "spacing small"}),
+                        React.createElement(Dbm.react.area.List, {items: Dbm.react.source.item("objectTypes"), className: "inline-list standard-tag-list standard-tag-list-expand", "as": "objectType", "keyField": "(root)"},
+                            React.createElement("div", {"className": "standard-tag standard-tag-padding standard-tag-list-item inline-list-item display-inline-block"},
+                                Dbm.react.text.text(Dbm.react.source.contextVariable("objectType"))
+                            )
+                        ),
+                        React.createElement("div", {"className": "spacing small"}),
+                        React.createElement(Dbm.react.area.List, {items: Dbm.react.source.item("objectTypes"), "as": "objectType", "keyField": "(root)"},
                             React.createElement(Dbm.react.admin.objects.InjectObjectTypeEditor, {type: Dbm.react.source.contextVariable("objectType")})
                         )
                     )

package/react/form/CustomSelection.js

@@ -0,0 +1,69 @@
+import React from "react";
+import Dbm from "../../index.js";
+
+export default class CustomSelection extends Dbm.react.BaseObject {
+    _construct() {
+        super._construct();
+
+        let valueProperty = this.getDynamicPropWithoutState("value", null);
+        let itemsProperty = this.getDynamicPropWithoutState("items", []);
+
+        let openProperty = this.item.requireProperty("open", false);
+        this.item.requireProperty("rows", []);
+
+        this.item.requireProperty("selectedItem", null);
+
+        let mappedList = Dbm.flow.updatefunctions.basic.mappedList(itemsProperty, [this._getScopedCallFunctionCommand(this._newRow, [Dbm.core.source.event("mappedItem")])]);
+        this.item.setValue("mappedList", mappedList);
+        this.item.properties.rows.connectInput(mappedList.output.properties.items);
+
+        let singleSelection = new Dbm.flow.controllers.select.SingleSelection();
+        this.item.setValue("singleSelection", singleSelection.item);
+        singleSelection.item.properties.value.connectInput(valueProperty);
+
+        let closeCommand = Dbm.commands.setProperty(openProperty, false);
+        this.item.setValue("closeCommand", closeCommand);
+
+        let path = this.getPropValueWithDefault("path", "id");
+        let getItemBy = Dbm.flow.updatefunctions.basic.getItemBy(itemsProperty, valueProperty, path);
+        this.item.setValue("getItemBy", getItemBy);
+
+        this.item.properties.selectedItem.connectInput(getItemBy.output.properties.value);
+    }
+
+    _newRow(aRow) {
+        //console.log("_newRow");
+        //console.log(aRow);
+
+        let path = this.getPropValueWithDefault("path", "id");
+
+        let value = Dbm.objectPath(aRow, "forItem." + path);
+
+        let selectedProperty = this.item.singleSelection.controller.addSelectionValue(value);
+
+        aRow.setValue("value", value);
+        aRow.requireProperty("selected", false).connectInput(selectedProperty);
+    }
+
+    _renderMainElement() {
+
+        let children = Dbm.utils.ArrayFunctions.singleOrArray(this.getPropValue("children"));
+        
+        let slots = Dbm.react.ChildFunctions.splitIntoSlots(children);
+                
+        let buttonElement = slots["button"];
+        let mainChildren = slots.main;
+
+        let contextValues = {"value": this.item.properties["props/value"], "selectedItem": this.item.properties.selectedItem, "rows": this.item.properties.rows, "closeCommand": this.item.closeCommand};
+
+        return this._createMainElement(Dbm.react.form.Dropdown, {"open": this.item.properties.open},
+            React.createElement(Dbm.react.context.AddContextVariables, {"data-slot": "button", "values": contextValues}, 
+                React.createElement(Dbm.react.area.InsertElement, {"element": buttonElement})
+            ),
+            React.createElement(Dbm.react.context.AddContextVariables, {"values": contextValues}, 
+                React.createElement(Dbm.react.area.InsertElement, {"element": mainChildren})
+            )
+        );
+    }
+}
+

package/react/form/GraphApiObjectCustomSelection.js

@@ -0,0 +1,105 @@
+import React from "react";
+import Dbm from "../../index.js";
+
+export default class GraphApiObjectSelection extends Dbm.react.BaseObject {
+    _construct() {
+        super._construct();
+
+        this.getDynamicProp("value", "");
+        this.item.requireProperty("items", []);
+        this.item.requireProperty("sortedItems", []);
+
+        let objectType = this.getPropValue("objectType");
+        let encodings = Dbm.utils.ArrayFunctions.arrayOrSeparatedString(this.getPropValueWithDefault("encoding", "name"), ",", true);
+
+        {
+            let selects = [
+                    {"type": "byObjectType", "objectType": objectType},
+                    {"type": "includeDraft"},
+                    {"type": "includePrivate"}
+                ];
+            if(this.getPropValue("anyStatus")) {
+                selects = [
+                    {"type": "byObjectType", "objectType": objectType},
+                    {"type": "includeAnyStatus"}
+                ];
+            }
+
+            let request = Dbm.getCachedGraphApi().requestRange(
+                selects,
+                encodings
+            );
+
+            this.item.properties.items.connectInput(request.properties.items);
+
+            Dbm.flow.runWhenMatched(request.properties.status, Dbm.loading.LoadingStatus.LOADED, Dbm.commands.callFunction(this._itemsLoaded.bind(this), [request]));
+        }
+    }
+
+    _itemsLoaded(aRequest) {
+
+        let nameField = this.getPropValueWithDefault("nameField", "name");
+
+        let currentArray = [].concat(aRequest.items);
+        Dbm.utils.ArrayFunctions.naturalSortOnField(currentArray, nameField);
+
+        this.item.sortedItems = currentArray;
+    }
+
+    _renderMainElement() {
+
+        let value = this.getDynamicProp("value");
+        let nameField = this.getPropValueWithDefault("nameField", "name");
+
+        return this._createMainElement(Dbm.react.form.CustomSelection, {"value": value, "items": this.item.properties.sortedItems, "path": nameField},
+
+    React.createElement("div", {
+    "data-slot": "button",
+    children: [React.createElement(Dbm.react.area.HasData, {
+      check: Dbm.react.source.contextVariable("value"),
+      children: React.createElement(Dbm.react.context.AddItemToContext, {
+        item: Dbm.react.source.contextVariable("selectedItem"),
+        children: [React.createElement(Dbm.react.area.HasData, {
+          check: Dbm.react.source.item(),
+          children: React.createElement("div", {
+            children: Dbm.react.text.text(Dbm.react.source.item("name"))
+          })
+        }), React.createElement(Dbm.react.area.HasData, {
+          check: Dbm.react.source.item(),
+          checkType: "invert/default",
+          children: React.createElement("div", {
+            children: Dbm.react.text.text(Dbm.react.source.contextVariable("value"))
+          })
+        })]
+      })
+    }), React.createElement(Dbm.react.area.HasData, {
+      check: Dbm.react.source.contextVariable("value"),
+      checkType: "invert/default",
+      children: React.createElement("div", {
+        children: Dbm.react.text.translatedText("Select")
+      })
+    })]
+  }), React.createElement("div", {
+    children: React.createElement(Dbm.react.area.HasData, {
+      check: Dbm.react.source.contextVariable("isVisible"),
+      children: React.createElement(Dbm.react.area.List, {
+        items: Dbm.react.source.contextVariable("rows"),
+        as: "row",
+        children: React.createElement(Dbm.react.context.AddItemToContext, {
+          item: Dbm.react.source.contextVariable("row.forItem"),
+          children: React.createElement(Dbm.react.interaction.CommandButton, {
+            commands: [Dbm.commands.setProperty(Dbm.react.source.contextVariable("row.properties.selected"), true), Dbm.react.source.contextVariable("closeCommand")],
+            children: React.createElement("div", {
+              children: Dbm.react.text.text(Dbm.react.source.item("name"))
+            })
+          })
+        })
+      })
+    })
+  })
+
+
+        );
+    }
+}
+

package/react/form/index.js

@@ -7,6 +7,7 @@ export {default as LabelledArea} from "./LabelledArea.js";
 export {default as FileDropArea} from "./FileDropArea.js";
 export {default as Selection} from "./Selection.js";
 export {default as GraphApiObjectSelection} from "./GraphApiObjectSelection.js";
+export {default as GraphApiObjectCustomSelection} from "./GraphApiObjectCustomSelection.js";
 export {default as GraphApiSelectOrCreateObject} from "./GraphApiSelectOrCreateObject.js";
 export {default as GraphApiImage} from "./GraphApiImage.js";
 export {default as EditArray} from "./EditArray.js";
@@ -16,6 +17,7 @@ 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 CustomSelection} from "./CustomSelection.js";
 
 export const validationStateClassName = function(aChildren) {
     return React.createElement(Dbm.react.AddProps, {className: Dbm.react.source.contextVariable("field.properties.validationState")},

package/react/svg/AddGlobalFilterClasses.js

@@ -0,0 +1,34 @@
+import Dbm from "../../index.js";
+import React from "react";
+
+export default class GlobalFilters extends Dbm.core.BaseObject {
+    _construct() {
+        super._construct();
+
+        this._styleTag = null;
+
+        let colorFilters = Dbm.getRepositoryItem("globalSvg");
+        let filtersProperty = colorFilters.requireProperty("filters", []);
+
+        filtersProperty.addUpdate(this._getScopedCallFunctionCommand(this._updateStyles));
+        this._updateStyles();
+    }
+
+    _updateStyles() {
+        console.log("_updateStyles");
+
+        let colorFilters = Dbm.getRepositoryItem("globalSvg");
+        console.log(colorFilters.filters.length);
+
+        if(colorFilters.filters.length) {
+            if(!this._styleTag) {
+                this._styleTag = document.createElement("style");
+                document.head.appendChild(this._styleTag);
+            }
+
+            let declarations = Dbm.utils.ArrayFunctions.mapField(colorFilters.filters, "classDeclaration");
+            this._styleTag.innerHTML = declarations.join("\n");
+            console.log(declarations);
+        }
+    }
+}

package/react/svg/index.js

@@ -3,6 +3,7 @@ import React from "react";
 
 export {default as GlobalFilters} from "./GlobalFilters.js";
 export {default as MatrixFilter} from "./MatrixFilter.js";
+export {default as AddGlobalFilterClasses} from "./AddGlobalFilterClasses.js";
 
 export const addGlobalRgbColorFilter = function(aName, aR, aG, aB) {
 
@@ -11,6 +12,7 @@ export const addGlobalRgbColorFilter = function(aName, aR, aG, aB) {
 
     let item = Dbm.getRepositoryItem("globalSvg/filters/" + aName);
     item.setValue("element", React.createElement(Dbm.react.svg.MatrixFilter, {"id": aName, "matrix": Dbm.utils.svg.ColorMatrixFunctions.floodColor(aR, aG, aB)}));
+    item.setValue("classDeclaration", "." + aName + "{filter:url(\"#" + aName + "\")}");
 
     let filters = [].concat(colorFilters.filters);
     filters.push(item);