Skip to content

A platform for community discussion. Free, open, simple.

5.8 KB
Raw Blame
# frozen_string_literal: true

module DiscourseWorkflows
  module Nodes
    module Wait
      class V1 < NodeType
        WAIT_UNITS = %w[seconds minutes hours days].freeze

        description(
          name: "flow:wait",
          version: "1.0",
          defaults: {
            icon: "pause",
            color: "salmon",
          },
          outputs: %w[main],
          output_contracts: [
            {
              mode: :passthrough,
              variants: [
                {
                  schema: Schema::WEBHOOK_REQUEST_SCHEMA,
                  mode: :union,
                  display_options: {
                    show: {
                      resume: ["webhook"],
                      limit_wait_time: [true],
                      timeout_amount: [{ condition: { exists: true } }],
                    },
                  },
                },
                {
                  schema: Schema::WEBHOOK_REQUEST_SCHEMA,
                  display_options: {
                    show: {
                      resume: ["webhook"],
                    },
                  },
                },
              ],
            },
          ],
          properties:
            lambda do
              webhook_fields =
                Schemas::Webhook::CONFIGURATION_FIELDS.transform_values do |field|
                  display_options = field[:display_options] || {}
                  show = (display_options[:show] || {}).merge(resume: ["webhook"])
                  field.merge(display_options: display_options.merge(show: show))
                end

              {
                resume: {
                  type: :options,
                  required: true,
                  default: "time_interval",
                  options: %w[time_interval webhook],
                },
                wait_amount: {
                  type: :integer,
                  required: true,
                  default: 1,
                  display_options: {
                    show: {
                      resume: ["time_interval"],
                    },
                  },
                },
                wait_unit: {
                  type: :options,
                  required: true,
                  default: "hours",
                  options: WAIT_UNITS,
                  display_options: {
                    show: {
                      resume: ["time_interval"],
                    },
                  },
                },
                webhook_info: {
                  type: :notice,
                  display_options: {
                    show: {
                      resume: ["webhook"],
                    },
                  },
                },
                **webhook_fields,
                webhook_suffix:
                  Schemas::Webhook::WEBHOOK_SUFFIX_FIELD.merge(
                    display_options: {
                      show: {
                        resume: ["webhook"],
                      },
                    },
                  ),
                limit_wait_time: {
                  type: :boolean,
                  default: false,
                  display_options: {
                    show: {
                      resume: ["webhook"],
                    },
                  },
                },
                timeout_amount: {
                  type: :integer,
                  required: false,
                  display_options: {
                    show: {
                      resume: ["webhook"],
                      limit_wait_time: [true],
                    },
                  },
                },
                timeout_unit: {
                  type: :options,
                  required: false,
                  default: "hours",
                  options: WAIT_UNITS,
                  display_options: {
                    show: {
                      resume: ["webhook"],
                      limit_wait_time: [true],
                    },
                  },
                },
              }
            end,
          capabilities: {
            waits_for_resume: true,
            produces_data: false,
          },
        )

        def execute(exec_ctx)
          resume_mode = exec_ctx.get_node_parameter("resume", 0, default: "time_interval")

          if resume_mode == "webhook"
            waiting_until = webhook_waiting_until(exec_ctx)
          else
            amount = exec_ctx.get_node_parameter("wait_amount", 0, default: 1).to_i
            unit = exec_ctx.get_node_parameter("wait_unit", 0, default: "hours")

            if amount <= 0
              raise_node_error!(I18n.t("discourse_workflows.errors.wait.amount_must_be_positive"))
            end
            if WAIT_UNITS.exclude?(unit)
              raise_node_error!(I18n.t("discourse_workflows.errors.wait.invalid_unit", unit: unit))
            end

            waiting_until = amount.public_send(unit).from_now
          end

          exec_ctx.put_execution_to_wait(waiting_until)
          [exec_ctx.input_items]
        end

        private

        def webhook_waiting_until(exec_ctx)
          return nil unless exec_ctx.get_node_parameter("limit_wait_time", 0, default: false)

          timeout_amount = exec_ctx.get_node_parameter("timeout_amount", 0, default: nil).presence
          timeout_amount = timeout_amount.to_i if timeout_amount
          timeout_unit = exec_ctx.get_node_parameter("timeout_unit", 0, default: "hours").presence

          if WAIT_UNITS.exclude?(timeout_unit)
            raise_node_error!(
              I18n.t("discourse_workflows.errors.wait.invalid_timeout_unit", unit: timeout_unit),
            )
          end
          if timeout_amount && timeout_amount <= 0
            raise_node_error!(
              I18n.t("discourse_workflows.errors.wait.timeout_amount_must_be_positive"),
            )
          end

          timeout_amount&.public_send(timeout_unit)&.from_now
        end
      end
    end
  end
end