A platform for community discussion. Free, open, simple.
FEATURE: Board workflow nodes for board & column creation (#43361)
Martin Brennan3a4ce6187eaf
diff --git a/app/models/access_control_list.rb b/app/models/access_control_list.rbindex dcf336b7c5b..e4c84cfab7b 100644--- a/app/models/access_control_list.rb+++ b/app/models/access_control_list.rb@@ -78,6 +78,16 @@ class AccessControlList < ActiveRecord::Baseelseauto_group_ids = [Group::AUTO_GROUPS[:logged_in_users]]+ if user.is_system_user?+ auto_group_ids.concat(+ [+ Group::AUTO_GROUPS[:admins],+ Group::AUTO_GROUPS[:staff],+ Group::AUTO_GROUPS[:moderators],+ ],+ )+ end+# TODO (martin) Remove when granular_anonymous_and_logged_in_groups_permissions becomes permanent,# it's similar logic to User.in_any_groups?if !SiteSetting.granular_anonymous_and_logged_in_groups_permissionsdiff --git a/frontend/discourse/app/ui-kit/d-access-control-field.gjs b/frontend/discourse/app/ui-kit/d-access-control-field.gjsindex 686d3fe3dd7..a3bc3ad412d 100644--- a/frontend/discourse/app/ui-kit/d-access-control-field.gjs+++ b/frontend/discourse/app/ui-kit/d-access-control-field.gjs@@ -2,6 +2,7 @@ import Component from "@glimmer/component";import { action } from "@ember/object";import { service } from "@ember/service";import { ajax } from "discourse/lib/ajax";+import { or } from "discourse/truth-helpers";import DAccessControl from "discourse/ui-kit/d-access-control";import { i18n } from "discourse-i18n";@@ -9,6 +10,10 @@ export default class DAccessControlField extends Component {@service site;@service dialog;+ get name() {+ return this.args.name ?? "acl";+ }+@actionasync validateAccess(name, value, { addError, preventSubmit }) {const acl = value || [];@@ -82,10 +87,13 @@ export default class DAccessControlField extends Component {<@form.Field@description={{@description}}@format="max"- @name="acl"+ @name={{this.name}}+ @onSet={{@onSet}}+ @showOptional={{@showOptional}}@title={{@title}}@type="custom"@validate={{this.validateAccess}}+ @validation={{@validation}}as |field|><field.Control>@@ -93,7 +101,7 @@ export default class DAccessControlField extends Component {@acl={{field.value}}@aclTarget={{@aclTarget}}@groups={{this.site.groups}}- @onChange={{@onChange}}+ @onChange={{or @onChange field.set}}@transformPermissionOptions={{@transformPermissionOptions}}/></field.Control>diff --git a/frontend/discourse/app/ui-kit/d-access-control-permission-menu.gjs b/frontend/discourse/app/ui-kit/d-access-control-permission-menu.gjsnew file mode 100644index 00000000000..7575784e657--- /dev/null+++ b/frontend/discourse/app/ui-kit/d-access-control-permission-menu.gjs@@ -0,0 +1,83 @@+import Component from "@glimmer/component";+import { fn } from "@ember/helper";+import { action } from "@ember/object";+import DMenu from "discourse/float-kit/components/d-menu";+import { eq } from "discourse/truth-helpers";+import DButton from "discourse/ui-kit/d-button";+import DDropdownMenu from "discourse/ui-kit/d-dropdown-menu";+import dConcatClass from "discourse/ui-kit/helpers/d-concat-class";+import dIcon from "discourse/ui-kit/helpers/d-icon";++const PermissionTrigger = <template>+ <button+ class="btn btn-default d-access-control__permission d-access-control-permission-menu"+ disabled={{@disabled}}+ type="button"+ ...attributes+ >+ <span class="d-button-label">{{@label}}</span>+ {{dIcon "angle-down"}}+ </button>+</template>;++export default class DAccessControlPermissionMenu extends Component {+ get label() {+ return this.args.options.find((option) => option.id === this.args.value)+ ?.name;+ }++ @action+ select(close, permission) {+ close();+ this.args.onChange(permission);+ }++ <template>+ <DMenu+ data-permission={{@value}}+ ...attributes+ @autofocus={{false}}+ @disabled={{@disabled}}+ @identifier="d-access-control__permission-menu"+ @modalForMobile={{true}}+ @triggerComponent={{component+ PermissionTrigger+ disabled=@disabled+ label=this.label+ }}+ >+ <:content as |menu|>+ <DDropdownMenu as |dropdown|>+ {{#each @options key="id" as |option|}}+ {{#if (eq option.id "remove")}}+ <dropdown.divider />+ {{/if}}+ <dropdown.item>+ <DButton+ class={{dConcatClass+ "d-access-control__permission-option"+ "--with-description"+ (if (eq option.id "remove") "--remove")+ (if (eq option.id @value) "-selected")+ }}+ data-permission-id={{option.id}}+ @action={{fn this.select menu.close option.id}}+ >+ <div class="d-access-control__permission-texts">+ <span+ class="d-access-control__permission-label"+ >{{option.name}}</span>+ {{#if option.description}}+ <span+ class="d-access-control__permission-description"+ >{{option.description}}</span>+ {{/if}}+ </div>+ </DButton>+ </dropdown.item>+ {{/each}}+ </DDropdownMenu>+ </:content>+ </DMenu>+ </template>+}diff --git a/frontend/discourse/app/ui-kit/d-access-control.gjs b/frontend/discourse/app/ui-kit/d-access-control.gjsindex 3c56a5bff4a..1af7181ffdd 100644--- a/frontend/discourse/app/ui-kit/d-access-control.gjs+++ b/frontend/discourse/app/ui-kit/d-access-control.gjs@@ -3,13 +3,12 @@ import { cached } from "@glimmer/tracking";import { fn, hash } from "@ember/helper";import { action } from "@ember/object";import { service } from "@ember/service";-import DMenu from "discourse/float-kit/components/d-menu";+import { isEmpty } from "@ember/utils";import DTooltip from "discourse/float-kit/components/d-tooltip";import { AUTO_GROUPS } from "discourse/lib/constants";import { prioritizeNameFallback } from "discourse/lib/settings";-import { eq } from "discourse/truth-helpers";-import DButton from "discourse/ui-kit/d-button";-import DDropdownMenu from "discourse/ui-kit/d-dropdown-menu";+import { eq, or } from "discourse/truth-helpers";+import DAccessControlPermissionMenu from "discourse/ui-kit/d-access-control-permission-menu";import dAvatar from "discourse/ui-kit/helpers/d-avatar";import dConcatClass from "discourse/ui-kit/helpers/d-concat-class";import dIcon from "discourse/ui-kit/helpers/d-icon";@@ -38,7 +37,7 @@ const REMOVE_ACTION = {),};-function defaultPermissions() {+export function defaultPermissions() {return [{id: READ_ONLY_PERMISSION,@@ -63,20 +62,6 @@ function rowTypeSortOrder(type) {return ROW_TYPE_SORT_ORDER[type] ?? 2;}-const AccessControlPermissionTrigger = <template>- <button- class="btn btn-default d-access-control__permission"- disabled={{@disabled}}- type="button"- ...attributes- >- <span class="d-button-label">- {{@label}}- </span>- {{dIcon "angle-down"}}- </button>-</template>;-export default class DAccessControl extends Component {@service site;@@ -97,7 +82,9 @@ export default class DAccessControl extends Component {}return (- this.site.access_control?.mandatory_acl?.[this.args.aclTarget.type] || []+ this.site.access_control?.mandatory_acl?.[+ this.args.aclTarget.key ?? this.args.aclTarget.type+ ] || []);}@@ -114,7 +101,9 @@ export default class DAccessControl extends Component {}return (- this.site.access_control?.banned_acl?.[this.args.aclTarget.type] || []+ this.site.access_control?.banned_acl?.[+ this.args.aclTarget.key ?? this.args.aclTarget.type+ ] || []);}@@ -166,18 +155,25 @@ export default class DAccessControl extends Component {// TODO (martin) How are we going to deal with users that have the Owner permission// here if we don't want to expose that in the UI?get rows() {- const mappedAcl = this.acl.map((entry) => ({- key: `${granteeValue(entry.type, entry.id)}:${entry.permission}`,- id: entry.id,- permission: entry.permission,- display_name: entry.display_name,- sort_name: entry.sort_name || entry.name || entry.display_name,- username: entry.username,- name: entry.name,- avatar_template: entry.avatar_template,- type: entry.type,- mandatory: Boolean(entry.mandatory),- }));+ const mappedAcl = this.acl.map((entry) => {+ const hydratedEntry = this.#hydrateDisplayName({ ...entry });++ return {+ key: `${granteeValue(hydratedEntry.type, hydratedEntry.id)}:${hydratedEntry.permission}`,+ id: hydratedEntry.id,+ permission: hydratedEntry.permission,+ display_name: hydratedEntry.display_name,+ sort_name:+ hydratedEntry.sort_name ||+ hydratedEntry.name ||+ hydratedEntry.display_name,+ username: hydratedEntry.username,+ name: hydratedEntry.name,+ avatar_template: hydratedEntry.avatar_template,+ type: hydratedEntry.type,+ mandatory: Boolean(hydratedEntry.mandatory),+ };+ });return mappedAcl.sort((a, b) => {if (a.mandatory !== b.mandatory) {@@ -331,9 +327,7 @@ export default class DAccessControl extends Component {}@action- onRowPermissionChange(close, granteeType, granteeId, permission) {- close?.();-+ onRowPermissionChange(granteeType, granteeId, permission) {if (permission === REMOVE_ACTION.id) {this.args.onChange(this.acl.filter(@@ -372,10 +366,19 @@ export default class DAccessControl extends Component {});}- @action- permissionLabel(permissionId) {- return this.permissionOptions.find((option) => option.id === permissionId)- .name;+ #hydrateDisplayName(entry) {+ if (!isEmpty(entry.display_name)) {+ return entry;+ }++ if (entry.type === "group") {+ const group = (this.args.groups || []).find(({ id }) => id === entry.id);+ entry.display_name = group?.full_name || group?.name;+ } else if (entry.type === "user") {+ entry.display_name = prioritizeNameFallback(entry.name, entry.username);+ }++ return entry;}// TODO (martin) How are we going to deal with users that have the Owner permission@@ -402,7 +405,7 @@ export default class DAccessControl extends Component {}}@value={{null}}/>- {{#if this.rows.length}}+ {{#if (or this.rows.length (has-block "additionalRows"))}}<div class="d-access-control__rows">{{#each this.rows key="key" as |row|}}<div@@ -441,64 +444,18 @@ export default class DAccessControl extends Component {{{/if}}</span></span>- <DMenu- data-permission={{row.permission}}- @autofocus={{false}}- @identifier="d-access-control__permission-menu"- @modalForMobile={{true}}- @triggerComponent={{component- AccessControlPermissionTrigger- label=(this.permissionLabel row.permission)- disabled=row.mandatory+ <DAccessControlPermissionMenu+ @disabled={{row.mandatory}}+ @onChange={{fn this.onRowPermissionChange row.type row.id}}+ @options={{this.excludeBannedPermissions+ this.permissionOptions+ row}}- >- <:content as |args|>- <DDropdownMenu as |dropdown|>- {{#each- (this.excludeBannedPermissions this.permissionOptions row)- key="id"- as |option|- }}- {{#if (eq option.id "remove")}}- <dropdown.divider />- {{/if}}- <dropdown.item>- <DButton- class={{dConcatClass- "d-access-control__permission-option"- "--with-description"- (if (eq option.id "remove") "--remove")- (if (eq option.id row.permission) "-selected")- }}- data-permission-id={{option.id}}- @action={{fn- this.onRowPermissionChange- args.close- row.type- row.id- option.id- }}- >- <div class="d-access-control__permission-texts">- <span class="d-access-control__permission-label">- {{option.name}}- </span>- {{#if option.description}}- <span- class="d-access-control__permission-description"- >- {{option.description}}- </span>- {{/if}}- </div>- </DButton>- </dropdown.item>- {{/each}}- </DDropdownMenu>- </:content>- </DMenu>+ @value={{row.permission}}+ /></div>{{/each}}+ {{yield to="additionalRows"}}</div>{{/if}}</div>diff --git a/frontend/discourse/tests/integration/components/d-access-control-test.gjs b/frontend/discourse/tests/integration/components/d-access-control-test.gjsindex b347bd784c4..99c9e5adc2b 100644--- a/frontend/discourse/tests/integration/components/d-access-control-test.gjs+++ b/frontend/discourse/tests/integration/components/d-access-control-test.gjs@@ -92,6 +92,66 @@ function rowNames() {module("Integration | Component | DAccessControl", function (hooks) {setupRenderingTest(hooks);+ test("hydrates missing group and user display names", async function (assert) {+ const state = controlledState([+ { type: "group", id: 42, permission: "edit" },+ {+ type: "user",+ id: 7,+ username: "alice",+ name: "alice",+ display_name: "",+ permission: "view",+ },+ ]);++ await render(+ <template>+ <DAccessControl+ @acl={{state.acl}}+ @groups={{GROUPS}}+ @onChange={{state.onChange}}+ />+ </template>+ );++ assert+ .dom(+ '.d-access-control__row[data-row-type="group"][data-row-id="42"] .d-access-control__item-name'+ )+ .hasText("Team A");+ assert+ .dom(+ '.d-access-control__row[data-row-type="user"][data-row-id="7"] .d-access-control__item-name'+ )+ .hasText("alice");+ });++ test("renders additional rows without fixed ACL entries", async function (assert) {+ const state = controlledState();++ await render(+ <template>+ <DAccessControl+ @acl={{state.acl}}+ @groups={{GROUPS}}+ @onChange={{state.onChange}}+ >+ <:additionalRows>+ <div class="d-access-control__row">Additional access</div>+ </:additionalRows>+ </DAccessControl>+ </template>+ );++ assert+ .dom(".d-access-control__rows")+ .hasText(+ "Additional access",+ "keeps additional access inside the ACL list"+ );+ });+test("adds a group with the default permission via the preloaded grantee chooser", async function (assert) {const state = controlledState();@@ -781,6 +841,56 @@ module("Integration | Component | DAccessControl", function (hooks) {module("Integration | Component | DAccessControlField", function (hooks) {setupRenderingTest(hooks);+ test("binds a named field and updates FormKit without an onChange callback", async function (assert) {+ this.site.groups = GROUPS;+ this.data = { permissions: [] };+ this.onSubmit = sinon.spy();+ pretender.post("/access-control/evaluate.json", (request) => {+ const payload = JSON.parse(request.requestBody);+ assert.strictEqual(+ payload.target_type,+ aclTarget.type,+ "evaluates the target class"+ );+ assert.strictEqual(+ payload.new_acl[0].id,+ 42,+ "evaluates the named field value"+ );+ return response({});+ });++ await render(+ <template>+ <Form @data={{this.data}} @onSubmit={{this.onSubmit}} as |form|>+ <DAccessControlField+ @aclTarget={{aclTarget}}+ @form={{form}}+ @name="permissions"+ @title="Permissions"+ />+ <form.Submit />+ </Form>+ </template>+ );++ const chooser = selectKit(".d-access-control__chooser");+ await chooser.expand();+ await chooser.selectRowByValue("group:42");+ await formKit().submit();++ const data = this.onSubmit.firstCall.args[0];+ assert.strictEqual(+ data.permissions[0].permission,+ "edit",+ "submits the updated permissions"+ );+ assert.false(+ Object.hasOwn(data, "acl"),+ "does not create the default acl field"+ );+ });+test("reports confirmed access loss and allows submission", async function (assert) {const dialog = getOwner(this).lookup("service:dialog");sinon.stub(dialog, "confirm").resolves(true);diff --git a/plugins/boards/admin/assets/javascripts/discourse/initializers/boards-workflows.js b/plugins/boards/admin/assets/javascripts/discourse/initializers/boards-workflows.jsnew file mode 100644index 00000000000..5902dfc9962--- /dev/null+++ b/plugins/boards/admin/assets/javascripts/discourse/initializers/boards-workflows.js@@ -0,0 +1,50 @@+import curryComponent from "ember-curry-component";+import { withPluginApi } from "discourse/lib/plugin-api";+import {+ boardPermissionOptions,+ buildDefaultBoardAcl,+} from "discourse/plugins/boards/discourse/lib/boards-access-control";++export default {+ name: "boards-workflows",++ initialize(container, app) {+ const site = container.lookup("service:site");+ const siteSettings = container.lookup("service:site-settings");++ if (!siteSettings.enable_discourse_workflows) {+ return;+ }++ const fieldArgs = {+ transformPermissionOptions: boardPermissionOptions,+ };++ withPluginApi((api) => {+ api.registerValueTransformer("workflow-node-defaults", ({ value }) => ({+ ...value,+ "action:create_board": () => ({+ acl: buildDefaultBoardAcl(site, siteSettings),+ }),+ }));++ api.registerValueTransformer(+ "workflow-field-control",+ ({ value, context }) => {+ if (+ context.node?.type !== "action:create_board" ||+ context.fieldName !== "acl" ||+ context.control !== "access_control"+ ) {+ return value;+ }++ return {+ ...value,+ renderer: curryComponent(value.renderer, fieldArgs, app),+ };+ }+ );+ });+ },+};diff --git a/plugins/boards/assets/javascripts/discourse/components/boards-access-control-field.gjs b/plugins/boards/assets/javascripts/discourse/components/boards-access-control-field.gjsnew file mode 100644index 00000000000..55c407e8fd1--- /dev/null+++ b/plugins/boards/assets/javascripts/discourse/components/boards-access-control-field.gjs@@ -0,0 +1,31 @@+import Component from "@glimmer/component";+import DAccessControlField from "discourse/ui-kit/d-access-control-field";+import { i18n } from "discourse-i18n";+import { boardPermissionOptions } from "../lib/boards-access-control";++export default class BoardsAccessControlField extends Component {+ get aclTarget() {+ return {+ type: "Boards::Board",+ key: "Boards::Board",+ id: this.args.boardId,+ name: i18n("boards.manage.board"),+ };+ }++ <template>+ <DAccessControlField+ @aclTarget={{this.aclTarget}}+ @description={{@description}}+ @form={{@form}}+ @name={{@name}}+ @onAccessLossConfirmed={{@onAccessLossConfirmed}}+ @onChange={{@onChange}}+ @onSet={{@onSet}}+ @showOptional={{@showOptional}}+ @title={{@title}}+ @transformPermissionOptions={{boardPermissionOptions}}+ @validation={{@validation}}+ />+ </template>+}diff --git a/plugins/boards/assets/javascripts/discourse/components/modal/boards-board-settings.gjs b/plugins/boards/assets/javascripts/discourse/components/modal/boards-board-settings.gjsindex 769ed7cef1d..9903e7c2da1 100644--- a/plugins/boards/assets/javascripts/discourse/components/modal/boards-board-settings.gjs+++ b/plugins/boards/assets/javascripts/discourse/components/modal/boards-board-settings.gjs@@ -1,6 +1,6 @@import Component from "@glimmer/component";import { cached, tracked } from "@glimmer/tracking";-import { array, fn } from "@ember/helper";+import { fn } from "@ember/helper";import { action } from "@ember/object";import { cancel } from "@ember/runloop";import { service } from "@ember/service";@@ -8,15 +8,15 @@ import { isEmpty } from "@ember/utils";import Form from "discourse/components/form";import { ajax } from "discourse/lib/ajax";import { popupAjaxError } from "discourse/lib/ajax-error";-import { AUTO_GROUPS } from "discourse/lib/constants";import discourseDebounce from "discourse/lib/debounce";import { slugify } from "discourse/lib/utilities";import CategorySelector from "discourse/select-kit/components/category-selector";import { eq, or } from "discourse/truth-helpers";-import DAccessControlField from "discourse/ui-kit/d-access-control-field";import DButton from "discourse/ui-kit/d-button";import DModal from "discourse/ui-kit/d-modal";import { i18n } from "discourse-i18n";+import { buildDefaultBoardAcl } from "../../lib/boards-access-control";+import BoardsAccessControlField from "../boards-access-control-field";import BoardsEditableTitle from "../boards-editable-title";const CONSTRAINT_TYPE_OPTIONS = [@@ -101,7 +101,7 @@ export default class BoardsBoardSettings extends Component {show_tags: true,show_topic_thumbnail: false,require_confirmation: false,- acl: this.#buildDefaultAcl(),+ acl: buildDefaultBoardAcl(this.site, this.siteSettings),};}@@ -109,20 +109,6 @@ export default class BoardsBoardSettings extends Component {return this.args.model.isNew;}- get boardsManageBoardAllowedGroupIds() {- return this.siteSettings.groupSettingArray(- "boards_manage_board_allowed_groups"- );- }-- get aclTarget() {- return {- type: "Boards::Board",- id: this.args.model.board?.id,- name: i18n("boards.manage.board"),- };- }-get slugPlaceholder() {const boardName = this.formApi.get("name");@@ -200,30 +186,6 @@ export default class BoardsBoardSettings extends Component {this.args.closeModal();}- @action- transformPermissionOptions(options) {- const viewOption = options.find((option) => option.id === "view");- viewOption.description = i18n(- "boards.manage.board_access_permission_viewer_description"- );-- const editOption = options.find((option) => option.id === "edit");- editOption.description = i18n(- "boards.manage.board_access_permission_editor_description"- );-- options.push({- id: "manage",- level: 3,- name: i18n("boards.manage.board_access_permission_manager"),- description: i18n(- "boards.manage.board_access_permission_manager_description"- ),- });-- return options;- }-@actionaclChanged(acl) {this.reloadAfterSave = false;@@ -235,37 +197,6 @@ export default class BoardsBoardSettings extends Component {this.reloadAfterSave = true;}- #buildDefaultAcl() {- const defaultAcl = [];-- this.boardsManageBoardAllowedGroupIds.forEach((groupId) => {- const group = this.site.groupsById[groupId];- if (group) {- defaultAcl.push({- type: "group",- id: group.id,- permission: "manage",- display_name: group.full_name,- });- }- });-- if (- !this.boardsManageBoardAllowedGroupIds.includes(- AUTO_GROUPS.logged_in_users.id- )- ) {- defaultAcl.push({- type: "group",- id: AUTO_GROUPS.logged_in_users.id,- permission: "view",- display_name: this.site.groupFullName(AUTO_GROUPS.logged_in_users.id),- });- }-- return defaultAcl;- }-_checkConstraints(categoryIds, tagNames) {if (this.isNew) {return;@@ -355,15 +286,13 @@ export default class BoardsBoardSettings extends Component {</form.Section><form.Section>- <DAccessControlField- @aclTarget={{this.aclTarget}}+ <BoardsAccessControlField+ @boardId={{@model.board.id}}@description={{i18n "boards.manage.board_access_description"}}@form={{form}}- @mustHavePermissions={{array "manage"}}@onAccessLossConfirmed={{this.accessLossConfirmed}}@onChange={{this.aclChanged}}@title={{i18n "boards.manage.board_access"}}- @transformPermissionOptions={{this.transformPermissionOptions}}/></form.Section>diff --git a/plugins/boards/assets/javascripts/discourse/lib/boards-access-control.js b/plugins/boards/assets/javascripts/discourse/lib/boards-access-control.jsnew file mode 100644index 00000000000..0a175931de2--- /dev/null+++ b/plugins/boards/assets/javascripts/discourse/lib/boards-access-control.js@@ -0,0 +1,55 @@+import { AUTO_GROUPS } from "discourse/lib/constants";+import { i18n } from "discourse-i18n";++export function buildDefaultBoardAcl(site, siteSettings) {+ const managerGroupIds = siteSettings.groupSettingArray(+ "boards_manage_board_allowed_groups"+ );+ const defaultAcl = [];++ managerGroupIds.forEach((groupId) => {+ const group = site.groupsById[groupId];+ if (group) {+ defaultAcl.push({+ type: "group",+ id: group.id,+ permission: "manage",+ display_name: group.full_name,+ });+ }+ });++ if (!managerGroupIds.includes(AUTO_GROUPS.logged_in_users.id)) {+ defaultAcl.push({+ type: "group",+ id: AUTO_GROUPS.logged_in_users.id,+ permission: "view",+ display_name: site.groupFullName(AUTO_GROUPS.logged_in_users.id),+ });+ }++ return defaultAcl;+}++export function boardPermissionOptions(options) {+ const viewOption = options.find((option) => option.id === "view");+ viewOption.description = i18n(+ "boards.manage.board_access_permission_viewer_description"+ );++ const editOption = options.find((option) => option.id === "edit");+ editOption.description = i18n(+ "boards.manage.board_access_permission_editor_description"+ );++ options.push({+ id: "manage",+ level: 3,+ name: i18n("boards.manage.board_access_permission_manager"),+ description: i18n(+ "boards.manage.board_access_permission_manager_description"+ ),+ });++ return options;+}diff --git a/plugins/boards/config/locales/client.en.yml b/plugins/boards/config/locales/client.en.ymlindex 0b021b9c065..bf62689f565 100644--- a/plugins/boards/config/locales/client.en.yml+++ b/plugins/boards/config/locales/client.en.yml@@ -1,5 +1,35 @@en:js:+ discourse_workflows:+ node_unavailable:+ requires_boards: "Requires Boards to be enabled"+ nodes:+ "action:create_board_column": "Create board column"+ "action:create_board": "Create board"+ node_descriptions:+ "action:create_board_column": "Create a column on a board with an optional icon, color, tag, and default sort"+ "action:create_board": "Create a board with access permissions and optional tag and category constraints"+ create_board_column:+ board_id: "Board"+ board_id_description: "Select a board or use a board ID from a previous step."+ title: "Title"+ icon: "Icon"+ color: "Color"+ tag_name: "Tag"+ default_sort: "Default sort"+ default_sort_priority: "Priority"+ default_sort_recency: "Recency"+ actor_username: "Performed by user"+ create_board:+ name: "Name"+ slug: "Slug"+ slug_description: "Leave blank to generate a slug from the board name."+ tag_names: "Tags"+ category_ids: "Categories"+ category_ids_description: "Select one or more categories that topic cards can belong to for the board."+ actor_username: "Performed by user"+ acl: "Board access"+ acl_description: "Choose who can view, edit, and manage the board."boards:filter_boards: "Filter boards"filter_boards_no_results: "No boards match your search"diff --git a/plugins/boards/config/locales/server.en.yml b/plugins/boards/config/locales/server.en.ymlindex 7f1a1ee89d3..658ff75591a 100644--- a/plugins/boards/config/locales/server.en.yml+++ b/plugins/boards/config/locales/server.en.yml@@ -1,4 +1,16 @@en:+ discourse_workflows:+ errors:+ create_board_column:+ board_not_found: "Could not find the board for this column."+ forbidden: "The workflow execution user does not have permission to manage this board."+ invalid_params: "Could not create board column: %{errors}"+ failed: "Could not create the board column."+ create_board:+ forbidden: "The workflow execution user does not have permission to create boards."+ invalid_params: "Could not create board: %{errors}"+ acl_failed: "Could not create the board's access permissions. Check the selected groups and permissions."+ failed: "Could not create the board."site_settings:boards_enabled: "Organize topics, and lightweight standalone “floater” cards, into configurable, drag-and-drop kanban-style boards and columns, all with a purpose built management UI and per-board access control"boards_manage_board_allowed_groups: "Groups allowed to create and configure boards."diff --git a/plugins/boards/lib/boards/workflows/schema.rb b/plugins/boards/lib/boards/workflows/schema.rbnew file mode 100644index 00000000000..86b0cf0e0af--- /dev/null+++ b/plugins/boards/lib/boards/workflows/schema.rb@@ -0,0 +1,46 @@+# frozen_string_literal: true++module Boards+ module Workflows+ module Schema+ CREATE_BOARD_COLUMN_OUTPUT_SCHEMA = {+ "$schema" => DiscourseWorkflows::Schema::DRAFT_URI,+ "type" => "object",+ "properties" => {+ "column_id" => {+ "type" => "integer",+ },+ "title" => {+ "type" => "string",+ },+ "unicode_title" => {+ "type" => "string",+ },+ },+ "required" => %w[column_id title unicode_title],+ "additionalProperties" => false,+ }.freeze++ CREATE_BOARD_OUTPUT_SCHEMA = {+ "$schema" => DiscourseWorkflows::Schema::DRAFT_URI,+ "type" => "object",+ "properties" => {+ "board_id" => {+ "type" => "integer",+ },+ "slug" => {+ "type" => "string",+ },+ "name" => {+ "type" => "string",+ },+ "unicode_name" => {+ "type" => "string",+ },+ },+ "required" => %w[board_id slug name unicode_name],+ "additionalProperties" => false,+ }.freeze+ end+ end+enddiff --git a/plugins/boards/lib/discourse_workflows/nodes/create_board/v1.rb b/plugins/boards/lib/discourse_workflows/nodes/create_board/v1.rbnew file mode 100644index 00000000000..570d910c9d7--- /dev/null+++ b/plugins/boards/lib/discourse_workflows/nodes/create_board/v1.rb@@ -0,0 +1,139 @@+# frozen_string_literal: true++if defined?(DiscourseWorkflows)+ module DiscourseWorkflows+ module Nodes+ module CreateBoard+ class V1 < DiscourseWorkflows::NodeType+ description(+ name: "action:create_board",+ version: "1.0",+ defaults: {+ icon: "boards",+ color: "light-green",+ },+ group: "discourse_actions",+ available: -> { SiteSetting.boards_enabled },+ unavailable_reason_key: "discourse_workflows.node_unavailable.requires_boards",+ capabilities: {+ run_scope: "per_item",+ },+ output_contracts: [{ schema: Boards::Workflows::Schema::CREATE_BOARD_OUTPUT_SCHEMA }],+ properties: {+ name: {+ type: :string,+ required: true,+ },+ slug: {+ type: :string,+ },+ tag_names: {+ type: :array,+ ui: {+ control: :tags,+ },+ },+ category_ids: {+ type: :array,+ ui: {+ control: :category,+ multiple: true,+ },+ },+ actor_username: {+ type: :string,+ required: false,+ default: "system",+ ui: {+ control: :actor,+ },+ control_options: {+ allow_anonymous: false,+ },+ },+ acl: {+ type: :object,+ required: true,+ ui: {+ control: :access_control,+ expression: false,+ },+ control_options: {+ acl_target_type: "Boards::Board",+ acl_target_key: Boards::Board.acl_target_key,+ acl_target_name: "boards.manage.board",+ permissions: Boards::Board::ACL_PERMISSIONS.values,+ },+ },+ },+ )++ def execute(exec_ctx)+ items =+ exec_ctx.input_items.map.with_index do |_item, item_index|+ actor = exec_ctx.actor_from_parameter("actor_username", item_index)+ config = {+ "name" => exec_ctx.get_node_parameter("name", item_index),+ "slug" => exec_ctx.get_node_parameter("slug", item_index),+ "tag_names" =>+ DiscourseWorkflows::NodeType.normalize_tag_names(+ exec_ctx.get_node_parameter("tag_names", item_index, default: []),+ ),+ "category_ids" =>+ DiscourseWorkflows::NodeType.normalize_category_ids(+ exec_ctx.get_node_parameter("category_ids", item_index, default: []),+ ),+ "acl" => exec_ctx.get_node_parameter("acl", item_index, default: []),+ }+ wrap(create_board(actor.guardian, config))+ end+ [items]+ end++ private++ def create_board(guardian, config)+ Boards::CreateBoard.call(guardian:, params: config, raw_board_params: config) do+ on_success do |board:|+ {+ "board_id" => board.id,+ "slug" => board.slug,+ "name" => board.name,+ "unicode_name" => board.unicode_name,+ }+ end+ on_failed_policy(:can_manage) do+ raise_node_error!(I18n.t("discourse_workflows.errors.create_board.forbidden"))+ end+ on_failed_contract do |contract|+ invalid_parameters!(contract.errors.full_messages.join(", "))+ end+ on_model_not_found(:board) do |step|+ case step.exception+ when ActiveRecord::RecordInvalid+ invalid_parameters!(step.exception.record.errors.full_messages.join(", "))+ when Discourse::InvalidParameters+ invalid_parameters!(step.exception.message)+ else+ raise_node_error!(I18n.t("discourse_workflows.errors.create_board.failed"))+ end+ end+ on_failed_step(:create_acl) do+ raise_node_error!(I18n.t("discourse_workflows.errors.create_board.acl_failed"))+ end+ on_failure do+ raise_node_error!(I18n.t("discourse_workflows.errors.create_board.failed"))+ end+ end+ end++ def invalid_parameters!(errors)+ raise_node_error!(+ I18n.t("discourse_workflows.errors.create_board.invalid_params", errors:),+ )+ end+ end+ end+ end+ end+enddiff --git a/plugins/boards/lib/discourse_workflows/nodes/create_board_column/v1.rb b/plugins/boards/lib/discourse_workflows/nodes/create_board_column/v1.rbnew file mode 100644index 00000000000..bf901f131fc--- /dev/null+++ b/plugins/boards/lib/discourse_workflows/nodes/create_board_column/v1.rb@@ -0,0 +1,187 @@+# frozen_string_literal: true++if defined?(DiscourseWorkflows)+ module DiscourseWorkflows+ module Nodes+ module CreateBoardColumn+ class V1 < DiscourseWorkflows::NodeType+ description(+ name: "action:create_board_column",+ version: "1.0",+ defaults: {+ icon: "rectangle-list",+ color: "light-green",+ },+ group: "discourse_actions",+ available: -> { SiteSetting.boards_enabled },+ unavailable_reason_key: "discourse_workflows.node_unavailable.requires_boards",+ capabilities: {+ run_scope: "per_item",+ },+ output_contracts: [+ { schema: Boards::Workflows::Schema::CREATE_BOARD_COLUMN_OUTPUT_SCHEMA },+ ],+ properties: {+ board_id: {+ type: :integer,+ required: true,+ type_options: {+ load_options_method: "boards",+ },+ ui: {+ control: :combo_box,+ },+ control_options: {+ filterable: true,+ value_property: :id,+ name_property: :name,+ },+ },+ title: {+ type: :string,+ required: true,+ },+ icon: {+ type: :string,+ ui: {+ control: :icon,+ },+ },+ color: {+ type: :string,+ ui: {+ control: :color,+ },+ },+ tag_name: {+ type: :string,+ type_options: {+ load_options_method: "tags",+ },+ ui: {+ control: :combo_box,+ },+ control_options: {+ filterable: true,+ value_property: :name,+ name_property: :name,+ },+ },+ default_sort: {+ type: :options,+ options: %w[priority recency],+ default: "priority",+ },+ actor_username: {+ type: :string,+ required: false,+ default: "system",+ ui: {+ control: :actor,+ },+ control_options: {+ allow_anonymous: false,+ },+ },+ },+ )++ def self.load_options_context(context)+ guardian = context.guardian || context.user&.guardian+ return [] unless guardian++ case context.method_name+ when "boards"+ return [] unless guardian.can_manage_boards?+ boards = Boards::Board.with_acl_permission(guardian, "manage")+ if context.filter.present?+ boards =+ boards.where(+ "name ILIKE ?",+ "%#{ActiveRecord::Base.sanitize_sql_like(context.filter)}%",+ )+ end+ boards+ .order(:name, :id)+ .select(:id, :name)+ .map { |board| { id: board.id, name: board.unicode_name } }+ when "tags"+ tags = Tag.visible(guardian)+ if context.filter.present?+ tags =+ tags.where(+ "name ILIKE ?",+ "%#{ActiveRecord::Base.sanitize_sql_like(context.filter)}%",+ )+ end+ tags.order(:name).pluck(:name).map { |name| { name: } }+ end+ end++ def execute(exec_ctx)+ items =+ exec_ctx.input_items.map.with_index do |_item, item_index|+ guardian = exec_ctx.actor_from_parameter("actor_username", item_index).guardian+ params =+ %w[board_id title icon color tag_name default_sort].index_with do |name|+ exec_ctx.get_node_parameter(name, item_index)+ end+ %w[icon color tag_name default_sort].each do |name|+ params[name] = params[name].presence+ end+ params["color"] = params["color"]&.delete_prefix("#")+ wrap(create_column(guardian, params))+ end+ [items]+ end++ private++ def create_column(guardian, params)+ Boards::CreateColumn.call(guardian:, params:) do+ on_success do |column:|+ {+ "column_id" => column.id,+ "title" => column.title,+ "unicode_title" => column.unicode_title,+ }+ end+ on_model_not_found(:board) do+ raise_node_error!(+ I18n.t("discourse_workflows.errors.create_board_column.board_not_found"),+ )+ end+ on_failed_policy(:can_manage) do+ raise_node_error!(+ I18n.t("discourse_workflows.errors.create_board_column.forbidden"),+ )+ end+ on_failed_contract do |contract|+ invalid_parameters!(contract.errors.full_messages.join(", "))+ end+ on_model_not_found(:column) do |step|+ case step.exception+ when ActiveRecord::RecordInvalid+ invalid_parameters!(step.exception.record.errors.full_messages.join(", "))+ when Discourse::InvalidParameters+ invalid_parameters!(step.exception.message)+ else+ raise_node_error!(I18n.t("discourse_workflows.errors.create_board_column.failed"))+ end+ end+ on_failure do+ raise_node_error!(I18n.t("discourse_workflows.errors.create_board_column.failed"))+ end+ end+ end++ def invalid_parameters!(errors)+ raise_node_error!(+ I18n.t("discourse_workflows.errors.create_board_column.invalid_params", errors:),+ )+ end+ end+ end+ end+ end+enddiff --git a/plugins/boards/plugin.rb b/plugins/boards/plugin.rbindex d6232b97081..a0d4d1500bc 100644--- a/plugins/boards/plugin.rb+++ b/plugins/boards/plugin.rb@@ -17,7 +17,6 @@ register_asset "stylesheets/boards-topic-pill.scss"register_asset "stylesheets/boards-add-from-topic-menu.scss"register_svg_icon "table-columns"register_svg_icon "boards"-register_svg_icon "box-archive"module ::BoardsPLUGIN_NAME = "boards"@@ -26,6 +25,14 @@ endrequire_relative "lib/boards/engine"after_initialize do+ if respond_to?(:register_discourse_workflows_node)+ register_discourse_workflows_node do+ require_relative "lib/discourse_workflows/nodes/create_board/v1"+ require_relative "lib/discourse_workflows/nodes/create_board_column/v1"+ [DiscourseWorkflows::Nodes::CreateBoard::V1, DiscourseWorkflows::Nodes::CreateBoardColumn::V1]+ end+ end+# Keep queued jobs from the standalone plugin executable across the deploy.legacy_jobs =if Jobs.const_defined?(:DiscourseKanban, false)diff --git a/plugins/boards/spec/lib/discourse_workflows/nodes/create_board/v1_spec.rb b/plugins/boards/spec/lib/discourse_workflows/nodes/create_board/v1_spec.rbnew file mode 100644index 00000000000..b61297430cb--- /dev/null+++ b/plugins/boards/spec/lib/discourse_workflows/nodes/create_board/v1_spec.rb@@ -0,0 +1,266 @@+# frozen_string_literal: true++RSpec.describe DiscourseWorkflows::Nodes::CreateBoard::V1 do+ fab!(:manager, :moderator)+ fab!(:group)++ let(:sandbox) { DiscourseWorkflows::JsSandbox.new({ "$json" => {} }) }+ let(:configuration) do+ {+ "name" => "Project board",+ "acl" => [{ "type" => "group", "id" => group.id, "permission" => "manage" }],+ }+ end++ before do+ SiteSetting.enable_discourse_workflows = true+ SiteSetting.boards_enabled = true+ end++ after { sandbox.dispose }++ def execute_node(config = configuration, user: manager, items: [{ "json" => {} }])+ resolver = DiscourseWorkflows::ExpressionResolver.new({ "$json" => {} }, sandbox:)+ context =+ DiscourseWorkflows::Executor::NodeExecutionContext.new(+ input_items: items,+ user:,+ resolver:,+ parameters: config,+ property_schema: described_class.property_schema,+ )+ described_class.new(parameters: config).execute(context).first.map { |item| item.fetch("json") }+ end++ it "registers a per-item Discourse action with a declarative ACL control" do+ expect(described_class.identifier).to eq("action:create_board")+ expect(described_class.description).to include(+ version: "1.0",+ group: "discourse_actions",+ defaults: {+ icon: "boards",+ color: "light-green",+ },+ capabilities: {+ run_scope: "per_item",+ },+ )+ expect(DiscourseWorkflows::PropertySchemaValidator.validate_node(described_class)).to be_empty+ expect(described_class.property_schema[:acl]).to include(+ required: true,+ type: :object,+ ui: {+ control: :access_control,+ expression: false,+ },+ control_options: {+ acl_target_type: "Boards::Board",+ acl_target_key: Boards::Board.acl_target_key,+ acl_target_name: "boards.manage.board",+ permissions: %w[view edit manage],+ },+ )+ expect(described_class.property_schema[:actor_username]).to include(+ type: :string,+ required: false,+ default: "system",+ ui: {+ control: :actor,+ },+ control_options: {+ allow_anonymous: false,+ },+ )+ expect(described_class).to be_available+ SiteSetting.boards_enabled = false+ expect(described_class).not_to be_available+ end++ it "creates a board with an explicit slug as the configured actor" do+ output =+ execute_node(+ configuration.merge("slug" => "custom-board", "actor_username" => manager.username),+ ).first+ board = Boards::Board.find(output.fetch("board_id"))++ expect(board).to have_attributes(+ name: "Project board",+ slug: "custom-board",+ created_by: manager,+ )+ expect(output).to eq(+ "board_id" => board.id,+ "slug" => board.slug,+ "name" => board.name,+ "unicode_name" => board.unicode_name,+ )+ expect(output).to match_node_output_schema(described_class)+ expect(board.history.sole).to have_attributes(action: "board_created", acting_user: manager)+ expect(board.permission_acl.permission_group_ids("manage")).to contain_exactly(+ group.id,+ Group::AUTO_GROUPS[:admins],+ )+ end++ it "generates a slug and defaults to the system user regardless of the triggering user" do+ output = execute_node(user: Fabricate(:user)).first+ board = Boards::Board.find(output.fetch("board_id"))++ expect(board).to have_attributes(slug: "project-board", created_by: Discourse.system_user)+ expect(output).to match_node_output_schema(described_class)+ end++ it "passes tag names, categories, and flattened permissions to board creation" do+ tag = Fabricate(:tag)+ category = Fabricate(:category)+ config =+ configuration.merge(+ "tag_names" => [tag.name],+ "category_ids" => [category.id],+ "acl" =>+ configuration["acl"] ++ [+ {+ "type" => "group",+ "id" => Group::AUTO_GROUPS[:logged_in_users],+ "permission" => "view",+ },+ ],+ )++ output = execute_node(config).first+ board = Boards::Board.find(output.fetch("board_id"))++ expect(board.tag_ids).to eq([tag.id])+ expect(board.category_ids).to eq([category.id])+ expect(board.permission_acl.permission_group_ids("view")).to eq(+ [Group::AUTO_GROUPS[:logged_in_users]],+ )+ expect(output).to match_node_output_schema(described_class)+ end++ it "resolves the name separately for each input item" do+ config = configuration.merge("name" => "={{ $json.name }}")+ items = [{ "json" => { "name" => "First board" } }, { "json" => { "name" => "Second board" } }]++ outputs = execute_node(config, items:)++ expect(outputs.pluck("slug")).to eq(%w[first-board second-board])+ expect(outputs.pluck("board_id").uniq.size).to eq(2)+ outputs.each { |output| expect(output).to match_node_output_schema(described_class) }+ end++ it "resolves group access separately for each item and preserves fixed permissions" do+ other_group = Fabricate(:group)+ config =+ configuration.merge(+ "name" => "={{ $json.name }}",+ "acl" => {+ "entries" => configuration["acl"],+ "group_ids" => "={{ $json.group_ids }}",+ "permission" => "edit",+ },+ )+ items = [+ {+ "json" => {+ "name" => "First",+ "group_ids" => [group.id, other_group.id, other_group.id],+ },+ },+ { "json" => { "name" => "Second", "group_ids" => [] } },+ ]++ boards = execute_node(config, items:).map { |output| Boards::Board.find(output["board_id"]) }++ expect(boards.first.permission_acl.permission_group_ids("edit")).to eq([other_group.id])+ expect(boards.first.permission_acl.permission_group_ids("manage")).to contain_exactly(+ group.id,+ Group::AUTO_GROUPS[:admins],+ )+ expect(boards.last.permission_acl.permission_group_ids("edit")).to be_empty+ end++ it "rejects automatic input groups before creating a board" do+ config =+ configuration.merge(+ "acl" => {+ "entries" => configuration["acl"],+ "group_ids" => "={{ $json.group_ids }}",+ "permission" => "manage",+ },+ )+ items = [{ "json" => { "group_ids" => [Group::AUTO_GROUPS[:anonymous_users]] } }]++ expect do+ expect { execute_node(config, items:) }.to raise_error(+ DiscourseWorkflows::NodeError,+ I18n.t("discourse_workflows.errors.create_board.acl_failed"),+ )+ end.not_to change { Boards::Board.count }+ end++ it "rejects an unauthorized configured actor without creating a board" do+ user = Fabricate(:user)++ expect do+ expect {+ execute_node(configuration.merge("actor_username" => user.username))+ }.to raise_error(+ DiscourseWorkflows::NodeError,+ I18n.t("discourse_workflows.errors.create_board.forbidden"),+ )+ end.not_to change { Boards::Board.count }+ end++ it "reports contract failures as node errors" do+ expect { execute_node(configuration.merge("name" => "")) }.to raise_error(+ DiscourseWorkflows::NodeError,+ /Could not create board:.*Name/,+ )+ end++ it "reports model validation failures as node errors" do+ execute_node++ expect { execute_node }.to raise_error(+ DiscourseWorkflows::NodeError,+ /Slug has already been taken/,+ )+ end++ it "reports tag resolution failures as node errors" do+ SiteSetting.tagging_enabled = true+ SiteSetting.create_tag_allowed_groups = Group::AUTO_GROUPS[:admins].to_s+ user = Fabricate(:user)+ group.add(user)+ SiteSetting.boards_manage_board_allowed_groups = group.id.to_s++ expect do+ execute_node(+ configuration.merge("tag_names" => ["missing-tag"], "actor_username" => user.username),+ user:,+ )+ end.to raise_error(DiscourseWorkflows::NodeError, /Unknown tag names: missing-tag/)+ end++ it "reports banned ACL failures and rolls back board creation" do+ config =+ configuration.merge(+ "acl" => [+ {+ "type" => "group",+ "id" => Group::AUTO_GROUPS[:anonymous_users],+ "permission" => "manage",+ },+ ],+ )++ expect do+ expect { execute_node(config) }.to raise_error(+ DiscourseWorkflows::NodeError,+ I18n.t("discourse_workflows.errors.create_board.acl_failed"),+ )+ end.not_to change { Boards::Board.count }+ end+enddiff --git a/plugins/boards/spec/lib/discourse_workflows/nodes/create_board_column/v1_spec.rb b/plugins/boards/spec/lib/discourse_workflows/nodes/create_board_column/v1_spec.rbnew file mode 100644index 00000000000..acc1126df89--- /dev/null+++ b/plugins/boards/spec/lib/discourse_workflows/nodes/create_board_column/v1_spec.rb@@ -0,0 +1,254 @@+# frozen_string_literal: true++RSpec.describe DiscourseWorkflows::Nodes::CreateBoardColumn::V1 do+ fab!(:admin)+ fab!(:manager, :user)+ fab!(:manage_group, :group)+ fab!(:board) do+ Fabricate(:boards_board, name: "Project board", additional_manage_groups: [manage_group])+ end++ before do+ SiteSetting.enable_discourse_workflows = true+ SiteSetting.boards_enabled = true+ SiteSetting.boards_manage_board_allowed_groups = manage_group.id.to_s+ manage_group.add(manager)+ end++ it "registers an available per-item action with a dynamic board selector" do+ expect(described_class.identifier).to eq("action:create_board_column")+ expect(described_class.description).to include(+ version: "1.0",+ group: "discourse_actions",+ defaults: {+ icon: "rectangle-list",+ color: "light-green",+ },+ capabilities: {+ run_scope: "per_item",+ },+ )+ expect(DiscourseWorkflows::PropertySchemaValidator.validate_node(described_class)).to be_empty+ expect(described_class.property_schema[:board_id]).to include(+ required: true,+ type: :integer,+ type_options: {+ load_options_method: "boards",+ },+ )+ expect(described_class.property_schema[:board_id][:ui]).to include(control: :combo_box)+ expect(described_class.property_schema[:actor_username]).to include(+ type: :string,+ required: false,+ default: "system",+ ui: {+ control: :actor,+ },+ control_options: {+ allow_anonymous: false,+ },+ )+ expect(described_class).to be_available+ SiteSetting.boards_enabled = false+ expect(described_class).not_to be_available+ end++ describe ".load_options_context" do+ def load_options(user: manager, filter: nil)+ context =+ DiscourseWorkflows::LoadOptionsContext.new(+ method_name: "boards",+ user:,+ guardian: user.guardian,+ filter:,+ node_class: described_class,+ )+ described_class.load_options_context(context)+ end++ it "lists only boards the configuring user can manage" do+ other_board = Fabricate(:boards_board)++ expect(load_options).to eq([{ id: board.id, name: board.name }])+ expect(load_options(user: admin)).to contain_exactly(+ { id: board.id, name: board.name },+ { id: other_board.id, name: other_board.name },+ )+ end++ it "filters board names case-insensitively" do+ Fabricate(:boards_board, name: "Other", additional_manage_groups: [manage_group])++ expect(load_options(filter: "PROJECT")).to eq([{ id: board.id, name: board.name }])+ expect(load_options(filter: "missing")).to be_empty+ end+ end++ describe "#execute" do+ let(:sandbox) { DiscourseWorkflows::JsSandbox.new({ "$json" => {} }) }+ let(:configuration) { { "board_id" => board.id, "title" => "Backlog" } }++ after { sandbox.dispose }++ def execute_node(config = configuration, user: manager, items: [{ "json" => {} }])+ resolver = DiscourseWorkflows::ExpressionResolver.new({ "$json" => {} }, sandbox:)+ context =+ DiscourseWorkflows::Executor::NodeExecutionContext.new(+ input_items: items,+ user:,+ resolver:,+ parameters: config,+ property_schema: described_class.property_schema,+ )+ described_class+ .new(parameters: config)+ .execute(context)+ .first+ .map { |item| item.fetch("json") }+ end++ it "creates a column with defaults as the configured actor" do+ output = execute_node(configuration.merge("actor_username" => manager.username)).first+ column = Boards::Column.find(output.fetch("column_id"))++ expect(column).to have_attributes(+ board_id: board.id,+ title: "Backlog",+ default_sort: "priority",+ icon: nil,+ color: nil,+ tag_id: nil,+ )+ expect(output).to eq(+ "column_id" => column.id,+ "title" => column.title,+ "unicode_title" => column.unicode_title,+ )+ expect(output).to match_node_output_schema(described_class)+ expect(board.history.sole).to have_attributes(action: "column_added", acting_user: manager)+ end++ it "defaults to the system user regardless of the triggering user" do+ execute_node(user: Fabricate(:user))++ expect(board.history.sole.acting_user).to eq(Discourse.system_user)+ end++ it "passes optional values and normalizes picker colors for the service" do+ tag = Fabricate(:tag)+ output =+ execute_node(+ configuration.merge(+ "icon" => "check",+ "color" => "#1A2B3C",+ "tag_name" => tag.name,+ "default_sort" => "recency",+ ),+ ).first++ expect(Boards::Column.find(output.fetch("column_id"))).to have_attributes(+ icon: "check",+ color: "1A2B3C",+ tag_id: tag.id,+ default_sort: "recency",+ )+ end++ it "treats empty optional values as unset" do+ output =+ execute_node(+ configuration.merge("icon" => "", "color" => "", "tag_name" => "", "default_sort" => ""),+ ).first++ expect(Boards::Column.find(output.fetch("column_id"))).to have_attributes(+ icon: nil,+ color: nil,+ tag_id: nil,+ default_sort: "priority",+ )+ end++ it "resolves the board id and title for each input item" do+ other_board = Fabricate(:boards_board, additional_manage_groups: [manage_group])+ items = [+ { "json" => { "board_id" => board.id, "title" => "First" } },+ { "json" => { "board_id" => other_board.id, "title" => "Second" } },+ ]++ outputs =+ execute_node(+ { "board_id" => "={{ $json.board_id }}", "title" => "={{ $json.title }}" },+ items:,+ )++ expect(outputs.pluck("title")).to eq(%w[First Second])+ expect(+ outputs.map { |output| Boards::Column.find(output.fetch("column_id")).board_id },+ ).to eq([board.id, other_board.id])+ outputs.each { |output| expect(output).to match_node_output_schema(described_class) }+ end++ it "rejects an unauthorized configured actor without creating a column" do+ user = Fabricate(:user)++ expect do+ expect do+ execute_node(configuration.merge("actor_username" => user.username))+ end.to raise_error(+ DiscourseWorkflows::NodeError,+ I18n.t("discourse_workflows.errors.create_board_column.forbidden"),+ )+ end.not_to change { Boards::Column.count }+ end++ it "reports a missing board as a node error" do+ expect { execute_node(configuration.merge("board_id" => 0)) }.to raise_error(+ DiscourseWorkflows::NodeError,+ I18n.t("discourse_workflows.errors.create_board_column.board_not_found"),+ )+ end++ it "reports invalid title and color as node errors" do+ [{ "title" => "" }, { "color" => "purple" }].each do |invalid_params|+ expect { execute_node(configuration.merge(invalid_params)) }.to raise_error(+ DiscourseWorkflows::NodeError,+ /Could not create board column/,+ )+ end+ end++ it "reports invalid sort and unknown tags as node errors" do+ SiteSetting.create_tag_allowed_groups = Group::AUTO_GROUPS[:admins].to_s+ config = configuration.merge("actor_username" => manager.username)++ [+ [+ { "default_sort" => "random" },+ I18n.t("boards.errors.invalid_column_sort", sort: "random"),+ ],+ [+ { "tag_name" => "missing-tag" },+ I18n.t("boards.errors.unknown_tag_name", tag_name: "missing-tag"),+ ],+ ].each do |invalid_params, error|+ expect { execute_node(config.merge(invalid_params)) }.to raise_error(+ DiscourseWorkflows::NodeError,+ I18n.t("discourse_workflows.errors.create_board_column.invalid_params", errors: error),+ )+ end+ end++ it "reports duplicate column tags without creating another column" do+ tag = Fabricate(:tag)+ config = configuration.merge("tag_name" => tag.name)+ execute_node(config)++ expect do+ expect { execute_node(config) }.to raise_error(+ DiscourseWorkflows::NodeError,+ /#{Regexp.escape(I18n.t("boards.errors.cannot_use_same_tag_multiple_times", tag_name: tag.name))}/,+ )+ end.not_to change { Boards::Column.count }+ end+ end+enddiff --git a/plugins/discourse-workflows/about.json b/plugins/discourse-workflows/about.jsonindex ec86a3934cc..a5ff21a102c 100644--- a/plugins/discourse-workflows/about.json+++ b/plugins/discourse-workflows/about.json@@ -1,5 +1,10 @@{"frontend": {"staticModules": true+ },+ "tests": {+ "requiredPlugins": [+ "boards"+ ]}}diff --git a/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/configurators/access-control-list-control.gjs b/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/configurators/access-control-list-control.gjsnew file mode 100644index 00000000000..f0c161fe6d5--- /dev/null+++ b/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/configurators/access-control-list-control.gjs@@ -0,0 +1,234 @@+import Component from "@glimmer/component";+import { fn, hash } from "@ember/helper";+import { on } from "@ember/modifier";+import { action } from "@ember/object";+import { service } from "@ember/service";+import FKLabel from "discourse/form-kit/components/fk/label";+import FKOptional from "discourse/form-kit/components/fk/optional";+import DAccessControl, {+ defaultPermissions,+} from "discourse/ui-kit/d-access-control";+import DAccessControlPermissionMenu from "discourse/ui-kit/d-access-control-permission-menu";+import DTextField from "discourse/ui-kit/d-text-field";+import { i18n } from "discourse-i18n";+import {+ fieldShowDescription,+ isExpression,+ propertyDescription,+} from "../../../lib/workflows/property-engine";+import ExpressionWrapper from "./expression-wrapper";++const GROUP_SCHEMA = {+ type: "array",+ item_schema: { type: "integer" },+};++function accessControlValue(value) {+ return Array.isArray(value) || !value+ ? { entries: value || [], group_ids: "", permission: "view" }+ : { entries: [], group_ids: "", permission: "view", ...value };+}++function plainGroupIds(value) {+ return Array.isArray(value) ? JSON.stringify(value) : value;+}++export default class AccessControlListControl extends Component {+ @service site;++ get aclTarget() {+ const options = this.args.schema.control_options || {};+ return {+ type: options.acl_target_type,+ key: options.acl_target_key,+ name: options.acl_target_name+ ? i18n(options.acl_target_name)+ : this.args.label,+ };+ }++ get description() {+ if (fieldShowDescription(this.args.schema)) {+ return propertyDescription(this.args.nodeDefinition, this.args.fieldName);+ }+ }++ get permissionOptions() {+ const options =+ this.args.transformPermissionOptions?.(defaultPermissions()) ||+ defaultPermissions();+ return options.filter((option) => this.permissions.includes(option.id));+ }++ get permissions() {+ return this.args.schema.control_options?.permissions || ["view", "edit"];+ }++ get requiredPermissions() {+ return this.args.schema.control_options?.required_permissions;+ }++ get validation() {+ return this.args.schema.required ? "required" : undefined;+ }++ @action+ setEntries(field, entries) {+ field.set({ ...accessControlValue(field.value), entries });+ }++ @action+ setGroupIds(field, group_ids) {+ field.set({ ...accessControlValue(field.value), group_ids });+ }++ @action+ setPlainGroupIds(field, event) {+ const value = event.target.value;+ let parsed = value;+ try {+ parsed = JSON.parse(value);+ } catch {+ // Keep incomplete input editable until validation.+ }+ this.setGroupIds(field, parsed);+ }++ @action+ setPermission(field, permission) {+ field.set({ ...accessControlValue(field.value), permission });+ }++ // Checks whether the ACL settings are valid before the form can be saved:+ //+ // - Group IDs: If you enter a literal value, it must be an array of+ // non-negative whole numbers, such as [12, 34]. Expressions are checked+ // later, when the workflow runs.+ // - If group input is supplied, its selected permission must be+ // allowed by the node (e.g. for Boards, only Viewer/Editor/Manager)+ // - Checks the fixed entries, mandatory entries, and+ // input-group permission for any required permission. For e.g. Boards, there must+ // be a Manager.+ @action+ validateConfiguration(name, value, { addError }) {+ const config = accessControlValue(value);+ const groups = config.group_ids;+ const hasInput = groups !== undefined && groups !== null && groups !== "";+ const dynamic = isExpression(groups);+ const error = (message) =>+ addError(name, { title: this.args.label, message });++ if (+ hasInput &&+ !dynamic &&+ (!Array.isArray(groups) ||+ !groups.every((id) => Number.isInteger(id) && id >= 0))+ ) {+ error(i18n("discourse_workflows.access_control.invalid_input"));+ }+ if (hasInput && !this.permissions.includes(config.permission)) {+ error(i18n("discourse_workflows.access_control.invalid_permission"));+ }+ const mandatory =+ this.site.access_control?.mandatory_acl?.[+ this.aclTarget.key ?? this.aclTarget.type+ ] || [];+ const entries = [...(config.entries || []), ...mandatory];+ if (hasInput && (dynamic || groups.length)) {+ entries.push({ permission: config.permission });+ }+ if (+ this.requiredPermissions?.length &&+ !entries.some((entry) =>+ this.requiredPermissions.includes(entry.permission)+ )+ ) {+ error(+ i18n("access_control.manage.required_permission_not_added", {+ permission: this.requiredPermissions.join(", "),+ typeName: this.aclTarget.name,+ })+ );+ }+ }++ <template>+ <@form.Field+ @description={{this.description}}+ @format="max"+ @name={{@fieldName}}+ @onSet={{@onSet}}+ @showOptional={{@showOptional}}+ @title={{@label}}+ @type="custom"+ @validate={{this.validateConfiguration}}+ @validation={{this.validation}}+ as |field|+ >+ <field.Control>+ {{#let (accessControlValue field.value) as |config|}}+ <div class="workflows-access-control">+ <DAccessControl+ @acl={{config.entries}}+ @aclTarget={{this.aclTarget}}+ @groups={{this.site.groups}}+ @onChange={{fn this.setEntries field}}+ @transformPermissionOptions={{@transformPermissionOptions}}+ >+ <:additionalRows>+ <div+ class="d-access-control__row workflows-access-control__input-row"+ >+ <div class="workflows-access-control__groups">+ <FKLabel+ class="form-kit__container-title"+ @fieldId="{{field.id}}-groups"+ >+ <span>{{i18n+ "discourse_workflows.access_control.groups_from_input"+ }}</span>+ <FKOptional />+ </FKLabel>+ <ExpressionWrapper+ @field={{hash+ value=config.group_ids+ set=(fn this.setGroupIds field)+ }}+ @inputId="{{field.id}}-groups"+ @inputLabel={{i18n+ "discourse_workflows.access_control.groups_from_input"+ }}+ @placeholder={{i18n+ "discourse_workflows.access_control.input_placeholder"+ }}+ @schema={{GROUP_SCHEMA}}+ @session={{@session}}+ @supportsExpression={{true}}+ >+ <DTextField+ id="{{field.id}}-groups"+ @placeholder={{i18n+ "discourse_workflows.access_control.input_placeholder"+ }}+ @value={{plainGroupIds config.group_ids}}+ {{on "input" (fn this.setPlainGroupIds field)}}+ />+ </ExpressionWrapper>+ </div>+ <div class="workflows-access-control__permission">+ <DAccessControlPermissionMenu+ id="{{field.id}}-permission"+ @onChange={{fn this.setPermission field}}+ @options={{this.permissionOptions}}+ @value={{config.permission}}+ />+ </div>+ </div>+ </:additionalRows>+ </DAccessControl>+ </div>+ {{/let}}+ </field.Control>+ </@form.Field>+ </template>+}diff --git a/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/configurators/actor-control.gjs b/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/configurators/actor-control.gjsindex 3e7393517c7..03881820458 100644--- a/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/configurators/actor-control.gjs+++ b/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/configurators/actor-control.gjs@@ -25,6 +25,14 @@ const KIND_OPTIONS = [export default class ActorControl extends Component {@tracked kind = actorKindForValue(this.args.field.value);+ get kindOptions() {+ if (this.args.schema?.control_options?.allow_anonymous === false) {+ return KIND_OPTIONS.filter(({ id }) => id !== ACTOR_KIND.anonymous);+ }++ return KIND_OPTIONS;+ }+get showUserChooser() {return this.kind === ACTOR_KIND.user;}@@ -66,7 +74,7 @@ export default class ActorControl extends Component {<div class="workflows-actor-control"><ComboBoxclass="workflows-actor-control__kind"- @content={{KIND_OPTIONS}}+ @content={{this.kindOptions}}@nameProperty="name"@onChange={{this.handleKindChange}}@value={{this.kind}}diff --git a/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/configurators/expression-input.gjs b/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/configurators/expression-input.gjsindex 482160f650e..9affa6de06e 100644--- a/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/configurators/expression-input.gjs+++ b/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/configurators/expression-input.gjs@@ -217,6 +217,16 @@ export default class ExpressionInput extends Component {}, 150);}+ @action+ labelEditor(view) {+ if (this.args.inputId) {+ view.contentDOM.id = this.args.inputId;+ }+ if (this.args.inputLabel) {+ view.contentDOM.setAttribute("aria-label", this.args.inputLabel);+ }+ }+@actionregisterWrapper(element) {this.wrapperElement = element;@@ -274,6 +284,7 @@ export default class ExpressionInput extends Component {@onChange={{this.handleChange}}@onFocusIn={{this.handleFocusIn}}@onFocusOut={{this.handleFocusOut}}+ @onSetup={{this.labelEditor}}@value={{this.displayValue}}/></div>diff --git a/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/configurators/expression-wrapper.gjs b/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/configurators/expression-wrapper.gjsindex 12875c71627..3af21c39a54 100644--- a/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/configurators/expression-wrapper.gjs+++ b/plugins/discourse-workflows/admin/assets/javascripts/admin/components/workflows/configurators/expression-wrapper.gjs@@ -272,6 +272,8 @@ export default class ExpressionWrapper extends Component {<ExpressionInput@autofocus={{true}}@field={{@field}}+ @inputId={{@inputId}}+ @inputLabel={{@inputLabel}}@placeholder={{@placeholder}}@session={{@session}}/>diff --git a/plugins/discourse-workflows/admin/assets/javascripts/admin/lib/workflows/field-control-registry.js b/plugins/discourse-workflows/admin/assets/javascripts/admin/lib/workflows/field-control-registry.jsindex 6d406694976..da55117f45c 100644--- a/plugins/discourse-workflows/admin/assets/javascripts/admin/lib/workflows/field-control-registry.js+++ b/plugins/discourse-workflows/admin/assets/javascripts/admin/lib/workflows/field-control-registry.js@@ -1,3 +1,4 @@+import AccessControlListControl from "../../components/workflows/configurators/access-control-list-control";import ActorControl from "../../components/workflows/configurators/actor-control";import BooleanControl from "../../components/workflows/configurators/boolean-control";import CategoryControl from "../../components/workflows/configurators/category-control";@@ -28,6 +29,7 @@ import UserOrGroupControl from "../../components/workflows/configurators/user-orimport UserSeenTriggerOptions from "../../components/workflows/configurators/user-seen-trigger-options";const FIELD_CONTROL_REGISTRY = {+ access_control: { kind: "standalone", renderer: AccessControlListControl },notice: { kind: "standalone", renderer: NoticeControl },actor: { kind: "field", type: "custom", renderer: ActorControl },boolean: { kind: "standalone", renderer: BooleanControl },@@ -76,6 +78,7 @@ const FIELD_CONTROL_REGISTRY = {},select: { kind: "field", type: "select", renderer: SelectControl },icon: { kind: "field", type: "icon", renderer: IconControl },+ color: { kind: "field", type: "color", renderer: DefaultInputControl },checkbox: { kind: "field", type: "checkbox", renderer: DefaultInputControl },textarea: { kind: "field", type: "textarea", renderer: DefaultInputControl },time: { kind: "field", type: "input-time", renderer: DefaultInputControl },diff --git a/plugins/discourse-workflows/assets/stylesheets/common/configurator/configurator.scss b/plugins/discourse-workflows/assets/stylesheets/common/configurator/configurator.scssindex c48c941dce0..db509518bc0 100644--- a/plugins/discourse-workflows/assets/stylesheets/common/configurator/configurator.scss+++ b/plugins/discourse-workflows/assets/stylesheets/common/configurator/configurator.scss@@ -465,3 +465,26 @@}}}++.workflows-access-control {+ &__input-row {+ align-items: flex-start;+ gap: var(--space-12);+ padding-block: var(--space-3);+ }++ &__groups {+ flex: 1 1 0;+ min-width: 0;++ input {+ width: 100%;+ margin: 0;+ }+ }++ &__permission {+ flex: 0 0 auto;+ text-align: end;+ }+}diff --git a/plugins/discourse-workflows/config/locales/client.en.yml b/plugins/discourse-workflows/config/locales/client.en.ymlindex 822670504e9..727e6eeb886 100644--- a/plugins/discourse-workflows/config/locales/client.en.yml+++ b/plugins/discourse-workflows/config/locales/client.en.yml@@ -676,6 +676,12 @@ en:mode_run_once_for_all_items: "Run once for all items"code: "JavaScript code"code_description: "Access the previous step's output via $json. Return an object to pass data to the next step."+ access_control:+ groups_from_input: "Groups from input"+ permission: "Permission"+ input_placeholder: "Drop a group input here"+ invalid_input: "Groups from input must be an array of group IDs or an expression."+ invalid_permission: "Choose a valid permission."parameter_field:fixed: "Fixed"plain: "Plain"diff --git a/plugins/discourse-workflows/config/locales/server.en.yml b/plugins/discourse-workflows/config/locales/server.en.ymlindex cad0cd59e3a..752c668cb84 100644--- a/plugins/discourse-workflows/config/locales/server.en.yml+++ b/plugins/discourse-workflows/config/locales/server.en.yml@@ -40,6 +40,10 @@ en:tool_finished: "Finished %{tool}"summarizing: "Preparing workflow authoring response"errors:+ access_control:+ invalid_groups: "Groups from input must resolve to an array of valid group IDs."+ missing_groups: "Groups from input contains groups that no longer exist."+ required_permission: "Access must include at least one %{permissions} permission."too_many_tags: "A workflow can have at most %{max} tags."tag_too_long: "Tags can have at most %{max} characters."tag_contains_comma: "Tags cannot contain commas."diff --git a/plugins/discourse-workflows/lib/discourse_workflows/executor/access_control_parameter.rb b/plugins/discourse-workflows/lib/discourse_workflows/executor/access_control_parameter.rbnew file mode 100644index 00000000000..b61d7045932--- /dev/null+++ b/plugins/discourse-workflows/lib/discourse_workflows/executor/access_control_parameter.rb@@ -0,0 +1,90 @@+# frozen_string_literal: true++module DiscourseWorkflows+ class Executor+ # Workflow ACL fields store fixed grants alongside a group-ID expression and+ # a shared permission. Services need a flattened list of individual grants.+ # This service resolves only the group input, validates its runtime value,+ # and merges it with the literal grants, which take precedence. Authorization+ # and persistence remain the responsibility of the resource's write service.+ #+ # Saved configuration (with view/edit/manage allowed):+ # {+ # entries: [{ type: "group", id: 12, permission: "manage" }],+ # group_ids: "={{ $json.group_ids }}",+ # permission: "edit"+ # }+ # Workflow input: { "group_ids" => [12, 34, 56] }+ # Returned ACL (the fixed grant for group 12 takes precedence):+ # [+ # { type: "group", id: 12, permission: "manage" },+ # { type: "group", id: 34, permission: "edit" },+ # { type: "group", id: 56, permission: "edit" }+ # ]+ class AccessControlParameter+ include Service::Base++ params do+ attribute :value++ def configuration+ (value.is_a?(Hash) ? value : { entries: value }).with_indifferent_access+ end+ end++ options do+ attribute :required_permissions+ attribute :acl_target_type+ end++ model :input_group_ids, :resolve_input_groups, optional: true+ policy :valid_group_ids+ policy :groups_exist+ model :acl, :merge_grants, optional: true+ policy :required_permissions_present++ private++ def resolve_input_groups(params:, resolver:)+ input = params.configuration[:group_ids]+ input.nil? || input == "" ? [] : resolver.resolve(input)+ end++ def valid_group_ids(input_group_ids:)+ input_group_ids.is_a?(Array) && input_group_ids.all? { |id| id.is_a?(Integer) && id >= 0 }+ end++ def groups_exist(input_group_ids:)+ Group.where(id: input_group_ids).count == input_group_ids.uniq.size+ end++ def merge_grants(params:, input_group_ids:)+ configuration = params.configuration+ entries = AccessControlList.dedup_flattened_list(configuration[:entries])+ fixed_group_ids = entries.select { |entry| entry[:type] == "group" }.pluck(:id)+ entries ++ (input_group_ids.uniq - fixed_group_ids).map do |id|+ {+ type: "group",+ id: id,+ permission: configuration[:permission],+ }.with_indifferent_access+ end+ end++ def required_permissions_present(acl:, options:)+ return true if options.required_permissions.blank?++ effective_acl =+ if options.acl_target_type.present?+ AccessControlList.inject_mandatory_acl(acl, options.acl_target_type)+ else+ acl+ end+ effective_acl.any? do |entry|+ options.required_permissions.include?(entry[:permission].to_s)+ end+ end+ end+ end+enddiff --git a/plugins/discourse-workflows/lib/discourse_workflows/executor/parameter_resolver.rb b/plugins/discourse-workflows/lib/discourse_workflows/executor/parameter_resolver.rbindex a0ce4b81c48..2fb69cbfba7 100644--- a/plugins/discourse-workflows/lib/discourse_workflows/executor/parameter_resolver.rb+++ b/plugins/discourse-workflows/lib/discourse_workflows/executor/parameter_resolver.rb@@ -60,7 +60,7 @@ module DiscourseWorkflowsenddef resolve_parameter(name, schema)- return @parameters[name] if no_data_expression?(schema)+ return @parameters[name] if no_data_expression?(schema) && !access_control_schema?(schema)if condition_builder_schema?(schema)conditions = @parameters.fetch("conditions") { [] }@@ -76,6 +76,7 @@ module DiscourseWorkflowsenddef resolve_parameter_value(value, schema = nil)+ return resolve_access_control(value, schema) if access_control_schema?(schema)return value if no_data_expression?(schema)return resolve_fixed_collection_value(value, schema) if fixed_collection_schema?(schema)return resolve_collection_value(value, schema) if collection_schema?(schema)@@ -94,6 +95,38 @@ module DiscourseWorkflowscoerce_parameter_value(resolved_value, schema)end+ def resolve_access_control(value, schema)+ # Contracts normalize hash keys; keep the saved workflow configuration untouched.+ Executor::AccessControlParameter.call(+ params: {+ value: value.deep_dup,+ },+ options:+ (schema_value(schema, :control_options) || {}).with_indifferent_access.slice(+ :required_permissions,+ :acl_target_type,+ ),+ resolver: @resolver,+ ) do+ on_success { |acl:| return acl }+ on_model_not_found(:input_group_ids) { |model| raise model.exception }+ on_failed_policy(:valid_group_ids) do+ raise NodeError, I18n.t("discourse_workflows.errors.access_control.invalid_groups")+ end+ on_failed_policy(:groups_exist) do+ raise NodeError, I18n.t("discourse_workflows.errors.access_control.missing_groups")+ end+ on_model_not_found(:acl) { |model| raise model.exception }+ on_failed_policy(:required_permissions_present) do |options:|+ raise NodeError,+ I18n.t(+ "discourse_workflows.errors.access_control.required_permission",+ permissions: options.required_permissions.join(", "),+ )+ end+ end+ end+def resolve_hash_parameter_value(value, schema)fields = schema_value(schema, :fields) || {}@@ -216,6 +249,10 @@ module DiscourseWorkflowsschema_value(schema, :no_data_expression) == trueend+ def access_control_schema?(schema)+ schema_value(schema_value(schema, :ui), :control).to_s == "access_control"+ end+def coerce_parameter_value(value, schema)return value if schema_value(schema, :type).to_s != "boolean"diff --git a/plugins/discourse-workflows/lib/discourse_workflows/property_schema_validator.rb b/plugins/discourse-workflows/lib/discourse_workflows/property_schema_validator.rbindex 6a72e3e5359..a197a6e93e3 100644--- a/plugins/discourse-workflows/lib/discourse_workflows/property_schema_validator.rb+++ b/plugins/discourse-workflows/lib/discourse_workflows/property_schema_validator.rb@@ -70,6 +70,12 @@ module DiscourseWorkflows].freezeKNOWN_CONTROL_OPTIONS_KEYS = %i[+ acl_target_type+ acl_target_key+ acl_target_name+ required_permissions+ permissions+ allow_anonymousaction_iconaction_labelaction_route@@ -88,6 +94,8 @@ module DiscourseWorkflows].freezeKNOWN_UI_CONTROLS = %i[+ color+ access_controlactorbooleancategorydiff --git a/plugins/discourse-workflows/spec/lib/discourse_workflows/executor/access_control_parameter_spec.rb b/plugins/discourse-workflows/spec/lib/discourse_workflows/executor/access_control_parameter_spec.rbnew file mode 100644index 00000000000..2ee13bca8f3--- /dev/null+++ b/plugins/discourse-workflows/spec/lib/discourse_workflows/executor/access_control_parameter_spec.rb@@ -0,0 +1,123 @@+# frozen_string_literal: true++RSpec.describe DiscourseWorkflows::Executor::AccessControlParameter do+ describe ".call" do+ subject(:result) { described_class.call(params:, options:, **dependencies) }++ fab!(:group)+ fab!(:other_group, :group)++ let(:params) { { value: } }+ let(:options) { {} }+ let(:dependencies) { { resolver: expression_resolver } }+ let(:sandbox) { DiscourseWorkflows::JsSandbox.new({}) }+ let(:expression_resolver) { DiscourseWorkflows::ExpressionResolver.new({}, sandbox:) }+ let(:entries) { [{ type: "group", id: group.id, permission: "view" }] }+ let(:value) { { entries:, group_ids: [other_group.id], permission: "edit" } }++ after do+ expression_resolver.dispose+ sandbox.dispose+ end++ it "combines fixed entries and input groups with their selected permissions" do+ expect(result).to run_successfully+ expect(result[:acl].map(&:symbolize_keys)).to eq(+ entries + [{ type: "group", id: other_group.id, permission: "edit" }],+ )+ end++ it "keeps fixed permissions when input groups overlap and removes duplicates" do+ value[:entries] = entries * 2+ value[:group_ids] = [group.id, other_group.id, other_group.id]++ expect(result).to run_successfully+ expect(result[:acl].map(&:symbolize_keys)).to eq(+ entries + [{ type: "group", id: other_group.id, permission: "edit" }],+ )+ end++ it "accepts saved arrays including the system user and everyone group" do+ params[:value] = [+ { type: "user", id: Discourse::SYSTEM_USER_ID, permission: "edit" },+ { type: "group", id: Group::AUTO_GROUPS[:everyone], permission: "view" },+ ]++ expect(result).to run_successfully+ expect(result[:acl].map(&:symbolize_keys)).to eq(params[:value])+ end++ it "passes through custom permissions without an allowlist option" do+ entries.first[:permission] = "manage"+ value[:permission] = "manage"++ expect(result).to run_successfully+ expect(result[:acl].map(&:symbolize_keys)).to eq(+ entries + [{ type: "group", id: other_group.id, permission: "manage" }],+ )+ end++ it "ignores the shared permission when group input is absent" do+ value[:group_ids] = ""+ value[:permission] = nil++ expect(result).to run_successfully+ expect(result[:acl].map(&:symbolize_keys)).to eq(entries)+ end++ it "accepts an empty input array" do+ value[:group_ids] = []++ expect(result).to run_successfully+ expect(result[:acl].map(&:symbolize_keys)).to eq(entries)+ end++ it "rejects input IDs that are strings" do+ value[:group_ids] = [other_group.id.to_s]++ expect(result).to fail_a_policy(:valid_group_ids)+ end++ it "rejects input groups that no longer exist" do+ other_group.destroy!++ expect(result).to fail_a_policy(:groups_exist)+ end++ it "checks required permissions against the resolved ACL" do+ options[:required_permissions] = ["edit"]+ value[:group_ids] = []++ expect(result).to fail_a_policy(:required_permissions_present)+ end++ it "allows a required permission supplied by input groups" do+ options[:required_permissions] = ["edit"]++ expect(result).to run_successfully+ expect(result[:acl].map(&:symbolize_keys)).to eq(+ entries + [{ type: "group", id: other_group.id, permission: "edit" }],+ )+ end++ it "counts mandatory permissions without adding them to the returned ACL" do+ target_class =+ Class.new do+ def self.has_mandatory_acl?+ true+ end++ def self.mandatory_acl+ [{ type: :group, id: Group::AUTO_GROUPS[:admins], permission: "manage" }]+ end+ end+ options.merge!(required_permissions: ["manage"], acl_target_type: "WorkflowAclTarget")+ value[:group_ids] = ""++ stub_const(Object, :WorkflowAclTarget, target_class) do+ expect(result).to run_successfully+ expect(result[:acl].map(&:symbolize_keys)).to eq(entries)+ end+ end+ end+enddiff --git a/plugins/discourse-workflows/spec/lib/discourse_workflows/executor/parameter_resolver_spec.rb b/plugins/discourse-workflows/spec/lib/discourse_workflows/executor/parameter_resolver_spec.rbindex e498fa885ac..4489caaab90 100644--- a/plugins/discourse-workflows/spec/lib/discourse_workflows/executor/parameter_resolver_spec.rb+++ b/plugins/discourse-workflows/spec/lib/discourse_workflows/executor/parameter_resolver_spec.rb@@ -50,6 +50,118 @@ RSpec.describe DiscourseWorkflows::Executor::ParameterResolver doendend+ context "with access control input groups" do+ fab!(:group)+ let(:schema) do+ {+ acl: {+ type: :object,+ ui: {+ control: :access_control,+ expression: false,+ },+ control_options: {+ permissions: %w[view edit manage],+ },+ },+ }+ end+ let(:entries) do+ [+ {+ "type" => "group",+ "id" => group.id,+ "permission" => "view",+ "name" => "={{ $json.name }}",+ },+ ]+ end+ let(:parameters) do+ {+ "acl" => {+ "entries" => entries,+ "group_ids" => "={{ $json.groups }}",+ "permission" => "edit",+ },+ }+ end+ let(:items) { [{ "json" => { "groups" => [group.id, group.id] } }] }++ it "keeps fixed entries literal and gives them precedence over input groups" do+ expect(resolver.resolve("acl")).to eq(entries)+ end++ it "continues accepting saved fixed-only arrays" do+ parameters["acl"] = entries+ expect(resolver.resolve("acl")).to eq(entries)+ end++ it "resolves input groups with default control options" do+ schema[:acl].delete(:control_options)+ parameters["acl"]["entries"] = []++ expect(resolver.resolve("acl")).to eq(+ [{ "type" => "group", "id" => group.id, "permission" => "edit" }],+ )+ end++ it "resolves input groups when whole-field expressions are disabled" do+ schema[:acl][:no_data_expression] = true+ parameters["acl"]["entries"] = []++ expect(resolver.resolve("acl")).to eq(+ [{ "type" => "group", "id" => group.id, "permission" => "edit" }],+ )+ end++ it "rejects results that are not arrays of integer IDs" do+ [nil, false, group.id, group.id.to_s, [group.id.to_s], [-1], [1.5], [{}]].each do |invalid|+ items.first["json"]["groups"] = invalid+ expect { resolver.resolve("acl") }.to raise_error(+ DiscourseWorkflows::NodeError,+ I18n.t("discourse_workflows.errors.access_control.invalid_groups"),+ )+ end+ end++ it "rejects IDs for deleted groups" do+ deleted_group = Fabricate(:group)+ deleted_group.destroy!+ parameters["acl"]["group_ids"] = [deleted_group.id]+ expect { resolver.resolve("acl") }.to raise_error(+ DiscourseWorkflows::NodeError,+ I18n.t("discourse_workflows.errors.access_control.missing_groups"),+ )+ end++ it "keeps the selected permission literal for the resource service to validate" do+ parameters["acl"]["entries"] = []+ parameters["acl"]["permission"] = "={{ 'manage' }}"++ expect(resolver.resolve("acl")).to eq(+ [{ "type" => "group", "id" => group.id, "permission" => "={{ 'manage' }}" }],+ )+ end++ it "enforces required permissions after resolving an empty input" do+ schema[:acl][:control_options].merge!(required_permissions: ["edit"])+ parameters["acl"]["entries"] = []+ parameters["acl"]["group_ids"] = []+ expect { resolver.resolve("acl") }.to raise_error(+ DiscourseWorkflows::NodeError,+ I18n.t(+ "discourse_workflows.errors.access_control.required_permission",+ permissions: "edit",+ ),+ )+ end++ it "accepts blank input without adding groups" do+ parameters["acl"]["group_ids"] = ""+ expect(resolver.resolve("acl")).to eq(entries)+ end+ end+context "with condition-builder parameters" dolet(:parameters) do{diff --git a/plugins/discourse-workflows/spec/lib/discourse_workflows/property_schema_validator_spec.rb b/plugins/discourse-workflows/spec/lib/discourse_workflows/property_schema_validator_spec.rbindex 1756e544bab..83c5e5676d3 100644--- a/plugins/discourse-workflows/spec/lib/discourse_workflows/property_schema_validator_spec.rb+++ b/plugins/discourse-workflows/spec/lib/discourse_workflows/property_schema_validator_spec.rb@@ -100,6 +100,28 @@ RSpec.describe DiscourseWorkflows::PropertySchemaValidator doexpect(validate(schema)).to eq([])end+ it "accepts an access control with target metadata and required permissions" do+ schema = {+ permissions: {+ type: :object,+ required: true,+ ui: {+ control: :access_control,+ expression: false,+ },+ control_options: {+ acl_target_type: "Example::Target",+ acl_target_key: "example_target",+ acl_target_name: "example.target",+ required_permissions: ["manage"],+ permissions: %w[view edit manage],+ },+ },+ }++ expect(validate(schema)).to eq([])+ end+it "flags unknown ui.control values" doerrors = validate(title: { type: :string, ui: { control: :neon } })expect(errors.first).to include("title.ui.control")diff --git a/plugins/discourse-workflows/test/javascripts/integration/components/workflows/access-control-list-control-test.gjs b/plugins/discourse-workflows/test/javascripts/integration/components/workflows/access-control-list-control-test.gjsnew file mode 100644index 00000000000..3d82cce8fb1--- /dev/null+++ b/plugins/discourse-workflows/test/javascripts/integration/components/workflows/access-control-list-control-test.gjs@@ -0,0 +1,347 @@+import { hash } from "@ember/helper";+import { click, fillIn, render, triggerEvent } from "@ember/test-helpers";+import { module, test } from "qunit";+import sinon from "sinon";+import Form from "discourse/components/form";+import { setupRenderingTest } from "discourse/tests/helpers/component-test";+import pretender, { response } from "discourse/tests/helpers/create-pretender";+import formKit from "discourse/tests/helpers/form-kit-helper";+import selectKit from "discourse/tests/helpers/select-kit-helper";+import Field from "discourse/plugins/discourse-workflows/admin/components/workflows/configurators/field";+import { WORKFLOW_VARIABLE_MIME } from "discourse/plugins/discourse-workflows/admin/lib/workflows/expression-context";++module(+ "Integration | Component | Workflows | AccessControlListControl",+ function (hooks) {+ setupRenderingTest(hooks);++ hooks.beforeEach(function () {+ this.site.groups = [+ { id: 41, name: "managers", full_name: "Managers", automatic: false },+ { id: 42, name: "readers", full_name: "Readers", automatic: false },+ ];+ this.site.access_control = {+ mandatory_acl: {+ example: [{ type: "group", id: 41, permission: "edit" }],+ },+ banned_acl: {+ example: [{ type: "group", id: 42, permission: "edit" }],+ },+ };+ this.configuration = { permissions: [] };+ this.onSubmit = sinon.spy();+ this.onSet = sinon.spy((value, { set, name }) => set(name, value));+ this.schema = {+ type: "object",+ required: true,+ ui: { control: "access_control", expression: false },+ control_options: {+ acl_target_type: "Example::Target",+ acl_target_key: "example",+ required_permissions: ["view"],+ },+ };+ pretender.post("/access-control/evaluate.json", () => response({}));+ pretender.get("/admin/plugins/discourse-workflows/variables.json", () =>+ response({ variables: [] })+ );+ });++ test("uses the target key for ACL metadata with group input available", async function (assert) {+ this.configuration.permissions = [+ { type: "group", id: 42, permission: "view" },+ ];++ await render(+ <template>+ <Form+ @data={{this.configuration}}+ @onSubmit={{this.onSubmit}}+ as |form data|+ >+ <Field+ @configuration={{data}}+ @fieldName="permissions"+ @form={{form}}+ @label="Permissions"+ @node={{hash type="action:example"}}+ @onSet={{this.onSet}}+ @schema={{this.schema}}+ />+ <form.Submit />+ </Form>+ </template>+ );++ assert+ .dom('.d-access-control__row[data-row-id="41"]')+ .hasClass("--mandatory", "loads mandatory rows by key");+ assert+ .dom(".d-access-control__rows .workflows-access-control__input-row")+ .exists("always includes group input alongside fixed ACL rows");+ await click(+ '.d-access-control__row[data-row-id="42"] .d-access-control__permission'+ );+ assert+ .dom('.d-access-control__permission-option[data-permission-id="edit"]')+ .doesNotExist("filters banned permissions by key");+ await click(+ '.d-access-control__permission-option[data-permission-id="view"]'+ );+ await formKit().submit();+ assert.true(+ this.onSubmit.calledOnce,+ "submits the ACL through the standalone control"+ );+ });++ test("updates the named FormKit field through onSet", async function (assert) {+ this.site.access_control = { mandatory_acl: {}, banned_acl: {} };+ this.schema.control_options.required_permissions = ["edit"];+ await render(+ <template>+ <Form+ @data={{this.configuration}}+ @onSubmit={{this.onSubmit}}+ as |form data|+ >+ <Field+ @configuration={{data}}+ @fieldName="permissions"+ @form={{form}}+ @label="Permissions"+ @onSet={{this.onSet}}+ @schema={{this.schema}}+ />+ <form.Submit />+ </Form>+ </template>+ );++ const chooser = selectKit(".d-access-control__chooser");+ await chooser.expand();+ await chooser.selectRowByValue("group:42");+ await formKit().submit();++ assert.true(this.onSet.calledOnce, "uses the field's onSet hook");+ assert.strictEqual(+ this.onSubmit.firstCall.args[0].permissions.entries[0].id,+ 42,+ "submits the chosen grantee"+ );+ });++ test("requires the declared permission before submitting", async function (assert) {+ this.configuration.permissions = [+ { type: "group", id: 42, permission: "edit" },+ ];+ await render(+ <template>+ <Form+ @data={{this.configuration}}+ @onSubmit={{this.onSubmit}}+ as |form data|+ >+ <Field+ @configuration={{data}}+ @fieldName="permissions"+ @form={{form}}+ @label="Permissions"+ @schema={{this.schema}}+ />+ <form.Submit />+ </Form>+ </template>+ );+ await formKit().submit();+ assert.false(+ this.onSubmit.called,+ "blocks submission without the required permission"+ );+ assert.dom(".form-kit__errors").exists("shows the validation error");+ });++ module("groups from input", function (inputHooks) {+ inputHooks.beforeEach(function () {+ this.site.access_control = { mandatory_acl: {}, banned_acl: {} };+ this.configuration.permissions = [+ { type: "group", id: 41, permission: "view" },+ ];+ });++ async function renderControl(context) {+ await render(+ <template>+ <Form+ @data={{context.configuration}}+ @onSubmit={{context.onSubmit}}+ as |form data|+ >+ <Field+ @configuration={{data}}+ @fieldName="permissions"+ @form={{form}}+ @label="Permissions"+ @onSet={{context.onSet}}+ @schema={{context.schema}}+ />+ <form.Submit />+ </Form>+ </template>+ );+ }++ test("saves a dropped expression and shared permission alongside edited fixed entries", async function (assert) {+ await renderControl(this);+ const transfer = {+ types: [WORKFLOW_VARIABLE_MIME],+ getData: () => JSON.stringify({ id: "group_ids" }),+ };+ await triggerEvent(".workflows-access-control__groups input", "drop", {+ dataTransfer: transfer,+ });+ await click(+ ".workflows-access-control__permission .d-access-control__permission"+ );+ await click(+ '.d-access-control__permission-option[data-permission-id="edit"]'+ );+ const chooser = selectKit(".d-access-control__chooser");+ await chooser.expand();+ await chooser.selectRowByValue("group:42");+ await formKit().submit();++ const saved = this.onSubmit.firstCall.args[0].permissions;+ assert.strictEqual(+ saved.group_ids,+ "={{ $json.group_ids }}",+ "keeps the expression when editing fixed access"+ );+ assert.strictEqual(+ saved.permission,+ "edit",+ "keeps the shared permission"+ );+ assert.deepEqual(+ saved.entries.map(({ id, permission }) => ({ id, permission })),+ [+ { id: 41, permission: "view" },+ { id: 42, permission: "edit" },+ ],+ "saves both fixed entries"+ );+ assert.true(this.onSet.called, "uses the outer FormKit onSet");+ assert+ .dom(".workflows-access-control__groups .cm-content")+ .hasAttribute(+ "aria-label",+ "Groups from input",+ "labels the expression editor"+ );+ assert+ .dom(".workflows-access-control__groups label")+ .hasText(+ "Groups from input (optional)",+ "marks the group input optional"+ );+ });++ test("reopens a saved input and retains it when changing permission", async function (assert) {+ this.configuration.permissions = {+ entries: this.configuration.permissions,+ group_ids: "={{ $json.group_ids }}",+ permission: "edit",+ };+ await renderControl(this);+ assert+ .dom(".workflows-access-control__groups .cm-content")+ .exists("loads the saved expression");+ assert+ .dom(+ ".workflows-access-control__permission .d-access-control__permission"+ )+ .hasText("Editor", "loads its permission");+ await click(+ ".workflows-access-control__permission .d-access-control__permission"+ );+ await click(+ '.d-access-control__permission-option[data-permission-id="view"]'+ );+ await formKit().submit();+ assert.strictEqual(+ this.onSubmit.firstCall.args[0].permissions.group_ids,+ "={{ $json.group_ids }}",+ "does not replace the expression with preview data"+ );+ assert.strictEqual(+ this.onSubmit.firstCall.args[0].permissions.permission,+ "view",+ "saves the new permission"+ );+ });++ test("defers required permission validation for dynamic groups", async function (assert) {+ this.configuration.permissions = {+ entries: [],+ group_ids: "={{ $json.group_ids }}",+ permission: "view",+ };+ await renderControl(this);+ await formKit().submit();+ assert.true(+ this.onSubmit.calledOnce,+ "allows execution to validate the resolved groups"+ );+ });++ test("clears input groups without removing fixed entries", async function (assert) {+ const entries = this.configuration.permissions;+ this.configuration.permissions = {+ entries,+ group_ids: [42],+ permission: "edit",+ };+ await renderControl(this);+ await fillIn(".workflows-access-control__groups input", "");+ await formKit().submit();+ assert.deepEqual(+ this.onSubmit.firstCall.args[0].permissions,+ { entries, group_ids: "", permission: "edit" },+ "clears only the input groups"+ );+ });++ test("edits literal group IDs while retaining fixed entries and permission", async function (assert) {+ const entries = this.configuration.permissions;+ this.configuration.permissions = {+ entries,+ group_ids: [41],+ permission: "edit",+ };+ await renderControl(this);+ assert+ .dom(".workflows-access-control__groups input")+ .hasValue("[41]", "renders the saved array as editable text");++ await fillIn(".workflows-access-control__groups input", "[41, 42]");+ await formKit().submit();++ assert.deepEqual(+ this.onSubmit.firstCall.args[0].permissions,+ { entries, group_ids: [41, 42], permission: "edit" },+ "updates the IDs without losing the other ACL settings"+ );+ });++ test("rejects literal values that are not ID arrays", async function (assert) {+ await renderControl(this);+ await fillIn(".workflows-access-control__groups input", "42");+ await formKit().submit();+ assert.false(this.onSubmit.called, "blocks an invalid literal");+ assert+ .dom(".form-kit__errors")+ .includesText("array of group IDs", "explains the expected input");+ });+ });+ }+);diff --git a/plugins/discourse-workflows/test/javascripts/integration/components/workflows/actor-control-test.gjs b/plugins/discourse-workflows/test/javascripts/integration/components/workflows/actor-control-test.gjsindex 72f97e40ad2..0589a2e5923 100644--- a/plugins/discourse-workflows/test/javascripts/integration/components/workflows/actor-control-test.gjs+++ b/plugins/discourse-workflows/test/javascripts/integration/components/workflows/actor-control-test.gjs@@ -53,6 +53,26 @@ module("Integration | Component | workflows actor control", function (hooks) {);});+ test("can exclude the anonymous kind", async function (assert) {+ this.field = fieldFor("system");+ this.schema = { control_options: { allow_anonymous: false } };++ await render(+ <template>+ <ActorControl+ @field={{this.field}}+ @schema={{this.schema}}+ @supportsExpression={{false}}+ />+ </template>+ );++ const kind = selectKit(".workflows-actor-control__kind");+ await kind.expand();++ assert.false(kind.rowByValue("anonymous").exists());+ });+test("renders the user chooser for a specific username", async function (assert) {this.field = fieldFor("alice");diff --git a/plugins/discourse-workflows/test/javascripts/integration/components/workflows/boards-workflows-test.gjs b/plugins/discourse-workflows/test/javascripts/integration/components/workflows/boards-workflows-test.gjsnew file mode 100644index 00000000000..e157519da88--- /dev/null+++ b/plugins/discourse-workflows/test/javascripts/integration/components/workflows/boards-workflows-test.gjs@@ -0,0 +1,235 @@+import { hash } from "@ember/helper";+import { click, fillIn, render } from "@ember/test-helpers";+import { module, test } from "qunit";+import sinon from "sinon";+import Form from "discourse/components/form";+import { AUTO_GROUPS } from "discourse/lib/constants";+import { setupRenderingTest } from "discourse/tests/helpers/component-test";+import pretender, { response } from "discourse/tests/helpers/create-pretender";+import formKit from "discourse/tests/helpers/form-kit-helper";+import { i18n } from "discourse-i18n";+import Field from "discourse/plugins/discourse-workflows/admin/components/workflows/configurators/field";+import { createNode } from "discourse/plugins/discourse-workflows/admin/components/workflows/editor/node-factory";++module("Integration | Component | BoardsWorkflows", function (hooks) {+ setupRenderingTest(hooks);++ hooks.beforeEach(function () {+ this.siteSettings.enable_discourse_workflows = true;+ this.siteSettings.boards_manage_board_allowed_groups = "1|2";+ const initializer =+ require("discourse/plugins/boards/discourse/initializers/boards-workflows").default;+ initializer.initialize(this.owner, this.owner);+ this.node = createNode("action:create_board", []);+ this.onSubmit = sinon.spy();+ this.schema = {+ type: "object",+ required: true,++ ui: { control: "access_control", expression: false },+ control_options: {+ acl_target_type: "Boards::Board",+ acl_target_key: "Boards::Board",+ permissions: ["view", "edit", "manage"],+ },+ };+ this.site.access_control = {+ mandatory_acl: {+ "Boards::Board": [{ type: "group", id: 1, permission: "manage" }],+ },+ banned_acl: {+ "Boards::Board": [+ {+ type: "group",+ id: AUTO_GROUPS.logged_in_users.id,+ permission: "edit",+ },+ ],+ },+ };+ pretender.post("/access-control/evaluate.json", () => response({}));+ });++ test("creates defaults from manager groups without overwriting an explicit ACL", function (assert) {+ assert.deepEqual(+ this.node.configuration.acl.map(({ id, permission }) => ({+ id,+ permission,+ })),+ [+ { id: 1, permission: "manage" },+ { id: 2, permission: "manage" },+ { id: AUTO_GROUPS.logged_in_users.id, permission: "view" },+ ],+ "new nodes use the board settings defaults"+ );+ this.siteSettings.boards_manage_board_allowed_groups = "1|5";+ const node = createNode("action:create_board", []);+ assert.deepEqual(+ node.configuration.acl.map(({ id, permission }) => ({ id, permission })),+ [+ { id: 1, permission: "manage" },+ { id: 5, permission: "manage" },+ ],+ "logged-in managers are not duplicated"+ );+ const explicit = createNode("action:create_board", [], null, {+ configOverrides: { acl: [] },+ });+ assert.deepEqual(+ explicit.configuration.acl,+ [],+ "keeps explicitly supplied ACLs"+ );+ assert.false(+ Object.hasOwn(createNode("action:example", []).configuration, "acl"),+ "does not add defaults to other nodes"+ );+ });++ test("uses the board permissions and submits changes through FormKit", async function (assert) {+ await render(+ <template>+ <Form+ @data={{this.node.configuration}}+ @onSubmit={{this.onSubmit}}+ as |form data|+ >+ <Field+ @configuration={{data}}+ @fieldName="acl"+ @form={{form}}+ @label="Board access"+ @node={{this.node}}+ @schema={{this.schema}}+ />+ <form.Submit />+ </Form>+ </template>+ );+ assert+ .dom('.d-access-control__row[data-row-id="1"]')+ .hasClass("--mandatory", "locks the mandatory admin permission");+ await click(+ '.d-access-control__row[data-row-id="5"] .d-access-control__permission'+ );+ assert+ .dom('.d-access-control__permission-option[data-permission-id="manage"]')+ .includesText(+ i18n("boards.manage.board_access_permission_manager"),+ "offers board management"+ );+ assert+ .dom('.d-access-control__permission-option[data-permission-id="view"]')+ .includesText(+ i18n("boards.manage.board_access_permission_viewer_description"),+ "uses board-specific descriptions"+ );+ assert+ .dom('.d-access-control__permission-option[data-permission-id="edit"]')+ .doesNotExist("applies the board's banned permissions");+ await click(+ '.d-access-control__permission-option[data-permission-id="manage"]'+ );+ await fillIn(".workflows-access-control__groups input", "[41,42]");+ await click(+ ".workflows-access-control__permission .d-access-control__permission"+ );+ assert+ .dom('.d-access-control__permission-option[data-permission-id="manage"]')+ .includesText(+ i18n("boards.manage.board_access_permission_manager_description"),+ "shows the board manager description for input groups"+ );+ assert+ .dom('.d-access-control__permission-option[data-permission-id="view"]')+ .includesText(+ i18n("boards.manage.board_access_permission_viewer_description"),+ "shares the board viewer description"+ );+ assert+ .dom('.d-access-control__permission-option[data-permission-id="remove"]')+ .doesNotExist("input groups do not offer Remove");+ await click(+ '.d-access-control__permission-option[data-permission-id="manage"]'+ );+ await formKit().submit();+ assert.strictEqual(+ this.onSubmit.firstCall.args[0].acl.permission,+ "manage",+ "saves the shared manager permission"+ );+ assert.deepEqual(+ this.onSubmit.firstCall.args[0].acl.group_ids,+ [41, 42],+ "saves the input groups"+ );+ assert.strictEqual(+ this.onSubmit.firstCall.args[0].acl.entries.find(+ (entry) => entry.id === 5+ ).permission,+ "manage",+ "submits the changed board permission"+ );+ });++ test("relies on mandatory ACL for manager access", async function (assert) {+ this.configuration = {+ acl: [{ type: "group", id: 5, permission: "view" }],+ };+ await render(+ <template>+ <Form+ @data={{this.configuration}}+ @onSubmit={{this.onSubmit}}+ as |form data|+ >+ <Field+ @configuration={{data}}+ @fieldName="acl"+ @form={{form}}+ @label="Board access"+ @node={{this.node}}+ @schema={{this.schema}}+ />+ <form.Submit />+ </Form>+ </template>+ );+ await formKit().submit();+ assert.true(+ this.onSubmit.calledOnce,+ "accepts viewer-only configuration because manager access is mandatory"+ );+ assert+ .dom('.d-access-control__row[data-row-id="1"]')+ .hasClass("--mandatory", "retains mandatory admin access");+ });++ test("leaves other nodes on the generic ACL renderer", async function (assert) {+ this.configuration = {+ acl: [{ type: "group", id: 5, permission: "view" }],+ };+ this.schema.control_options = { acl_target_type: "Example::Target" };+ await render(+ <template>+ <Form @data={{this.configuration}} as |form data|>+ <Field+ @configuration={{data}}+ @fieldName="acl"+ @form={{form}}+ @label="Access"+ @node={{hash type="action:example"}}+ @schema={{this.schema}}+ />+ </Form>+ </template>+ );+ await click(+ '.d-access-control__row[data-row-id="5"] .d-access-control__permission'+ );+ assert+ .dom('.d-access-control__permission-option[data-permission-id="manage"]')+ .doesNotExist("does not apply board permissions to other nodes");+ });+});diff --git a/plugins/discourse-workflows/test/javascripts/integration/components/workflows/create-board-column-workflow-test.gjs b/plugins/discourse-workflows/test/javascripts/integration/components/workflows/create-board-column-workflow-test.gjsnew file mode 100644index 00000000000..6635b25da4a--- /dev/null+++ b/plugins/discourse-workflows/test/javascripts/integration/components/workflows/create-board-column-workflow-test.gjs@@ -0,0 +1,115 @@+import { hash } from "@ember/helper";+import { fillIn, render, triggerEvent } from "@ember/test-helpers";+import { module, test } from "qunit";+import sinon from "sinon";+import Form from "discourse/components/form";+import { setupRenderingTest } from "discourse/tests/helpers/component-test";+import pretender, { response } from "discourse/tests/helpers/create-pretender";+import formKit from "discourse/tests/helpers/form-kit-helper";+import selectKit from "discourse/tests/helpers/select-kit-helper";+import Field from "discourse/plugins/discourse-workflows/admin/components/workflows/configurators/field";+import { WORKFLOW_VARIABLE_MIME } from "discourse/plugins/discourse-workflows/admin/lib/workflows/expression-context";++module("Integration | Component | CreateBoardColumnWorkflow", function (hooks) {+ setupRenderingTest(hooks);++ hooks.beforeEach(function () {+ this.siteSettings.enable_discourse_workflows = true;+ this.data = {};+ this.onSubmit = sinon.spy();+ this.boardSchema = {+ type: "integer",+ required: true,+ type_options: { load_options_method: "boards" },+ ui: { control: "combo_box" },+ control_options: {+ filterable: true,+ value_property: "id",+ name_property: "name",+ },+ };+ this.definition = {+ name: "action:create_board_column",+ metadata: { boards: [{ id: 42, name: "Project board" }] },+ };+ pretender.get("/admin/plugins/discourse-workflows/variables.json", () =>+ response({ variables: [] })+ );+ });++ test("selects a board ID and accepts a previous node output instead", async function (assert) {+ await render(+ <template>+ <Form @data={{this.data}} @onSubmit={{this.onSubmit}} as |form data|>+ <Field+ @configuration={{data}}+ @fieldName="board_id"+ @form={{form}}+ @label="Board"+ @nodeDefinition={{this.definition}}+ @schema={{this.boardSchema}}+ />+ <form.Submit />+ </Form>+ </template>+ );+ const chooser = selectKit(".combo-box");+ await chooser.expand();+ await chooser.selectRowByValue(42);+ await formKit().submit();+ assert.strictEqual(+ this.onSubmit.firstCall.args[0].board_id,+ 42,+ "stores the integer ID"+ );+ await triggerEvent(".workflows-property-engine__control-wrapper", "drop", {+ dataTransfer: {+ types: [WORKFLOW_VARIABLE_MIME],+ getData: () => JSON.stringify({ id: "board_id" }),+ },+ });+ assert+ .dom(".cm-content")+ .exists("switches the board selector to an expression");+ await formKit().submit();+ assert.strictEqual(+ this.onSubmit.lastCall.args[0].board_id,+ "={{ $json.board_id }}",+ "keeps the earlier node's board ID expression"+ );+ });++ test("renders the color picker and preserves dropped expressions", async function (assert) {+ await render(+ <template>+ <Form @data={{this.data}} @onSubmit={{this.onSubmit}} as |form data|>+ <Field+ @configuration={{data}}+ @fieldName="color"+ @form={{form}}+ @label="Color"+ @schema={{hash type="string" ui=(hash control="color")}}+ />+ <form.Submit />+ </Form>+ </template>+ );+ assert.dom('input[type="color"]').exists("uses the FormKit color picker");+ await fillIn('input[type="text"]', "ff8800");+ await formKit().submit();+ assert.strictEqual(+ this.onSubmit.firstCall.args[0].color,+ "ff8800",+ "saves the selected color"+ );+ await triggerEvent('input[type="text"]', "drop", {+ clientX: 0,+ clientY: 0,+ dataTransfer: {+ types: [WORKFLOW_VARIABLE_MIME],+ getData: () => JSON.stringify({ id: "color" }),+ },+ });+ assert.dom(".cm-content").exists("accepts dynamic colors");+ });+});diff --git a/spec/models/access_control_list_spec.rb b/spec/models/access_control_list_spec.rbindex a57e389c37f..768cb7b0e1c 100644--- a/spec/models/access_control_list_spec.rb+++ b/spec/models/access_control_list_spec.rb@@ -341,6 +341,15 @@ RSpec.describe AccessControlList doexpect(described_class.matching_user(user)).to include(direct_user_acl)end+ it "matches admin grants for the system user without an admin membership row" do+ system_user = User.find(Discourse::SYSTEM_USER_ID)+ system_user.group_users.where(group_id: Group::AUTO_GROUPS[:admins]).delete_all+ admin_acl = Fabricate(:access_control_list, allowed_group_ids: [Group::AUTO_GROUPS[:admins]])++ expect(described_class.matching_user(system_user)).to include(admin_acl)+ expect(described_class.matching_user(user)).not_to include(admin_acl)+ end+it "does not match acls for groups the user does not belong to" doexpect(described_class.matching_user(user)).not_to include(other_group_acl, anonymous_acl)end