A platform for community discussion. Free, open, simple.
# frozen_string_literal: true
module DiscourseWorkflows
module Nodes
module Summarize
class V1 < NodeType
AGGREGATIONS = %w[
append
average
collect
concatenate
count
count_unique
first
last
max
min
sum
unique
].freeze
OUTPUT_PREFIXES = {
"append" => "appended_",
"average" => "average_",
"collect" => "collected_",
"concatenate" => "concatenated_",
"count" => "count_",
"count_unique" => "unique_count_",
"first" => "first_",
"last" => "last_",
"max" => "max_",
"min" => "min_",
"sum" => "sum_",
"unique" => "unique_",
}.freeze
SEPARATORS = {
"comma" => ",",
"comma_space" => ", ",
"space" => " ",
"newline" => "\n",
"none" => "",
}.freeze
SEPARATOR_OPTIONS = (SEPARATORS.keys + ["custom"]).freeze
NUMBER_TYPE = { "type" => %w[number null] }.freeze
INTEGER_TYPE = { "type" => "integer" }.freeze
STRING_TYPE = { "type" => "string" }.freeze
ARRAY_TYPE = { "type" => "array" }.freeze
ANY_TYPE = {}.freeze
description(
name: "action:summarize",
version: "1.0",
defaults: {
icon: "layer-group",
color: "yellow",
},
group: "data",
previewable: true,
capabilities: {
run_scope: "all_items",
},
properties: {
fields_to_split_by: {
type: :string,
required: false,
no_data_expression: true,
ui: {
control: :field_path,
multiple: true,
},
control_options: {
none_label_i18n_key: "discourse_workflows.summarize.group_by_none",
},
},
fields_to_summarize: {
type: :fixed_collection,
required: true,
ui: {
control: :summarize_aggregations,
},
type_options: {
multiple_values: true,
},
options: [
{
name: "values",
values: {
aggregation: {
type: :options,
required: true,
options: AGGREGATIONS,
default: "count",
no_data_expression: true,
},
field: {
type: :string,
required: false,
no_data_expression: true,
ui: {
control: :field_path,
},
},
output_field_name: {
type: :string,
required: false,
no_data_expression: true,
},
separate_by: {
type: :options,
required: false,
options: SEPARATOR_OPTIONS,
default: "comma_space",
no_data_expression: true,
display_options: {
show: {
aggregation: ["concatenate"],
},
},
},
custom_separator: {
type: :string,
required: false,
no_data_expression: true,
display_options: {
show: {
separate_by: ["custom"],
},
},
},
},
},
],
},
},
)
# The output keys depend on how the node is configured, so the contract is derived
# from the configuration rather than declared as a constant.
def self.output_schemas(configuration = {}, input_schemas: [])
config = (configuration || {}).deep_stringify_keys
rows = Array(config.dig("fields_to_summarize", "values"))
split_fields = split_field_list(config["fields_to_split_by"])
properties = {}
split_fields.each { |field| properties[field_key(field, split_fields)] = ANY_TYPE }
rows.each { |row| properties[output_key(row, rows)] = schema_type_for(row) }
[Schema.document(properties)]
end
def self.split_field_list(value)
value.to_s.split(",").filter_map { |field| field.strip.presence }
end
def self.leaf_name(field)
return field if field.exclude?(".")
field.split(".").last
end
def self.field_key(field, fields)
leaf = leaf_name(field)
return leaf if fields.count { |other| leaf_name(other) == leaf } < 2
sanitize_key(field)
end
def self.output_key(row, rows)
row = row.deep_stringify_keys
explicit = row["output_field_name"].to_s.strip
return explicit if explicit.present?
prefix = OUTPUT_PREFIXES.fetch(row["aggregation"].to_s, "")
field = row["field"].to_s.strip
return prefix.chomp("_") if field.empty?
"#{prefix}#{sanitize_key(field_key(field, derived_fields(rows, row["aggregation"])))}"
end
def self.derived_fields(rows, aggregation)
rows.filter_map do |row|
row = row.deep_stringify_keys
if row["aggregation"] != aggregation || row["output_field_name"].to_s.strip.present?
next
end
row["field"].to_s.strip.presence
end
end
def self.sanitize_key(name)
name.to_s.gsub(/["\[\]]/, "").gsub(/[ .]/, "_")
end
def self.schema_type_for(row)
case row.deep_stringify_keys["aggregation"].to_s
when "count", "count_unique"
INTEGER_TYPE
when "sum", "average"
NUMBER_TYPE
when "concatenate"
STRING_TYPE
when "append", "collect", "unique"
ARRAY_TYPE
else
ANY_TYPE
end
end
def execute(exec_ctx)
split_fields =
self.class.split_field_list(
exec_ctx.get_node_parameter("fields_to_split_by", 0, default: ""),
)
split_keys = split_fields.map { |field| self.class.field_key(field, split_fields) }
rows = normalized_rows(exec_ctx)
keyed_rows = rows.map { |row| [self.class.output_key(row, rows), row] }
validate_unique_output_keys!(keyed_rows.map(&:first))
groups = group_items(exec_ctx.input_items, split_fields)
[separate_items(groups, split_keys, keyed_rows, exec_ctx)]
end
private
def normalized_rows(exec_ctx)
rows =
Array(exec_ctx.get_node_parameter("fields_to_summarize.values", 0, default: [])).map(
&:deep_stringify_keys
)
if rows.empty?
raise_node_error!(
I18n.t("discourse_workflows.errors.summarize.no_aggregations"),
description: I18n.t("discourse_workflows.errors.summarize.no_aggregations_help"),
)
end
rows.each { |row| validate_aggregation!(row) }
rows
end
def validate_aggregation!(row)
aggregation = row["aggregation"].to_s
return if AGGREGATIONS.include?(aggregation)
raise_node_error!(
I18n.t(
"discourse_workflows.errors.summarize.invalid_aggregation",
aggregation: aggregation,
),
)
end
def validate_unique_output_keys!(keys)
duplicate = keys.tally.find { |_key, count| count > 1 }&.first
return if duplicate.nil?
raise_node_error!(
I18n.t("discourse_workflows.errors.summarize.duplicate_output_field", field: duplicate),
description: I18n.t("discourse_workflows.errors.summarize.duplicate_output_field_help"),
)
end
def group_items(input_items, split_fields)
return [{ keys: [], items: input_items }] if split_fields.empty?
input_items
.group_by { |item| split_fields.map { |field| dig_field(item_json(item), field) } }
.map { |keys, items| { keys: keys, items: items } }
end
def separate_items(groups, split_keys, keyed_rows, exec_ctx)
groups.map do |group|
json = split_keys.zip(group[:keys]).to_h.merge!(aggregate(group[:items], keyed_rows))
wrap(json, paired_item: paired_items_for(group[:items], exec_ctx))
end
end
def aggregate(items, keyed_rows)
keyed_rows.to_h { |key, row| [key, compute(row, items)] }
end
def compute(row, items)
field = row["field"].to_s.strip
case row["aggregation"].to_s
when "count"
return items.length if field.empty?
values(items, field).length
when "count_unique"
unique_values(items, field).length
when "unique"
unique_values(items, field)
when "append"
values(items, field)
when "collect"
return items.map { |item| item_json(item) } if field.empty?
values(items, field)
when "concatenate"
values(items, field).map { |value| cell(value) }.join(separator(row))
when "first"
values(items, field).first
when "last"
values(items, field).last
when "sum"
numeric_values(items, field).sum
when "average"
numbers = numeric_values(items, field)
return nil if numbers.empty?
numbers.sum.to_f / numbers.length
when "min"
comparable_values(items, field).min
when "max"
comparable_values(items, field).max
end
end
def values(items, field)
items.filter_map do |item|
value = dig_field(item_json(item), field)
value unless empty_value?(value)
end
end
# Array-valued fields are flattened so that, for example, per-post tag arrays
# collapse into the set of tags used across a group.
def unique_values(items, field)
items
.flat_map do |item|
value = dig_field(item_json(item), field)
value.is_a?(Array) ? value : [value]
end
.reject { |value| empty_value?(value) }
.uniq
end
def numeric_values(items, field)
items.filter_map { |item| numeric(dig_field(item_json(item), field)) }
end
def comparable_values(items, field)
raw = values(items, field)
return [] if raw.empty?
numbers = raw.map { |value| numeric(value) }
return numbers if numbers.none?(&:nil?)
raw.map(&:to_s)
end
def numeric(value)
case value
when Numeric
value
when String
Float(value)
end
rescue ArgumentError, TypeError
nil
end
def separator(row)
key = row["separate_by"].to_s
return row["custom_separator"].to_s if key == "custom"
SEPARATORS.fetch(key, ", ")
end
def cell(value)
value.is_a?(Hash) || value.is_a?(Array) ? JSON.generate(value) : value.to_s
end
def empty_value?(value)
return true if value.nil?
return value.empty? if value.respond_to?(:empty?)
false
end
def item_json(item)
item.fetch("json") { {} }
end
def dig_field(json, field)
field.split(".").reduce(json) { |value, key| value.is_a?(Hash) ? value[key] : nil }
end
def paired_items_for(items, exec_ctx)
items.map { |item| exec_ctx.paired_item_for(item) }
end
end
end
end
end