dbm 1.4.6 → 1.4.7

package/core/BaseObject.js

@@ -20,4 +20,40 @@ export default class BaseObject extends Dbm.core.LifeCycleObject {
 
         return this;
     }
+
+    _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[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));
+    }
+
+    addUpdateCallWhenMatched(aPropertyOrName, aMatchValue, aFunction, aArguments = []) {
+        let addUpdateCommandWhenMatched = Dbm.objectPath(Dbm.getRepositoryItem("library"), "Dbm/flow/addUpdateCommandWhenMatched");
+        addUpdateCommandWhenMatched(this._propertyOrName(aPropertyOrName), aMatchValue, this._getScopedCallFunctionCommand(aFunction, aArguments));
+    }
+
+    destroy() {
+        if(this._item) {
+            //METODO: destroy item
+        }
+        this._item = null;
+        super.destroy();
+    }
 }

package/dbm.js

@@ -6,7 +6,6 @@ export const setupGlobalInstance = function(aObject, aPath) {
     }
 }
 
-
 export const getInstance = function() {
     return globalThis.dbm;
 }

package/flow/ExternalObjectUpdater.js

@@ -0,0 +1,65 @@
+import Dbm from "../index.js";
+
+export default class ExternalObjectUpdater extends Dbm.core.BaseObject {
+    _construct() {
+        super._construct();
+
+        this.item.requireProperty("object", null);
+        this.item.requireProperty("updateFunctions", []);
+        this.item.requireProperty("running", true);
+
+        this.addUpdateCallWhenMatched("running", true, this.start);
+        this.addUpdateCallWhenMatched("running", false, this.stop);
+
+    }
+
+    get object() {
+        return this.item.object;
+    }
+
+    addProperty(aName, aValue, aPath = null) {
+        if(!aPath) {
+            aPath = aName;
+        }
+
+        let property = this.item.requireProperty(aName, null);
+        property.setOrConnect(aValue);
+        let updateFunction = Dbm.flow.updatefunctions.basic.setProperty(this.item.properties.object, aPath, property);
+        this.item.setValue("update/" + aName, updateFunction);
+        this.item.addToArray("updateFunctions", updateFunction);
+
+        if(this.item.running) {
+            updateFunction.output.properties.value.startUpdating();
+        }
+        
+        return property;
+    }
+
+    start() {
+        let currentArray = this.item.updateFunctions;
+        let currentArrayLength = currentArray.length;
+        for(let i = 0; i < currentArrayLength; i++) {
+            let updateFunction = currentArray[i];
+            updateFunction.output.properties.value.startUpdating();
+        }
+
+        return this;
+    }
+
+    stop() {
+        let currentArray = this.item.updateFunctions;
+        let currentArrayLength = currentArray.length;
+        for(let i = 0; i < currentArrayLength; i++) {
+            let updateFunction = currentArray[i];
+            updateFunction.output.properties.value.stopUpdating();
+        }
+
+        return this;
+    }
+
+    destroy() {
+        this.stop();
+
+        super.destroy();
+    }
+}

package/flow/FlowProperty.js

@@ -137,12 +137,12 @@ export default class FlowProperty extends Dbm.flow.FlowBaseObject {
     }
 
     startUpdating() {
-        Dbm.getInstance().repository.getItem("propertyUpdater").controller.addProperty(this);
+        Dbm.getRepositoryItem("propertyUpdater").controller.addProperty(this);
         return this;
     }
 
     stopUpdating() {
-        Dbm.getInstance().repository.getItem("propertyUpdater").controller.removeProperty(this);
+        Dbm.getRepositoryItem("propertyUpdater").controller.removeProperty(this);
         return this;
     }
 

package/flow/index.js

@@ -7,6 +7,7 @@ export {default as UpdateFunctionInputs} from "./UpdateFunctionInputs.js";
 export {default as UpdateFunctionOutputs} from "./UpdateFunctionOutputs.js";
 export {default as DirtyCommands} from "./DirtyCommands.js";
 export {default as FlowPropertyWithExternalInput} from "./FlowPropertyWithExternalInput.js";
+export {default as ExternalObjectUpdater} from "./ExternalObjectUpdater.js";
 
 export * as updatefunctions from "./updatefunctions/index.js";
 export * as controllers from "./controllers/index.js";
@@ -48,7 +49,7 @@ export const addUpdateCommandWhenMatched = function(aProperty, aMatchValue, aCom
 	
 	updateData["whenMatched"] = whenMatched;
 	
-	return whenMatched;
+	return updateData;
 }
 
 export const runWhenMatched = function(aProperty, aMatchValue, aCommand) {
@@ -83,4 +84,12 @@ export const animateValue = function(aValue, aTime = 0.5, aEasing = null) {
 	returnObject.setValue("updateCommand", updateCommand);
 	
 	return returnObject;
+}
+
+export const externalObject = function(aObject) {
+    let returnObject = new Dbm.flow.ExternalObjectUpdater();
+
+    returnObject.item.properties.object.setOrConnect(aObject);
+
+    return returnObject;
 }

package/flow/updatefunctions/basic/SetProperty.js

@@ -0,0 +1,30 @@
+import Dbm from "../../../index.js";
+
+export default class SetProperty extends Dbm.flow.FlowUpdateFunction {
+
+    _construct() {
+        super._construct();
+        
+        this.input.register("value", "");
+        this.input.register("object", null);
+        this.input.register("propertyName", null);
+
+        this.output.register("value", null);
+    }
+
+    _update() {
+        //console.log("_update");
+
+        let value = this.input.value;
+
+        let propertyName = this.input.propertyName;
+        let object = this.input.object;
+
+        if(propertyName && object) {
+            Dbm.setAtObjectPath(object, propertyName, value);
+        }
+        
+        
+        this.output.value = value;
+    }
+}

package/flow/updatefunctions/basic/index.js

@@ -7,6 +7,7 @@ export {default as PropertyOf} from "./PropertyOf.js";
 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 const runCommand = function(aValue, aCommand) {
 	let updateFunction = new Dbm.flow.updatefunctions.basic.RunCommand();
@@ -123,4 +124,15 @@ export const translationProperty = function(aId, aDefaultValue = null, aPath = n
 	let updateFunction = translation(aId, aDefaultValue, aPath, aAdditionalPath, aTranslations);
 
 	return updateFunction.output.properties.value;
+}
+
+export const setProperty = function(aObject, aPropertyName, aValue = null) {
+	let updateFunction = new Dbm.flow.updatefunctions.basic.SetProperty();
+
+	let properties = updateFunction.input.properties;
+	properties.value.setOrConnect(aValue);
+	properties.object.setOrConnect(aObject);
+	properties.propertyName.setOrConnect(aPropertyName);
+
+	return updateFunction;
 }

package/node/communication/PostmarkApiClient.js

@@ -33,6 +33,11 @@ export default class PostmarkApiClient extends Dbm.core.BaseObject {
 			TextBody: aMessageItem.textContent,
         };
 
+		let replyTo = Dbm.objectPath(aMessageItem, "additionalData.replyTo");
+		if(replyTo) {
+			emailData["ReplyTo"] = replyTo;
+		}
+
         let response = await fetch('https://api.postmarkapp.com/email', {
             method: 'POST',
             headers: {

package/node/communication/index.js

@@ -1,4 +1,6 @@
 import Dbm from "../../index.js";
+import fs from "node:fs";
+
 export {default as PostmarkApiClient} from "./PostmarkApiClient.js";
 export {default as EmailMessage} from "./EmailMessage.js";
 
@@ -22,17 +24,59 @@ export const createEmailAction = async function(aTo, aSubject, aHtmlContent, aTe
     return action;
 }
 
-export const sendUnformattedEmail = async function(aTo, aSubject, aBody, aFrom = null, aAdditionalData = null) {
+export const sendUnformattedEmail = function(aTo, aSubject, aBody, aFrom = null, aAdditionalData = null) {
     return createEmailAction(aTo, aSubject, null, aBody, aFrom, aAdditionalData);
 }
 
-export const sendEmail = async function(aTo, aSubject, aBody, aFrom = null, aAdditionalData = null) {
-
-    let textBody = aBody; //METODO: strip tags
+export const sendEmail = function(aTo, aSubject, aBody, aFrom = null, aAdditionalData = null) {
 
+    let textBody = null;
+    let textConverter = Dbm.repository.getControllerIfExists("htmlToTextConverter");
+    if(textConverter) {
+        textBody = textConverter.convertToText(aBody);
+    }
+    
     return createEmailAction(aTo, aSubject, aBody, textBody, aFrom, aAdditionalData);
 }
 
+export const sendEmailTemplate = async function(aTemplateIdentifer, aTo, aKeywordReplace, aLanguage = "default", aDesignFilePath = null, aFrom = null, aAdditionalData = null) {
+    let emailTemplate = await Dbm.node.getDatabase().getIdentifiableObjectIfExists("emailTemplate", aTemplateIdentifer);
+
+    if(emailTemplate) {
+        await Dbm.node.forAll(emailTemplate.loadFields(), emailTemplate.loadFieldTranslations("title", "content"));
+
+        let subject = aKeywordReplace.replaceKeywords(emailTemplate.getTranslatedFieldValue("title", aLanguage));
+        let content = aKeywordReplace.replaceKeywords(emailTemplate.getTranslatedFieldValue("content", aLanguage));
+
+        if(!aDesignFilePath) {
+            aDesignFilePath = Dbm.repository.getValueIfExists("emailDesigns", "default/" + aLanguage);
+
+            if(!aDesignFilePath && (aLanguage !== "default")) {
+                aDesignFilePath = Dbm.repository.getValueIfExists("emailDesigns", "default/default");
+            }
+        }
+
+        if(aDesignFilePath) {
+            //let assetsDir = Dbm.getInstance().repository.getItem("site").assetsDir;
+            let mailContent = await fs.promises.readFile(aDesignFilePath, 'utf8');
+
+            let designKeywordReplace = new Dbm.utils.KeywordReplace();
+            designKeywordReplace.addKeyword("subject", subject);
+            designKeywordReplace.addKeyword("content", content);
+            designKeywordReplace.addKeyword("language", (aLanguage !== "default") ? aLanguage : ""); //MENOTE: get default language
+
+            //MENOTE: should we have keywords from settings here
+
+            content = designKeywordReplace.replaceKeywords(mailContent);
+        }
+        
+        await sendEmail(aTo, subject, content, aFrom, aAdditionalData);
+    }
+    else {
+        console.warn("No email template " + aTemplateIdentifer);
+    }
+}
+
 export const createPostmarkClient = function(aToken, aDefaultFromEmail = null) {
     let client = new Dbm.node.communication.PostmarkApiClient();
 

package/node/index.js

@@ -4,3 +4,7 @@ export * as communication from "./communication/index.js";
 export const getDatabase = function() {
     return Dbm.getRepositoryItem("graphDatabase").controller;
 }
+
+export const forAll = function(...aPromises) {
+    return Promise.all(aPromises);
+}

package/package.json

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

package/react/blocks/index.js

@@ -591,7 +591,25 @@ export let registerAllBlocks = function() {
         pageEditors.push(newEditor);
     }
 
+{
+        let objectTypeEditor = Dbm.getInstance().repository.getItem("admin/objectTypeEditors/emailTemplate");
+        if(!objectTypeEditor.editors) {
+            objectTypeEditor.setValue("editors", []);
+        }
+
+        let newArray = [].concat(objectTypeEditor.editors);
+        newArray.push(Dbm.getInstance().repository.getItem("admin/itemEditors/name"));
+        newArray.push(Dbm.getInstance().repository.getItem("admin/itemEditors/identifier"));
+        newArray.push(Dbm.getInstance().repository.getItem("admin/itemEditors/title"));
 
+        {
+            let itemEditor = new Dbm.repository.Item();
+            itemEditor.setValue("element", createElement(Dbm.react.admin.objects.itemeditors.RichTextFieldWithTranslations, {"label": "Content", "fieldName": "content"}));
+            newArray.push(itemEditor);
+        }
+        
+        objectTypeEditor.editors = newArray;
+    }
 
     admin.pageEditors = pageEditors;
 

package/repository/index.js

@@ -1,2 +1,25 @@
+import Dbm from "../index.js";
+
 export {default as Item} from "./Item.js";
-export {default as Repository} from "./Repository.js";
+export {default as Repository} from "./Repository.js";
+
+export const getItem = function(aName) {
+    return Dbm.getInstance().repository.getItem(aName);
+}
+
+export const getItemIfExists = function(aName) {
+    return Dbm.getInstance().repository.getItemIfExists(aName);
+}
+
+export const getValueIfExists = function(aObjectName, aPropertyName) {
+    let object = getItemIfExists(aObjectName);
+    if(!object) {
+        return null;
+    }
+
+    return Dbm.objectPath(object, aPropertyName);
+}
+
+export const getControllerIfExists = function(aObjectName) {
+    return getValueIfExists(aObjectName, "controller");
+}

package/startup/index.js

@@ -3,7 +3,7 @@ import Dbm from "../index.js";
 export {default as Runner} from "./Runner.js";
 export {default as Controller} from "./Controller.js";
 
-export let runStartup = function(aGlobalScope = "dbmstartup", aModulesName = "modules") {
+export const runStartup = function(aGlobalScope = "dbmstartup", aModulesName = "modules") {
     if(!window[aGlobalScope][aModulesName].isSetup) {
         let controller = new Dbm.startup.Controller();
 
@@ -25,4 +25,11 @@ export let runStartup = function(aGlobalScope = "dbmstartup", aModulesName = "mo
 
         currentArray.splice(0, currentArrayLength);
     }
+}
+
+export const setupLibrary = function() {
+    let library = Dbm.getRepositoryItem("library");
+    library.setValue("Dbm/commands/CallFunction", Dbm.commands.CallFunction);
+    library.setValue("Dbm/flow/addUpdateCommand", Dbm.flow.addUpdateCommand);
+    library.setValue("Dbm/flow/addUpdateCommandWhenMatched", Dbm.flow.addUpdateCommandWhenMatched);
 }

package/utils/KeywordReplace.js

@@ -0,0 +1,102 @@
+import Dbm from "../index.js";
+
+export default class KeywordReplace extends Dbm.core.BaseObject {
+    
+    _construct() {
+		super._construct();
+
+        this.item.setValue("keywordStart", "{{");
+        this.item.setValue("keywordMatch", "[^\\{\\}]*");
+        this.item.setValue("keywordEnd", "}}");
+
+        this.item.setValue("keywordProviders", []);
+        this.addKeywordProvider("default", {});
+		
+		return this;
+	}
+	
+	addKeyword(aKeyword, aValue) {
+        this.item["keywordProvider/default"][aKeyword.toLowerCase()] = aValue;
+
+        return this;
+    }
+
+    addKeywordProvider(aName, aKeywordProvider) {
+        this.item.addToArray("keywordProviders", aKeywordProvider);
+        this.item.setValue("keywordProvider/" + aName.toLowerCase(), aKeywordProvider);
+
+        return this;
+    }
+
+    escapeRegex(aText) {
+        return aText.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    }
+
+    _getRegex() {
+        let keywordStart = this.escapeRegex(this.item.keywordStart);
+        let keywordEnd = this.escapeRegex(this.item.keywordEnd);
+
+        let regex = new RegExp(keywordStart + "\\s*(" + this.item.keywordMatch + ")\\s*" + keywordEnd, "g");
+
+        return regex;
+    }
+
+    _trimRegexKey(aRegexResult) {
+        let normalizedKey = aRegexResult[1].replace(/\s+/g, "").toLowerCase();
+        return normalizedKey;
+    }
+
+    findKeywords(aText) {
+
+        let regex = this._getRegex();
+
+        let keywords =  [...regex].map(this._trimRegexKey);
+
+        return keywords;
+    }
+
+    getKeywordValue(aKeyword) {
+
+        let index = aKeyword.indexOf(":");
+        if(index === -1) {
+            let currentArray = this.item.keywordProviders;
+            let currentArrayLength = currentArray.length;
+            for(let i = 0; i < currentArrayLength; i++) {
+                let provider = currentArray[i];
+                let value = Dbm.objectPath(provider, aKeyword);
+                if(value !== undefined) {
+                    return value;
+                }
+            }
+        }
+        else {
+            let group = aKeyword.substring(0, index);
+            let keyword = aKeyword.substring(index+1);
+
+            let value = Dbm.objectPath(this.item["keywordProvider/" + group.toLowerCase()], keyword.toLowerCase());
+            if(value !== undefined) {
+                return value;
+            }
+        }
+
+        return null;
+    }
+
+    _regexReplaceKeyword(aFullMatch, aKey) {
+        let normalizedKey = aKey.replace(/\s+/g, "");
+
+        let newValue = this.getKeywordValue(normalizedKey);
+        if(newValue) {
+            return newValue;
+        }
+
+        return aFullMatch;
+    }
+
+    replaceKeywords(aText) {
+        let newText = aText.replace(this._getRegex(), this._regexReplaceKeyword.bind(this));
+
+        console.log(newText);
+        return newText;
+    }
+}

package/utils/index.js

@@ -9,6 +9,7 @@ export * as ObjectFunctions from "./ObjectFunctions.js";
 
 export {default as MultidimensionalArrayHolder} from "./MultidimensionalArrayHolder.js";
 export {default as ArrayOperationResult} from "./ArrayOperationResult.js";
+export {default as KeywordReplace} from "./KeywordReplace.js";
 
 export * as thirdparty from "./thirdparty/index.js";
 export * as svg from "./svg/index.js";