Skip to content

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

6.2 KB
Raw Blame
# frozen_string_literal: true

module DiscourseWorkflows
  module Nodes
    module Group
      class V1 < NodeType
        OPERATIONS = %w[add remove get check_membership].freeze
        GROUP_ACTION_SCHEMA =
          Schema.merge(
            Schema::GROUP_SCHEMA,
            Schema::USER_SCHEMA,
            Schema.document("changed" => { "type" => "boolean" }),
          )

        description(
          name: "action:group",
          version: "1.0",
          defaults: {
            icon: "user-plus",
            color: "indigo",
          },
          group: "discourse_actions",
          capabilities: {
            run_scope: "per_item",
          },
          output_contracts: [
            {
              variants: [
                {
                  schema: GROUP_ACTION_SCHEMA,
                  display_options: {
                    show: {
                      operation: %w[add remove],
                    },
                  },
                },
                { schema: Schema::GROUP_SCHEMA, display_options: { show: { operation: ["get"] } } },
                {
                  schema: Schema::GROUP_MEMBERSHIP_SCHEMA,
                  mode: :merge,
                  display_options: {
                    show: {
                      operation: ["check_membership"],
                    },
                  },
                },
              ],
            },
          ],
          properties: {
            operation: {
              type: :options,
              required: true,
              options: OPERATIONS,
              default: "add",
              ui: {
                expression: true,
              },
            },
            username: {
              type: :string,
              required: true,
              display_options: {
                show: {
                  operation: %w[add remove check_membership],
                },
              },
              ui: {
                control: :user,
              },
            },
            group_id: {
              type: :integer,
              required: true,
              type_options: {
                load_options_method: "groups",
              },
              ui: {
                control: :group_select,
              },
              control_options: {
                value_property: "id",
                name_property: "name",
                filterable: true,
              },
            },
            set_primary_group: {
              type: :boolean,
              required: false,
              default: false,
              ui: {
                control: :boolean,
                expression: true,
              },
              display_options: {
                show: {
                  operation: ["add"],
                },
              },
            },
            **actor_property,
          },
        )

        def self.load_options_context(context)
          case context.method_name
          when "groups"
            ::Group
              .order(:name)
              .pluck(:id, :name)
              .select { |_, name| context.matches_filter?(name) }
              .map { |id, name| { id:, name: } }
          end
        end

        def execute(exec_ctx)
          items =
            exec_ctx.input_items.map.with_index do |item, item_index|
              config = {
                "operation" => exec_ctx.get_node_parameter("operation", item_index, default: "add"),
                "username" => exec_ctx.get_node_parameter("username", item_index),
                "group_id" => exec_ctx.get_node_parameter("group_id", item_index),
                "set_primary_group" =>
                  exec_ctx.get_node_parameter("set_primary_group", item_index, default: false),
              }

              if config["operation"] == "check_membership"
                next check_membership(exec_ctx, item, config, item_index)
              end

              wrap(process(exec_ctx, config, item_index))
            end

          [items]
        end

        private

        def process(exec_ctx, config, item_index)
          group = ::Group.find(config["group_id"])
          actor = exec_ctx.actor_from_parameter("actor_username", item_index)
          guardian = actor.guardian
          guardian.ensure_can_see_group!(group)

          return { group: serialize_group(group, guardian) } if config["operation"] == "get"

          guardian.ensure_can_edit_group!(group)

          user = exec_ctx.find_user(username: config["username"])

          logger = GroupActionLogger.new(actor, group)

          case config["operation"]
          when "remove"
            changed = group.remove(user)
            logger.log_remove_user_from_group(user)
          else
            changed = GroupManager.new(group).add([user.id]).present?
            logger.log_add_user_to_group(user)
            changed = set_primary_group(user, group, guardian) || changed if config[
              "set_primary_group"
            ]
          end

          {
            group: serialize_group(group.reload, guardian),
            user: serialize_user(user.reload, guardian:),
            changed:,
          }
        end

        def set_primary_group(user, group, guardian)
          guardian.ensure_can_change_primary_group!(user, group)
          return false if user.primary_group_id == group.id

          user.update!(primary_group_id: group.id)
        end

        def check_membership(exec_ctx, item, config, item_index)
          group = ::Group.find(config["group_id"])
          actor = exec_ctx.actor_from_parameter("actor_username", item_index)
          guardian = actor.guardian
          guardian.ensure_can_see_group!(group)

          user = exec_ctx.find_user(username: config["username"])
          membership_data = {
            "group_id" => group.id,
            "group_name" => group.name,
            "user_id" => user.id,
            "username" => user.username,
            "in_group" => user.in_any_groups?([group.id]),
          }

          wrap(
            item.fetch("json", {}).merge("group_membership" => membership_data),
            paired_item: exec_ctx.paired_item_for(item),
          )
        end

        def serialize_group(group, guardian)
          serialize_record(group, WebHookGroupSerializer, scope: guardian)
        end
      end
    end
  end
end