;
+ openModal?: (modalData: ModalData
) => void;
+ };
+}
+
+function TestResultsModal({
+ onExited,
+ actions,
+}: Props): JSX.Element {
+ const dispatch = useDispatch();
+ const [term, setTerm] = useState('');
+ const [users, setUsers] = useState([]);
+ const [total, setTotal] = useState(0);
+ const [loading, setLoading] = useState(true);
+ const [cursorHistory, setCursorHistory] = useState([]); // Stores the 'after' cursor for page 1, page 2, etc.
+
+ const fetchUsers = useCallback(async (searchTerm: string, cursor: string, reset: boolean = false) => {
+ setLoading(true);
+ const result: ActionResult = await dispatch(actions.searchUsers(searchTerm, cursor, USERS_TO_FETCH));
+ if (result?.data) {
+ const newUsers = result.data.users;
+ if (reset) {
+ setUsers(newUsers);
+ } else {
+ setUsers((prevUsers) => [...prevUsers, ...newUsers]);
+ }
+ setTotal(result.data.total);
+ } else {
+ setUsers([]);
+ setTotal(0);
+ }
+ setLoading(false);
+ }, [dispatch, actions]);
+
+ useEffect(() => {
+ fetchUsers(term, '');
+ }, []);
+
+ const handleSearch = (newTerm: string) => {
+ setCursorHistory([]);
+ setTerm(newTerm);
+ fetchUsers(newTerm, '', true);
+ };
+
+ const handleNextPage = (page: number) => {
+ if (loading || !users.length) {
+ return;
+ }
+ if (page * USERS_PER_PAGE < USERS_TO_FETCH) {
+ return;
+ }
+ const cursorForNextPage = users[users.length - 1].id;
+ setCursorHistory([...cursorHistory, cursorForNextPage]);
+ fetchUsers(term, cursorForNextPage);
+ };
+
+ return (
+
+
+
+
+
+
+
+
+ );
+}
+
+export default TestResultsModal;
diff --git a/webapp/channels/src/components/admin_console/access_control/modals/user_sync/synced_user_list.tsx b/webapp/channels/src/components/admin_console/access_control/modals/user_sync/synced_user_list.tsx
new file mode 100644
index 0000000000..724599d919
--- /dev/null
+++ b/webapp/channels/src/components/admin_console/access_control/modals/user_sync/synced_user_list.tsx
@@ -0,0 +1,107 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+import React, {useState, useEffect, useCallback} from 'react';
+import {FormattedMessage} from 'react-intl';
+import {useDispatch} from 'react-redux';
+
+import type {UserProfile} from '@mattermost/types/users';
+
+import type {ActionResult} from 'mattermost-redux/types/actions';
+
+import {UserGroupsSVG} from 'components/common/svg_images_components/user_groups_svg';
+import SearchableUserList from 'components/searchable_user_list/searchable_user_list_container';
+
+import type {ActionFuncAsync} from 'types/store';
+
+type SyncedUserListProps = {
+ userIds: string[];
+ noResultsMessageId: string;
+ noResultsDefaultMessage: string;
+ actions: {
+ getProfilesByIds: (userIds: string[]) => ActionFuncAsync;
+ };
+};
+
+const USERS_PER_PAGE = 10;
+
+// TODO: this component should be improved:
+// - make pagination work
+// - improve search
+
+export const SyncedUserList = ({userIds, noResultsMessageId, noResultsDefaultMessage, actions}: SyncedUserListProps): JSX.Element => {
+ const dispatch = useDispatch();
+ const [users, setUsers] = useState([]);
+ const [currentPage, setCurrentPage] = useState(0);
+
+ const totalUsers = userIds.length;
+
+ const fetchUsers = useCallback(async (page: number) => {
+ const startIndex = page * USERS_PER_PAGE;
+ const endIndex = startIndex + USERS_PER_PAGE;
+ const idsToFetch = userIds.slice(startIndex, endIndex);
+
+ await dispatch(actions.getProfilesByIds(idsToFetch)).then((result: ActionResult) => {
+ if (result?.data) {
+ setUsers([...result.data]);
+ } else {
+ setUsers([]);
+ }
+ });
+ }, [userIds]);
+
+ useEffect(() => {
+ fetchUsers(currentPage);
+ }, [currentPage]);
+
+ const handleSearch = (searchTerm: string) => {
+ if (searchTerm === '') {
+ fetchUsers(0);
+ } else {
+ setUsers(users.filter((user) => {
+ return user.username.toLowerCase().includes(searchTerm.toLowerCase()) ||
+ user.first_name.toLowerCase().includes(searchTerm.toLowerCase()) ||
+ user.last_name.toLowerCase().includes(searchTerm.toLowerCase()) ||
+ user.email.toLowerCase().includes(searchTerm.toLowerCase()) ||
+ user.nickname.toLowerCase().includes(searchTerm.toLowerCase());
+ }));
+ }
+ };
+
+ if (userIds.length === 0) {
+ return (
+
+
+
+
+
+ );
+ }
+
+ return (
+ {
+ setCurrentPage(currentPage + 1);
+ }}
+ previousPage={() => {
+ setCurrentPage(currentPage - 1);
+ }}
+ search={handleSearch}
+ actionUserProps={{}}
+ />
+ );
+};
+
+export default SyncedUserList;
diff --git a/webapp/channels/src/components/admin_console/access_control/modals/user_sync/user_sync_modal.scss b/webapp/channels/src/components/admin_console/access_control/modals/user_sync/user_sync_modal.scss
new file mode 100644
index 0000000000..426f546a85
--- /dev/null
+++ b/webapp/channels/src/components/admin_console/access_control/modals/user_sync/user_sync_modal.scss
@@ -0,0 +1,56 @@
+#user-list-modal-dialog {
+ .modal-header {
+ padding-bottom: 0px;
+ }
+
+ .tabs {
+ display: flex;
+ padding: 0 32px;
+ border-bottom: 1px solid var(--center-channel-color-16);
+ margin-bottom: 12px;
+ }
+
+ .tab-button {
+ padding: 10px 15px;
+ border: none;
+ margin-bottom: -1px;
+ background: none;
+ color: rgba(var(--center-channel-color-rgb), 0.64);
+ cursor: pointer;
+ font-weight: 600;
+
+ &.active {
+ border-bottom: 2px solid var(--button-bg);
+ color: var(--button-bg);
+ }
+
+ &:hover:not(.active) {
+ color: var(--center-channel-color);
+ }
+ }
+
+ .tab-content {
+ .filtered-user-list {
+ height: 440px;
+ overflow-y: auto;
+ }
+
+ .no-user-message {
+ display: flex;
+ height: 440px;
+ flex-direction: column;
+ align-items: center;
+ justify-content: center;
+ color: rgba(var(--center-channel-color-rgb), 0.64);
+ text-align: center;
+
+ .empty-state-svg {
+ margin-bottom: 20px;
+ }
+
+ .primary-message {
+ padding-bottom: 24px;
+ }
+ }
+ }
+}
diff --git a/webapp/channels/src/components/admin_console/access_control/modals/user_sync/user_sync_modal.tsx b/webapp/channels/src/components/admin_console/access_control/modals/user_sync/user_sync_modal.tsx
new file mode 100644
index 0000000000..9ce62ea77f
--- /dev/null
+++ b/webapp/channels/src/components/admin_console/access_control/modals/user_sync/user_sync_modal.tsx
@@ -0,0 +1,107 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+import React, {useState} from 'react';
+import {FormattedMessage} from 'react-intl';
+
+import {GenericModal} from '@mattermost/components';
+
+import {getProfilesByIds} from 'mattermost-redux/actions/users';
+
+import {SyncedUserList} from './synced_user_list';
+
+import './user_sync_modal.scss';
+
+// Types for sync results
+export type ChannelMembersSyncResults = {
+ MembersAdded: string[];
+ MembersRemoved: string[];
+};
+
+// Modal for showing detailed user lists
+type UserListModalProps = {
+ channelId: string;
+ channelName: string;
+ syncResults: ChannelMembersSyncResults;
+ onClose: () => void;
+};
+
+export const UserListModal = ({channelId, channelName, syncResults, onClose}: UserListModalProps): JSX.Element => {
+ const [activeTab, setActiveTab] = useState<'added' | 'removed'>('added');
+
+ const handleTabChange = (tab: 'added' | 'removed') => {
+ setActiveTab(tab);
+ };
+
+ const displayName = channelName || channelId;
+
+ return (
+
+ handleTabChange('added')}
+ >
+
+ handleTabChange('removed')}
+ >
+
+
+
+ {activeTab === 'added' && (
+
+
+ );
+};
+
+export default UserListModal;
diff --git a/webapp/channels/src/components/admin_console/access_control/policies.scss b/webapp/channels/src/components/admin_console/access_control/policies.scss
new file mode 100644
index 0000000000..b899ef0abc
--- /dev/null
+++ b/webapp/channels/src/components/admin_console/access_control/policies.scss
@@ -0,0 +1,166 @@
+.PolicyTable {
+ overflow: auto;
+
+ .DataGrid {
+ padding: 0;
+ background-color: rgba(var(--sys-white-rgb), 0.04);
+
+ &_search {
+ height: 4em;
+ border-bottom: none;
+ }
+
+ &_searchBar {
+ margin-left: 0 !important;
+ }
+
+ &_header {
+ padding-left: 12px;
+ font-size: 1em;
+ font-weight: 600;
+
+ .DataGrid_cell {
+ display: flex;
+
+ &[data-field="name"] {
+ justify-content: flex-start;
+ }
+
+ &[data-field="resources"] {
+ display: flex;
+ align-items: left;
+ justify-content: flex-start;
+ }
+ }
+ }
+
+ .DataGrid_rows {
+ .DataGrid_row {
+ display: flex;
+ min-height: 40px;
+ padding-left: 12px !important;
+ border-left: none;
+ background-color: rgba(var(--sys-white-rgb), 0.04);
+ cursor: pointer;
+
+ &:hover {
+ border-left: none;
+ background-color: rgba(0, 0, 0, 0.05);
+ }
+
+ .policy-name {
+ width: 100%;
+ padding: 10px 0;
+ }
+
+ .policy-resources {
+ width: 100%;
+ padding: 10px 0;
+ text-align: left;
+ }
+
+ .policy-actions {
+ display: flex;
+ width: 100%;
+ justify-content: flex-end;
+ padding-right: 8px;
+ }
+
+ .policy-menu-button {
+ display: flex;
+ width: 32px;
+ height: 32px;
+ align-items: center;
+ justify-content: center;
+ padding: 0;
+ border: none;
+ border-radius: 4px;
+ background: transparent;
+ color: rgba(var(--center-channel-color-rgb), 0.56);
+ cursor: pointer;
+
+ &:hover {
+ background: rgba(var(--center-channel-color-rgb), 0.08);
+ color: rgba(var(--center-channel-color-rgb), 0.72);
+ }
+
+ .icon {
+ display: flex;
+ align-items: center;
+ justify-content: center;
+ font-size: 18px;
+ line-height: 18px;
+ }
+ }
+ }
+ }
+
+ &_footer {
+ border-bottom: 0;
+ }
+ }
+
+ .policy-header {
+ display: flex;
+ align-items: center;
+ justify-content: space-between;
+ margin-bottom: 16px;
+
+ &-text {
+ h1 {
+ margin-bottom: 8px;
+ font-size: 20px;
+ font-weight: 600;
+ }
+
+ p {
+ margin: 0;
+ color: rgba(63, 67, 80, 0.72);
+ }
+ }
+
+ .btn-primary {
+ display: flex;
+ align-items: center;
+ padding: 10px 16px;
+ gap: 8px;
+
+ .icon {
+ font-size: 18px;
+ }
+ }
+ }
+
+ .action-wrapper {
+ display: flex;
+ justify-content: flex-end;
+ padding: 0 16px;
+
+ .icon-button {
+ display: flex;
+ width: 32px;
+ height: 32px;
+ align-items: center;
+ justify-content: center;
+ border: none;
+ border-radius: 4px;
+ background: transparent;
+ color: rgba(63, 67, 80, 0.72);
+ cursor: pointer;
+
+ &:hover {
+ background-color: rgba(63, 67, 80, 0.08);
+ color: rgba(63, 67, 80, 0.8);
+ }
+
+ .icon {
+ font-size: 18px;
+ }
+ }
+ }
+}
+
+.actions-column {
+ justify-content: flex-end !important;
+ text-align: right;
+}
diff --git a/webapp/channels/src/components/admin_console/access_control/policies.test.tsx b/webapp/channels/src/components/admin_console/access_control/policies.test.tsx
new file mode 100644
index 0000000000..3fe59e0c5c
--- /dev/null
+++ b/webapp/channels/src/components/admin_console/access_control/policies.test.tsx
@@ -0,0 +1,106 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+import {shallow} from 'enzyme';
+import React from 'react';
+import {act} from 'react-dom/test-utils';
+
+import type {AccessControlPolicy} from '@mattermost/types/access_control';
+
+import type {ActionResult} from 'mattermost-redux/types/actions';
+
+import type {Column} from 'components/admin_console/data_grid/data_grid';
+
+import PolicyList from './policies';
+
+const mockHistoryPushInternal = jest.fn();
+jest.mock('utils/browser_history', () => ({
+ getHistory: () => ({
+ push: mockHistoryPushInternal,
+ }),
+}));
+
+describe('components/admin_console/access_control/PolicyList', () => {
+ const mockSearchPolicies = jest.fn();
+ const mockDeletePolicy = jest.fn();
+ const defaultProps = {
+ actions: {
+ searchPolicies: mockSearchPolicies,
+ deletePolicy: mockDeletePolicy,
+ },
+ };
+
+ beforeEach(() => {
+ mockSearchPolicies.mockReset();
+ mockDeletePolicy.mockReset();
+ mockHistoryPushInternal.mockReset();
+ });
+
+ test('should match snapshot with no policies', async () => {
+ mockSearchPolicies.mockResolvedValue({data: {policies: [], total: 0}} as ActionResult);
+ const wrapper = shallow(;
+ deletePolicy: (id: string) => Promise;
+ };
+};
+
+const PAGE_SIZE = 10;
+
+export default function PolicyList(props: Props): JSX.Element {
+ const [policies, setPolicies] = useState([]);
+ const [page, setPage] = useState(0);
+ const [after, setAfter] = useState('');
+ const [loading, setLoading] = useState(false);
+ const [search, setSearch] = useState('');
+ const [searchErrored, setSearchErrored] = useState(false);
+ const [cursorHistory, setCursorHistory] = useState([]);
+ const [total, setTotal] = useState(0);
+ const intl = useIntl();
+
+ const history = useMemo(() => getHistory(), []);
+
+ useEffect(() => {
+ fetchPolicies();
+ }, []);
+
+ const fetchPolicies = async (term = '', afterParam = '', resetPage = false) => {
+ setLoading(true);
+
+ try {
+ const action = await props.actions.searchPolicies(term, 'parent', afterParam, PAGE_SIZE + 1);
+ const data = action.data.policies || [];
+ const newTotal = action.data.total || 0;
+
+ // Check if we have more data than the page size, indicating there's a next page
+ const hasNextPage = data.length > PAGE_SIZE;
+
+ // If we have more data than needed, remove the extra item (which is used to check for next page)
+ const newPolicies = hasNextPage ? data.slice(0, PAGE_SIZE) : data;
+
+ // Get the ID of the last policy for the next cursor
+ const lastPolicyId = newPolicies.length > 0 ? newPolicies[newPolicies.length - 1].id : '';
+
+ if (resetPage) {
+ setPolicies(newPolicies);
+ setLoading(false);
+ setAfter(lastPolicyId);
+ setTotal(newTotal);
+ setPage(0);
+ setCursorHistory([]);
+ } else {
+ setPolicies(newPolicies);
+ setLoading(false);
+ setAfter(lastPolicyId);
+ setTotal(newTotal);
+ }
+ } catch (error) {
+ setLoading(false);
+ setSearchErrored(true);
+ }
+ };
+
+ const onSearch = async (term: string) => {
+ if (term.length === 0) {
+ setPage(0);
+ setAfter('');
+ setLoading(false);
+ setSearchErrored(false);
+ setSearch('');
+ fetchPolicies();
+ return;
+ }
+
+ setLoading(true);
+ setSearch(term);
+ await fetchPolicies(term, '', true);
+ };
+
+ const nextPage = async () => {
+ // Save current cursor to history for "previous" navigation
+ const newCursorHistory = [...cursorHistory, after];
+
+ setLoading(true);
+ setPage(page + 1);
+ setCursorHistory(newCursorHistory);
+
+ await fetchPolicies(search, after);
+ };
+
+ const previousPage = async () => {
+ if (cursorHistory.length === 0) {
+ return;
+ }
+
+ // Remove the current cursor from history
+ const newCursorHistory = [...cursorHistory];
+ newCursorHistory.pop();
+
+ // Get the previous cursor
+ const previousCursor = newCursorHistory.length > 0 ? newCursorHistory[newCursorHistory.length - 1] : '';
+
+ setLoading(true);
+ setPage(page - 1);
+ setCursorHistory(newCursorHistory);
+
+ await fetchPolicies(search, previousCursor);
+ };
+
+ const getResources = (policy: AccessControlPolicy) => {
+ const childIds = policy.props?.child_ids as string[];
+ if (!childIds || childIds.length === 0) {
+ return (
+
+ {policy.name}
+
+ ),
+ resources: (
+
+ {getResources(policy)}
+
+ ),
+ actions: (
+
+ {!props.simpleMode && (
+
+ ),
+ },
+ onClick: () => {
+ if (props.onPolicySelected) {
+ props.onPolicySelected(policy);
+ } else {
+ history.push(`/admin_console/user_management/attribute_based_access_control/edit_policy/${policy.id}`);
+ }
+ },
+ };
+ });
+ };
+
+ const getColumns = (): Column[] => {
+ return [
+ {
+ name: (
+
+ {!props.simpleMode && (
+
+
+
{
+ history.push('/admin_console/user_management/attribute_based_access_control/edit_policy');
+ }}
+ >
+
+
+
+
+ )}
+
+
+
+
+
+
+
+
+
+
+ }
+ labelClassName="col-sm-4 vertically-centered-label"
+ onChange={[Function]}
+ placeholder="Add a unique policy name"
+ value=""
+ />
+
+ }
+ id="admin.access_control.policy.edit_policy.autoSyncMembership"
+ label={
+
+
+ }
+ onChange={[Function]}
+ setByEnv={false}
+ value={false}
+ />
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ }
+ labelClassName="col-sm-4 vertically-centered-label"
+ onChange={[Function]}
+ placeholder="Add a unique policy name"
+ value=""
+ />
+
+ }
+ id="admin.access_control.policy.edit_policy.autoSyncMembership"
+ label={
+
+
+ }
+ onChange={[Function]}
+ setByEnv={false}
+ value={false}
+ />
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ,
+ },
+ Object {
+ "field": "team",
+ "fixed": true,
+ "name": ,
+ },
+ Object {
+ "field": "remove",
+ "fixed": true,
+ "name": "",
+ "textAlign": "right",
+ },
+ ]
+ }
+ endCount={2}
+ filterProps={
+ Object {
+ "keys": Array [
+ "teams",
+ ],
+ "onFilter": [Function],
+ "options": Object {
+ "teams": Object {
+ "keys": Array [
+ "team_ids",
+ ],
+ "name": "Teams",
+ "type": Object {
+ "$$typeof": Symbol(react.memo),
+ "WrappedComponent": [Function],
+ "compare": null,
+ "type": [Function],
+ },
+ "values": Object {
+ "team_ids": Object {
+ "name":
+`;
+
+exports[`components/admin_console/access_control/channel_list should match snapshot with channels to add 1`] = `
+
+ ,
+ },
+ Object {
+ "field": "team",
+ "fixed": true,
+ "name": ,
+ },
+ Object {
+ "field": "remove",
+ "fixed": true,
+ "name": "",
+ "textAlign": "right",
+ },
+ ]
+ }
+ endCount={3}
+ filterProps={
+ Object {
+ "keys": Array [
+ "teams",
+ ],
+ "onFilter": [Function],
+ "options": Object {
+ "teams": Object {
+ "keys": Array [
+ "team_ids",
+ ],
+ "name": "Teams",
+ "type": Object {
+ "$$typeof": Symbol(react.memo),
+ "WrappedComponent": [Function],
+ "compare": null,
+ "type": [Function],
+ },
+ "values": Object {
+ "team_ids": Object {
+ "name":
,
+ "value": Array [],
+ },
+ },
+ },
+ },
+ }
+ }
+ loading={true}
+ nextPage={[Function]}
+ onSearch={[Function]}
+ page={0}
+ previousPage={[Function]}
+ rows={
+ Array [
+ Object {
+ "cells": Object {
+ "id": "channel3",
+ "name":
,
+ "remove":
+ ,
+ "team": "Team 1",
+ },
+ },
+ ]
+ }
+ startCount={1}
+ term=""
+ total={3}
+ />
+
+ ,
+ },
+ Object {
+ "field": "team",
+ "fixed": true,
+ "name": ,
+ },
+ Object {
+ "field": "remove",
+ "fixed": true,
+ "name": "",
+ "textAlign": "right",
+ },
+ ]
+ }
+ endCount={2}
+ filterProps={
+ Object {
+ "keys": Array [
+ "teams",
+ ],
+ "onFilter": [Function],
+ "options": Object {
+ "teams": Object {
+ "keys": Array [
+ "team_ids",
+ ],
+ "name": "Teams",
+ "type": Object {
+ "$$typeof": Symbol(react.memo),
+ "WrappedComponent": [Function],
+ "compare": null,
+ "type": [Function],
+ },
+ "values": Object {
+ "team_ids": Object {
+ "name":
+`;
+
+exports[`components/admin_console/access_control/channel_list should match snapshot with no channels 1`] = `
+
+ ,
+ },
+ Object {
+ "field": "team",
+ "fixed": true,
+ "name": ,
+ },
+ Object {
+ "field": "remove",
+ "fixed": true,
+ "name": "",
+ "textAlign": "right",
+ },
+ ]
+ }
+ endCount={0}
+ filterProps={
+ Object {
+ "keys": Array [
+ "teams",
+ ],
+ "onFilter": [Function],
+ "options": Object {
+ "teams": Object {
+ "keys": Array [
+ "team_ids",
+ ],
+ "name": "Teams",
+ "type": Object {
+ "$$typeof": Symbol(react.memo),
+ "WrappedComponent": [Function],
+ "compare": null,
+ "type": [Function],
+ },
+ "values": Object {
+ "team_ids": Object {
+ "name":
+`;
diff --git a/webapp/channels/src/components/admin_console/access_control/policy_details/channel_list/channel_list.scss b/webapp/channels/src/components/admin_console/access_control/policy_details/channel_list/channel_list.scss
new file mode 100644
index 0000000000..c3a86f749f
--- /dev/null
+++ b/webapp/channels/src/components/admin_console/access_control/policy_details/channel_list/channel_list.scss
@@ -0,0 +1,47 @@
+.AccessControlPolicyChannelsList {
+ .Filter_content.Filter__show {
+ width: 320px;
+ }
+
+ .FilterList {
+ width: auto;
+ }
+
+ .ChannelList__nameColumn {
+ display: inline-flex;
+ align-items: center;
+ justify-content: center;
+
+ span.channel-icon {
+ margin: 3px 8px 0 0;
+ }
+ }
+
+ .DataGrid {
+ padding: 0;
+ background-color: rgba(var(--sys-white-rgb), 0.04);
+
+ &_search {
+ border-bottom: none;
+ }
+
+ &_searchBar {
+ margin-left: 0;
+ }
+
+ .DataGrid_rows {
+ .DataGrid_row {
+ display: flex;
+ min-height: 40px;
+ border-left: none;
+ background-color: rgba(var(--sys-white-rgb), 0.04);
+ cursor: pointer;
+
+ &:hover {
+ border-left: none;
+ background-color: rgba(0, 0, 0, 0.05);
+ }
+ }
+ }
+ }
+}
diff --git a/webapp/channels/src/components/admin_console/access_control/policy_details/channel_list/channel_list.test.tsx b/webapp/channels/src/components/admin_console/access_control/policy_details/channel_list/channel_list.test.tsx
new file mode 100644
index 0000000000..8848fa742a
--- /dev/null
+++ b/webapp/channels/src/components/admin_console/access_control/policy_details/channel_list/channel_list.test.tsx
@@ -0,0 +1,100 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+import {shallow} from 'enzyme';
+import React from 'react';
+
+import type {ChannelWithTeamData} from '@mattermost/types/channels';
+
+import ChannelList from './channel_list';
+
+describe('components/admin_console/access_control/channel_list', () => {
+ const mockSearchChannels = jest.fn();
+ const mockSetChannelListSearch = jest.fn();
+ const mockSetChannelListFilters = jest.fn();
+ const mockOnRemoveCallback = jest.fn();
+ const mockOnUndoRemoveCallback = jest.fn();
+ const mockOnAddCallback = jest.fn();
+
+ const defaultProps = {
+ channels: [],
+ totalCount: 2,
+ searchTerm: '',
+ filters: {},
+ policyId: 'policy1',
+ onRemoveCallback: mockOnRemoveCallback,
+ onUndoRemoveCallback: mockOnUndoRemoveCallback,
+ onAddCallback: mockOnAddCallback,
+ channelsToRemove: {},
+ channelsToAdd: {},
+ actions: {
+ searchChannels: jest.fn().mockResolvedValue({
+ data: {
+ channels: [
+ {id: 'channel1', name: 'Channel 1', display_name: 'Channel 1', team_display_name: 'Team 1', type: 'O'} as ChannelWithTeamData,
+ {id: 'channel2', name: 'channel2', display_name: 'Channel 2', team_display_name: 'Team 2', type: 'P'} as ChannelWithTeamData,
+ ],
+ },
+ }),
+ setChannelListSearch: mockSetChannelListSearch,
+ setChannelListFilters: mockSetChannelListFilters,
+ },
+ };
+
+ beforeEach(() => {
+ mockSearchChannels.mockReset();
+ mockSetChannelListSearch.mockReset();
+ mockSetChannelListFilters.mockReset();
+ mockOnRemoveCallback.mockReset();
+ mockOnUndoRemoveCallback.mockReset();
+ mockOnAddCallback.mockReset();
+ });
+
+ test('should match snapshot with no channels', () => {
+ const props = {
+ ...defaultProps,
+ channels: [],
+ totalCount: 0,
+ policyId: '',
+ };
+ const wrapper = shallow(;
+ channelsToAdd: Record;
+ actions: {
+ searchChannels: (id: string, term: string, opts: ChannelSearchOpts) => Promise;
+ setChannelListSearch: (term: string) => void;
+ setChannelListFilters: (filters: ChannelSearchOpts) => void;
+ };
+}
+
+type State = {
+ loading: boolean;
+ page: number;
+ after: string;
+ cursorHistory: string[];
+}
+
+const PAGE_SIZE = 10;
+
+export default class ChannelList extends React.PureComponent {
+ private mounted = false;
+ private searchDebounced;
+
+ public constructor(props: Props) {
+ super(props);
+ this.state = {
+ after: '',
+ loading: false,
+ page: 0,
+ cursorHistory: [],
+ };
+
+ this.searchDebounced = debounce(
+ async () => {
+ const {policyId, searchTerm, filters, actions} = this.props;
+ if (policyId) {
+ await actions.searchChannels(policyId, searchTerm, filters);
+ }
+ this.setState({loading: false});
+ },
+ Constants.SEARCH_TIMEOUT_MILLISECONDS,
+ );
+ }
+
+ componentDidMount = () => {
+ this.mounted = true;
+ this.loadPage(0, PAGE_SIZE + 1);
+ };
+
+ componentWillUnmount = () => {
+ this.searchDebounced.cancel();
+ this.mounted = false;
+ };
+
+ public async componentDidUpdate(prevProps: Props) {
+ const {policyId, searchTerm, filters} = this.props;
+ const filtersModified = !isEqual(prevProps.filters, filters);
+ const searchTermModified = prevProps.searchTerm !== searchTerm;
+
+ if (searchTermModified || filtersModified) {
+ this.setState({loading: true});
+
+ if (searchTerm === '') {
+ if (filtersModified && policyId) {
+ await prevProps.actions.searchChannels(policyId, searchTerm, filters);
+ } else {
+ // Reset pagination state when clearing search
+ this.setState({
+ after: '',
+ page: 0,
+ cursorHistory: [],
+ });
+ await this.loadPage(0, PAGE_SIZE + 1);
+ }
+ this.setState({loading: false});
+ return;
+ }
+
+ this.searchDebounced();
+ }
+ }
+
+ private loadPage = async (page: number, pageSize = PAGE_SIZE + 1) => {
+ const {policyId, searchTerm, filters, actions} = this.props;
+
+ if (!policyId || !this.mounted) {
+ return;
+ }
+
+ this.setState({loading: true});
+
+ const searchFilters = {...filters, page, per_page: pageSize};
+
+ try {
+ const action = await actions.searchChannels(policyId, searchTerm, searchFilters);
+ const data = action.data.channels || [];
+
+ // Check if we have more data than the page size, indicating there's a next page
+ const hasNextPage = data.length > PAGE_SIZE;
+
+ // If we have more data than needed, remove the extra item (which is used to check for next page)
+ const channels = hasNextPage ? data.slice(0, PAGE_SIZE) : data;
+
+ // Get the ID of the last channel for the next cursor
+ const lastChannelId = channels.length > 0 ? channels[channels.length - 1].id : '';
+
+ this.setState({
+ after: lastChannelId,
+ loading: false,
+ });
+ } catch (error) {
+ this.setState({loading: false});
+ }
+ };
+
+ private nextPage = async () => {
+ const {after, cursorHistory, page} = this.state;
+
+ // Save current cursor to history for "previous" navigation
+ const newCursorHistory = [...cursorHistory, after];
+
+ this.setState({
+ loading: true,
+ page: page + 1,
+ cursorHistory: newCursorHistory,
+ });
+
+ await this.loadPage(page + 1, PAGE_SIZE);
+ };
+
+ private previousPage = async () => {
+ const {cursorHistory, page} = this.state;
+
+ if (cursorHistory.length === 0) {
+ return;
+ }
+
+ // Remove the current cursor from history
+ const newCursorHistory = [...cursorHistory];
+ newCursorHistory.pop();
+
+ this.setState({
+ loading: true,
+ page: page - 1,
+ cursorHistory: newCursorHistory,
+ });
+
+ await this.loadPage(page - 1, PAGE_SIZE);
+ };
+
+ private getVisibleTotalCount = (): number => {
+ const {channelsToAdd, totalCount} = this.props;
+ const channelsToAddCount = Object.keys(channelsToAdd).length;
+ return (totalCount + channelsToAddCount);
+ };
+
+ public getPaginationProps = (): {startCount: number; endCount: number; total: number} => {
+ const {page} = this.state;
+ const startCount = (page * PAGE_SIZE) + 1;
+ const total = this.getVisibleTotalCount();
+ const endCount = Math.min((page + 1) * PAGE_SIZE, total);
+
+ return {startCount, endCount, total};
+ };
+
+ private removeChannel = (channel: ChannelWithTeamData) => {
+ const {channelsToRemove, onRemoveCallback, onUndoRemoveCallback} = this.props;
+ const {page} = this.state;
+
+ // Toggle between adding and removing the channel
+ if (channelsToRemove[channel.id] === channel) {
+ // If the channel is already marked for removal, undo it
+ onUndoRemoveCallback(channel);
+ return;
+ }
+
+ // If the channel is not marked for removal, mark it
+ onRemoveCallback(channel);
+
+ const {endCount} = this.getPaginationProps();
+ if (endCount > this.getVisibleTotalCount() && (endCount % PAGE_SIZE) === 1 && page > 0) {
+ this.setState({page: page - 1});
+ }
+ };
+
+ getColumns = (): Column[] => {
+ return [
+ {
+ name: (
+
+ ),
+ field: 'name',
+ fixed: true,
+ },
+ {
+ name: (
+
+ ),
+ field: 'team',
+ fixed: true,
+ },
+ {
+ name: '',
+ field: 'remove',
+ textAlign: 'right',
+ fixed: true,
+ },
+ ];
+ };
+
+ getRows = () => {
+ const {channels, channelsToRemove, channelsToAdd} = this.props;
+ const {startCount, endCount} = this.getPaginationProps();
+
+ // Combine channels to add with existing channels
+ const channelsToDisplay = [
+ ...Object.values(channelsToAdd),
+ ...channels,
+ ].slice(startCount - 1, endCount);
+
+ return channelsToDisplay.map((channel) => {
+ // Determine which icon to display based on channel type
+ let iconToDisplay =
+ {iconToDisplay}
+
+
+ {channel.display_name}
+
+
+
{
+ e.preventDefault();
+ this.removeChannel(channel);
+ }}
+ href='#'
+ >
+ {buttonText}
+
+ ),
+ },
+ };
+ });
+ };
+
+ onSearch = (searchTerm: string) => {
+ this.props.actions.setChannelListSearch(searchTerm);
+ };
+
+ onFilter = (filterOptions: FilterOptions) => {
+ const filters: ChannelSearchOpts = {};
+ const {team_ids: teamIds} = filterOptions.teams.values;
+ if ((teamIds.value as string[]).length) {
+ filters.team_ids = teamIds.value as string[];
+ }
+ this.props.actions.setChannelListFilters(filters);
+ };
+
+ render() {
+ const rows: Row[] = this.getRows();
+ const columns: Column[] = this.getColumns();
+ const {startCount, endCount, total} = this.getPaginationProps();
+
+ const filterOptions: FilterOptions = {
+ teams: {
+ name: 'Teams',
+ values: {
+ team_ids: {
+ name: (
+
+
+ );
+ }
+}
diff --git a/webapp/channels/src/components/admin_console/access_control/policy_details/channel_list/index.ts b/webapp/channels/src/components/admin_console/access_control/policy_details/channel_list/index.ts
new file mode 100644
index 0000000000..dfb43629f8
--- /dev/null
+++ b/webapp/channels/src/components/admin_console/access_control/policy_details/channel_list/index.ts
@@ -0,0 +1,83 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+import memoize from 'memoize-one';
+import {connect} from 'react-redux';
+import {bindActionCreators} from 'redux';
+import type {Dispatch} from 'redux';
+
+import type {Channel, ChannelSearchOpts, ChannelWithTeamData} from '@mattermost/types/channels';
+
+import {searchAccessControlPolicyChannels as searchChannels} from 'mattermost-redux/actions/access_control';
+import {searchChannelsInheritsPolicy, makeGetChannelsInAccessControlPolicy} from 'mattermost-redux/selectors/entities/access_control';
+import {filterChannelList} from 'mattermost-redux/selectors/entities/channels';
+import {filterChannelsMatchingTerm, channelListToMap} from 'mattermost-redux/utils/channel_utils';
+
+import {setChannelListSearch, setChannelListFilters} from 'actions/views/search';
+
+import type {GlobalState} from 'types/store';
+
+import ChannelList from './channel_list';
+
+type OwnProps = {
+ policyId?: string;
+ channelsToAdd: Record;
+}
+
+const EMPTY_FILTERS: ChannelSearchOpts = {};
+const EMPTY_SEARCH_TERM = '';
+
+function searchChannelsToAdd(channels: Record, term: string, filters: ChannelSearchOpts): Record {
+ const filteredChannels = filterChannelsMatchingTerm(Object.values(channels), term);
+ const filteredWithFilters = filterChannelList(filteredChannels, filters);
+ return channelListToMap(filteredWithFilters);
+}
+
+function makeMapStateToProps() {
+ const getPolicyChannels = makeGetChannelsInAccessControlPolicy();
+ const memoizedSearchChannelsToAdd = memoize(searchChannelsToAdd);
+ return (state: GlobalState, ownProps: OwnProps) => {
+ const {channelsToAdd, policyId} = ownProps;
+ const searchTerm = state.views.search.channelListSearch.term || EMPTY_SEARCH_TERM;
+ const filters = state.views.search.channelListSearch?.filters || EMPTY_FILTERS;
+
+ let channels: ChannelWithTeamData[] = [];
+ let totalCount = 0;
+
+ if (searchTerm || Object.keys(filters).length !== 0) {
+ channels = policyId ? searchChannelsInheritsPolicy(state, policyId, searchTerm, filters) as ChannelWithTeamData[] : [];
+ const filteredChannelsToAdd = memoizedSearchChannelsToAdd(channelsToAdd, searchTerm, filters) as Record;
+ totalCount = channels.length;
+ return {
+ channels,
+ totalCount,
+ searchTerm,
+ channelsToAdd: filteredChannelsToAdd,
+ filters,
+ };
+ }
+
+ channels = policyId ? getPolicyChannels(state, {policyId}) as ChannelWithTeamData[] : [];
+ totalCount = channels.length;
+
+ return {
+ channels,
+ totalCount,
+ searchTerm,
+ channelsToAdd,
+ filters,
+ };
+ };
+}
+
+function mapDispatchToProps(dispatch: Dispatch) {
+ return {
+ actions: bindActionCreators({
+ searchChannels,
+ setChannelListSearch,
+ setChannelListFilters,
+ }, dispatch),
+ };
+}
+
+export default connect(makeMapStateToProps, mapDispatchToProps)(ChannelList);
diff --git a/webapp/channels/src/components/admin_console/access_control/policy_details/index.ts b/webapp/channels/src/components/admin_console/access_control/policy_details/index.ts
new file mode 100644
index 0000000000..accb0fda49
--- /dev/null
+++ b/webapp/channels/src/components/admin_console/access_control/policy_details/index.ts
@@ -0,0 +1,52 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+import {connect} from 'react-redux';
+import {bindActionCreators} from 'redux';
+import type {Dispatch} from 'redux';
+
+import {getAccessControlPolicy as fetchPolicy, createAccessControlPolicy as createPolicy, deleteAccessControlPolicy as deletePolicy, searchAccessControlPolicyChannels as searchChannels, assignChannelsToAccessControlPolicy, unassignChannelsFromAccessControlPolicy, getAccessControlFields, updateAccessControlPolicyActive} from 'mattermost-redux/actions/access_control';
+import {createJob} from 'mattermost-redux/actions/jobs';
+import {getAccessControlPolicy as getPolicy} from 'mattermost-redux/selectors/entities/access_control';
+
+import {setNavigationBlocked} from 'actions/admin_actions.jsx';
+
+import type {GlobalState} from 'types/store';
+
+import PolicyDetails from './policy_details';
+
+type OwnProps = {
+ match: {
+ params: {
+ policy_id: string;
+ };
+ };
+}
+
+function mapStateToProps(state: GlobalState, ownProps: OwnProps) {
+ const policyId = ownProps.match.params.policy_id;
+ const policy = getPolicy(state, policyId);
+ return {
+ policy,
+ policyId,
+ };
+}
+
+function mapDispatchToProps(dispatch: Dispatch) {
+ return {
+ actions: bindActionCreators({
+ fetchPolicy,
+ createPolicy,
+ deletePolicy,
+ searchChannels,
+ assignChannelsToAccessControlPolicy,
+ unassignChannelsFromAccessControlPolicy,
+ setNavigationBlocked,
+ getAccessControlFields,
+ createJob,
+ updateAccessControlPolicyActive,
+ }, dispatch),
+ };
+}
+
+export default connect(mapStateToProps, mapDispatchToProps)(PolicyDetails);
diff --git a/webapp/channels/src/components/admin_console/access_control/policy_details/policy_details.scss b/webapp/channels/src/components/admin_console/access_control/policy_details/policy_details.scss
new file mode 100644
index 0000000000..50428d530c
--- /dev/null
+++ b/webapp/channels/src/components/admin_console/access_control/policy_details/policy_details.scss
@@ -0,0 +1,28 @@
+.AccessControlPolicySettings {
+ .form-group {
+ min-height: 40px;
+ }
+
+ .delete-policy {
+ .btn-primary:not(:disabled) {
+ background-color: var(--dnd-indicator);
+ }
+ }
+
+ .vertically-centered-label {
+ padding-top: 7px;
+ }
+
+ .EditPolicy__error {
+ display: flex;
+ align-items: center;
+ margin-left: 12px;
+ color: var(--error-text);
+ font-size: 14px;
+
+ i {
+ margin-right: 4px;
+ font-size: 16px;
+ }
+ }
+}
diff --git a/webapp/channels/src/components/admin_console/access_control/policy_details/policy_details.test.tsx b/webapp/channels/src/components/admin_console/access_control/policy_details/policy_details.test.tsx
new file mode 100644
index 0000000000..7488c95327
--- /dev/null
+++ b/webapp/channels/src/components/admin_console/access_control/policy_details/policy_details.test.tsx
@@ -0,0 +1,167 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+import {shallow} from 'enzyme';
+import React from 'react';
+import {act} from 'react-dom/test-utils';
+
+import type {ChannelWithTeamData} from '@mattermost/types/channels';
+
+import PolicyDetails from './policy_details';
+
+jest.mock('utils/browser_history', () => ({
+ getHistory: () => ({
+ push: jest.fn(),
+ }),
+}));
+
+describe('components/admin_console/access_control/policy_details/PolicyDetails', () => {
+ const mockCreatePolicy = jest.fn();
+ const mockUpdatePolicy = jest.fn();
+ const mockDeletePolicy = jest.fn();
+ const mockSearchChannels = jest.fn();
+ const mockSetChannelListSearch = jest.fn();
+ const mockSetChannelListFilters = jest.fn();
+ const mockOnRemoveCallback = jest.fn();
+ const mockOnUndoRemoveCallback = jest.fn();
+ const mockOnAddCallback = jest.fn();
+ const mockFetchPolicy = jest.fn();
+ const mockSetNavigationBlocked = jest.fn();
+ const mockAssignChannelsToAccessControlPolicy = jest.fn();
+ const mockUnassignChannelsFromAccessControlPolicy = jest.fn();
+ const mockGetAccessControlExpressionAutocomplete = jest.fn();
+ const mockGetAccessControlFields = jest.fn();
+ const mockCreateJob = jest.fn();
+ const mockUpdateAccessControlPolicyActive = jest.fn();
+
+ const defaultProps = {
+ policyId: 'policy1',
+ channels: [
+ {id: 'channel1', name: 'Channel 1', display_name: 'Channel 1', team_display_name: 'Team 1', type: 'O'} as ChannelWithTeamData,
+ {id: 'channel2', name: 'channel2', display_name: 'Channel 2', team_display_name: 'Team 2', type: 'P'} as ChannelWithTeamData,
+ ],
+ totalCount: 2,
+ searchTerm: '',
+ filters: {},
+ onRemoveCallback: mockOnRemoveCallback,
+ onUndoRemoveCallback: mockOnUndoRemoveCallback,
+ onAddCallback: mockOnAddCallback,
+ channelsToRemove: {},
+ channelsToAdd: {},
+ autocompleteResult: {entities: {}},
+ actions: {
+ createPolicy: mockCreatePolicy,
+ updatePolicy: mockUpdatePolicy,
+ deletePolicy: mockDeletePolicy,
+ searchChannels: mockSearchChannels,
+ setChannelListSearch: mockSetChannelListSearch,
+ setChannelListFilters: mockSetChannelListFilters,
+ fetchPolicy: mockFetchPolicy,
+ setNavigationBlocked: mockSetNavigationBlocked,
+ assignChannelsToAccessControlPolicy: mockAssignChannelsToAccessControlPolicy,
+ unassignChannelsFromAccessControlPolicy: mockUnassignChannelsFromAccessControlPolicy,
+ getAccessControlExpressionAutocomplete: mockGetAccessControlExpressionAutocomplete,
+ getAccessControlFields: mockGetAccessControlFields,
+ createJob: mockCreateJob,
+ updateAccessControlPolicyActive: mockUpdateAccessControlPolicyActive,
+ },
+ };
+
+ beforeEach(() => {
+ mockCreatePolicy.mockReset();
+ mockUpdatePolicy.mockReset();
+ mockDeletePolicy.mockReset();
+ mockSearchChannels.mockReset();
+ mockSetChannelListSearch.mockReset();
+ mockSetChannelListFilters.mockReset();
+ mockOnRemoveCallback.mockReset();
+ mockOnUndoRemoveCallback.mockReset();
+ mockOnAddCallback.mockReset();
+ mockFetchPolicy.mockReset();
+ mockSetNavigationBlocked.mockReset();
+ mockAssignChannelsToAccessControlPolicy.mockReset();
+ mockUnassignChannelsFromAccessControlPolicy.mockReset();
+ mockGetAccessControlExpressionAutocomplete.mockReset();
+ mockGetAccessControlFields.mockReset();
+ mockCreateJob.mockReset();
+ mockUpdateAccessControlPolicyActive.mockReset();
+ });
+
+ test('should match snapshot with new policy', () => {
+ const props = {
+ ...defaultProps,
+ policyId: '',
+ };
+ const wrapper = shallow(;
+ createPolicy: (policy: AccessControlPolicy) => Promise;
+ deletePolicy: (id: string) => Promise;
+ searchChannels: (id: string, term: string, opts: ChannelSearchOpts) => Promise;
+ setNavigationBlocked: (blocked: boolean) => void;
+ assignChannelsToAccessControlPolicy: (policyId: string, channelIds: string[]) => Promise;
+ unassignChannelsFromAccessControlPolicy: (policyId: string, channelIds: string[]) => Promise;
+ getAccessControlFields: (after: string, limit: number) => Promise;
+ createJob: (job: JobTypeBase & { data: any }) => Promise;
+ updateAccessControlPolicyActive: (policyId: string, active: boolean) => Promise;
+}
+
+export interface PolicyDetailsProps {
+ policy?: AccessControlPolicy;
+ policyId?: string;
+ actions: PolicyActions;
+}
+
+interface ChannelChanges {
+ removed: Record;
+ added: Record;
+ removedCount: number;
+}
+
+function PolicyDetails({
+ policy,
+ policyId,
+ actions,
+}: PolicyDetailsProps): JSX.Element {
+ const [policyName, setPolicyName] = useState(policy?.name || '');
+ const [expression, setExpression] = useState(policy?.rules?.[0]?.expression || '');
+ const [autoSyncMembership, setAutoSyncMembership] = useState(policy?.active || false);
+ const [serverError, setServerError] = useState(undefined);
+ const [addChannelOpen, setAddChannelOpen] = useState(false);
+ const [editorMode, setEditorMode] = useState<'cel' | 'table'>('table');
+ const [channelChanges, setChannelChanges] = useState({
+ removed: {},
+ added: {},
+ removedCount: 0,
+ });
+ const [saveNeeded, setSaveNeeded] = useState(false);
+ const [channelsCount, setChannelsCount] = useState(0);
+ const [autocompleteResult, setAutocompleteResult] = useState([]);
+ const [showConfirmationModal, setShowConfirmationModal] = useState(false);
+ const [showDeleteConfirmationModal, setShowDeleteConfirmationModal] = useState(false);
+ const {formatMessage} = useIntl();
+ useEffect(() => {
+ loadPage();
+ }, [policyId]);
+
+ // Check if expression is simple enough for table mode
+ const isSimpleExpression = (expr: string): boolean => {
+ if (!expr) {
+ return true;
+ }
+
+ // Expression is simple if it only contains user.attributes.X == "Y" or user.attributes.X in ["Y", "Z"]
+ // or user.attributes.X.startsWith/endsWith/contains("Y")
+ return expr.split('&&').every((condition) => {
+ const trimmed = condition.trim();
+ return trimmed.match(/^user\.attributes\.\w+\s*(==|!=)\s*['"][^'"]+['"]$/) ||
+ trimmed.match(/^user\.attributes\.\w+\s+in\s+\[.*?\]$/) ||
+ trimmed.match(/^user\.attributes\.\w+\.startsWith\(['"][^'"]+['"].*?\)$/) ||
+ trimmed.match(/^user\.attributes\.\w+\.endsWith\(['"][^'"]+['"].*?\)$/) ||
+ trimmed.match(/^user\.attributes\.\w+\.contains\(['"][^'"]+['"].*?\)$/);
+ });
+ };
+
+ const loadPage = async () => {
+ // Fetch autocomplete fields first, as they are general and needed for both new and existing policies.
+ const fieldsPromise = actions.getAccessControlFields('', 100).then((result) => {
+ if (result.data) {
+ setAutocompleteResult(result.data);
+ }
+ });
+
+ if (policyId) {
+ // For existing policies, fetch policy details and channels
+ const policyPromise = actions.fetchPolicy(policyId).then((result) => {
+ setPolicyName(result.data?.name || '');
+ setExpression(result.data?.rules?.[0]?.expression || '');
+ setAutoSyncMembership(result.data?.active || false);
+ });
+
+ const channelsPromise = actions.searchChannels(policyId, '', {per_page: DEFAULT_PAGE_SIZE}).then((result) => {
+ setChannelsCount(result.data?.total_count || 0);
+ });
+
+ // Wait for all fetches for an existing policy
+ await Promise.all([fieldsPromise, policyPromise, channelsPromise]);
+ } else {
+ // For new policies, just ensure general fields are fetched.
+ // Policy name, expression, etc., are already initialized from props or defaults by useState.
+ await fieldsPromise;
+ }
+ };
+
+ const handleSubmit = async (apply = false) => {
+ let success = true;
+ let currentPolicyId = policyId;
+
+ // --- Step 1: Create/Update Policy ---
+ await actions.createPolicy({
+ id: currentPolicyId || '',
+ name: policyName,
+ rules: [{expression, actions: ['*']}] as AccessControlPolicyRule[],
+ type: 'parent',
+ version: 'v0.1',
+ }).then((result) => {
+ if (result.error) {
+ setServerError(result.error.message);
+ success = false;
+ return;
+ }
+ currentPolicyId = result.data?.id;
+ setPolicyName(result.data?.name || '');
+ setExpression(result.data?.rules?.[0]?.expression || '');
+ setAutoSyncMembership(result.data?.active || false);
+ });
+
+ if (!currentPolicyId || !success) {
+ return;
+ }
+
+ // --- Step 2: Update Policy Active ---
+ try {
+ await actions.updateAccessControlPolicyActive(currentPolicyId, autoSyncMembership);
+ } catch (error) {
+ setServerError(`Error updating policy active status: ${error.message}`);
+ success = false;
+ return;
+ }
+
+ // --- Step 3: Assign Channels ---
+ if (success) {
+ try {
+ if (channelChanges.removedCount > 0) {
+ await actions.unassignChannelsFromAccessControlPolicy(currentPolicyId, Object.keys(channelChanges.removed));
+ }
+ if (Object.keys(channelChanges.added).length > 0) {
+ await actions.assignChannelsToAccessControlPolicy(currentPolicyId, Object.keys(channelChanges.added));
+ }
+
+ setChannelChanges({removed: {}, added: {}, removedCount: 0});
+ } catch (error) {
+ setServerError(`Error assigning channels: ${error.message}`);
+ success = false;
+ return;
+ }
+ }
+
+ // --- Step 4: Create Job if necessary ---
+ if (apply) {
+ try {
+ const job: JobTypeBase & { data: any } = {
+ type: JobTypes.ACCESS_CONTROL_SYNC,
+ data: {parent_id: currentPolicyId},
+ };
+ await actions.createJob(job);
+ } catch (error) {
+ setServerError(`Error creating job: ${error.message}`);
+ success = false;
+ return;
+ }
+ }
+
+ // --- Step 5: Navigate lastly ---
+ setSaveNeeded(false);
+ setShowConfirmationModal(false);
+ actions.setNavigationBlocked(false);
+ getHistory().push('/admin_console/user_management/attribute_based_access_control');
+ };
+
+ const handleDelete = async () => {
+ if (!policyId) {
+ return; // Should not happen if delete button is enabled correctly
+ }
+
+ let success = true;
+
+ // --- Step 1: Unassign Channels (if necessary) ---
+ if (channelChanges.removedCount > 0) {
+ try {
+ await actions.unassignChannelsFromAccessControlPolicy(policyId, Object.keys(channelChanges.removed));
+ } catch (error) {
+ setServerError(`Error unassigning channels: ${error.message}`);
+ success = false;
+ }
+ }
+
+ // --- Step 2: Delete Policy and Navigate ---
+ if (success) {
+ try {
+ await actions.deletePolicy(policyId);
+ } catch (error) {
+ setServerError(`Error deleting policy: ${error.message}`);
+ }
+ }
+
+ if (success) {
+ getHistory().push('/admin_console/user_management/attribute_based_access_control');
+ }
+ };
+
+ const handleChannelChanges = (channels: ChannelWithTeamData[], isAdding: boolean) => {
+ setChannelChanges((prev) => {
+ const newChanges = cloneDeep(prev);
+
+ channels.forEach((channel) => {
+ if (isAdding) {
+ if (newChanges.removed[channel.id]) {
+ delete newChanges.removed[channel.id];
+ newChanges.removedCount--;
+ } else {
+ newChanges.added[channel.id] = channel;
+ }
+ } else if (newChanges.added[channel.id]) {
+ delete newChanges.added[channel.id];
+ } else if (!newChanges.removed[channel.id]) {
+ newChanges.removedCount++;
+ newChanges.removed[channel.id] = channel;
+ }
+ });
+
+ return newChanges;
+ });
+ setSaveNeeded(true);
+ actions.setNavigationBlocked(true);
+ };
+
+ const handleUndoRemove = (channel: ChannelWithTeamData) => {
+ setChannelChanges((prev) => {
+ const newChanges = cloneDeep(prev);
+ if (newChanges.removed[channel.id]) {
+ delete newChanges.removed[channel.id];
+ newChanges.removedCount--;
+ }
+ return newChanges;
+ });
+ setSaveNeeded(true);
+ actions.setNavigationBlocked(true);
+ };
+
+ const hasChannels = () => {
+ // If there are channels on the server (minus any pending removals) or newly added channels
+ return (
+ (channelsCount > channelChanges.removedCount) ||
+ (Object.keys(channelChanges.added).length > 0)
+ );
+ };
+
+ return (
+
+
+
+
+
+
+
+
+
+ }
+ value={policyName}
+ placeholder={formatMessage({
+ id: 'admin.access_control.policy.edit_policy.policyName.placeholder',
+ defaultMessage: 'Add a unique policy name',
+ })}
+ onChange={(_, value) => {
+ setPolicyName(value);
+ setSaveNeeded(true);
+ }}
+ labelClassName='col-sm-4 vertically-centered-label'
+ inputClassName='col-sm-8'
+ />
+
+
+ }
+ value={autoSyncMembership}
+ onChange={(_, value) => {
+ setAutoSyncMembership(value);
+ setSaveNeeded(true);
+ }}
+ setByEnv={false}
+ helpText={
+
+ }
+ />
+
+
+
+
+
+
+ {editorMode === 'cel' ? (
+ {
+ setExpression(value);
+ setSaveNeeded(true);
+ }}
+ onValidate={() => {}}
+ userAttributes={autocompleteResult.map((attr) => ({
+ attribute: attr.name,
+ values: [],
+ }))}
+ />
+ ) : (
+ {
+ setExpression(value);
+ setSaveNeeded(true);
+ }}
+ onValidate={() => {}}
+ userAttributes={autocompleteResult.map((attr) => ({
+ attribute: attr.name,
+ values: [],
+ }))}
+ />
+ )}
+
+
+
+
+
+
+
+ handleChannelChanges([channel], false)}
+ onUndoRemoveCallback={handleUndoRemove}
+ channelsToRemove={channelChanges.removed}
+ channelsToAdd={channelChanges.added}
+ policyId={policyId}
+ />
+
+
+ {policyId && (
+
+
+
+
+ )}
+
+
setAddChannelOpen(false)}
+ onChannelsSelected={(channels) => handleChannelChanges(channels, true)}
+ groupID={''}
+ alreadySelected={Object.values(channelChanges.added).map((channel) => channel.id)}
+ excludeAccessControlPolicyEnforced={true}
+ excludeTypes={['O', 'D', 'G']}
+ />
+ )}
+
+ {showConfirmationModal && (
+ setShowConfirmationModal(false)}
+ onConfirm={handleSubmit}
+ channelsAffected={(channelsCount - channelChanges.removedCount) + Object.keys(channelChanges.added).length}
+ />
+ )}
+
+ {showDeleteConfirmationModal && (
+ setShowDeleteConfirmationModal(false)}
+ handleConfirm={handleDelete}
+ handleCancel={() => setShowDeleteConfirmationModal(false)}
+ modalHeaderText={
+
+ )}
+
+
+ {
+ if (hasChannels()) {
+ setShowConfirmationModal(true);
+ } else {
+ handleSubmit();
+ }
+ }}
+ defaultMessage={
+
+
+ {serverError && (
+
+
+ )}
+
+
+ );
+}
+
+export default PolicyDetails;
diff --git a/webapp/channels/src/components/admin_console/admin_definition.tsx b/webapp/channels/src/components/admin_console/admin_definition.tsx
index 3d5b61052c..3da1fa0406 100644
--- a/webapp/channels/src/components/admin_console/admin_definition.tsx
+++ b/webapp/channels/src/components/admin_console/admin_definition.tsx
@@ -41,6 +41,9 @@ import {isCloudLicense} from 'utils/license_utils';
import {ID_PATH_PATTERN} from 'utils/path';
import {getSiteURL} from 'utils/url';
+import PolicyList from './access_control';
+import AccessControlPolicyJobs from './access_control/jobs';
+import PolicyDetails from './access_control/policy_details';
import * as DefinitionConstants from './admin_definition_constants';
import AuditLoggingCertificateUploadSetting from './audit_logging';
import Audits from './audits';
@@ -77,6 +80,7 @@ import {
GroupsFeatureDiscovery,
MobileSecurityFeatureDiscovery,
} from './feature_discovery/features';
+import AttributeBasedAccessControlFeatureDiscovery from './feature_discovery/features/attribute_based_access_control';
import FeatureFlags, {messages as featureFlagsMessages} from './feature_flags';
import GroupDetails from './group_settings/group_details';
import GroupSettings from './group_settings/group_settings';
@@ -664,6 +668,117 @@ const AdminDefinition: AdminDefinitionType = {
},
restrictedIndicator: getRestrictedIndicator(true, LicenseSkus.Enterprise),
},
+ access_control_policy_details_edit: {
+ url: `user_management/attribute_based_access_control/edit_policy/:policy_id(${ID_PATH_PATTERN})`,
+ isHidden: it.any(
+ it.configIsFalse('AccessControlSettings', 'EnableAttributeBasedAccessControl'),
+ it.not(it.licensedForSku(LicenseSkus.EnterpriseAdvanced)),
+ it.not(it.userHasReadPermissionOnResource(RESOURCE_KEYS.USER_MANAGEMENT.SYSTEM_ROLES)),
+ ),
+ isDisabled: it.any(
+ it.not(it.userHasWritePermissionOnResource(RESOURCE_KEYS.USER_MANAGEMENT.SYSTEM_ROLES)),
+ it.configIsFalse('FeatureFlags', 'AttributeBasedAccessControl'),
+ ),
+ schema: {
+ id: 'AccessControlPolicy',
+ component: PolicyDetails,
+ },
+
+ },
+ access_control_policy_details: {
+ url: 'user_management/attribute_based_access_control/edit_policy',
+ isHidden: it.any(
+ it.configIsFalse('AccessControlSettings', 'EnableAttributeBasedAccessControl'),
+ it.not(it.licensedForSku(LicenseSkus.EnterpriseAdvanced)),
+ it.not(it.userHasReadPermissionOnResource(RESOURCE_KEYS.USER_MANAGEMENT.SYSTEM_ROLES)),
+ it.configIsFalse('FeatureFlags', 'AttributeBasedAccessControl'),
+ ),
+ isDisabled: it.not(it.userHasWritePermissionOnResource(RESOURCE_KEYS.USER_MANAGEMENT.SYSTEM_ROLES)),
+ schema: {
+ id: 'AccessControlPolicy',
+ component: PolicyDetails,
+ },
+ },
+ attribute_based_access_control: {
+ url: 'user_management/attribute_based_access_control',
+ title: defineMessage({id: 'admin.sidebar.attributeBasedAccessControl', defaultMessage: 'Attribute-Based Access'}),
+ isHidden: it.any(
+ it.not(it.licensedForSku(LicenseSkus.EnterpriseAdvanced)),
+ it.not(it.userHasReadPermissionOnResource(RESOURCE_KEYS.USER_MANAGEMENT.SYSTEM_ROLES)),
+ it.configIsFalse('FeatureFlags', 'AttributeBasedAccessControl'),
+ ),
+ isDisabled: it.not(it.userHasWritePermissionOnResource(RESOURCE_KEYS.USER_MANAGEMENT.SYSTEM_ROLES)),
+ schema: {
+ id: 'AttributeBasedAccessControl',
+ isBeta: true,
+ name: defineMessage({id: 'admin.accesscontrol.title', defaultMessage: 'Attribute-Based Access'}),
+ sections: [
+ {
+ key: 'admin.accesscontrol.settings',
+ settings: [
+ {
+ type: 'bool',
+ key: 'AccessControlSettings.EnableAttributeBasedAccessControl',
+ label: defineMessage({id: 'admin.accesscontrol.enableTitle', defaultMessage: 'Allow attribute based access controls on this server'}),
+ help_text: defineMessage({id: 'admin.accesscontrol.enableDesc', defaultMessage: 'Allow access restrictions based on user attributes using custom access policies'}),
+ },
+ ],
+ },
+ {
+ key: 'admin.accesscontrol.policies',
+ isHidden: it.any(
+ it.configIsFalse('AccessControlSettings', 'EnableAttributeBasedAccessControl'),
+ it.stateIsFalse('AccessControlSettings.EnableAttributeBasedAccessControl'),
+ ),
+ settings: [
+ {
+ type: 'custom',
+ component: PolicyList,
+ key: 'PolicyListPanel',
+ },
+ ],
+ },
+ {
+ key: 'admin.accesscontrol.policyjobs',
+ isHidden: it.any(
+ it.configIsFalse('AccessControlSettings', 'EnableAttributeBasedAccessControl'),
+ it.stateIsFalse('AccessControlSettings.EnableAttributeBasedAccessControl'),
+ ),
+ settings: [
+ {
+ type: 'custom',
+ component: AccessControlPolicyJobs,
+ key: 'AcessControlPolicyJobs',
+ },
+ ],
+ },
+ ],
+ },
+ restrictedIndicator: getRestrictedIndicator(false, LicenseSkus.EnterpriseAdvanced),
+ },
+ attribute_based_access_control_feature_discovery: {
+ url: 'user_management/attribute_based_access_control',
+ isDiscovery: true,
+ title: defineMessage({id: 'admin.sidebar.attributeBasedAccessControl', defaultMessage: 'Attribute-Based Access'}),
+ isHidden: it.any(
+ it.licensedForSku(LicenseSkus.EnterpriseAdvanced),
+ it.not(it.enterpriseReady),
+ it.configIsFalse('FeatureFlags', 'AttributeBasedAccessControl'),
+ ),
+ schema: {
+ id: 'AttributeBasedAccessControl',
+ name: defineMessage({id: 'admin.accesscontrol.title', defaultMessage: 'Attribute-Based Access (Beta)'}),
+ settings: [
+ {
+ type: 'custom',
+ component: AttributeBasedAccessControlFeatureDiscovery,
+ key: 'AttributeBasedAccessControlFeatureDiscovery',
+ isDisabled: it.not(it.userHasWritePermissionOnResource(RESOURCE_KEYS.ABOUT.EDITION_AND_LICENSE)),
+ },
+ ],
+ },
+ restrictedIndicator: getRestrictedIndicator(true, LicenseSkus.EnterpriseAdvanced),
+ },
},
},
environment: {
diff --git a/webapp/channels/src/components/admin_console/admin_sidebar/__snapshots__/admin_sidebar.test.tsx.snap b/webapp/channels/src/components/admin_console/admin_sidebar/__snapshots__/admin_sidebar.test.tsx.snap
index e4142c3b33..9547865d2f 100644
--- a/webapp/channels/src/components/admin_console/admin_sidebar/__snapshots__/admin_sidebar.test.tsx.snap
+++ b/webapp/channels/src/components/admin_console/admin_sidebar/__snapshots__/admin_sidebar.test.tsx.snap
@@ -1496,6 +1496,30 @@ exports[`components/AdminSidebar should match snapshot with license with enterpr
/>
}
/>
+ {
Scope: 'scope',
} as Office365Settings,
FeatureFlags: {
+ AttributeBasedAccessControl: true,
CustomProfileAttributes: true,
CloudDedicatedExportUI: true,
CloudIPFiltering: true,
@@ -521,6 +522,7 @@ describe('components/AdminSidebar', () => {
Scope: 'scope',
} as Office365Settings,
FeatureFlags: {
+ AttributeBasedAccessControl: true,
CustomProfileAttributes: true,
CloudDedicatedExportUI: true,
CloudIPFiltering: true,
diff --git a/webapp/channels/src/components/admin_console/feature_discovery/features/attribute_based_access_control.tsx b/webapp/channels/src/components/admin_console/feature_discovery/features/attribute_based_access_control.tsx
new file mode 100644
index 0000000000..9c1f5e9328
--- /dev/null
+++ b/webapp/channels/src/components/admin_console/feature_discovery/features/attribute_based_access_control.tsx
@@ -0,0 +1,37 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+import React from 'react';
+import {defineMessage} from 'react-intl';
+
+import {LicenseSkus} from 'utils/constants';
+
+import SystemRolesSVG from './images/system_roles_svg';
+
+import FeatureDiscovery from '../index';
+
+const AttributeBasedAccessControlFeatureDiscovery: React.FC = () => {
+ return (
+ ;
@@ -38,9 +43,20 @@ export type Props = {
};
}
-class JobTable extends React.PureComponent {
+type State = {
+ currentPage: number;
+}
+
+class JobTable extends React.PureComponent {
interval: ReturnType|null = null;
+ constructor(props: Props) {
+ super(props);
+ this.state = {
+ currentPage: 0,
+ };
+ }
+
componentDidMount() {
this.props.actions.getJobsByType(this.props.jobType);
this.interval = setInterval(this.reload, 15000);
@@ -84,24 +100,45 @@ class JobTable extends React.PureComponent {
this.reload();
};
+ handleNextPage = () => {
+ if (this.props.perPage) {
+ const totalPages = Math.ceil(this.props.jobs.length / this.props.perPage);
+ if (this.state.currentPage < totalPages) {
+ this.setState({currentPage: this.state.currentPage + 1});
+ }
+ }
+ };
+
+ handlePrevPage = () => {
+ if (this.state.currentPage > 0) {
+ this.setState({currentPage: this.state.currentPage - 1});
+ }
+ };
+
render() {
+ const {perPage} = this.props;
+ const {currentPage} = this.state;
+
+ let paginatedJobs = this.props.jobs;
+ let startIndex = 0;
+ let endIndex = this.props.jobs.length;
+
+ if (perPage) {
+ startIndex = currentPage * perPage;
+ endIndex = Math.min(startIndex + perPage, this.props.jobs.length);
+ paginatedJobs = this.props.jobs.slice(startIndex, endIndex);
+ }
+
const showFilesColumn = this.props.jobType === JobTypes.MESSAGE_EXPORT && this.props.downloadExportResults;
- const items = this.props.jobs.map((job) => {
+ const hideDetailsColumn = this.props.jobType === JobTypes.ACCESS_CONTROL_SYNC;
+ const items = paginatedJobs.map((job) => {
return (
this.props.onRowClick!(job) : undefined}
+ className={this.props.onRowClick ? 'clickable' : ''}
>
-
-
{
/>
{this.getExtraInfoText(job)}
+ {showFilesColumn &&
+ {this.getExtraInfoText(job)}
+ )}
+
+
);
});
+ const renderFooter = (): JSX.Element | null => {
+ let footer: JSX.Element | null = null;
+
+ if (perPage) {
+ const firstPage = startIndex <= 0;
+ const lastPage = endIndex >= this.props.jobs.length;
+
+ footer = (
+
+ );
+ }
+
+ return footer;
+ };
+
return (
@@ -143,21 +237,12 @@ class JobTable extends React.PureComponent
{
>
-
- {showFilesColumn &&
-
-
-
- }
-
+ {showFilesColumn &&
+
+ }
+ {!hideDetailsColumn && (
+
+
+
+ )}
+
{items}
+ {perPage && this.props.jobs.length > 0 && (
+ renderFooter()
+ )}
}
diff --git a/webapp/channels/src/components/admin_console/schema_admin_settings.scss b/webapp/channels/src/components/admin_console/schema_admin_settings.scss
index 32bae08f20..896cf9a54a 100644
--- a/webapp/channels/src/components/admin_console/schema_admin_settings.scss
+++ b/webapp/channels/src/components/admin_console/schema_admin_settings.scss
@@ -29,3 +29,8 @@
.config-section:nth-child(1) {
margin-top: 0;
}
+
+.admin-header-beta-badge {
+ margin-right: auto;
+ margin-inline-start: 8px;
+}
diff --git a/webapp/channels/src/components/admin_console/schema_admin_settings.tsx b/webapp/channels/src/components/admin_console/schema_admin_settings.tsx
index 998a0d3a97..b2fb309690 100644
--- a/webapp/channels/src/components/admin_console/schema_admin_settings.tsx
+++ b/webapp/channels/src/components/admin_console/schema_admin_settings.tsx
@@ -32,6 +32,7 @@ import Markdown from 'components/markdown';
import SaveButton from 'components/save_button';
import AdminHeader from 'components/widgets/admin_console/admin_header';
import WarningIcon from 'components/widgets/icons/fa_warning_icon';
+import BetaTag from 'components/widgets/tag/beta_tag';
import WithTooltip from 'components/with_tooltip';
import * as I18n from 'i18n/i18n.jsx';
@@ -39,7 +40,7 @@ import Constants from 'utils/constants';
import {mappingValueFromRoles, rolesFromMapping} from 'utils/policy_roles_adapter';
import Setting from './setting';
-import type {AdminDefinitionSetting, AdminDefinitionSettingBanner, AdminDefinitionSettingDropdownOption, AdminDefinitionSubSectionSchema, ConsoleAccess} from './types';
+import type {AdminDefinitionConfigSchemaSection, AdminDefinitionSetting, AdminDefinitionSettingBanner, AdminDefinitionSettingDropdownOption, AdminDefinitionSubSectionSchema, ConsoleAccess} from './types';
import './schema_admin_settings.scss';
@@ -330,10 +331,19 @@ export class SchemaAdminSettings extends React.PureComponent {
name = this.props.schema.name;
}
+ const betaBadge = this.props.schema.isBeta && (
+
{name}
+ {betaBadge}
);
}
@@ -343,6 +353,7 @@ export class SchemaAdminSettings extends React.PureComponent {
{
return Boolean(setting.isHidden);
};
+ isSectionHidden = (section: AdminDefinitionConfigSchemaSection) => {
+ if (typeof section.isHidden === 'function') {
+ return section.isHidden(this.props.config, this.state, this.props.license);
+ }
+ return Boolean(section.isHidden);
+ };
+
buildButtonSetting = (setting: AdminDefinitionSetting) => {
if (!this.props.schema || setting.type !== 'button') {
return (<>);
@@ -1058,6 +1076,10 @@ export class SchemaAdminSettings extends React.PureComponent {
const sections: React.ReactNode[] = [];
schema.sections.forEach((section) => {
+ if (this.isSectionHidden(section)) {
+ return;
+ }
+
const settingsList: React.ReactNode[] = [];
if (section.settings) {
section.settings.forEach((setting) => {
diff --git a/webapp/channels/src/components/admin_console/team_channel_settings/channel/details/__snapshots__/channel_details.test.tsx.snap b/webapp/channels/src/components/admin_console/team_channel_settings/channel/details/__snapshots__/channel_details.test.tsx.snap
index 606e53335a..835e1cbb77 100644
--- a/webapp/channels/src/components/admin_console/team_channel_settings/channel/details/__snapshots__/channel_details.test.tsx.snap
+++ b/webapp/channels/src/components/admin_console/team_channel_settings/channel/details/__snapshots__/channel_details.test.tsx.snap
@@ -125,12 +125,15 @@ exports[`admin_console/team_channel_settings/channel/ChannelDetails should match
toPublic={true}
/>
;
+ onPolicySelected?: (policy: AccessControlPolicy) => void;
+ onPolicyRemoved: () => void;
+ };
+}
+
+export const ChannelAccessControl: React.FC = (props: Props): JSX.Element => {
+ const {accessControlPolicies, actions} = props;
+ const [showPolicySelectionModal, setShowPolicySelectionModal] = useState(false);
+
+ const intl = useIntl();
+
+ const handlePolicySelected = (policy: AccessControlPolicy) => {
+ if (actions.onPolicySelected && policy) {
+ actions.onPolicySelected(policy);
+ }
+ setShowPolicySelectionModal(false);
+ };
+
+ const handleClosePolicyModal = () => {
+ setShowPolicySelectionModal(false);
+ };
+
+ const handleOpenPolicyModal = () => {
+ setShowPolicySelectionModal(true);
+ };
+
+ const renderTable = () => {
+ if (!accessControlPolicies || accessControlPolicies.length === 0) {
+ return null;
+ }
+
+ return (
+
+
+
+
+
+
+
+
+
+
+
+
+
+ {accessControlPolicies.map((policy) => (
+
+ {policy.name}
+
+
+
+ ))}
+
+
+
{
+ handleOpenPolicyModal();
+ }}
+ >
+
+ );
+ }
+
+ return (
+ {
+ actions.onPolicyRemoved();
+ }}
+ >
+
+
+
+ {!accessControlPolicies && (
+
+
+ )}
+ {renderTable()}
+
+
+
+ );
+};
diff --git a/webapp/channels/src/components/admin_console/team_channel_settings/channel/details/channel_details.test.tsx b/webapp/channels/src/components/admin_console/team_channel_settings/channel/details/channel_details.test.tsx
index a36bdcb03d..20e47eaf52 100644
--- a/webapp/channels/src/components/admin_console/team_channel_settings/channel/details/channel_details.test.tsx
+++ b/webapp/channels/src/components/admin_console/team_channel_settings/channel/details/channel_details.test.tsx
@@ -93,6 +93,10 @@ describe('admin_console/team_channel_settings/channel/ChannelDetails', () => {
updateChannelMemberSchemeRoles: jest.fn(),
deleteChannel: jest.fn(),
unarchiveChannel: jest.fn(),
+ getAccessControlPolicy: jest.fn(),
+ deleteAccessControlPolicy: jest.fn(),
+ assignChannelToAccessControlPolicy: jest.fn(),
+ searchPolicies: jest.fn(),
};
const additionalProps = {
@@ -100,6 +104,7 @@ describe('admin_console/team_channel_settings/channel/ChannelDetails', () => {
guestAccountsEnabled: true,
channelModerationEnabled: true,
channelGroupsEnabled: true,
+ abacSupported: true,
isDisabled: false,
};
@@ -217,6 +222,10 @@ describe('admin_console/team_channel_settings/channel/ChannelDetails', () => {
updateChannelMemberSchemeRoles: jest.fn(),
deleteChannel: jest.fn(),
unarchiveChannel: jest.fn(),
+ getAccessControlPolicy: jest.fn(),
+ deleteAccessControlPolicy: jest.fn(),
+ assignChannelToAccessControlPolicy: jest.fn(),
+ searchPolicies: jest.fn(),
};
const additionalProps = {
@@ -225,6 +234,7 @@ describe('admin_console/team_channel_settings/channel/ChannelDetails', () => {
channelModerationEnabled: true,
channelGroupsEnabled: false,
isDisabled: false,
+ abacSupported: false,
};
if (!testChannel.id) {
@@ -342,6 +352,10 @@ describe('admin_console/team_channel_settings/channel/ChannelDetails', () => {
updateChannelMemberSchemeRoles: jest.fn(),
deleteChannel: jest.fn(),
unarchiveChannel: jest.fn(),
+ getAccessControlPolicy: jest.fn(),
+ deleteAccessControlPolicy: jest.fn(),
+ assignChannelToAccessControlPolicy: jest.fn(),
+ searchPolicies: jest.fn(),
};
const additionalProps = {
@@ -350,6 +364,7 @@ describe('admin_console/team_channel_settings/channel/ChannelDetails', () => {
channelModerationEnabled: true,
channelGroupsEnabled: false,
isDisabled: false,
+ abacSupported: true,
};
if (!testChannel.id) {
diff --git a/webapp/channels/src/components/admin_console/team_channel_settings/channel/details/channel_details.tsx b/webapp/channels/src/components/admin_console/team_channel_settings/channel/details/channel_details.tsx
index 52d97d3dba..f616391e23 100644
--- a/webapp/channels/src/components/admin_console/team_channel_settings/channel/details/channel_details.tsx
+++ b/webapp/channels/src/components/admin_console/team_channel_settings/channel/details/channel_details.tsx
@@ -5,6 +5,7 @@ import cloneDeep from 'lodash/cloneDeep';
import React from 'react';
import {FormattedMessage} from 'react-intl';
+import type {AccessControlPolicy} from '@mattermost/types/access_control';
import type {Channel, ChannelModeration as ChannelPermissions, ChannelModerationPatch} from '@mattermost/types/channels';
import {SyncableType} from '@mattermost/types/groups';
import type {SyncablePatch, Group} from '@mattermost/types/groups';
@@ -25,6 +26,7 @@ import AdminHeader from 'components/widgets/admin_console/admin_header';
import {getHistory} from 'utils/browser_history';
import Constants from 'utils/constants';
+import {ChannelAccessControl} from './channel_access_control_policy';
import {ChannelGroups} from './channel_groups';
import ChannelMembers from './channel_members';
import ChannelModeration from './channel_moderation';
@@ -50,6 +52,7 @@ export interface ChannelDetailsProps {
guestAccountsEnabled: boolean;
channelModerationEnabled: boolean;
channelGroupsEnabled: boolean;
+ abacSupported: boolean;
isDisabled?: boolean;
actions: ChannelDetailsActions;
}
@@ -81,6 +84,9 @@ interface ChannelDetailsState {
teamScheme?: Scheme;
isLocalArchived: boolean;
showArchiveConfirmModal: boolean;
+ policyToggled: boolean;
+ accessControlPolicies: AccessControlPolicy[];
+ abacSupported: boolean;
}
export type ChannelDetailsActions = {
@@ -102,6 +108,10 @@ export type ChannelDetailsActions = {
updateChannelMemberSchemeRoles: (channelId: string, userId: string, isSchemeUser: boolean, isSchemeAdmin: boolean) => Promise;
deleteChannel: (channelId: string) => Promise;
unarchiveChannel: (channelId: string) => Promise;
+ getAccessControlPolicy: (channelId: string) => Promise;
+ searchPolicies: (term: string, type: string, after: string, limit: number) => Promise;
+ assignChannelToAccessControlPolicy: (policyId: string, channelId: string) => Promise;
+ deleteAccessControlPolicy: (policyId: string) => Promise;
};
export default class ChannelDetails extends React.PureComponent {
@@ -129,6 +139,9 @@ export default class ChannelDetails extends React.PureComponent this.restrictChannelMentions());
}
actions.getChannel(channelID);
+
+ if (channel?.policy_enforced) {
+ this.fetchAccessControlPolicies(channelID);
+ this.setState({policyToggled: true});
+ }
}
if (channel?.team_id) {
@@ -204,7 +223,7 @@ export default class ChannelDetails extends React.PureComponent {
+ private setToggles = (isSynced: boolean, isPublic: boolean, policyEnforced: boolean) => {
const {channel} = this.props;
const isOriginallyPublic = channel?.type === Constants.OPEN_CHANNEL;
this.setState(
@@ -213,6 +232,7 @@ export default class ChannelDetails extends React.PureComponent this.processGroupsChange(this.state.groups),
);
@@ -387,7 +407,7 @@ export default class ChannelDetails extends React.PureComponent,
+ saving: false,
+ saveNeeded: true,
+ });
+ actions.setNavigationBlocked(true);
+ });
+ } else {
+ await actions.deleteAccessControlPolicy(channelID).catch((error) => {
+ this.setState({
+ serverError: ,
+ saving: false,
+ saveNeeded: true,
+ });
+ });
+ }
+
let privacyChanging = isPrivacyChanging;
if (serverError == null) {
privacyChanging = false;
@@ -691,6 +764,61 @@ export default class ChannelDetails extends React.PureComponent {
+ this.setState({
+ accessControlPolicies: [policy],
+ saveNeeded: true,
+ });
+ this.props.actions.setNavigationBlocked(true);
+ };
+
+ private onPolicyRemoved = () => {
+ this.setState({
+ accessControlPolicies: [],
+ saveNeeded: true,
+ });
+ this.props.actions.setNavigationBlocked(true);
+ };
+
+ private fetchAccessControlPolicies = (channelId: string) => {
+ if (!channelId) {
+ return;
+ }
+
+ // Always try to fetch policies, even if policy_enforced is false
+ // This ensures we have policies when toggling the flag
+ this.props.actions.getAccessControlPolicy(channelId).then((result) => {
+ if (result.data) {
+ const currentAccessControlPolicy = result.data;
+ const policies: AccessControlPolicy[] = [];
+ const promises: Array> = [];
+
+ if (currentAccessControlPolicy.imports && currentAccessControlPolicy.imports.length > 0) {
+ for (const policyId of currentAccessControlPolicy.imports) {
+ const promise = this.props.actions.getAccessControlPolicy(policyId).then((policyResult) => {
+ if (policyResult.data) {
+ policies.push(policyResult.data as AccessControlPolicy);
+ }
+ });
+
+ promises.push(promise);
+ }
+
+ Promise.all(promises).then(() => {
+ this.setState({
+ accessControlPolicies: policies,
+ });
+ });
+ } else {
+ // If there are no imports, still update state with empty array
+ this.setState({
+ accessControlPolicies: [],
+ });
+ }
+ }
+ });
+ };
+
public render = () => {
const {
totalGroups,
@@ -711,6 +839,8 @@ export default class ChannelDetails extends React.PureComponent {
isDefault={false}
isDisabled={false}
groupsSupported={true}
+ policyEnforced={false}
+ policyEnforcedToggleAvailable={false}
/>,
);
expect(wrapper).toMatchSnapshot();
@@ -30,6 +32,8 @@ describe('admin_console/team_channel_settings/channel/ChannelModes', () => {
isDefault={false}
isDisabled={false}
groupsSupported={false}
+ policyEnforced={false}
+ policyEnforcedToggleAvailable={false}
/>,
);
expect(wrapper).toMatchSnapshot();
diff --git a/webapp/channels/src/components/admin_console/team_channel_settings/channel/details/channel_modes.tsx b/webapp/channels/src/components/admin_console/team_channel_settings/channel/details/channel_modes.tsx
index 4fc64368fa..df511ebe13 100644
--- a/webapp/channels/src/components/admin_console/team_channel_settings/channel/details/channel_modes.tsx
+++ b/webapp/channels/src/components/admin_console/team_channel_settings/channel/details/channel_modes.tsx
@@ -13,24 +13,27 @@ interface Props {
isPublic: boolean;
isSynced: boolean;
isDefault: boolean;
- onToggle: (isSynced: boolean, isPublic: boolean) => void;
+ onToggle: (isSynced: boolean, isPublic: boolean, policyEnforced: boolean) => void;
isDisabled?: boolean;
groupsSupported?: boolean;
+ abacSupported?: boolean;
+ policyEnforced: boolean;
+ policyEnforcedToggleAvailable: boolean;
}
const SyncGroupsToggle: React.SFC = (props: Props): JSX.Element => {
- const {isPublic, isSynced, isDefault, onToggle, isDisabled} = props;
+ const {isPublic, isSynced, isDefault, onToggle, isDisabled, policyEnforced} = props;
return (
{
if (isDefault) {
return;
}
- onToggle(!isSynced, isPublic);
+ onToggle(!isSynced, isPublic, policyEnforced);
}}
title={(
= (props: Props): JSX.Element => {
};
const AllowAllToggle: React.SFC = (props: Props): JSX.Element | null => {
- const {isPublic, isSynced, isDefault, onToggle, isDisabled} = props;
+ const {isPublic, isSynced, isDefault, onToggle, isDisabled, policyEnforced} = props;
if (isSynced) {
return null;
}
return (
{
if (isDefault) {
return;
}
- onToggle(isSynced, !isPublic);
+ onToggle(isSynced, !isPublic, policyEnforced);
}}
title={(
= (props: Props): JSX.Element | null => {
);
};
+const PolicyEnforceToggle: React.SFC = (props: Props): JSX.Element | null => {
+ const {isPublic, isSynced, isDefault, onToggle, isDisabled, policyEnforced, policyEnforcedToggleAvailable} = props;
+ if (isSynced) {
+ return null;
+ }
+ return (
+ {
+ if (isDefault || !policyEnforcedToggleAvailable) {
+ return;
+ }
+ onToggle(isSynced, isPublic, !policyEnforced);
+ }}
+ title={(
+ = (props: Props): JSX.Element => {
- const {isPublic, isSynced, isDefault, onToggle, isDisabled, groupsSupported} = props;
+ const {isPublic, isSynced, isDefault, onToggle, isDisabled, groupsSupported, policyEnforced, policyEnforcedToggleAvailable, abacSupported} = props;
return (
= (props: Props): JSX.Element => {
>
- {groupsSupported &&
+ {!policyEnforced && groupsSupported &&
}
= (props: Props): JSX.Element => {
isDefault={isDefault}
onToggle={onToggle}
isDisabled={isDisabled}
+ policyEnforced={policyEnforced}
+ policyEnforcedToggleAvailable={policyEnforcedToggleAvailable}
/>
+ {abacSupported &&
+
);
};
+
diff --git a/webapp/channels/src/components/admin_console/team_channel_settings/channel/details/index.ts b/webapp/channels/src/components/admin_console/team_channel_settings/channel/details/index.ts
index 2d89a0ba91..8bc52009e0 100644
--- a/webapp/channels/src/components/admin_console/team_channel_settings/channel/details/index.ts
+++ b/webapp/channels/src/components/admin_console/team_channel_settings/channel/details/index.ts
@@ -7,6 +7,7 @@ import type {Dispatch} from 'redux';
import type {GlobalState} from '@mattermost/types/store';
+import {getAccessControlPolicy, deleteAccessControlPolicy, assignChannelsToAccessControlPolicy, searchAccessControlPolicies} from 'mattermost-redux/actions/access_control';
import {
addChannelMember,
deleteChannel,
@@ -36,7 +37,7 @@ import {getTeam} from 'mattermost-redux/selectors/entities/teams';
import {setNavigationBlocked} from 'actions/admin_actions';
-import {isMinimumEnterpriseLicense, isMinimumProfessionalLicense} from 'utils/license_utils';
+import {isMinimumEnterpriseAdvancedLicense, isMinimumEnterpriseLicense, isMinimumProfessionalLicense} from 'utils/license_utils';
import ChannelDetails from './channel_details';
@@ -60,6 +61,8 @@ function mapStateToProps(state: GlobalState, ownProps: OwnProps) {
// Channel Groups is only available for Enterprise and above
const channelGroupsEnabled = isLicensed && isMinimumEnterpriseLicense(license);
+ const abacSupported = isLicensed && isMinimumEnterpriseAdvancedLicense(license) && config.FeatureFlagAttributeBasedAccessControl === 'true';
+
const guestAccountsEnabled = config.EnableGuestAccounts === 'true';
const channelID = ownProps.match.params.channel_id;
const channel = getChannel(state, channelID);
@@ -81,10 +84,14 @@ function mapStateToProps(state: GlobalState, ownProps: OwnProps) {
guestAccountsEnabled,
channelModerationEnabled,
channelGroupsEnabled,
+ abacSupported,
};
}
function mapDispatchToProps(dispatch: Dispatch) {
+ const assignChannelToAccessControlPolicy = (policyId: string, channelId: string) => {
+ return assignChannelsToAccessControlPolicy(policyId, [channelId]);
+ };
return {
actions: bindActionCreators({
getGroups: fetchAssociatedGroups,
@@ -105,6 +112,10 @@ function mapDispatchToProps(dispatch: Dispatch) {
updateChannelMemberSchemeRoles,
deleteChannel,
unarchiveChannel,
+ getAccessControlPolicy,
+ assignChannelToAccessControlPolicy,
+ deleteAccessControlPolicy,
+ searchPolicies: searchAccessControlPolicies,
}, dispatch),
};
}
diff --git a/webapp/channels/src/components/admin_console/team_channel_settings/channel/list/__snapshots__/channel_list.test.tsx.snap b/webapp/channels/src/components/admin_console/team_channel_settings/channel/list/__snapshots__/channel_list.test.tsx.snap
index 6b7fef3dc1..ac0e935385 100644
--- a/webapp/channels/src/components/admin_console/team_channel_settings/channel/list/__snapshots__/channel_list.test.tsx.snap
+++ b/webapp/channels/src/components/admin_console/team_channel_settings/channel/list/__snapshots__/channel_list.test.tsx.snap
@@ -86,9 +86,17 @@ exports[`admin_console/team_channel_settings/channel/ChannelList should match sn
"keys": Array [
"group_constrained",
"exclude_group_constrained",
+ "access_control_policy_enforced",
],
"name": "Management",
"values": Object {
+ "access_control_policy_enforced": Object {
+ "name":
-
+
,
"name":
-
+
,
"name":
-
+
,
"name":
-
+
,
"name":
-
+
,
"name":
-
+
,
"name":
-
+
,
"name":
-
+
,
"name":
-
+
,
"name":
-
+
,
"name":
-
+
,
"name":
-
+
,
"name": Promise;
- getData: (page: number, perPage: number, notAssociatedToGroup?: string, excludeDefaultChannels?: boolean, includeDeleted?: boolean) => Promise;
+ getData: (page: number, perPage: number, notAssociatedToGroup?: string, excludeDefaultChannels?: boolean, includeDeleted?: boolean, accessControlPolicyEnforced?: boolean, excludeAccessControlPolicyEnforced?: boolean) => Promise;
};
data: ChannelWithTeamData[];
total: number;
@@ -58,6 +58,10 @@ const messages = defineMessages({
id: 'admin.channel_settings.channel_row.managementMethod.manual',
defaultMessage: 'Manual Invites',
},
+ attribute_based: {
+ id: 'admin.channel_settings.channel_row.managementMethod.attribute_based',
+ defaultMessage: 'Attribute Based',
+ },
});
export default class ChannelList extends React.PureComponent {
@@ -102,7 +106,7 @@ export default class ChannelList extends React.PureComponent
-
+ {(() => {
+ if (channel.policy_enforced) {
+ return
),
edit: (
@@ -256,10 +269,10 @@ export default class ChannelList extends React.PureComponent {
const filters: ChannelSearchOpts = {};
- const {group_constrained: groupConstrained, exclude_group_constrained: excludeGroupConstrained} = filterOptions.management.values;
+ const {group_constrained: groupConstrained, exclude_group_constrained: excludeGroupConstrained, access_control_policy_enforced: accessControlPolicyEnforced} = filterOptions.management.values;
const {public: publicChannels, private: privateChannels, deleted} = filterOptions.channels.values;
const {team_ids: teamIds} = filterOptions.teams.values;
- if (publicChannels.value || privateChannels.value || deleted.value || groupConstrained.value || excludeGroupConstrained.value || (teamIds.value as string[]).length) {
+ if (publicChannels.value || privateChannels.value || deleted.value || groupConstrained.value || excludeGroupConstrained.value || (teamIds.value as string[]).length || accessControlPolicyEnforced.value) {
filters.public = publicChannels.value as boolean;
if (filters.public) {
trackEvent('admin_channels_page', 'public_filter_applied_to_channel_list');
@@ -275,6 +288,11 @@ export default class ChannelList extends React.PureComponent) => {[x: string]: string};
onConfigSave?: (displayVal: any) => any;
@@ -181,6 +183,7 @@ export type AdminDefinitionConfigSchemaSection = {
header?: string | MessageDescriptor;
footer?: string | MessageDescriptor;
component?: Component;
+ isHidden?: Check;
}
type RestrictedIndicatorType = {
diff --git a/webapp/channels/src/components/card/title_and_button_card_header/title_and_button_card_header.tsx b/webapp/channels/src/components/card/title_and_button_card_header/title_and_button_card_header.tsx
index 11c2123c15..6c63cb182a 100644
--- a/webapp/channels/src/components/card/title_and_button_card_header/title_and_button_card_header.tsx
+++ b/webapp/channels/src/components/card/title_and_button_card_header/title_and_button_card_header.tsx
@@ -3,16 +3,39 @@
import React from 'react';
+import WithTooltip from 'components/with_tooltip';
+
type Props = {
title: React.ReactNode;
subtitle?: React.ReactNode;
buttonText?: React.ReactNode;
isDisabled?: boolean;
onClick?: () => void;
+ tooltipText?: string;
};
// This component can be used in the card header
const TitleAndButtonCardHeader: React.FC = (props: Props) => {
+ let button = (
+
+ {props.buttonText}
+
+ );
+
+ if (props.isDisabled && props.tooltipText) {
+ button = (
+
+ {button}
+
+ );
+ }
+
return (
<>
@@ -27,16 +50,8 @@ const TitleAndButtonCardHeader: React.FC
= (props: Props) => {
}
- {props.buttonText}
-
+ props.buttonText && props.onClick && button
}
-
);
};
diff --git a/webapp/channels/src/components/channel_selector_modal/channel_selector_modal.tsx b/webapp/channels/src/components/channel_selector_modal/channel_selector_modal.tsx
index e58356839a..e2e2e6244f 100644
--- a/webapp/channels/src/components/channel_selector_modal/channel_selector_modal.tsx
+++ b/webapp/channels/src/components/channel_selector_modal/channel_selector_modal.tsx
@@ -24,13 +24,15 @@ type Props = {
intl: IntlShape;
groupID: string;
actions: {
- loadChannels: (page?: number, perPage?: number, notAssociatedToGroup?: string, excludeDefaultChannels?: boolean, excludePolicyConstrained?: boolean) => Promise>;
+ loadChannels: (page?: number, perPage?: number, notAssociatedToGroup?: string, excludeDefaultChannels?: boolean, excludePolicyConstrained?: boolean, excludeAccessControlPolicyEnforced?: boolean) => Promise>;
setModalSearchTerm: (term: string) => void;
searchAllChannels: (term: string, opts?: ChannelSearchOpts) => Promise>;
};
alreadySelected?: string[];
excludePolicyConstrained?: boolean;
+ excludeAccessControlPolicyEnforced?: boolean;
excludeTeamIds?: string[];
+ excludeTypes?: string[];
}
type State = {
@@ -56,7 +58,7 @@ export class ChannelSelectorModal extends React.PureComponent {
};
componentDidMount() {
- this.props.actions.loadChannels(0, CHANNELS_PER_PAGE + 1, this.props.groupID, false, this.props.excludePolicyConstrained).then((response) => {
+ this.props.actions.loadChannels(0, CHANNELS_PER_PAGE + 1, this.props.groupID, false, this.props.excludePolicyConstrained, this.props.excludeAccessControlPolicyEnforced).then((response) => {
this.setState({channels: response.data!.sort(compareChannels)});
this.setChannelsLoadingState(false);
});
@@ -68,7 +70,7 @@ export class ChannelSelectorModal extends React.PureComponent {
const searchTerm = this.props.searchTerm;
if (searchTerm === '') {
- this.props.actions.loadChannels(0, CHANNELS_PER_PAGE + 1, this.props.groupID, false, this.props.excludePolicyConstrained).then((response) => {
+ this.props.actions.loadChannels(0, CHANNELS_PER_PAGE + 1, this.props.groupID, false, this.props.excludePolicyConstrained, this.props.excludeAccessControlPolicyEnforced).then((response) => {
this.setState({channels: response.data!.sort(compareChannels)});
this.setChannelsLoadingState(false);
});
@@ -130,7 +132,7 @@ export class ChannelSelectorModal extends React.PureComponent {
handlePageChange = (page: number, prevPage: number) => {
if (page > prevPage) {
this.setChannelsLoadingState(true);
- this.props.actions.loadChannels(page, CHANNELS_PER_PAGE + 1, this.props.groupID, false, this.props.excludePolicyConstrained).then((response) => {
+ this.props.actions.loadChannels(page, CHANNELS_PER_PAGE + 1, this.props.groupID, false, this.props.excludePolicyConstrained, this.props.excludeAccessControlPolicyEnforced).then((response) => {
const newState = [...this.state.channels];
const stateChannelIDs = this.state.channels.map((stateChannel) => stateChannel.id);
response.data!.forEach((serverChannel) => {
@@ -221,6 +223,9 @@ export class ChannelSelectorModal extends React.PureComponent {
if (this.props.excludeTeamIds) {
options = options.filter((channel) => this.props.excludeTeamIds?.indexOf(channel.team_id) === -1);
}
+ if (this.props.excludeTypes) {
+ options = options.filter((channel) => this.props.excludeTypes?.indexOf(channel.type) === -1);
+ }
const values = this.state.values.map((i): ChannelWithTeamDataValue => ({...i, label: i.display_name, value: i.id}));
return (
diff --git a/webapp/channels/src/components/searchable_user_list/searchable_user_list_container.tsx b/webapp/channels/src/components/searchable_user_list/searchable_user_list_container.tsx
index f3faae5bd4..0068870185 100644
--- a/webapp/channels/src/components/searchable_user_list/searchable_user_list_container.tsx
+++ b/webapp/channels/src/components/searchable_user_list/searchable_user_list_container.tsx
@@ -15,6 +15,7 @@ type Props = {
total: number;
extraInfo?: {[key: string]: Array};
nextPage: (page: number) => void;
+ previousPage?: (page: number) => void;
search: (term: string) => void;
actions?: React.ReactNode[];
actionProps?: {
@@ -53,6 +54,7 @@ export default function SearchableUserListContainer(props: Props) {
const previousPage = () => {
setPage(page - 1);
+ props.previousPage?.(page - 1);
};
const search = (term: string) => {
diff --git a/webapp/channels/src/components/widgets/tag/beta_tag.tsx b/webapp/channels/src/components/widgets/tag/beta_tag.tsx
index 291a03a7a0..f61f95cf5a 100644
--- a/webapp/channels/src/components/widgets/tag/beta_tag.tsx
+++ b/webapp/channels/src/components/widgets/tag/beta_tag.tsx
@@ -6,20 +6,21 @@ import React from 'react';
import {useIntl} from 'react-intl';
import Tag from './tag';
-import type {TagSize} from './tag';
+import type {TagSize, TagVariant} from './tag';
type Props = {
className?: string;
size?: TagSize;
+ variant?: TagVariant;
}
-const BetaTag = ({className = '', size = 'xs'}: Props) => {
+const BetaTag = ({className = '', size = 'xs', variant = 'info'}: Props) => {
const {formatMessage} = useIntl();
return (
CEL Documentation.",
+ "admin.access_control.cel_help_modal.important_notes_title": "Important Notes",
+ "admin.access_control.cel_help_modal.subheader": "With CEL you can define conditions to filter user attributes and control resource access.",
+ "admin.access_control.cel_help_modal.title": "Common Expression Language (CEL)",
+ "admin.access_control.cel.line_and_column_number": "L{lineNumber}:{columnNumber}",
+ "admin.access_control.cel.validateSyntax": "Validate syntax",
+ "admin.access_control.cel.validating": "Validating...",
+ "admin.access_control.delete": "Delete",
+ "admin.access_control.edit": "Edit",
+ "admin.access_control.edit_policy.apply_policy": "Apply policy",
+ "admin.access_control.edit_policy.cancel": "Cancel",
+ "admin.access_control.edit_policy.save": "Save",
+ "admin.access_control.edit_policy.save_policy": "Save policy",
+ "admin.access_control.edit_policy.serverError": "There are errors in the form above: {serverError}",
+ "admin.access_control.jobTable.details.subheader": "Finished at {finishedAt}",
+ "admin.access_control.policies.add_policy": "Add policy",
+ "admin.access_control.policies.applies_to": "Applies to",
+ "admin.access_control.policies.description": "Create policies containing attribute based access rules and the resources they apply to.",
+ "admin.access_control.policies.menu.aria_label": "Policy actions menu",
+ "admin.access_control.policies.name": "Name",
+ "admin.access_control.policies.resources.channels": "{count, number} {count, plural, one {channel} other {channels}}",
+ "admin.access_control.policies.resources.none": "None",
+ "admin.access_control.policies.title": "Access Control Policies",
+ "admin.access_control.policy.channels_affected": "Are you sure you want to save and apply the access control policy?",
+ "admin.access_control.policy.edit_policy.autoSyncMembership": "Auto-add members based on access rules:",
+ "admin.access_control.policy.edit_policy.autoSyncMembership.description": "Users who match the attribute values configured below will be automatically added as new members. Regardless of this setting, users who later no longer match the configured attribute values will be removed from the channel after the next sync.",
+ "admin.access_control.policy.edit_policy.channel_selector.addChannels": "Add channels",
+ "admin.access_control.policy.edit_policy.channel_selector.remove": "Remove",
+ "admin.access_control.policy.edit_policy.channel_selector.subtitle": "Add channels that this attribute based access policy will apply to.",
+ "admin.access_control.policy.edit_policy.channel_selector.title": "Assigned channels",
+ "admin.access_control.policy.edit_policy.channel_selector.to_be_removed": "To be removed",
+ "admin.access_control.policy.edit_policy.delete_confirmation.confirm_button": "Delete Policy",
+ "admin.access_control.policy.edit_policy.delete_confirmation.message": "Are you sure you want to delete this policy? This action cannot be undone.",
+ "admin.access_control.policy.edit_policy.delete_confirmation.title": "Confirm Policy Deletion",
+ "admin.access_control.policy.edit_policy.delete_policy.delete": "Delete",
+ "admin.access_control.policy.edit_policy.delete_policy.subtitle": "This policy will be deleted and cannot be recovered.",
+ "admin.access_control.policy.edit_policy.delete_policy.subtitle.has_resources": "Remove all assigned resources (eg. Channels) to be able to delete this policy",
+ "admin.access_control.policy.edit_policy.delete_policy.title": "Delete policy",
+ "admin.access_control.policy.edit_policy.policyName": "Access control policy name:",
+ "admin.access_control.policy.edit_policy.policyName.placeholder": "Add a unique policy name",
+ "admin.access_control.policy.edit_policy.switch_to_advanced": "Switch to Advanced Mode",
+ "admin.access_control.policy.edit_policy.switch_to_simple": "Switch to Simple Mode",
+ "admin.access_control.policy.edit_policy.title": "Edit Access Control Policy",
+ "admin.access_control.policy.enforce_immediately": "Enforce policy immediately",
+ "admin.access_control.policy.save_only": "Are you sure you want to save this access control policy?",
+ "admin.access_control.policy.save_policy_confirmation_body": "Applying this policy will allow users with the appropriate attribute values to be added to the selected channels. Existing channel members will be removed from these channels if they are not assigned the values defined in this access policy.",
+ "admin.access_control.policy.save_policy_confirmation_body.inactive": "Only users who match the attribute values configured below can be added to the selected channels. Existing channel members will be removed from these channels if they are not assigned the values defined in this access policy.",
+ "admin.access_control.policy.save_policy_confirmation_subheader": "{count} channels will be affected.",
+ "admin.access_control.policy.save_policy_confirmation_title": "Save access control policy ",
+ "admin.access_control.table_editor.add_attribute": "Add attribute",
+ "admin.access_control.table_editor.attribute": "Attribute",
+ "admin.access_control.table_editor.blank_state": "Select a user attribute and values to create a rule",
+ "admin.access_control.table_editor.learnMore": "Learn more about creating access expressions with examples.",
+ "admin.access_control.table_editor.operator": "Operator",
+ "admin.access_control.table_editor.operator.contains": "contains",
+ "admin.access_control.table_editor.operator.ends_with": "ends with",
+ "admin.access_control.table_editor.operator.in": "in",
+ "admin.access_control.table_editor.operator.is": "is",
+ "admin.access_control.table_editor.operator.is_not": "is not",
+ "admin.access_control.table_editor.operator.starts_with": "starts with",
+ "admin.access_control.table_editor.remove_row": "Remove row",
+ "admin.access_control.table_editor.selector.filter_attributes": "Search attributes...",
+ "admin.access_control.table_editor.selector.filter_operators": "Search operators...",
+ "admin.access_control.table_editor.selector.select_attribute": "Select attribute",
+ "admin.access_control.table_editor.test_access_rule": "Test access rule",
+ "admin.access_control.table_editor.value.placeholder": "Add value...",
+ "admin.access_control.table_editor.values": "Values",
+ "admin.access_control.table_editor.values.placeholder": "Add values...",
+ "admin.access_control.testResults": "Access Rule Test Results",
+ "admin.accesscontrol.enableDesc": "Allow access restrictions based on user attributes using custom access policies",
+ "admin.accesscontrol.enableTitle": "Allow attribute based access controls on this servers",
+ "admin.accesscontrol.title": "Attribute-Based Access",
"admin.advance.cluster": "High Availability",
"admin.advance.metrics": "Performance Monitoring",
"admin.announcement_banner_feature_discovery.copy": "Create announcement banners to notify all members of important information.",
"admin.announcement_banner_feature_discovery.title": "Create custom announcement banners with Mattermost Professional",
+ "admin.attribute_based_access_control_feature_discovery.desc": "Create policies containing access rules based on user attributes and apply them to channels and other resources within Mattermost.",
+ "admin.attribute_based_access_control_feature_discovery.title": "Use attribute based access policies to control channel access with Mattermost Enterprise Advanced",
"admin.audit_logging_experimental.certificate.help_text": "The certificate file used for audit logging encryption.",
"admin.audit_logging_experimental.certificate.remove_button": "Remove Certificate",
"admin.audit_logging_experimental.certificate.remove_help_text": "Remove the certificate used for audit logging encryption.",
@@ -456,31 +530,48 @@
"admin.cacheSettings.redisPassword": "Redis Password",
"admin.cacheSettings.redisPasswordDesc": "The password of the Redis server.",
"admin.cacheSettings.title": "Cache Settings",
+ "admin.channel_details.policy_public_error": "You cannot assign a policy to a public channel.",
+ "admin.channel_details.policy_synced_error": "You cannot assign a policy to a synced channel.",
"admin.channel_list.archived": "Archived",
+ "admin.channel_list.attributed_based": "Attribute Based",
"admin.channel_list.group_sync": "Group Sync",
"admin.channel_list.manual_invites": "Manual Invites",
"admin.channel_list.private": "Private",
"admin.channel_list.public": "Public",
+ "admin.channel_settings.channel_detail.access_control_policy_actions": "Actions",
+ "admin.channel_settings.channel_detail.access_control_policy_description": "Select an access policy for this channel to restrict membership.",
+ "admin.channel_settings.channel_detail.access_control_policy_name": "Name",
+ "admin.channel_settings.channel_detail.access_control_policy_title": "Access policy",
"admin.channel_settings.channel_detail.archive_confirm.button": "Save and Archive Channel",
"admin.channel_settings.channel_detail.archive_confirm.message": "Saving will archive the channel from the team and make it's contents inaccessible for all users. Are you sure you wish to save and archive this channel?",
"admin.channel_settings.channel_detail.archive_confirm.title": "Save and Archive Channel",
"admin.channel_settings.channel_detail.channel_configuration": "Channel Configuration",
"admin.channel_settings.channel_detail.channelOrganizationsMessage": "Shared with trusted organizations",
+ "admin.channel_settings.channel_detail.go_to_policy.aria_label": "Go to the policy",
"admin.channel_settings.channel_detail.groupsDescription": "Select groups to be added to this channel.",
"admin.channel_settings.channel_detail.groupsTitle": "Groups",
+ "admin.channel_settings.channel_detail.link_policy": "Link to a policy",
"admin.channel_settings.channel_detail.manageDescription": "Choose between inviting members manually or syncing members automatically from groups.",
"admin.channel_settings.channel_detail.manageTitle": "Channel Management",
"admin.channel_settings.channel_detail.membersDescription": "A list of users who are currently in the channel right now",
"admin.channel_settings.channel_detail.membersTitle": "Members",
+ "admin.channel_settings.channel_detail.policy_following": "This channel is currently using the following access policy.",
"admin.channel_settings.channel_detail.profileDescription": "Summary of the channel, including the channel name.",
"admin.channel_settings.channel_detail.profileTitle": "Channel Profile",
+ "admin.channel_settings.channel_detail.remove_policy": "Remove policy",
+ "admin.channel_settings.channel_detail.select_policy": "Select an access policy for this channel to restrict membership",
+ "admin.channel_settings.channel_detail.select_policy_description": "An access control policy will restrict channel membership based on user attributes.",
+ "admin.channel_settings.channel_detail.select_policy_title": "Select an Access Control Policy",
"admin.channel_settings.channel_detail.syncedGroupsDescription": "Add and remove channel members based on their group membership.",
"admin.channel_settings.channel_detail.syncedGroupsTitle": "Synced Groups",
"admin.channel_settings.channel_details.add_group": "Add Group",
"admin.channel_settings.channel_details.archiveChannel": "Archive Channel",
+ "admin.channel_settings.channel_details.attribute_based_description": "Restrict which users can be invited to this channel based on their user attributes and values. Only people who match the specified conditions will be allowed to be selected and added to this channel.",
"admin.channel_settings.channel_details.isDefaultDescr": "This default channel cannot be converted into a private channel.",
"admin.channel_settings.channel_details.isPublic": "Public channel or private channel",
"admin.channel_settings.channel_details.isPublicDescr": "Select Public for a channel any user can find and join. {br}Select Private to require channel invitations to join. {br}Use this switch to change this channel from public to private or from private to public.",
+ "admin.channel_settings.channel_details.policy_enforced_title": "Enable attribute based channel access",
+ "admin.channel_settings.channel_details.private_channel_only": "Only private channels can be attribute based.",
"admin.channel_settings.channel_details.syncGroupMembers": "Sync Group Members",
"admin.channel_settings.channel_details.syncGroupMembersDescr": "When enabled, adding and removing users from groups will add or remove them from this channel. The only way of inviting members to this channel is by adding the groups they belong to. {
+ return async (dispatch, getState) => {
+ let data;
+ try {
+ data = await Client4.updateOrCreateAccessControlPolicy(policy);
+ } catch (error) {
+ forceLogoutIfNecessary(error as ServerError, dispatch, getState);
+ return {error};
+ }
+
+ dispatch(
+ {type: AdminTypes.CREATE_ACCESS_CONTROL_POLICY_SUCCESS, data},
+ );
+
+ return {data};
+ };
+}
+
+export function deleteAccessControlPolicy(id: string) {
+ return bindClientFunc({
+ clientFunc: Client4.deleteAccessControlPolicy,
+ onSuccess: [AdminTypes.DELETE_ACCESS_CONTROL_POLICY_SUCCESS],
+ params: [
+ id,
+ ],
+ });
+}
+
+export function searchAccessControlPolicies(term: string, type: string, after: string, limit: number): ActionFuncAsync {
+ return async (dispatch, getState) => {
+ let data;
+ try {
+ data = await Client4.searchAccessControlPolicies(term, type, after, limit);
+ } catch (error) {
+ forceLogoutIfNecessary(error as ServerError, dispatch, getState);
+ return {error};
+ }
+
+ dispatch(
+ {type: AdminTypes.RECEIVED_ACCESS_CONTROL_POLICIES_SEARCH, data: data.policies},
+ );
+
+ return {data};
+ };
+}
+
+export function searchAccessControlPolicyChannels(id: string, term: string, opts: ChannelSearchOpts): ActionFuncAsync {
+ return async (dispatch, getState) => {
+ let data;
+ try {
+ data = await Client4.searchChildAccessControlPolicyChannels(id, term, opts);
+ } catch (error) {
+ forceLogoutIfNecessary(error as ServerError, dispatch, getState);
+ return {error};
+ }
+
+ const childs: Record = {};
+ childs[id] = data.channels.map((channel) => channel.id);
+
+ dispatch(batchActions([
+ {type: AdminTypes.RECEIVED_ACCESS_CONTROL_CHILD_POLICIES, data: childs},
+ {type: ChannelTypes.RECEIVED_CHANNELS, data: data.channels},
+ ]));
+
+ return {data};
+ };
+}
+
+export function assignChannelsToAccessControlPolicy(policyId: string, channelIds: string[]) {
+ return bindClientFunc({
+ clientFunc: Client4.assignChannelsToAccessControlPolicy,
+ onSuccess: [AdminTypes.ASSIGN_CHANNELS_TO_ACCESS_CONTROL_POLICY_SUCCESS],
+ params: [
+ policyId,
+ channelIds,
+ ],
+ });
+}
+
+export function unassignChannelsFromAccessControlPolicy(policyId: string, channelIds: string[]) {
+ return bindClientFunc({
+ clientFunc: Client4.unassignChannelsFromAccessControlPolicy,
+ onSuccess: [AdminTypes.UNASSIGN_CHANNELS_FROM_ACCESS_CONTROL_POLICY_SUCCESS],
+ params: [
+ policyId,
+ channelIds,
+ ],
+ });
+}
+
+export function getAccessControlFields(after: string, limit: number) {
+ return bindClientFunc({
+ clientFunc: Client4.getAccessControlFields,
+ params: [
+ after,
+ limit,
+ ],
+ });
+}
+
+export function updateAccessControlPolicyActive(policyId: string, active: boolean) {
+ return bindClientFunc({
+ clientFunc: Client4.updateAccessControlPolicyActive,
+ params: [
+ policyId,
+ active,
+ ],
+ });
+}
+
+export function searchUsersForExpression(expression: string, term: string, after: string, limit: number): ActionFuncAsync {
+ return async (dispatch, getState) => {
+ let data;
+ try {
+ data = await Client4.testAccessControlExpression(expression, term, after, limit);
+ } catch (error) {
+ forceLogoutIfNecessary(error as ServerError, dispatch, getState);
+ return {error};
+ }
+
+ dispatch(
+ {type: UserTypes.RECEIVED_PROFILES, data: data.users},
+ );
+
+ return {data};
+ };
+}
diff --git a/webapp/channels/src/packages/mattermost-redux/src/actions/channels.test.ts b/webapp/channels/src/packages/mattermost-redux/src/actions/channels.test.ts
index 1c3e18f0a4..143cd90817 100644
--- a/webapp/channels/src/packages/mattermost-redux/src/actions/channels.test.ts
+++ b/webapp/channels/src/packages/mattermost-redux/src/actions/channels.test.ts
@@ -1063,11 +1063,8 @@ describe('Actions.Channels', () => {
const mockQuery = {
page: 0,
per_page: 50,
- not_associated_to_group: '',
- exclude_default_channels: false,
include_total_count: true,
include_deleted: false,
- exclude_policy_constrained: false,
};
nock(Client4.getBaseRoute()).
get('/channels').
diff --git a/webapp/channels/src/packages/mattermost-redux/src/actions/channels.ts b/webapp/channels/src/packages/mattermost-redux/src/actions/channels.ts
index 597564ecd1..0c6e389eda 100644
--- a/webapp/channels/src/packages/mattermost-redux/src/actions/channels.ts
+++ b/webapp/channels/src/packages/mattermost-redux/src/actions/channels.ts
@@ -789,13 +789,13 @@ export function getArchivedChannels(teamId: string, page = 0, perPage: number =
};
}
-export function getAllChannelsWithCount(page = 0, perPage: number = General.CHANNELS_CHUNK_SIZE, notAssociatedToGroup = '', excludeDefaultChannels = false, includeDeleted = false, excludePolicyConstrained = false): ActionFuncAsync {
+export function getAllChannelsWithCount(page = 0, perPage: number = General.CHANNELS_CHUNK_SIZE, notAssociatedToGroup = '', excludeDefaultChannels = false, includeDeleted = false, excludePolicyConstrained = false, accessControlPolicyEnforced = false, excludeAccessControlPolicyEnforced = false): ActionFuncAsync {
return async (dispatch, getState) => {
dispatch({type: ChannelTypes.GET_ALL_CHANNELS_REQUEST, data: null});
let payload;
try {
- payload = await Client4.getAllChannels(page, perPage, notAssociatedToGroup, excludeDefaultChannels, true, includeDeleted, excludePolicyConstrained);
+ payload = await Client4.getAllChannels(page, perPage, notAssociatedToGroup, excludeDefaultChannels, true, includeDeleted, excludePolicyConstrained, accessControlPolicyEnforced, excludeAccessControlPolicyEnforced);
} catch (error) {
forceLogoutIfNecessary(error, dispatch, getState);
dispatch({type: ChannelTypes.GET_ALL_CHANNELS_FAILURE, error});
@@ -821,13 +821,13 @@ export function getAllChannelsWithCount(page = 0, perPage: number = General.CHAN
};
}
-export function getAllChannels(page = 0, perPage: number = General.CHANNELS_CHUNK_SIZE, notAssociatedToGroup = '', excludeDefaultChannels = false, excludePolicyConstrained = false): ActionFuncAsync {
+export function getAllChannels(page = 0, perPage: number = General.CHANNELS_CHUNK_SIZE, notAssociatedToGroup = '', excludeDefaultChannels = false, excludePolicyConstrained = false, excludeAccessControlPolicyEnforced = false, accessControlPolicyEnforced = false): ActionFuncAsync {
return async (dispatch, getState) => {
dispatch({type: ChannelTypes.GET_ALL_CHANNELS_REQUEST, data: null});
let channels;
try {
- channels = await Client4.getAllChannels(page, perPage, notAssociatedToGroup, excludeDefaultChannels, false, false, excludePolicyConstrained);
+ channels = await Client4.getAllChannels(page, perPage, notAssociatedToGroup, excludeDefaultChannels, false, false, excludePolicyConstrained, accessControlPolicyEnforced, excludeAccessControlPolicyEnforced);
} catch (error) {
forceLogoutIfNecessary(error, dispatch, getState);
dispatch({type: ChannelTypes.GET_ALL_CHANNELS_FAILURE, error});
diff --git a/webapp/channels/src/packages/mattermost-redux/src/reducers/entities/admin.ts b/webapp/channels/src/packages/mattermost-redux/src/reducers/entities/admin.ts
index e43ccd666a..f31d14e8b5 100644
--- a/webapp/channels/src/packages/mattermost-redux/src/reducers/entities/admin.ts
+++ b/webapp/channels/src/packages/mattermost-redux/src/reducers/entities/admin.ts
@@ -3,6 +3,7 @@
import {combineReducers} from 'redux';
+import type {AccessControlPolicy} from '@mattermost/types/access_control';
import type {ClusterInfo, AnalyticsRow, AnalyticsState, AdminState} from '@mattermost/types/admin';
import type {Audit} from '@mattermost/types/audits';
import type {Compliance} from '@mattermost/types/compliance';
@@ -649,6 +650,64 @@ function dataRetentionCustomPoliciesCount(state = 0, action: MMReduxAction) {
}
}
+function accessControlPolicies(state: IDMappedObjects = {}, action: MMReduxAction) {
+ switch (action.type) {
+ case AdminTypes.CREATE_ACCESS_CONTROL_POLICY_SUCCESS:
+ case AdminTypes.RECEIVED_ACCESS_CONTROL_POLICY:
+ return {
+ ...state,
+ [action.data.id]: action.data,
+ };
+ case AdminTypes.RECEIVED_ACCESS_CONTROL_POLICIES: {
+ const nextState: IDMappedObjects = {};
+ for (const policy of action.data) {
+ nextState[policy.id] = policy;
+ }
+ return nextState;
+ }
+ case AdminTypes.DELETE_ACCESS_CONTROL_POLICY_SUCCESS: {
+ const nextState = {...state};
+ Reflect.deleteProperty(nextState, action.data.id);
+ return nextState;
+ }
+ case AdminTypes.RECEIVED_ACCESS_CONTROL_POLICIES_SEARCH: {
+ const nextState = {...state};
+ for (const policy of action.data) {
+ nextState[policy.id] = policy;
+ }
+ return nextState;
+ }
+ case UserTypes.LOGOUT_SUCCESS:
+ return {};
+ default:
+ return state;
+ }
+}
+
+function channelsForAccessControlPolicy(state: Record = {}, action: MMReduxAction) {
+ switch (action.type) {
+ case AdminTypes.RECEIVED_ACCESS_CONTROL_CHILD_POLICIES:
+ if (action.data) {
+ return {...state, ...action.data};
+ }
+ return state;
+ case AdminTypes.ASSIGN_CHANNELS_TO_ACCESS_CONTROL_POLICY_SUCCESS:
+ return {
+ ...state,
+ [action.data.policyId]: action.data.channelIds,
+ };
+ case AdminTypes.UNASSIGN_CHANNELS_FROM_ACCESS_CONTROL_POLICY_SUCCESS:
+ return {
+ ...state,
+ [action.data.policyId]: action.data.channelIds,
+ };
+ case UserTypes.LOGOUT_SUCCESS:
+ return {};
+ default:
+ return state;
+ }
+}
+
export default combineReducers({
// array of LogObjects each representing a log entry (JSON)
@@ -711,4 +770,10 @@ export default combineReducers({
// the last trial license the server used.
prevTrialLicense,
+
+ // object with policy ids as keys and objects representing the policies as values
+ accessControlPolicies,
+
+ // object with policy ids as keys and arrays of channel ids as values
+ channelsForAccessControlPolicy,
});
diff --git a/webapp/channels/src/packages/mattermost-redux/src/selectors/entities/access_control.ts b/webapp/channels/src/packages/mattermost-redux/src/selectors/entities/access_control.ts
new file mode 100644
index 0000000000..a56c194b21
--- /dev/null
+++ b/webapp/channels/src/packages/mattermost-redux/src/selectors/entities/access_control.ts
@@ -0,0 +1,63 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+import type {Channel, ChannelWithTeamData, ChannelSearchOpts} from '@mattermost/types/channels';
+import type {GlobalState} from '@mattermost/types/store';
+
+import {filterChannelsMatchingTerm} from 'mattermost-redux/utils/channel_utils';
+
+import {filterChannelList} from './channels';
+
+import {createSelector} from '../create_selector';
+
+export function getAccessControlPolicy(state: GlobalState, id: string) {
+ return state.entities.admin.accessControlPolicies[id];
+}
+
+export const getChannelIdsForAccessControlPolicy = createSelector(
+ 'getChannelIdsForAccessControlPolicy',
+ (state: GlobalState, parentId: string) => state.entities.admin.channelsForAccessControlPolicy[parentId],
+ (channelIds) => (Array.isArray(channelIds) ? channelIds : []),
+) as (state: GlobalState, parentId: string) => string[];
+
+export function makeGetChannelsInAccessControlPolicy() {
+ return (createSelector(
+ 'getChannelsInAccessControlPolicy',
+ (state: GlobalState) => state.entities.channels.channels,
+ (state: GlobalState, props: {policyId: string}) => getChannelIdsForAccessControlPolicy(state, props.policyId),
+ (state: GlobalState) => state.entities.teams.teams,
+ (channels, ids, teams) => {
+ if (!ids) {
+ return [];
+ }
+
+ const policyChannels: ChannelWithTeamData[] = [];
+
+ ids.forEach((channelId) => {
+ const channel = channels[channelId];
+ if (channel) {
+ const team = teams[channel.team_id] || {};
+ policyChannels.push({
+ ...channel,
+ team_id: channel.team_id,
+ team_display_name: team.display_name || '',
+ team_name: team.name || '',
+ team_update_at: team.update_at || 0,
+ });
+ }
+ });
+
+ return policyChannels;
+ }) as (b: GlobalState, a: {
+ policyId: string;
+ }) => ChannelWithTeamData[]);
+}
+
+export function searchChannelsInheritsPolicy(state: GlobalState, policyId: string, term: string, filters: ChannelSearchOpts): Channel[] {
+ const channelsInPolicy = makeGetChannelsInAccessControlPolicy();
+ const channelArray = channelsInPolicy(state, {policyId});
+ let channels = filterChannelList(channelArray, filters);
+ channels = filterChannelsMatchingTerm(channels, term);
+
+ return channels;
+}
diff --git a/webapp/channels/src/packages/mattermost-redux/src/store/initial_state.ts b/webapp/channels/src/packages/mattermost-redux/src/store/initial_state.ts
index dccc2edcfd..b2e2e68587 100644
--- a/webapp/channels/src/packages/mattermost-redux/src/store/initial_state.ts
+++ b/webapp/channels/src/packages/mattermost-redux/src/store/initial_state.ts
@@ -119,6 +119,8 @@ const state: GlobalState = {
dataRetentionCustomPolicies: {},
dataRetentionCustomPoliciesCount: 0,
prevTrialLicense: {},
+ accessControlPolicies: {},
+ channelsForAccessControlPolicy: {},
},
jobs: {
jobs: {},
diff --git a/webapp/channels/src/utils/constants.tsx b/webapp/channels/src/utils/constants.tsx
index 2840bbf5ba..0fc2234733 100644
--- a/webapp/channels/src/utils/constants.tsx
+++ b/webapp/channels/src/utils/constants.tsx
@@ -344,6 +344,7 @@ export const ModalIdentifiers = {
CHANNEL_MEMBERS: 'channel_members',
CHANNEL_SETTINGS: 'channel_settings',
TEAM_MEMBERS: 'team_members',
+ TEST_RESULTS: 'test_results',
ADD_USER_TO_CHANNEL: 'add_user_to_channel',
ADD_USER_TO_ROLE: 'add_user_to_role',
ADD_USER_TO_TEAM: 'add_user_to_team',
@@ -933,6 +934,7 @@ export const JobTypes = {
BLEVE_POST_INDEXING: 'bleve_post_indexing',
LDAP_SYNC: 'ldap_sync',
MESSAGE_EXPORT: 'message_export',
+ ACCESS_CONTROL_SYNC: 'access_control_sync',
} as const;
export const JobStatuses = {
diff --git a/webapp/channels/webpack.config.js b/webapp/channels/webpack.config.js
index a4bf515fae..bbe032e9d6 100644
--- a/webapp/channels/webpack.config.js
+++ b/webapp/channels/webpack.config.js
@@ -13,6 +13,7 @@ const MiniCssExtractPlugin = require('mini-css-extract-plugin');
const webpack = require('webpack');
const {ModuleFederationPlugin} = require('webpack').container;
const WebpackPwaManifest = require('webpack-pwa-manifest');
+const MonacoWebpackPlugin = require('monaco-editor-webpack-plugin');
const packageJson = require('./package.json');
@@ -267,6 +268,40 @@ var config = {
sizes: '96x96',
}],
}),
+ new MonacoWebpackPlugin({
+ languages: [],
+
+ // don't include features we disable. these generally correspond to the options
+ // passed to editor initialization in note-content-editor.tsx
+ // @see https://github.com/microsoft/monaco-editor/blob/main/webpack-plugin/README.md#options
+ features: [
+ '!bracketMatching',
+ '!codeAction',
+ '!codelens',
+ '!colorPicker',
+ '!comment',
+ '!diffEditor',
+ '!diffEditorBreadcrumbs',
+ '!folding',
+ '!gotoError',
+ '!gotoLine',
+ '!gotoSymbol',
+ '!gotoZoom',
+ '!inspectTokens',
+ '!multicursor',
+ '!parameterHints',
+ '!quickCommand',
+ '!quickHelp',
+ '!quickOutline',
+ '!referenceSearch',
+ '!rename',
+ '!snippet',
+ '!stickyScroll',
+ '!suggest',
+ '!toggleHighContrast',
+ '!unicodeHighlighter',
+ ],
+ }),
],
};
diff --git a/webapp/package-lock.json b/webapp/package-lock.json
index f1f336eb64..958f2d7083 100644
--- a/webapp/package-lock.json
+++ b/webapp/package-lock.json
@@ -108,6 +108,8 @@
"marked": "github:mattermost/marked#3b13ba8ddf725327ddf0298361d6d304a021f2d1",
"memoize-one": "6.0.0",
"moment-timezone": "0.5.38",
+ "monaco-editor": "0.52.2",
+ "monaco-editor-webpack-plugin": "7.1.0",
"p-queue": "7.3.0",
"pdfjs-dist": "4.4.168",
"process": "0.11.10",
@@ -5090,7 +5092,6 @@
"version": "0.3.6",
"resolved": "https://registry.npmjs.org/@jridgewell/source-map/-/source-map-0.3.6.tgz",
"integrity": "sha512-1ZJTZebgqllO79ue2bm3rIGud/bOe0pP5BjSRCRxxYkEZS8STV7zN84UBbiYu7jy+eCKSnVIUgoWWE/tt+shMQ==",
- "dev": true,
"dependencies": {
"@jridgewell/gen-mapping": "^0.3.5",
"@jridgewell/trace-mapping": "^0.3.25"
@@ -6735,8 +6736,7 @@
"node_modules/@types/estree": {
"version": "0.0.51",
"resolved": "https://registry.npmjs.org/@types/estree/-/estree-0.0.51.tgz",
- "integrity": "sha512-CuPgU6f3eT/XgKKPqKd/gLZV1Xmvf1a2R5POBOGQa6uv82xpls89HU5zKeVoyR8XzHd1RGNOlQlvUe3CFkjWNQ==",
- "dev": true
+ "integrity": "sha512-CuPgU6f3eT/XgKKPqKd/gLZV1Xmvf1a2R5POBOGQa6uv82xpls89HU5zKeVoyR8XzHd1RGNOlQlvUe3CFkjWNQ=="
},
"node_modules/@types/express": {
"version": "4.17.21",
@@ -6942,8 +6942,7 @@
"node_modules/@types/json-schema": {
"version": "7.0.15",
"resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz",
- "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==",
- "dev": true
+ "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA=="
},
"node_modules/@types/json-stable-stringify": {
"version": "1.1.0",
@@ -7005,7 +7004,6 @@
"version": "20.11.30",
"resolved": "https://registry.npmjs.org/@types/node/-/node-20.11.30.tgz",
"integrity": "sha512-dHM6ZxwlmuZaRmUPfv1p+KrdD1Dci04FbdEm/9wEMouFqxYoFl5aMkt0VMAUtYRQDyYvD41WJLukhq/ha3YuTw==",
- "dev": true,
"dependencies": {
"undici-types": "~5.26.4"
}
@@ -8037,7 +8035,6 @@
"version": "1.12.1",
"resolved": "https://registry.npmjs.org/@webassemblyjs/ast/-/ast-1.12.1.tgz",
"integrity": "sha512-EKfMUOPRRUTy5UII4qJDGPpqfwjOmZ5jeGFwid9mnoqIFK+e0vqoi1qH56JpmZSzEL53jKnNzScdmftJyG5xWg==",
- "dev": true,
"dependencies": {
"@webassemblyjs/helper-numbers": "1.11.6",
"@webassemblyjs/helper-wasm-bytecode": "1.11.6"
@@ -8046,26 +8043,22 @@
"node_modules/@webassemblyjs/floating-point-hex-parser": {
"version": "1.11.6",
"resolved": "https://registry.npmjs.org/@webassemblyjs/floating-point-hex-parser/-/floating-point-hex-parser-1.11.6.tgz",
- "integrity": "sha512-ejAj9hfRJ2XMsNHk/v6Fu2dGS+i4UaXBXGemOfQ/JfQ6mdQg/WXtwleQRLLS4OvfDhv8rYnVwH27YJLMyYsxhw==",
- "dev": true
+ "integrity": "sha512-ejAj9hfRJ2XMsNHk/v6Fu2dGS+i4UaXBXGemOfQ/JfQ6mdQg/WXtwleQRLLS4OvfDhv8rYnVwH27YJLMyYsxhw=="
},
"node_modules/@webassemblyjs/helper-api-error": {
"version": "1.11.6",
"resolved": "https://registry.npmjs.org/@webassemblyjs/helper-api-error/-/helper-api-error-1.11.6.tgz",
- "integrity": "sha512-o0YkoP4pVu4rN8aTJgAyj9hC2Sv5UlkzCHhxqWj8butaLvnpdc2jOwh4ewE6CX0txSfLn/UYaV/pheS2Txg//Q==",
- "dev": true
+ "integrity": "sha512-o0YkoP4pVu4rN8aTJgAyj9hC2Sv5UlkzCHhxqWj8butaLvnpdc2jOwh4ewE6CX0txSfLn/UYaV/pheS2Txg//Q=="
},
"node_modules/@webassemblyjs/helper-buffer": {
"version": "1.12.1",
"resolved": "https://registry.npmjs.org/@webassemblyjs/helper-buffer/-/helper-buffer-1.12.1.tgz",
- "integrity": "sha512-nzJwQw99DNDKr9BVCOZcLuJJUlqkJh+kVzVl6Fmq/tI5ZtEyWT1KZMyOXltXLZJmDtvLCDgwsyrkohEtopTXCw==",
- "dev": true
+ "integrity": "sha512-nzJwQw99DNDKr9BVCOZcLuJJUlqkJh+kVzVl6Fmq/tI5ZtEyWT1KZMyOXltXLZJmDtvLCDgwsyrkohEtopTXCw=="
},
"node_modules/@webassemblyjs/helper-numbers": {
"version": "1.11.6",
"resolved": "https://registry.npmjs.org/@webassemblyjs/helper-numbers/-/helper-numbers-1.11.6.tgz",
"integrity": "sha512-vUIhZ8LZoIWHBohiEObxVm6hwP034jwmc9kuq5GdHZH0wiLVLIPcMCdpJzG4C11cHoQ25TFIQj9kaVADVX7N3g==",
- "dev": true,
"dependencies": {
"@webassemblyjs/floating-point-hex-parser": "1.11.6",
"@webassemblyjs/helper-api-error": "1.11.6",
@@ -8075,14 +8068,12 @@
"node_modules/@webassemblyjs/helper-wasm-bytecode": {
"version": "1.11.6",
"resolved": "https://registry.npmjs.org/@webassemblyjs/helper-wasm-bytecode/-/helper-wasm-bytecode-1.11.6.tgz",
- "integrity": "sha512-sFFHKwcmBprO9e7Icf0+gddyWYDViL8bpPjJJl0WHxCdETktXdmtWLGVzoHbqUcY4Be1LkNfwTmXOJUFZYSJdA==",
- "dev": true
+ "integrity": "sha512-sFFHKwcmBprO9e7Icf0+gddyWYDViL8bpPjJJl0WHxCdETktXdmtWLGVzoHbqUcY4Be1LkNfwTmXOJUFZYSJdA=="
},
"node_modules/@webassemblyjs/helper-wasm-section": {
"version": "1.12.1",
"resolved": "https://registry.npmjs.org/@webassemblyjs/helper-wasm-section/-/helper-wasm-section-1.12.1.tgz",
"integrity": "sha512-Jif4vfB6FJlUlSbgEMHUyk1j234GTNG9dBJ4XJdOySoj518Xj0oGsNi59cUQF4RRMS9ouBUxDDdyBVfPTypa5g==",
- "dev": true,
"dependencies": {
"@webassemblyjs/ast": "1.12.1",
"@webassemblyjs/helper-buffer": "1.12.1",
@@ -8094,7 +8085,6 @@
"version": "1.11.6",
"resolved": "https://registry.npmjs.org/@webassemblyjs/ieee754/-/ieee754-1.11.6.tgz",
"integrity": "sha512-LM4p2csPNvbij6U1f19v6WR56QZ8JcHg3QIJTlSwzFcmx6WSORicYj6I63f9yU1kEUtrpG+kjkiIAkevHpDXrg==",
- "dev": true,
"dependencies": {
"@xtuc/ieee754": "^1.2.0"
}
@@ -8103,7 +8093,6 @@
"version": "1.11.6",
"resolved": "https://registry.npmjs.org/@webassemblyjs/leb128/-/leb128-1.11.6.tgz",
"integrity": "sha512-m7a0FhE67DQXgouf1tbN5XQcdWoNgaAuoULHIfGFIEVKA6tu/edls6XnIlkmS6FrXAquJRPni3ZZKjw6FSPjPQ==",
- "dev": true,
"dependencies": {
"@xtuc/long": "4.2.2"
}
@@ -8111,14 +8100,12 @@
"node_modules/@webassemblyjs/utf8": {
"version": "1.11.6",
"resolved": "https://registry.npmjs.org/@webassemblyjs/utf8/-/utf8-1.11.6.tgz",
- "integrity": "sha512-vtXf2wTQ3+up9Zsg8sa2yWiQpzSsMyXj0qViVP6xKGCUT8p8YJ6HqI7l5eCnWx1T/FYdsv07HQs2wTFbbof/RA==",
- "dev": true
+ "integrity": "sha512-vtXf2wTQ3+up9Zsg8sa2yWiQpzSsMyXj0qViVP6xKGCUT8p8YJ6HqI7l5eCnWx1T/FYdsv07HQs2wTFbbof/RA=="
},
"node_modules/@webassemblyjs/wasm-edit": {
"version": "1.12.1",
"resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-edit/-/wasm-edit-1.12.1.tgz",
"integrity": "sha512-1DuwbVvADvS5mGnXbE+c9NfA8QRcZ6iKquqjjmR10k6o+zzsRVesil54DKexiowcFCPdr/Q0qaMgB01+SQ1u6g==",
- "dev": true,
"dependencies": {
"@webassemblyjs/ast": "1.12.1",
"@webassemblyjs/helper-buffer": "1.12.1",
@@ -8134,7 +8121,6 @@
"version": "1.12.1",
"resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-gen/-/wasm-gen-1.12.1.tgz",
"integrity": "sha512-TDq4Ojh9fcohAw6OIMXqiIcTq5KUXTGRkVxbSo1hQnSy6lAM5GSdfwWeSxpAo0YzgsgF182E/U0mDNhuA0tW7w==",
- "dev": true,
"dependencies": {
"@webassemblyjs/ast": "1.12.1",
"@webassemblyjs/helper-wasm-bytecode": "1.11.6",
@@ -8147,7 +8133,6 @@
"version": "1.12.1",
"resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-opt/-/wasm-opt-1.12.1.tgz",
"integrity": "sha512-Jg99j/2gG2iaz3hijw857AVYekZe2SAskcqlWIZXjji5WStnOpVoat3gQfT/Q5tb2djnCjBtMocY/Su1GfxPBg==",
- "dev": true,
"dependencies": {
"@webassemblyjs/ast": "1.12.1",
"@webassemblyjs/helper-buffer": "1.12.1",
@@ -8159,7 +8144,6 @@
"version": "1.12.1",
"resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-parser/-/wasm-parser-1.12.1.tgz",
"integrity": "sha512-xikIi7c2FHXysxXe3COrVUPSheuBtpcfhbpFj4gmu7KRLYOzANztwUU0IbsqvMqzuNK2+glRGWCEqZo1WCLyAQ==",
- "dev": true,
"dependencies": {
"@webassemblyjs/ast": "1.12.1",
"@webassemblyjs/helper-api-error": "1.11.6",
@@ -8173,7 +8157,6 @@
"version": "1.12.1",
"resolved": "https://registry.npmjs.org/@webassemblyjs/wast-printer/-/wast-printer-1.12.1.tgz",
"integrity": "sha512-+X4WAlOisVWQMikjbcvY2e0rwPsKQ9F688lksZhBcPycBBuii3O7m8FACbDMWDojpAqvjIncrG8J0XHKyQfVeA==",
- "dev": true,
"dependencies": {
"@webassemblyjs/ast": "1.12.1",
"@xtuc/long": "4.2.2"
@@ -8240,14 +8223,12 @@
"node_modules/@xtuc/ieee754": {
"version": "1.2.0",
"resolved": "https://registry.npmjs.org/@xtuc/ieee754/-/ieee754-1.2.0.tgz",
- "integrity": "sha512-DX8nKgqcGwsc0eJSqYt5lwP4DH5FlHnmuWWBRy7X0NcaGR0ZtuyeESgMwTYVEtxmsNGY+qit4QYT/MIYTOTPeA==",
- "dev": true
+ "integrity": "sha512-DX8nKgqcGwsc0eJSqYt5lwP4DH5FlHnmuWWBRy7X0NcaGR0ZtuyeESgMwTYVEtxmsNGY+qit4QYT/MIYTOTPeA=="
},
"node_modules/@xtuc/long": {
"version": "4.2.2",
"resolved": "https://registry.npmjs.org/@xtuc/long/-/long-4.2.2.tgz",
- "integrity": "sha512-NuHqBY1PB/D8xU6s/thBgOAiAP7HOYDQ32+BFZILJ8ivkUkAHQnWfn6WhL79Owj1qmUnoN/YPhktdIoucipkAQ==",
- "dev": true
+ "integrity": "sha512-NuHqBY1PB/D8xU6s/thBgOAiAP7HOYDQ32+BFZILJ8ivkUkAHQnWfn6WhL79Owj1qmUnoN/YPhktdIoucipkAQ=="
},
"node_modules/@yarnpkg/lockfile": {
"version": "1.1.0",
@@ -8306,7 +8287,6 @@
"version": "1.9.5",
"resolved": "https://registry.npmjs.org/acorn-import-attributes/-/acorn-import-attributes-1.9.5.tgz",
"integrity": "sha512-n02Vykv5uA3eHGM/Z2dQrcD56kL8TyDb2p1+0P83PClMnC/nc+anbQRhIOWnSq4Ke/KvDPrY3C9hDtC/A3eHnQ==",
- "dev": true,
"peerDependencies": {
"acorn": "^8"
}
@@ -8436,7 +8416,6 @@
"version": "3.5.2",
"resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-3.5.2.tgz",
"integrity": "sha512-5p6WTN0DdTGVQk6VjcEju19IgaHudalcfabD7yhDGeA6bcQnmL+CpveLJq/3hvfwd1aof6L386Ougkx6RfyMIQ==",
- "dev": true,
"peerDependencies": {
"ajv": "^6.9.1"
}
@@ -9233,7 +9212,6 @@
"version": "5.2.2",
"resolved": "https://registry.npmjs.org/big.js/-/big.js-5.2.2.tgz",
"integrity": "sha512-vyL2OymJxmarO8gxMr0mhChsO9QGwhynfuu4+MHTAW6czfq9humCB7rKpUjDd9YUiDPU4mzpyupFSvOClAwbmQ==",
- "dev": true,
"engines": {
"node": "*"
}
@@ -9881,7 +9859,6 @@
"version": "4.24.2",
"resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.24.2.tgz",
"integrity": "sha512-ZIc+Q62revdMcqC6aChtW4jz3My3klmCO1fEmINZY/8J3EpBg5/A/D0AKmBveUh6pgoeycoMkVMko84tuYS+Gg==",
- "dev": true,
"funding": [
{
"type": "opencollective",
@@ -10038,8 +10015,7 @@
"node_modules/buffer-from": {
"version": "1.1.2",
"resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz",
- "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==",
- "dev": true
+ "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ=="
},
"node_modules/buffer-xor": {
"version": "1.0.3",
@@ -10187,7 +10163,6 @@
"version": "1.0.30001674",
"resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001674.tgz",
"integrity": "sha512-jOsKlZVRnzfhLojb+Ykb+gyUSp9Xb57So+fAiFlLzzTKpqg8xxSav0e40c8/4F/v9N8QSvrRRaLeVzQbLqomYw==",
- "dev": true,
"funding": [
{
"type": "opencollective",
@@ -10355,7 +10330,6 @@
"version": "1.0.4",
"resolved": "https://registry.npmjs.org/chrome-trace-event/-/chrome-trace-event-1.0.4.tgz",
"integrity": "sha512-rNjApaLzuwaOTjCiT8lSDdGN1APCiqkChLMJxJPWLunPAt5fy8xgU9/jNOchV84wfIxrA0lRQB7oCT8jrn/wrQ==",
- "dev": true,
"engines": {
"node": ">=6.0"
}
@@ -12126,8 +12100,7 @@
"node_modules/electron-to-chromium": {
"version": "1.5.49",
"resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.49.tgz",
- "integrity": "sha512-ZXfs1Of8fDb6z7WEYZjXpgIRF6MEu8JdeGA0A40aZq6OQbS+eJpnnV49epZRna2DU/YsEjSQuGtQPPtvt6J65A==",
- "dev": true
+ "integrity": "sha512-ZXfs1Of8fDb6z7WEYZjXpgIRF6MEu8JdeGA0A40aZq6OQbS+eJpnnV49epZRna2DU/YsEjSQuGtQPPtvt6J65A=="
},
"node_modules/elliptic": {
"version": "6.6.0",
@@ -12187,7 +12160,6 @@
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/emojis-list/-/emojis-list-3.0.0.tgz",
"integrity": "sha512-/kyM18EfinwXZbno9FyUGeFh87KC8HRQBQGildHZbEuRyWFOmv1U10o9BBp8XVZDVNNuQKyIGIu5ZYAAXJ0V2Q==",
- "dev": true,
"engines": {
"node": ">= 4"
}
@@ -12509,8 +12481,7 @@
"node_modules/es-module-lexer": {
"version": "1.5.4",
"resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-1.5.4.tgz",
- "integrity": "sha512-MVNK56NiMrOwitFB7cqDwq0CQutbw+0BvLshJSse0MUNU+y1FC3bUS/AQg7oUng+/wKrrki7JfmwtVHkVfPLlw==",
- "dev": true
+ "integrity": "sha512-MVNK56NiMrOwitFB7cqDwq0CQutbw+0BvLshJSse0MUNU+y1FC3bUS/AQg7oUng+/wKrrki7JfmwtVHkVfPLlw=="
},
"node_modules/es-object-atoms": {
"version": "1.0.0",
@@ -12564,7 +12535,6 @@
"version": "3.2.0",
"resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
"integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
- "dev": true,
"engines": {
"node": ">=6"
}
@@ -13322,7 +13292,6 @@
"version": "3.3.0",
"resolved": "https://registry.npmjs.org/events/-/events-3.3.0.tgz",
"integrity": "sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==",
- "dev": true,
"engines": {
"node": ">=0.8.x"
}
@@ -14495,8 +14464,7 @@
"node_modules/glob-to-regexp": {
"version": "0.4.1",
"resolved": "https://registry.npmjs.org/glob-to-regexp/-/glob-to-regexp-0.4.1.tgz",
- "integrity": "sha512-lkX1HJXwyMcprw/5YUZc2s7DrpAiHB21/V+E1rHUrVNokkvB6bqMzT0VfV6/86ZNabt1k14YOIaT7nDvOX3Iiw==",
- "dev": true
+ "integrity": "sha512-lkX1HJXwyMcprw/5YUZc2s7DrpAiHB21/V+E1rHUrVNokkvB6bqMzT0VfV6/86ZNabt1k14YOIaT7nDvOX3Iiw=="
},
"node_modules/global": {
"version": "4.4.0",
@@ -14642,8 +14610,7 @@
"node_modules/graceful-fs": {
"version": "4.2.11",
"resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz",
- "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==",
- "dev": true
+ "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ=="
},
"node_modules/graphemer": {
"version": "1.4.0",
@@ -20234,7 +20201,6 @@
"version": "2.2.3",
"resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz",
"integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==",
- "dev": true,
"bin": {
"json5": "lib/cli.js"
},
@@ -20447,7 +20413,6 @@
"version": "4.3.0",
"resolved": "https://registry.npmjs.org/loader-runner/-/loader-runner-4.3.0.tgz",
"integrity": "sha512-3R/1M+yS3j5ou80Me59j7F9IMs4PXs3VqRrm0TU3AbKPxlmpoY1TNscJV/oGJXo8qCatFGTfDbY6W6ipGOYXfg==",
- "dev": true,
"engines": {
"node": ">=6.11.5"
}
@@ -20772,8 +20737,7 @@
"node_modules/merge-stream": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/merge-stream/-/merge-stream-2.0.0.tgz",
- "integrity": "sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==",
- "dev": true
+ "integrity": "sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w=="
},
"node_modules/merge2": {
"version": "1.4.1",
@@ -21016,6 +20980,36 @@
"node": "*"
}
},
+ "node_modules/monaco-editor": {
+ "version": "0.52.2",
+ "resolved": "https://registry.npmjs.org/monaco-editor/-/monaco-editor-0.52.2.tgz",
+ "integrity": "sha512-GEQWEZmfkOGLdd3XK8ryrfWz3AIP8YymVXiPHEdewrUq7mh0qrKrfHLNCXcbB6sTnMLnOZ3ztSiKcciFUkIJwQ=="
+ },
+ "node_modules/monaco-editor-webpack-plugin": {
+ "version": "7.1.0",
+ "resolved": "https://registry.npmjs.org/monaco-editor-webpack-plugin/-/monaco-editor-webpack-plugin-7.1.0.tgz",
+ "integrity": "sha512-ZjnGINHN963JQkFqjjcBtn1XBtUATDZBMgNQhDQwd78w2ukRhFXAPNgWuacaQiDZsUr4h1rWv5Mv6eriKuOSzA==",
+ "dependencies": {
+ "loader-utils": "^2.0.2"
+ },
+ "peerDependencies": {
+ "monaco-editor": ">= 0.31.0",
+ "webpack": "^4.5.0 || 5.x"
+ }
+ },
+ "node_modules/monaco-editor-webpack-plugin/node_modules/loader-utils": {
+ "version": "2.0.4",
+ "resolved": "https://registry.npmjs.org/loader-utils/-/loader-utils-2.0.4.tgz",
+ "integrity": "sha512-xXqpXoINfFhgua9xiqD8fPFHgkoq1mmmpE92WlDbm9rNRd/EbRb+Gqf908T2DMfuHjjJlksiK2RbHVOdD/MqSw==",
+ "dependencies": {
+ "big.js": "^5.2.2",
+ "emojis-list": "^3.0.0",
+ "json5": "^2.1.2"
+ },
+ "engines": {
+ "node": ">=8.9.0"
+ }
+ },
"node_modules/moo": {
"version": "0.5.2",
"resolved": "https://registry.npmjs.org/moo/-/moo-0.5.2.tgz",
@@ -21135,8 +21129,7 @@
"node_modules/neo-async": {
"version": "2.6.2",
"resolved": "https://registry.npmjs.org/neo-async/-/neo-async-2.6.2.tgz",
- "integrity": "sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw==",
- "dev": true
+ "integrity": "sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw=="
},
"node_modules/nice-try": {
"version": "1.0.5",
@@ -21258,8 +21251,7 @@
"node_modules/node-releases": {
"version": "2.0.18",
"resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.18.tgz",
- "integrity": "sha512-d9VeXT4SJ7ZeOqGX6R5EM022wpL+eWPooLI+5UpWn2jCT1aosUQEhQP214x33Wkwx3JQMvIm+tIoVOdodFS40g==",
- "dev": true
+ "integrity": "sha512-d9VeXT4SJ7ZeOqGX6R5EM022wpL+eWPooLI+5UpWn2jCT1aosUQEhQP214x33Wkwx3JQMvIm+tIoVOdodFS40g=="
},
"node_modules/nopt": {
"version": "5.0.0",
@@ -24637,7 +24629,6 @@
"version": "6.0.2",
"resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-6.0.2.tgz",
"integrity": "sha512-Saa1xPByTTq2gdeFZYLLo+RFE35NHZkAbqZeWNd3BpzppeVisAqpDjcp8dyf6uIvEqJRd46jemmyA4iFIeVk8g==",
- "dev": true,
"dependencies": {
"randombytes": "^2.1.0"
}
@@ -26364,7 +26355,6 @@
"version": "5.36.0",
"resolved": "https://registry.npmjs.org/terser/-/terser-5.36.0.tgz",
"integrity": "sha512-IYV9eNMuFAV4THUspIRXkLakHnV6XO7FEdtKjf/mDyrnqUg9LnlOn6/RwRvM9SZjR4GUq8Nk8zj67FzVARr74w==",
- "dev": true,
"dependencies": {
"@jridgewell/source-map": "^0.3.3",
"acorn": "^8.8.2",
@@ -26382,7 +26372,6 @@
"version": "5.3.10",
"resolved": "https://registry.npmjs.org/terser-webpack-plugin/-/terser-webpack-plugin-5.3.10.tgz",
"integrity": "sha512-BKFPWlPDndPs+NGGCr1U59t0XScL5317Y0UReNrHaw9/FwhPENlq6bfgs+4yPfyP51vqC1bQ4rp1EfXW5ZSH9w==",
- "dev": true,
"dependencies": {
"@jridgewell/trace-mapping": "^0.3.20",
"jest-worker": "^27.4.5",
@@ -26416,7 +26405,6 @@
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
"integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
- "dev": true,
"engines": {
"node": ">=8"
}
@@ -26425,7 +26413,6 @@
"version": "27.5.1",
"resolved": "https://registry.npmjs.org/jest-worker/-/jest-worker-27.5.1.tgz",
"integrity": "sha512-7vuh85V5cdDofPyxn58nrPjBktZo0u9x1g8WtjQol+jZDaE+fhN+cIvTj11GndBnMnyfrUOG1sZQxCdjKh+DKg==",
- "dev": true,
"dependencies": {
"@types/node": "*",
"merge-stream": "^2.0.0",
@@ -26439,7 +26426,6 @@
"version": "3.3.0",
"resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-3.3.0.tgz",
"integrity": "sha512-pN/yOAvcC+5rQ5nERGuwrjLlYvLTbCibnZ1I7B1LaiAz9BRBlE9GMgE/eqV30P7aJQUf7Ddimy/RsbYO/GrVGg==",
- "dev": true,
"dependencies": {
"@types/json-schema": "^7.0.8",
"ajv": "^6.12.5",
@@ -26457,7 +26443,6 @@
"version": "8.1.1",
"resolved": "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz",
"integrity": "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==",
- "dev": true,
"dependencies": {
"has-flag": "^4.0.0"
},
@@ -26471,14 +26456,12 @@
"node_modules/terser/node_modules/commander": {
"version": "2.20.3",
"resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz",
- "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==",
- "dev": true
+ "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ=="
},
"node_modules/terser/node_modules/source-map": {
"version": "0.6.1",
"resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
"integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
- "dev": true,
"engines": {
"node": ">=0.10.0"
}
@@ -26487,7 +26470,6 @@
"version": "0.5.21",
"resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.21.tgz",
"integrity": "sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==",
- "dev": true,
"dependencies": {
"buffer-from": "^1.0.0",
"source-map": "^0.6.0"
@@ -27058,8 +27040,7 @@
"node_modules/undici-types": {
"version": "5.26.5",
"resolved": "https://registry.npmjs.org/undici-types/-/undici-types-5.26.5.tgz",
- "integrity": "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==",
- "dev": true
+ "integrity": "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA=="
},
"node_modules/unicode-canonical-property-names-ecmascript": {
"version": "2.0.1",
@@ -27147,7 +27128,6 @@
"version": "1.1.1",
"resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.1.1.tgz",
"integrity": "sha512-R8UzCaa9Az+38REPiJ1tXlImTJXlVfgHZsglwBD/k6nj76ctsH1E3q4doGrukiLQd3sGQYu56r5+lo5r94l29A==",
- "dev": true,
"funding": [
{
"type": "opencollective",
@@ -27338,7 +27318,6 @@
"version": "2.4.2",
"resolved": "https://registry.npmjs.org/watchpack/-/watchpack-2.4.2.tgz",
"integrity": "sha512-TnbFSbcOCcDgjZ4piURLCbJ3nJhznVh9kw6F6iokjiFPl8ONxe9A6nMDVXDiNbrSfLILs6vB07F7wLBrwPYzJw==",
- "dev": true,
"dependencies": {
"glob-to-regexp": "^0.4.1",
"graceful-fs": "^4.1.2"
@@ -27374,7 +27353,6 @@
"version": "5.95.0",
"resolved": "https://registry.npmjs.org/webpack/-/webpack-5.95.0.tgz",
"integrity": "sha512-2t3XstrKULz41MNMBF+cJ97TyHdyQ8HCt//pqErqDvNjU9YQBnZxIHa11VXsi7F3mb5/aO2tuDxdeTPdU7xu9Q==",
- "dev": true,
"dependencies": {
"@types/estree": "^1.0.5",
"@webassemblyjs/ast": "^1.12.1",
@@ -27655,7 +27633,6 @@
"version": "5.17.1",
"resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.17.1.tgz",
"integrity": "sha512-LMHl3dXhTcfv8gM4kEzIUeTQ+7fpdA0l2tUf34BddXPkz2A5xJ5L/Pchd5BL6rdccM9QGvu0sWZzK1Z1t4wwyg==",
- "dev": true,
"dependencies": {
"graceful-fs": "^4.2.4",
"tapable": "^2.2.0"
@@ -27668,7 +27645,6 @@
"version": "5.1.1",
"resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-5.1.1.tgz",
"integrity": "sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw==",
- "dev": true,
"dependencies": {
"esrecurse": "^4.3.0",
"estraverse": "^4.1.1"
@@ -27681,7 +27657,6 @@
"version": "4.3.0",
"resolved": "https://registry.npmjs.org/estraverse/-/estraverse-4.3.0.tgz",
"integrity": "sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw==",
- "dev": true,
"engines": {
"node": ">=4.0"
}
@@ -27690,7 +27665,6 @@
"version": "3.3.0",
"resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-3.3.0.tgz",
"integrity": "sha512-pN/yOAvcC+5rQ5nERGuwrjLlYvLTbCibnZ1I7B1LaiAz9BRBlE9GMgE/eqV30P7aJQUf7Ddimy/RsbYO/GrVGg==",
- "dev": true,
"dependencies": {
"@types/json-schema": "^7.0.8",
"ajv": "^6.12.5",
@@ -27708,7 +27682,6 @@
"version": "2.2.1",
"resolved": "https://registry.npmjs.org/tapable/-/tapable-2.2.1.tgz",
"integrity": "sha512-GNzQvQTOIP6RyTfE2Qxb8ZVlNmw0n88vp1szwWRimP02mnTsx3Wtn5qRdqY9w2XduFNUgvOwhNnQsjwCp+kqaQ==",
- "dev": true,
"engines": {
"node": ">=6"
}
@@ -27717,7 +27690,6 @@
"version": "3.2.3",
"resolved": "https://registry.npmjs.org/webpack-sources/-/webpack-sources-3.2.3.tgz",
"integrity": "sha512-/DyMEOrDgLKKIG0fmvtz+4dUX/3Ghozwgm6iPp8KRhvn+eQf9+Q7GWxVNMk3+uCPWfdXYC4ExGBckIXdFEfH1w==",
- "dev": true,
"engines": {
"node": ">=10.13.0"
}
diff --git a/webapp/platform/client/src/client4.ts b/webapp/platform/client/src/client4.ts
index 6aec978094..ee14c49171 100644
--- a/webapp/platform/client/src/client4.ts
+++ b/webapp/platform/client/src/client4.ts
@@ -3,6 +3,7 @@
/* eslint-disable max-lines */
+import type {AccessControlPolicy, CELExpressionError, AccessControlTestResult, AccessControlPoliciesResult, AccessControlPolicyChannelsResult, AccessControlVisualAST} from '@mattermost/types/access_control';
import type {ClusterInfo, AnalyticsRow, SchemaMigration, LogFilterQuery} from '@mattermost/types/admin';
import type {AppBinding, AppCallRequest, AppCallResponse} from '@mattermost/types/apps';
import type {Audit} from '@mattermost/types/audits';
@@ -108,7 +109,7 @@ import type {
import type {Post, PostList, PostSearchResults, PostsUsageResponse, TeamsUsageResponse, PaginatedPostList, FilesUsageResponse, PostAcknowledgement, PostAnalytics, PostInfo} from '@mattermost/types/posts';
import type {PreferenceType} from '@mattermost/types/preferences';
import type {ProductNotices} from '@mattermost/types/product_notices';
-import type {UserPropertyField, UserPropertyFieldPatch} from '@mattermost/types/properties';
+import type {PropertyField, UserPropertyField, UserPropertyFieldPatch} from '@mattermost/types/properties';
import type {Reaction} from '@mattermost/types/reactions';
import type {RemoteCluster, RemoteClusterAcceptInvite, RemoteClusterPatch, RemoteClusterWithPassword} from '@mattermost/types/remote_clusters';
import type {UserReport, UserReportFilter, UserReportOptions} from '@mattermost/types/reports';
@@ -1547,7 +1548,9 @@ export default class Client4 {
excludeDefaultChannels: boolean | undefined,
includeTotalCount: false | undefined,
includeDeleted: boolean | undefined,
- excludePolicyConstrained: boolean | undefined
+ excludePolicyConstrained: boolean | undefined,
+ accessControlPolicyEnforced: boolean | undefined,
+ excludeAccessControlPolicyEnforced: boolean | undefined
): Promise;
getAllChannels(
page: number | undefined,
@@ -1556,7 +1559,9 @@ export default class Client4 {
excludeDefaultChannels: boolean | undefined,
includeTotalCount: true,
includeDeleted: boolean | undefined,
- excludePolicyConstrained: boolean | undefined
+ excludePolicyConstrained: boolean | undefined,
+ accessControlPolicyEnforced: boolean | undefined,
+ excludeAccessControlPolicyEnforced: boolean | undefined
): Promise;
getAllChannels(
page = 0,
@@ -1566,16 +1571,36 @@ export default class Client4 {
includeTotalCount = false,
includeDeleted = false,
excludePolicyConstrained = false,
+ accessControlPolicyEnforced = false,
+ excludeAccessControlPolicyEnforced = false,
) {
- const queryData = {
+ const queryData: Record = {
page,
per_page: perPage,
- not_associated_to_group: notAssociatedToGroup,
- exclude_default_channels: excludeDefaultChannels,
include_total_count: includeTotalCount,
include_deleted: includeDeleted,
- exclude_policy_constrained: excludePolicyConstrained,
};
+
+ if (notAssociatedToGroup) {
+ queryData.not_associated_to_group = notAssociatedToGroup;
+ }
+
+ if (excludeDefaultChannels) {
+ queryData.exclude_default_channels = excludeDefaultChannels;
+ }
+
+ if (excludePolicyConstrained) {
+ queryData.exclude_policy_constrained = excludePolicyConstrained;
+ }
+
+ if (accessControlPolicyEnforced) {
+ queryData.access_control_policy_enforced = accessControlPolicyEnforced;
+ }
+
+ if (excludeAccessControlPolicyEnforced) {
+ queryData.exclude_access_control_policy_enforced = excludeAccessControlPolicyEnforced;
+ }
+
return this.doFetch(
`${this.getChannelsRoute()}${buildQueryString(queryData)}`,
{method: 'get'},
@@ -4382,6 +4407,111 @@ export default class Client4 {
{method: 'post', headers: {'Connection-Id': connectionId}},
);
};
+
+ getAccessControlPolicy = (id: string) => {
+ return this.doFetch(
+ `${this.getBaseRoute()}/access_control_policies/${id}`,
+ {method: 'get'},
+ );
+ };
+
+ updateOrCreateAccessControlPolicy = (policy: AccessControlPolicy) => {
+ return this.doFetch(
+ `${this.getBaseRoute()}/access_control_policies`,
+ {method: 'put', body: JSON.stringify(policy)},
+ );
+ };
+
+ deleteAccessControlPolicy = (id: string) => {
+ return this.doFetch(
+ `${this.getBaseRoute()}/access_control_policies/${id}`,
+ {method: 'delete'},
+ );
+ };
+
+ getAccessControlPolicies = (after: string, limit: number) => {
+ return this.doFetch(
+ `${this.getBaseRoute()}/access_control_policies/search`,
+ {method: 'post', body: JSON.stringify({type: 'parent', cursor: {id: after}, limit})},
+ );
+ };
+
+ getChildPolicies = (parentId: string, after: string, limit: number) => {
+ return this.doFetch(
+ `${this.getBaseRoute()}/access_control_policies/search`,
+ {method: 'post', body: JSON.stringify({parent_id: parentId, cursor: {id: after}, limit})},
+ );
+ };
+
+ getChannelsForAccessControlPolicy = (policyId: string, after: string, limit: number) => {
+ return this.doFetch(
+ `${this.getBaseRoute()}/access_control_policies/${policyId}/resources/channels?after=${after}&limit=${limit}`,
+ {method: 'get'},
+ );
+ };
+
+ searchAccessControlPolicies = (term: string, type: string, after: string, limit: number) => {
+ return this.doFetch(
+ `${this.getBaseRoute()}/access_control_policies/search`,
+ {method: 'post', body: JSON.stringify({term, type, cursor: {id: after}, limit, include_children: true})},
+ );
+ };
+
+ searchChildAccessControlPolicyChannels = (policyId: string, term: string, opts: ChannelSearchOpts) => {
+ return this.doFetch(
+ `${this.getBaseRoute()}/access_control_policies/${policyId}/resources/channels/search?term=${term}`,
+ {method: 'post', body: JSON.stringify({term, ...opts})},
+ );
+ };
+
+ updateAccessControlPolicyActive = (policyId: string, active: boolean) => {
+ return this.doFetch(
+ `${this.getBaseRoute()}/access_control_policies/${policyId}/activate?active=${active}`,
+ {method: 'get'},
+ );
+ };
+
+ assignChannelsToAccessControlPolicy = (policyId: string, channelIds: string[]) => {
+ return this.doFetch(
+ `${this.getBaseRoute()}/access_control_policies/${policyId}/assign`,
+ {method: 'post', body: JSON.stringify({channel_ids: channelIds})},
+ );
+ };
+
+ unassignChannelsFromAccessControlPolicy = (policyId: string, channelIds: string[]) => {
+ return this.doFetch(
+ `${this.getBaseRoute()}/access_control_policies/${policyId}/unassign`,
+ {method: 'delete', body: JSON.stringify({channel_ids: channelIds})},
+ );
+ };
+
+ getAccessControlFields = (after: string, limit: number) => {
+ return this.doFetch(
+ `${this.getBaseRoute()}/access_control_policies/cel/autocomplete/fields?after=${after}&limit=${limit}`,
+ {method: 'get'},
+ );
+ };
+
+ checkAccessControlExpression = (expression: string) => {
+ return this.doFetch(
+ `${this.getBaseRoute()}/access_control_policies/cel/check`,
+ {method: 'post', body: JSON.stringify({expression})},
+ );
+ };
+
+ testAccessControlExpression = (expression: string, term: string, after: string, limit: number) => {
+ return this.doFetch(
+ `${this.getBaseRoute()}/access_control_policies/cel/test`,
+ {method: 'post', body: JSON.stringify({expression, term, after, limit})},
+ );
+ };
+
+ expressionToVisualFormat = (expression: string) => {
+ return this.doFetch(
+ `${this.getBaseRoute()}/access_control_policies/cel/visual_ast`,
+ {method: 'post', body: JSON.stringify({expression})},
+ );
+ };
}
export function parseAndMergeNestedHeaders(originalHeaders: any) {
diff --git a/webapp/platform/types/src/access_control.ts b/webapp/platform/types/src/access_control.ts
new file mode 100644
index 0000000000..33b01496c5
--- /dev/null
+++ b/webapp/platform/types/src/access_control.ts
@@ -0,0 +1,75 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+import type {ChannelWithTeamData} from './channels';
+import type {UserProfile} from './users';
+export type AccessControlPolicy = {
+ id: string;
+ name: string;
+ type: string;
+ revision?: number;
+ created_at?: number;
+ version?: string;
+ active?: boolean;
+ imports?: string[];
+ props?: Record;
+ rules: AccessControlPolicyRule[];
+}
+
+export type AccessControlPolicyCursor = {
+ id: string;
+}
+
+export type AccessControlPoliciesResult = {
+ policies: AccessControlPolicy[];
+ total: number;
+}
+
+export type AccessControlPolicySearchOpts = {
+ term: string;
+ type: string;
+ cursor: AccessControlPolicyCursor;
+ limit: number;
+}
+
+export type AccessControlPolicyChannelsResult = {
+ channels: ChannelWithTeamData[];
+ total: number;
+}
+
+export type AccessControlPolicyRule = {
+ actions?: string[];
+ expression: string;
+}
+
+export type CELExpressionError = {
+ message: string;
+ line: number;
+ column: number;
+}
+
+export type AccessControlTestResult = {
+ users: UserProfile[];
+ total: number;
+}
+
+export type AccessControlEntity = {
+ name: string;
+ attributes: AccessControlAttribute[];
+}
+
+export type AccessControlAttribute = {
+ name: string;
+ values: string[];
+}
+
+export type AccessControlVisualAST = {
+ conditions: AccessControlVisualASTNode[];
+}
+
+export type AccessControlVisualASTNode = {
+ attribute: string;
+ operator: string;
+ value: any;
+ value_type: number;
+}
diff --git a/webapp/platform/types/src/admin.ts b/webapp/platform/types/src/admin.ts
index 9fdacbac9e..fd3ddbeaf1 100644
--- a/webapp/platform/types/src/admin.ts
+++ b/webapp/platform/types/src/admin.ts
@@ -1,6 +1,7 @@
// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
// See LICENSE.txt for license information.
+import type {AccessControlPolicy} from './access_control';
import type {Audit} from './audits';
import type {Compliance} from './compliance';
import type {AdminConfig, ClientLicense, EnvironmentConfig} from './config';
@@ -10,7 +11,7 @@ import type {PluginRedux, PluginStatusRedux} from './plugins';
import type {SamlCertificateStatus, SamlMetadataResponse} from './saml';
import type {Team} from './teams';
import type {UserAccessToken, UserProfile} from './users';
-import type {RelationOneToOne} from './utilities';
+import type {RelationOneToOne, IDMappedObjects} from './utilities';
export enum LogLevelEnum {
SILLY = 'silly',
@@ -69,6 +70,8 @@ export type AdminState = {
dataRetentionCustomPolicies: DataRetentionCustomPolicies;
dataRetentionCustomPoliciesCount: number;
prevTrialLicense: ClientLicense;
+ accessControlPolicies: IDMappedObjects;
+ channelsForAccessControlPolicy: Record;
};
export type AnalyticsState = {
diff --git a/webapp/platform/types/src/channels.ts b/webapp/platform/types/src/channels.ts
index beeda9a0e2..23635374f3 100644
--- a/webapp/platform/types/src/channels.ts
+++ b/webapp/platform/types/src/channels.ts
@@ -68,6 +68,7 @@ export type Channel = {
props?: Record;
policy_id?: string | null;
banner_info?: ChannelBanner;
+ policy_enforced?: boolean;
};
export type ServerChannel = Channel & {
@@ -230,4 +231,7 @@ export type ChannelSearchOpts = {
deleted?: boolean;
page?: number;
per_page?: number;
+ access_control_policy_enforced?: boolean;
+ exclude_access_control_policy_enforced?: boolean;
+ parent_access_control_policy_id?: string;
};
diff --git a/webapp/platform/types/src/config.ts b/webapp/platform/types/src/config.ts
index ad43fd867c..34dc704be1 100644
--- a/webapp/platform/types/src/config.ts
+++ b/webapp/platform/types/src/config.ts
@@ -125,6 +125,7 @@ export type ClientConfig = {
FeatureFlagAppsEnabled: string;
FeatureFlagCallsEnabled: string;
FeatureFlagCustomProfileAttributes: string;
+ FeatureFlagAttributeBasedAccessControl: string;
FeatureFlagWebSocketEventScope: string;
ForgotPasswordLink: string;
GiphySdkKey: string;
diff --git a/webapp/platform/types/src/jobs.ts b/webapp/platform/types/src/jobs.ts
index 5c232d369d..c1b635a8b5 100644
--- a/webapp/platform/types/src/jobs.ts
+++ b/webapp/platform/types/src/jobs.ts
@@ -3,7 +3,7 @@
import type {IDMappedObjects} from './utilities';
-export type JobType = 'data_retention' | 'elasticsearch_post_indexing' | 'bleve_post_indexing' | 'ldap_sync' | 'message_export';
+export type JobType = 'data_retention' | 'elasticsearch_post_indexing' | 'bleve_post_indexing' | 'ldap_sync' | 'message_export' | 'access_control_sync';
export type JobStatus = 'pending' | 'in_progress' | 'success' | 'error' | 'cancel_requested' | 'canceled' | 'warning';
export type Job = JobTypeBase & {
id: string;