A platform for community discussion. Free, open, simple.
# frozen_string_literal: true
require "liquid"
module DiscourseWorkflows
module Nodes
module Template
class V1 < NodeType
DEFAULT_TEMPLATE = <<~LIQUID
Items:
{% for item in items -%}
- {{ item.item_index }}: {{ item.name }}
{% endfor -%}
LIQUID
RUN_ONCE_FOR_ALL_ITEMS = "runOnceForAllItems"
RUN_ONCE_FOR_EACH_ITEM = "runOnceForEachItem"
RENDER_LENGTH_LIMIT = 1.megabyte
RENDER_SCORE_LIMIT = 200_000
ASSIGN_SCORE_LIMIT = 1.megabyte
OUTPUT_SCHEMA = {
"$schema" => Schema::DRAFT_URI,
"type" => "object",
"properties" => {
"template" => {
"type" => "string",
},
},
}.freeze
description(
name: "action:template",
version: "1.0",
defaults: {
icon: "code",
color: "green",
},
group: "data",
capabilities: {
run_scope: {
parameter: "mode",
values: {
RUN_ONCE_FOR_EACH_ITEM => "per_item",
RUN_ONCE_FOR_ALL_ITEMS => "all_items",
},
},
},
output_contracts: [{ schema: OUTPUT_SCHEMA }],
inputs: [
{ key: "main", type: "main", display_name: "Input", required: false, multiple: true },
],
required_inputs: 1,
properties: {
mode: {
type: :options,
default: RUN_ONCE_FOR_ALL_ITEMS,
options: [RUN_ONCE_FOR_EACH_ITEM, RUN_ONCE_FOR_ALL_ITEMS],
no_data_expression: true,
},
template: {
type: :string,
required: true,
default: DEFAULT_TEMPLATE,
no_data_expression: true,
ui: {
control: :code,
},
control_options: {
height: 240,
lang: :text,
},
},
},
)
def execute(exec_ctx)
template =
exec_ctx.get_node_parameter(
"template",
0,
default: DEFAULT_TEMPLATE,
options: {
raw_expressions: true,
},
).to_s
mode = exec_ctx.get_node_parameter("mode", 0, default: RUN_ONCE_FOR_ALL_ITEMS)
validate_mode!(mode)
[
(
if mode == RUN_ONCE_FOR_ALL_ITEMS
render_all_items(template, exec_ctx)
else
render_each_item(template, exec_ctx)
end
),
]
end
private
def validate_mode!(mode)
return if [RUN_ONCE_FOR_ALL_ITEMS, RUN_ONCE_FOR_EACH_ITEM].include?(mode)
raise_node_error!(
"Invalid Template mode",
description: "#{mode.inspect} is not a supported Template execution mode.",
)
end
def render_all_items(template, exec_ctx)
context = base_template_context(exec_ctx)
[
wrap(
{ "template" => render_template(template, context) },
paired_item: paired_items(exec_ctx),
),
]
end
def render_each_item(template, exec_ctx)
base_context = base_template_context(exec_ctx)
exec_ctx.input_items.map.with_index do |input_item, item_index|
wrap(
{
"template" =>
render_template(
template,
item_template_context(base_context, input_item, item_index),
),
},
paired_item: exec_ctx.paired_item_for(input_item),
)
end
end
def render_template(template, context)
parsed = Liquid::Template.parse(template)
parsed.resource_limits.render_length_limit = RENDER_LENGTH_LIMIT
parsed.resource_limits.render_score_limit = RENDER_SCORE_LIMIT
parsed.resource_limits.assign_score_limit = ASSIGN_SCORE_LIMIT
parsed.render!(context)
rescue Liquid::Error => e
raise_node_error!(
I18n.t("discourse_workflows.errors.template.invalid_template"),
description: e.message,
)
end
def base_template_context(exec_ctx)
workflow = workflow_context(exec_ctx)
{
"items" => input_items(exec_ctx),
"inputs" => exec_ctx.inputs.map { |group| template_items(group) },
"items_count" => exec_ctx.input_items.length,
"vars" => (exec_ctx.vars || {}).deep_stringify_keys,
"workflow" => workflow,
"execution" => execution_context(exec_ctx, workflow),
"site_settings" => site_settings_context,
}
end
def item_template_context(base_context, input_item, item_index)
item = template_item(input_item, item_index)
item.merge(base_context).merge("item" => item, "item_index" => item_index + 1)
end
def site_settings_context
settings =
SiteSetting
.all_settings
.each_with_object({}) do |setting, result|
name = setting[:setting].to_s
result[name] = setting[:secret] ? "[FILTERED]" : setting[:value]
end
SiteSetting.hidden_settings.each { |name| settings[name.to_s] ||= "[FILTERED]" }
SiteSetting.secret_settings.each { |name| settings[name.to_s] = "[FILTERED]" }
settings
end
def input_items(exec_ctx)
template_items(exec_ctx.input_items)
end
def template_items(items)
items.map.with_index { |input_item, item_index| template_item(input_item, item_index) }
end
def template_item(input_item, item_index)
input_item
.fetch("json") { {} }
.deep_stringify_keys
.merge("item" => input_item.deep_stringify_keys, "item_index" => item_index + 1)
end
def paired_items(exec_ctx)
exec_ctx.input_items.map { |item| exec_ctx.paired_item_for(item) }
end
def workflow_context(exec_ctx)
exec_ctx.get_workflow.to_h
end
def execution_context(exec_ctx, workflow)
{
"id" => exec_ctx.execution_id,
"workflow_id" => workflow["id"],
"workflow_name" => workflow["name"],
}.compact
end
end
end
end
end