@ytsaurus/ui 0.0.3

package/src/ui/store/selectors/accounts/accounts.js

@@ -0,0 +1,274 @@
+import _ from 'lodash';
+import {createSelector} from 'reselect';
+import {ACCOUNTS_TABLE_ID, ROOT_ACCOUNT_NAME} from '../../../constants/accounts/accounts';
+import {getTables} from '../../../store/selectors/tables';
+import hammer from '../../../common/hammer';
+import ypath from '../../../common/thor/ypath';
+import {
+    getAccountNames,
+    getAccountsColumnFields,
+    getAccountsMapByName,
+    getAccountsTree,
+    getAccountMasterMemoryMedia,
+} from './accounts-ts';
+import {concatByAnd} from '../../../common/hammer/predicate';
+import {accountMemoryMediumToFieldName} from '../../../utils/accounts/accounts-selector';
+import {visitTreeItems} from '../../../utils/utils';
+
+export const getActiveAccount = (state) => state.accounts.accounts.activeAccount;
+export const getActiveMediumFilter = (state) => state.accounts.accounts.activeMediumFilter;
+export const getUsableAccounts = (state) => state.accounts.accounts.usableAccounts;
+export const getAccountsNameFilter = (state) => state.accounts.accounts.activeNameFilter;
+export const getAccountsAbcServiceIdSlugFilter = (state) =>
+    state.accounts.accounts.abcServiceFilter;
+export const getAccountsSortInfo = (state) => getTables(state)[ACCOUNTS_TABLE_ID];
+
+export const getEditableAccount = (state) => state.accounts.accounts.editableAccount;
+
+const getEditableAccountSubtreeNames = createSelector(
+    [getAccountsTree, getEditableAccount],
+    prepareSubtreeNames,
+);
+
+export const getEditableAccountParentSuggests = createSelector(
+    [getAccountNames, getEditableAccountSubtreeNames],
+    (allNames, excludeNames) => {
+        const excludeNamesSet = new Set(excludeNames);
+        return _.filter(allNames, (name) => !excludeNamesSet.has(name));
+    },
+);
+
+const getFlattenTree = createSelector(
+    [getAccountsTree, getActiveAccount, getAccountsNameFilter, getAccountsAbcServiceIdSlugFilter],
+    prepareAccountsFlattenTreeImpl,
+);
+
+export const getActiveAccountSubtree = createSelector(
+    getActiveAccount,
+    getFlattenTree,
+    getActiveAccountSubtreeImpl,
+);
+
+export const getActiveAccountAggregationRow = createSelector(
+    [getActiveAccountSubtree, getAccountMasterMemoryMedia],
+    ({activeTreeItem}, masterMemoryMedia) => calcAggregationRow(activeTreeItem, masterMemoryMedia),
+);
+
+export const getActiveAccountSubtreeNames = createSelector(
+    getActiveAccountSubtree,
+    getActiveAccountSubtreeNamesImpl,
+);
+
+export const prepareAccountsFlattenTree = createSelector(
+    [getAccountsSortInfo, getFlattenTree, getAccountsColumnFields],
+    sortFlattenTree,
+);
+
+export function getAccountName(treeItem) {
+    const {attributes: account} = treeItem || {};
+    return account && account.name;
+}
+
+function prepareSubtreeNames(tree, account) {
+    if (_.isEmpty(tree) || _.isEmpty(account)) {
+        return [];
+    }
+
+    const res = [];
+    hammer.treeList.treeForEach(tree[account.name], (node) => {
+        res.push(getAccountName(node));
+    });
+    return res;
+}
+
+function prepareAccountsFlattenTreeImpl(treeList, activeAccount, nameFilter = '', {slug} = {}) {
+    let root = treeList['<Root>'];
+    if (root === undefined) {
+        return [];
+    }
+
+    if (activeAccount && treeList[activeAccount]) {
+        root = {...root, children: [treeList[activeAccount]]};
+    }
+
+    let filteredRoot = root;
+
+    const isRoot = (treeNode) => {
+        const {attributes: account} = treeNode;
+        return treeNode === root || account.name === activeAccount;
+    };
+
+    const predicates = [];
+    if (nameFilter) {
+        predicates.push((treeNode) => {
+            const {attributes: account} = treeNode;
+            const {name} = account;
+
+            return isRoot(treeNode) || -1 !== name.indexOf(nameFilter);
+        });
+    }
+
+    if (slug) {
+        predicates.push((treeNode) => {
+            return isRoot(treeNode) || slug === ypath.getValue(treeNode.attributes, '/@abc/slug');
+        });
+    }
+
+    if (predicates.length) {
+        filteredRoot = hammer.treeList.filterTree(root, concatByAnd(...predicates));
+    }
+
+    return filteredRoot;
+}
+
+function sortFlattenTree(sortInfo, flattenTree = [], columnFields) {
+    if (sortInfo) {
+        hammer.treeList.sortTree(flattenTree, sortInfo, columnFields);
+    }
+
+    const sortedTree = hammer.treeList.flattenTree(flattenTree);
+    return sortedTree;
+}
+
+function findByName(treeNode, name) {
+    if (name === getAccountName(treeNode)) {
+        return treeNode;
+    }
+
+    for (const childNode of treeNode.children || []) {
+        const res = findByName(childNode, name);
+        if (res) {
+            return res;
+        }
+    }
+
+    return undefined;
+}
+
+function getActiveAccountSubtreeImpl(activeAccount, treeRoot) {
+    if (!activeAccount) {
+        return {treeRoot};
+    }
+
+    const activeTreeItem = findByName(treeRoot, activeAccount);
+    return {treeRoot, activeTreeItem};
+}
+
+const AGGREGATION_FIELDS = [
+    'totalNodeCount',
+    'nodeCountLimit',
+    'totalChunkCount',
+    'chunkCountLimit',
+    'totalTabletCount',
+    'tabletCountLimit',
+    'totalTabletStaticMemory',
+    'tabletStaticMemoryLimit',
+    'totalMasterMemory',
+    'masterMemoryLimit',
+    'master_memory_detailed.nodes',
+    'master_memory_detailed.chunks',
+    'master_memory_detailed.attributes',
+    'master_memory_detailed.tablets',
+    'master_memory_detailed.schemas',
+];
+
+const AGGREGATION_PER_MEDIUM_FIELDS = ['totalDiskSpace', 'diskSpaceLimit'];
+const AGGREGATION_MASTER_MEMORY_FIELDS = ['total', 'limit'];
+
+function addIfDefined(dst, src, key) {
+    const srcValue = _.get(src, key);
+    const dstValue = _.get(dst, key);
+    if (srcValue === null || srcValue === undefined) {
+        return dstValue;
+    }
+
+    return (dstValue || 0) + srcValue;
+}
+
+function calcAggregationRow(treeItem, masterMemoryMedia) {
+    const {children} = treeItem || {};
+    if (!children || !children.length) {
+        return null;
+    }
+
+    const aggAccount = {
+        name: 'Aggregation',
+        perMedium: {},
+    };
+
+    _.forEach(children, (treeItem) => {
+        const {attributes: account} = treeItem;
+        _.forEach(AGGREGATION_FIELDS, (key) => {
+            _.set(aggAccount, key, addIfDefined(aggAccount, account, key));
+        });
+
+        _.forEach(account.perMedium, (data, mediumType) => {
+            _.forEach(AGGREGATION_PER_MEDIUM_FIELDS, (key) => {
+                let aggMediumData = aggAccount.perMedium[mediumType];
+                if (!aggMediumData) {
+                    aggMediumData = aggAccount.perMedium[mediumType] = {};
+                }
+                aggMediumData[key] = addIfDefined(aggMediumData, data, key);
+            });
+        });
+
+        _.forEach(masterMemoryMedia, (medium) => {
+            _.forEach(AGGREGATION_MASTER_MEMORY_FIELDS, (field) => {
+                const srcField = accountMemoryMediumToFieldName('master_memory/' + medium);
+                const key = `${srcField}.${field}`;
+                _.set(aggAccount, key, addIfDefined(aggAccount, account, key));
+            });
+        });
+    });
+
+    const aggTreeItem = {
+        isAggregation: true,
+        children: [],
+        attributes: aggAccount,
+        parent: treeItem.name,
+        name: treeItem.name + '/Aggregation',
+    };
+
+    return aggTreeItem;
+}
+
+function getActiveAccountSubtreeNamesImpl({activeTreeItem}) {
+    const res = [];
+    visitTreeItems(activeTreeItem, (item) => {
+        res.push(getAccountName(item));
+    });
+    return res;
+}
+
+export const getActiveAccountBreadcrumbs = createSelector(
+    getActiveAccount,
+    getAccountsMapByName,
+    (activeAccount, nameToAccountMap) => {
+        const parentNode = (name) => {
+            const account = nameToAccountMap[name] || {attributes: {}};
+            return account && account.parent;
+        };
+
+        const loaded = nameToAccountMap[activeAccount] !== undefined;
+        const namesArr = [];
+        if (loaded) {
+            let name = activeAccount;
+            while (name && name !== ROOT_ACCOUNT_NAME) {
+                namesArr.push(name);
+                name = parentNode(name);
+            }
+        }
+        const items = [
+            {text: '<Accounts>', url: '', title: ''},
+            ..._.map(namesArr.reverse(), (name) => {
+                return {
+                    value: name,
+                    text: name,
+                    url: `?account=${name}`,
+                    title: name,
+                };
+            }),
+        ];
+        return items;
+    },
+);

package/src/ui/store/selectors/accounts/dashboard.js

@@ -0,0 +1,46 @@
+import _ from 'lodash';
+import {createSelector} from 'reselect';
+import {
+    getUsableAccounts,
+    prepareAccountsFlattenTree,
+} from '../../../store/selectors/accounts/accounts';
+import {getFavouriteAccounts} from '../../../store/selectors/favourites';
+import {
+    getAccountsVisibilityMode,
+    getAccountsVisibilityModeOfDashboard,
+} from '../../../store/selectors/settings';
+import {filterFlattenTreeByViewContext} from '../../../utils/accounts';
+import {getActiveAccount} from './accounts-ts';
+
+export const getUsableAccountsSet = createSelector([getUsableAccounts], (items) => {
+    return new Set(items);
+});
+
+/**
+ * This selector cannot be moved to 'store/selectors/accounts/accounts'
+ * because of cyclic dependencies.
+ */
+export const getFavouriteAccountsSet = createSelector([getFavouriteAccounts], (items) => {
+    return new Set(_.map(items, 'path'));
+});
+
+export const getFilteredAccountsOfDashboard = createSelector(
+    [
+        prepareAccountsFlattenTree,
+        getUsableAccountsSet,
+        getAccountsVisibilityModeOfDashboard,
+        getFavouriteAccountsSet,
+    ],
+    filterFlattenTreeByViewContext,
+);
+
+export const getFilteredAccounts = createSelector(
+    [
+        prepareAccountsFlattenTree,
+        getUsableAccountsSet,
+        getAccountsVisibilityMode,
+        getFavouriteAccountsSet,
+        getActiveAccount,
+    ],
+    filterFlattenTreeByViewContext,
+);

package/src/ui/store/selectors/acl.js

@@ -0,0 +1,287 @@
+import {createSelector} from 'reselect';
+import _ from 'lodash';
+import {calculateLoadingStatus} from '../../utils/utils';
+
+const prepareColumnsNames = (columnsPermissions) => {
+    const columns = _.map(columnsPermissions, (permission) => permission.columns);
+
+    return _.uniq(_.flatten(columns));
+};
+
+const prepareSubjects = (subjects, type) => {
+    return _.map(subjects, (subject) => ({
+        ...subject,
+        type,
+        subjects: [subject.value],
+        subjectType: subject.type === 'users' ? 'user' : 'group',
+        groupInfo:
+            subject.type === 'groups' ? {name: subject.group_name, url: subject.url} : undefined,
+    }));
+};
+
+export const getAllUserPermissions = (state, idmKind) => state.acl[idmKind].userPermissions;
+export const getAllObjectPermissions = (state, idmKind) => state.acl[idmKind].objectPermissions;
+
+export const getAllObjectPermissionsOrderedByInheritanceAndSubject = createSelector(
+    [getAllObjectPermissions],
+    OrderByInheritanceAndSubject,
+);
+
+export const getAllObjectPermissionsOrderedByStatus = createSelector(
+    [getAllObjectPermissions],
+    OrderByRoleStatus,
+);
+export const getAllColumnGroups = (state, idmKind) => state.acl[idmKind].columnGroups;
+export const getAllColumnGroupsActual = createSelector([getAllColumnGroups], (items) => {
+    const filtered = _.filter(items, (item) => !item.removed);
+    return _.sortBy(filtered, ['name']);
+});
+
+function OrderByRoleStatus(items) {
+    const unrecognized = [];
+    const requested = [];
+    const depriving = [];
+    const rest = [];
+    _.forEach(items, (item) => {
+        const {isDepriving, isRequested, isUnrecognized, isApproved} = item;
+        if (isUnrecognized) {
+            unrecognized.push(item);
+        } else if (isDepriving) {
+            depriving.push(item);
+        } else if (isRequested || isApproved) {
+            requested.push(item);
+        } else {
+            rest.push(item);
+        }
+    });
+    return [...requested, ...depriving, ...unrecognized, ...rest];
+}
+
+function OrderByInheritanceAndSubject(items) {
+    return _.sortBy(items, [
+        (item) => !item.inherited,
+        (item) => (item.subjects && item.subjects[0]) || true,
+    ]);
+}
+
+export const getColumnsColumns = (state, idmKind) => state.acl[idmKind].columnsColumns;
+export const getObjectSubjects = (state, idmKind) => state.acl[idmKind].objectSubject;
+
+const getReadApprovers = (state, idmKind) => state.acl[idmKind].readApprovers;
+const getResponsibles = (state, idmKind) => state.acl[idmKind].responsible;
+const getAuditors = (state, idmKind) => state.acl[idmKind].auditors;
+
+export const getNotInheritedReadApprovers = createSelector([getReadApprovers], (readApprovers) =>
+    _.filter(readApprovers, (readApprover) => !readApprover.inherited),
+);
+export const getNotInheritedResponsibles = createSelector([getResponsibles], (responsibles) =>
+    _.filter(responsibles, (responsible) => !responsible.inherited),
+);
+export const getNotInheritedAuditors = createSelector([getAuditors], (auditros) =>
+    _.filter(auditros, (auditro) => !auditro.inherited),
+);
+
+const getAllApprovers = createSelector(
+    [getReadApprovers, getResponsibles, getAuditors],
+    (readApprovers, responsibles, auditros) => {
+        return [
+            ...prepareSubjects(readApprovers, 'read_approver'),
+            ...prepareSubjects(responsibles, 'responsible'),
+            ...prepareSubjects(auditros, 'auditor'),
+        ];
+    },
+);
+
+export const getApproversOrderedByInheritanceAndSubject = createSelector(
+    [getAllApprovers],
+    OrderByInheritanceAndSubject,
+);
+
+export const getApprovers = createSelector([getAllApprovers], OrderByRoleStatus);
+
+export const getAllAccessColumnsPermissions = createSelector(
+    [getAllObjectPermissions],
+    (objectPermissions) => {
+        const filteredPermissions = _.filter(
+            objectPermissions,
+            (permission) => permission.action === 'allow' && permission.columns?.length > 0,
+        );
+        return _.map(filteredPermissions, (permission) => ({
+            ...permission,
+            type: 'columns',
+        }));
+    },
+);
+
+export const getAllAccessColumnsPermissionsOrderedByInheritanceAndSubject = createSelector(
+    [getAllAccessColumnsPermissions],
+    OrderByInheritanceAndSubject,
+);
+
+const getAllDenyColumnsPermissions = createSelector(
+    [getAllObjectPermissions],
+    (objectPermissions) => {
+        const filteredPermissions = _.filter(
+            objectPermissions,
+            (permission) => permission.action === 'deny' && permission.columns?.length > 0,
+        );
+
+        return _.map(filteredPermissions, (permission) => ({
+            ...permission,
+            type: 'columns',
+        }));
+    },
+);
+
+export const getAllAccessColumnsNames = createSelector(
+    [getAllAccessColumnsPermissions],
+    prepareColumnsNames,
+);
+
+export const getAllDenyColumnsNames = createSelector(
+    [getAllDenyColumnsPermissions],
+    prepareColumnsNames,
+);
+
+export const getDenyColumnsItems = createSelector([getAllDenyColumnsNames], (names) =>
+    _.map(names, (name) => ({key: name, value: name, title: name})),
+);
+
+export const isPermissionDeleted = (state, idmKind) => state.acl[idmKind].isPermissionDeleted;
+export const permissionDeletionError = (state, idmKind) => state.acl[idmKind].deletionError;
+export const getLastDeletedPermissionKey = (state, idmKind) => state.acl[idmKind].deletedItemKey;
+export const getIdmPermissionsRequestError = (state, idmKind) =>
+    state.acl[idmKind].idmPermissionsRequestError;
+export const getIdmManageAclRequestError = (state, idmKind) =>
+    state.acl[idmKind].idmManageAclRequestError;
+export const getIdmPathVersion = (state, idmKind) => state.acl[idmKind].version;
+
+const makeReadApproversHighlightedIndex = createSelector(
+    [getApprovers, getObjectSubjects],
+    (readApprovers, subjectFilter) => {
+        const textCache = {};
+        const rowCache = {};
+        if (subjectFilter) {
+            _.forEach(readApprovers, ({value}, index) => {
+                const pos = value.indexOf(subjectFilter);
+                textCache[value] = {start: pos, length: subjectFilter.length};
+                rowCache[index] = rowCache[index] || pos === -1;
+            });
+        }
+        return {
+            text: (subject) => {
+                return textCache[subject] || {};
+            },
+            row: (index) => {
+                return rowCache[index];
+            },
+        };
+    },
+);
+
+const makePermissionSubjectHighlightedIndex = createSelector(
+    [getAllObjectPermissionsOrderedByStatus, getObjectSubjects],
+    (permissions, subjectFilter) => {
+        const textCache = {};
+        const rowCache = {};
+        if (subjectFilter) {
+            _.forEach(permissions, ({subjects, subjectType, tvmInfo}, index) => {
+                let rowIsHighlighted = false;
+                _.forEach(subjects, (subject) => {
+                    const text = subjectType === 'tvm' ? `${tvmInfo.name} (${subject})` : subject;
+                    const pos = text.toLowerCase().indexOf(subjectFilter.toLowerCase());
+                    textCache[text] = {
+                        start: pos,
+                        length: subjectFilter.length,
+                    };
+                    rowIsHighlighted = rowIsHighlighted || pos !== -1;
+                });
+                rowCache[index] = !rowIsHighlighted;
+            });
+        }
+
+        return {
+            text: (subject) => {
+                return textCache[subject] || {};
+            },
+            row: (index) => {
+                return rowCache[index];
+            },
+        };
+    },
+);
+
+const makeColumnHighlighterIndex = createSelector(
+    [getAllAccessColumnsPermissions, getObjectSubjects, getColumnsColumns],
+    (columnPermissions, subjectFilter, columnFilter) => {
+        const textCache = {};
+        const rowCache = {};
+        if (columnFilter || subjectFilter) {
+            _.forEach(columnPermissions, ({subjects, columns}, index) => {
+                let subjectFound = !subjectFilter;
+                if (subjectFilter) {
+                    _.forEach(subjects, (subject) => {
+                        const pos = subject.indexOf(subjectFilter);
+                        subjectFound = subjectFound || pos !== -1;
+                    });
+                }
+                let columnFound = !columnFilter;
+                if (columnFilter) {
+                    _.forEach(columns, (column) => {
+                        const pos = column.indexOf(columnFilter);
+                        if (pos !== -1) {
+                            textCache[column] = {
+                                start: pos,
+                                length: columnFilter.length,
+                            };
+                        }
+                        columnFound = columnFound || pos !== -1;
+                    });
+                }
+                rowCache[index] = !subjectFound || !columnFound;
+            });
+        }
+        return {
+            text: (column) => {
+                return textCache[column] || {};
+            },
+            row: (index) => {
+                return rowCache[index];
+            },
+        };
+    },
+);
+
+export const getAclHightlightedByFilter = createSelector(
+    [
+        makeReadApproversHighlightedIndex,
+        makePermissionSubjectHighlightedIndex,
+        makeColumnHighlighterIndex,
+    ],
+    (approvers, permission, columns) => {
+        return {
+            subjects(type, subject) {
+                if (type !== undefined && type !== 'columns') {
+                    return approvers.text(subject);
+                }
+                return permission.text(subject);
+            },
+            columns: columns.text,
+
+            approverRows: approvers.row,
+            permissionRows: permission.row,
+            columnRows: columns.row,
+        };
+    },
+);
+
+const getAclLoading = (state, idmKind) => state.acl[idmKind].loading;
+const getAclLoaded = (state, idmKind) => state.acl[idmKind].loaded;
+const getAclError = (state, idmKind) => state.acl[idmKind].error;
+
+export const getAclLoadState = createSelector(
+    [getAclLoading, getAclLoaded, getAclError],
+    (loading, loaded, error) => {
+        return calculateLoadingStatus(loading, loaded, error);
+    },
+);