Multiple Document Creation

[jviseur]

I have a need where I need to create a set of document using the same data source but each document has it's own template.
Is there a way that can be done using n8n and DocxTemplater?

One option is to call the Workflow as many times as there are templates and then manually zip the documents. Is there an option to feed all templates and generate the documents and then zip them?

[jreyesr]

Hello @jviseur! In principle, rendering the same data against multiple templates should be doable with a Merge node set to Combine by All Possible Combinations. Something like this:

The Merge node should be set up like this:

Then, you need to ensure that the branch that generates the templates, e.g. from Google Drive or from Read from Disk or from HTTP Requests or from FTP or whatever, generates multiple items, each with a Binary property. The other branch should contain the JSON document that you'll use as context (or you could just write it directly on the DocxTemplater node, in the Data field)

Combine+All Possible Combinations will multiply the N items with binary data by the 1 item with JSON data, and the result will be N×1=N items with both JSON and binary data. Those can then be passed as normal to the DocxTemplater node, it'll automatically (like almost all N8N nodes) run once for each of the items that it's passed.

---

As for compressing all those output items into a single one, you could handle it like discussed here. You need to add a Code node that converts all the items, each with a data binary property, into a single item with multiple Binary properties. You can copy the JSON below and paste it into your workflow, it should become the appropriate node (or you can also find it in the discussion thread linked above)

{
  "nodes": [
    {
      "parameters": {
        "jsCode": "let binaries = {}, binary_keys = [];\n\nfor (const [index, inputItem] of Object.entries($input.all())) {\n  binaries[`data_${index}`] = inputItem.binary.data;\n  binary_keys.push(`data_${index}`);\n}\n\nreturn [{\n    json: {\n        binary_keys: binary_keys.join(',')\n    },\n    binary: binaries\n}];\n"
      },
      "name": "Merge items",
      "type": "n8n-nodes-base.code",
      "position": [
        432,
        584
      ],
      "typeVersion": 1
    }
  ],
  "connections": {
    "Merge items": {
      "main": [
        []
      ]
    }
  }
}

This node will work like this:

It receives multiple items, each with the same binary property (here it's data, which is the default in N8N) and outputs a single item, with multiple binary properties data_0, data_1 and so on. This is necessary because the Compress node acts on each item that it receives, so if you just feed the N items into Compress you'll get N zip files, each with just one file inside.

Then, you can add a Compression node like this one:

{
  "nodes": [
    {
      "parameters": {
        "operation": "compress",
        "binaryPropertyName": "={{ $binary.keys().join(\",\") }}",
        "fileName": "docs.zip"
      },
      "type": "n8n-nodes-base.compression",
      "typeVersion": 1.1,
      "position": [
        656,
        584
      ],
      "name": "Compression"
    }
  ],
  "connections": {}
}

The trick in that node is that the Input Binary Fields setting is set to {{ $binary.keys().join(",") }}, which dynamically adjusts to however many data_X binary properties exist in the input item. Otherwise, you'd have to hard-code all those property names, which I guess you can do in your case, but it may not always be feasible if the number of templates that will be rendered is not known beforehand or can change.

Let me know if this works or if you encounter any errors

[jviseur]

@jreyesr thank you for your answer

[jviseur]

I manage to get it to function

The Code block I set up 3 templates with a code for each template to be included in the final file name.

``` [
  {
    "Record": "1",
    "Member": "10000",
    "Templates": [
      {
        "template": "Template1.docx",
        "code": "Code1"
      },
      {
        "template": "Template2.docx",
        "code": "Code2"
      },
      {
        "template": "Template3.docx",
        "code": "Code3"
      }
    ]
  }
]

Code1 converts the input to
```javascript
[
  {
    "template": "Template1.docx",
    "code": "Code1",
    "url": "https://URL1"
  },
  {
    "template": "Template2.docx",
    "code": "Code2",
    "url": "https://URL2"
  },
  {
    "template": "Template3.docx",
    "code": "Code3",
    "url": "https://URL3"
  }
]

Get Template gets all 3 templates which will be combined with the data source.
Build extra Data sources does some manipulation of the source data to create additional data (calculated data) that is used in the templates. In this case each template need to be out put twice, one for each recipient.

All 6 documents are fed into the DocxTemplater who in turn outputs 6 document
Combine docs turn parallel stream in to a serial stream that is then combine into a single zip file