document template: editor for text and html

entity/DocumentTemplate_entity/DocumentTemplate_entity.aod

@@ -77,6 +77,10 @@
     <entityField>
       <name>BINDATA</name>
       <contentType>FILE</contentType>
+      <onValueChange>%aditoprj%/entity/DocumentTemplate_entity/entityfields/bindata/onValueChange.js</onValueChange>
+      <onValueChangeTypes>
+        <element>MASK</element>
+      </onValueChangeTypes>
     </entityField>
     <entityConsumer>
       <name>Documents</name>
@@ -143,7 +147,6 @@
       <title>Text</title>
       <contentType>LONG_TEXT</contentType>
       <contentTypeProcess>%aditoprj%/entity/DocumentTemplate_entity/entityfields/content/contentTypeProcess.js</contentTypeProcess>
-      <state>INVISIBLE</state>
       <stateProcess>%aditoprj%/entity/DocumentTemplate_entity/entityfields/content/stateProcess.js</stateProcess>
       <valueProcess>%aditoprj%/entity/DocumentTemplate_entity/entityfields/content/valueProcess.js</valueProcess>
     </entityField>

entity/DocumentTemplate_entity/entityfields/bindata/onValueChange.js

+import("DocumentTemplate_lib");
+import("system.neon");
+import("system.vars");
+
+// note: could not use only the valueProcess from $field.Content because then it refreshed $field.Content just before save.
+// --> only set in $field.Content.valueProcess if $field.Content is null and set it from here only if MASK triggered change
+if((vars.get("$sys.operatingstate") == neon.OPERATINGSTATE_EDIT || vars.get("$sys.operatingstate") == neon.OPERATINGSTATE_NEW))
+{
+    vars.set("$field.Content", DocumentTemplateUtils.getTemplateContent(vars.get("$field.DOCUMENTTEMPLATEID"), new FileUpload(vars.get("$local.value"))))
+}

entity/DocumentTemplate_entity/entityfields/content/contentTypeProcess.js

 import("system.result");
-import("KeywordRegistry_basic");
 import("system.vars");
-import("system.neon");
+import("DocumentTemplate_lib");
 
-if (vars.get("$field.CLASSIFICATION") == $KeywordRegistry.documentTemplateTypeCategory$htmlTemplate() 
-    || vars.get("$field.KIND") == $KeywordRegistry.documentTemplateType$mail())
-{
-    result.string("HTML");
-}
\ No newline at end of file
+var type = DocumentTemplateUtils.getContentType(vars.get("$field.DOCUMENTTEMPLATEID"), new FileUpload(vars.get("$field.BINDATA")))
+
+if (type == DocumentTemplate.types.HTML)
+    result.string("HTML");
\ No newline at end of file

entity/DocumentTemplate_entity/entityfields/content/stateProcess.js

-import("MimeType_lib");
-import("Document_lib");
-import("KeywordRegistry_basic");
-import("system.neon");
 import("system.result");
 import("system.vars");
+import("system.neon");
 
-if((vars.get("$field.KIND") == $KeywordRegistry.documentTemplateType$textModular() || vars.get("$field.KIND") == $KeywordRegistry.documentTemplateType$mail())
-        && vars.get("$field.BINDATA") == "")
-{
-    var mimeType = DocumentUtil.getMimeTypeFromUpload(vars.get("$field.NAME"));
-        
-    if (mimeType == MimeTypes.TXT() || vars.get("$sys.operatingstate") == neon.OPERATINGSTATE_NEW)
-    {
-        result.string(neon.COMPONENTSTATE_EDITABLE);
-    }
-}
\ No newline at end of file
+if (vars.get("$field.Content") || !vars.get("$field.BINDATA"))
+    result.string(neon.COMPONENTSTATE_EDITABLE);
+else
+    result.string(neon.COMPONENTSTATE_INVISIBLE);
\ No newline at end of file

entity/DocumentTemplate_entity/entityfields/content/valueProcess.js

-import("MimeType_lib");
-import("Sql_lib");
-import("Document_lib");
-import("system.util");
-import("system.db");
-import("system.neon");
 import("system.result");
+import("system.neon");
+import("system.neon");
+import("DocumentTemplate_lib");
 import("system.vars");
 
-if(vars.get("$field.KIND").trim() == "TEX" && vars.get("$field.BINDATA") == "" && vars.get("$sys.operatingstate") == neon.OPERATINGSTATE_EDIT)
+if((vars.get("$sys.operatingstate") == neon.OPERATINGSTATE_EDIT || vars.get("$sys.operatingstate") == neon.OPERATINGSTATE_NEW) && vars.get("$this.value") == null)
 {
-    var mimeType = DocumentUtil.getMimeTypeFromUpload(vars.get("$field.NAME"));
-    
-    if (mimeType == MimeTypes.TXT())
-    {
-        var binaryId      = db.cell(SqlCondition.begin()
-            .andPrepareVars("ASYS_BINARIES.ROW_ID", "$field.DOCUMENTTEMPLATEID")
-            .buildSql("select ID from ASYS_BINARIES"), SqlUtils.getSystemAlias());
-        result.string(util.decodeBase64String(db.getBinaryContent(binaryId, SqlUtils.getSystemAlias())));
-    }
-}
\ No newline at end of file
+    result.string(DocumentTemplateUtils.getTemplateContent(vars.get("$field.DOCUMENTTEMPLATEID"), new FileUpload(vars.get("$field.BINDATA"))))
+}

entity/DocumentTemplate_entity/recordcontainers/db/onDBUpdate.js

@@ -3,7 +3,8 @@ import("system.vars");
 import("Document_lib");
 
 var rowdata = vars.get("$local.rowdata");
+var content = vars.get("$field.Content");
 var upload = new FileUpload(vars.get("$field.BINDATA"));
 var rowId = vars.get("$local.uid");
 
-DocumentTemplateUtils.updateTemplateData(rowId, upload, rowdata["DOCUMENTTEMPLATE.KIND"], vars.get("$field.Content"), rowdata["DOCUMENTTEMPLATE.NAME"]);
\ No newline at end of file
+DocumentTemplateUtils.updateTemplateData(rowId, upload, rowdata["DOCUMENTTEMPLATE.KIND"], content, rowdata["DOCUMENTTEMPLATE.CLASSIFICATION"], rowdata["DOCUMENTTEMPLATE.NAME"]);
\ No newline at end of file

process/DocumentTemplate_lib/process.js

@@ -178,6 +178,19 @@ DocumentTemplate.types = {
             default:
                 return null;
         }
+    },
+    /**
+     * chooses the type depending on the extension in the metadata. If the extension doesn't work, try mimetype
+     * @param {String[]} pBinaryMetadata the binary metadata from system.db
+     */
+    fromBinaryMetadata: function(pBinaryMetadata)
+    {
+        let filename = pBinaryMetadata[db.BINARY_FILENAME].split(".");
+        let type = DocumentTemplate.types.fromFileExtension(filename[filename.length - 1]);
+        if (type == null)
+            type = DocumentTemplate.types.fromMimeType(pBinaryMetadata[db.BINARY_MIMETYPE]);
+        
+        return type;
     }
 };
 
@@ -674,15 +687,20 @@ function DocumentTemplateUtils () {}
  * if pText is provided, it is used as template, otherwise pFileUpload
  * 
  * @param {FileUpload} pFileUpload upload value
+ * @param {String} pKind kind of template
  * @param {String} pText text input
  * @param {String} pClassification the classification type. Used if pText is not empty. Defines if it is saved as txt or html.
  * @param {String} pTemplateName name of the template
- * @param {String} pKind kind of template
  * @return {FileUpload} a FileUpload object with the data
  */
-DocumentTemplateUtils.chooseSuppliedTemplate = function (pFileUpload, pText, pClassification, pTemplateName, pKind)
+DocumentTemplateUtils.chooseSuppliedTemplate = function (pFileUpload, pKind, pText, pClassification, pTemplateName)
 {
-    if (!pFileUpload.isFilled() && pText != "")
+    if (pFileUpload.isFilled() && pText != "")
+    {
+        // use fileUpload but use the custom text as bindata
+        pFileUpload.bindata = util.encodeBase64String(pText);
+    }
+    else if (!pFileUpload.isFilled() && pText != "")
     {
         pFileUpload.filename = pTemplateName;
         
@@ -702,18 +720,11 @@ DocumentTemplateUtils.chooseSuppliedTemplate = function (pFileUpload, pText, pCl
  */
 DocumentTemplateUtils.insertTemplateData = function (pTemplateId, pFileUpload, pKind, pText, pClassification, pTemplateName)
 {
-    var textInput = "";
-    if (pKind == $KeywordRegistry.documentTemplateType$textModular()
-        || (pKind == $KeywordRegistry.documentTemplateType$mail() && !pFileUpload.isFilled()))
-    {
-        textInput = pText;
-    }
-
-    pFileUpload = DocumentTemplateUtils.chooseSuppliedTemplate(pFileUpload, textInput, pClassification, pTemplateName, pKind)
+    pFileUpload = DocumentTemplateUtils.chooseSuppliedTemplate(pFileUpload, pKind, pText, pClassification, pTemplateName)
     if (pFileUpload.isFilled())
     {
         db.insertBinary("DOCUMENTTEMPLATE", "DOCUMENT", pTemplateId, 
-            "", pFileUpload.bindata, pFileUpload.filename, "", "MAINDOCUMENT", SqlUtils.getSystemAlias());
+            "", pFileUpload.bindata, pFileUpload.filename, "", "TEMPLATE", SqlUtils.getSystemAlias());
     }
 }
 
@@ -722,18 +733,91 @@ DocumentTemplateUtils.insertTemplateData = function (pTemplateId, pFileUpload, p
  */
 DocumentTemplateUtils.updateTemplateData = function (pTemplateId, pFileUpload, pKind, pText, pClassification, pTemplateName)
 {
-    var textInput = pKind == $KeywordRegistry.documentTemplateType$textModular() ? pText : "";
-    pFileUpload = DocumentTemplateUtils.chooseSuppliedTemplate(pFileUpload, textInput, pClassification, pTemplateName, pKind)
+    pFileUpload = DocumentTemplateUtils.chooseSuppliedTemplate(pFileUpload, pKind, pText, pClassification, pTemplateName)
     if (pFileUpload.isFilled())
     {
         var assignmentTable = "DOCUMENTTEMPLATE";
         var assignmentName= "DOCUMENT";
-        var binMeta = db.getBinaryMetadata(assignmentTable, assignmentName, pTemplateId, false, SqlUtils.getSystemAlias(), "MAINDOCUMENT");
-        logging.log(JSON.stringify([binMeta], null, "\t"))
+        var keyword = "TEMPLATE";
+        var binMeta = db.getBinaryMetadata(assignmentTable, assignmentName, pTemplateId, false, SqlUtils.getSystemAlias(), keyword);
         
         if (binMeta.length == 0)
             SingleBinaryUtils.insertMainDocument(assignmentTable, assignmentName, pTemplateId, pFileUpload.bindata, pFileUpload.filename, null, SqlUtils.getSystemAlias());
         else
-            db.updateBinary(binMeta[0][db.BINARY_ID], "", pFileUpload.bindata, pFileUpload.filename, "", "MAINDOCUMENT", SqlUtils.getSystemAlias());
+            db.updateBinary(binMeta[0][db.BINARY_ID], "", pFileUpload.bindata, pFileUpload.filename, "", keyword, SqlUtils.getSystemAlias());
+    }
+}
+
+/**
+ * loads content from a fileUpload or if it's empty from a template in ASYS_BINARIES
+ * @param {String} pTemplateId the id of the template
+ * @param {FileUpload} pFileUpload upload object
+ * 
+ * @return {String} content or ""
+ */
+DocumentTemplateUtils.getTemplateContent = function (pTemplateId, pFileUpload)
+{
+    var type;
+    var bindata;
+    
+    if (pFileUpload.isFilled())
+    {
+        type = DocumentTemplate.types.fromFileExtension(pFileUpload.fileExtension);
+        bindata = pFileUpload.bindata
+    }
+    else
+    {
+        var assignmentTable = "DOCUMENTTEMPLATE";
+        var assignmentName= "DOCUMENT";
+        var keyword = "TEMPLATE";
+        
+        var binMeta = db.getBinaryMetadata(assignmentTable, assignmentName, pTemplateId, false, SqlUtils.getSystemAlias(), keyword);
+        
+        if (binMeta.length != 0)
+        {           
+            let binMeta = db.getBinaryMetadata(assignmentTable, assignmentName, pTemplateId, false, SqlUtils.getSystemAlias(), keyword);
+            bindata = db.getBinaryContent(binMeta[0][db.BINARY_ID], SqlUtils.getSystemAlias());
+            type = DocumentTemplate.types.fromBinaryMetadata(binMeta[0]);
+        }
+    }
+    
+    if (type == DocumentTemplate.types.HTML || type == DocumentTemplate.types.TXT)
+    {
+        return util.decodeBase64String(bindata);
+    }
+    
+    return "";
+}
+
+/**
+ * loads the type from a fileUpload or if it's empty from a template in ASYS_BINARIES
+ * @param {String} pTemplateId the id of the template
+ * @param {FileUpload} pFileUpload upload object
+ * 
+ * @return {String} type via DocumentTemplate.types or null
+ */
+DocumentTemplateUtils.getContentType = function (pTemplateId, pFileUpload)
+{
+    var type;
+    
+    if (pFileUpload.isFilled())
+    {
+        type = DocumentTemplate.types.fromFileExtension(pFileUpload.fileExtension);
+    }
+    else
+    {
+        var assignmentTable = "DOCUMENTTEMPLATE";
+        var assignmentName= "DOCUMENT";
+        var keyword = "TEMPLATE";
+        
+        var binMeta = db.getBinaryMetadata(assignmentTable, assignmentName, pTemplateId, false, SqlUtils.getSystemAlias(), keyword);
+        
+        if (binMeta.length != 0)
+        {           
+            let binMeta = db.getBinaryMetadata(assignmentTable, assignmentName, pTemplateId, false, SqlUtils.getSystemAlias(), keyword);
+            type = DocumentTemplate.types.fromBinaryMetadata(binMeta[0]);
+        }
     }
-}
\ No newline at end of file
+    
+    return type;
+}