@nocobase/client 0.7.0-alpha.82 → 0.7.1-alpha.4

package/src/acl/ACLProvider.tsx

@@ -1,167 +0,0 @@
-import { useFieldSchema } from '@formily/react';
-import { Spin } from 'antd';
-import React, { createContext, useContext } from 'react';
-import { Redirect } from 'react-router-dom';
-import { useAPIClient, useRequest } from '../api-client';
-import { useCollection } from '../collection-manager';
-import { useRecordIsOwn } from '../record-provider';
-import { SchemaComponentOptions, useDesignable } from '../schema-component';
-
-export const ACLContext = createContext(null);
-
-export const ACLProvider = (props) => {
-  return (
-    <SchemaComponentOptions
-      components={{ ACLCollectionFieldProvider, ACLActionProvider, ACLMenuItemProvider, ACLCollectionProvider }}
-    >
-      {props.children}
-    </SchemaComponentOptions>
-  );
-};
-
-export const ACLRolesCheckProvider = (props) => {
-  const { setDesignable } = useDesignable();
-  const api = useAPIClient();
-  const result = useRequest(
-    {
-      url: 'roles:check',
-    },
-    {
-      onSuccess(data) {
-        if (!data?.data?.allowConfigure && !data?.data?.allowAll) {
-          setDesignable(false);
-        }
-        if (data?.data?.role !== api.auth.role) {
-          api.auth.setRole(data?.data?.role);
-        }
-      },
-    },
-  );
-  if (result.loading) {
-    return <Spin />;
-  }
-  if (result.error) {
-    return <Redirect to={'/signin'} />;
-  }
-  return <ACLContext.Provider value={result}>{props.children}</ACLContext.Provider>;
-};
-
-export const useRoleRecheck = () => {
-  const ctx = useContext(ACLContext);
-  const { allowAll, allowConfigure } = useACLRoleContext();
-  return () => {
-    if (allowAll || allowConfigure) {
-      return;
-    }
-    ctx.refresh();
-  };
-};
-
-export const useACLContext = () => {
-  return useContext(ACLContext);
-};
-
-export const useACLRoleContext = () => {
-  const ctx = useContext(ACLContext);
-  const data = ctx.data?.data;
-
-  return {
-    ...data,
-    getActionParams(path: string, { skipOwnCheck, isOwn }) {
-      const [resourceName, act] = path.split(':');
-      const currentAction = data?.actionAlias?.[act] || act;
-      const hasResource = data?.resources?.includes(resourceName);
-      const params = data?.actions?.[`${resourceName}:${currentAction}`];
-      if (hasResource) {
-        if (!skipOwnCheck && params?.own) {
-          return isOwn ? params : null;
-        }
-        return params;
-      }
-      const strategyActions = data?.strategy?.actions || [];
-      const strategyAction = strategyActions?.find((action) => {
-        const [value] = action.split(':');
-        return value === currentAction;
-      });
-      if (!strategyAction) {
-        return;
-      }
-      if (skipOwnCheck) {
-        return {};
-      }
-      const [, actionScope] = strategyAction.split(':');
-      if (actionScope === 'own') {
-        return isOwn;
-      }
-      return {};
-    },
-  };
-};
-
-export const ACLAllowConfigure = (props) => {
-  const { allowAll, allowConfigure } = useACLRoleContext();
-  if (allowAll || allowConfigure) {
-    return <>{props.children}</>;
-  }
-  return null;
-};
-
-const ACLActionParamsContext = createContext<any>({});
-
-export const ACLCollectionProvider = (props) => {
-  const { allowAll, allowConfigure, getActionParams } = useACLRoleContext();
-  const fieldSchema = useFieldSchema();
-  const isOwn = useRecordIsOwn();
-  if (allowAll || allowConfigure) {
-    return <>{props.children}</>;
-  }
-  const path = fieldSchema['x-acl-action'];
-  const skipScopeCheck = fieldSchema['x-acl-action-props']?.skipScopeCheck;
-  if (!path) {
-    return <>{props.children}</>;
-  }
-  const params = getActionParams(path, { isOwn, skipOwnCheck: skipScopeCheck === false ? false : true });
-  if (!params) {
-    return null;
-  }
-  return <ACLActionParamsContext.Provider value={params}>{props.children}</ACLActionParamsContext.Provider>;
-};
-
-export const ACLActionProvider = (props) => {
-  const { name } = useCollection();
-  const fieldSchema = useFieldSchema();
-  const isOwn = useRecordIsOwn();
-  const { allowAll, allowConfigure, getActionParams } = useACLRoleContext();
-  if (!name || allowAll || allowConfigure) {
-    return <>{props.children}</>;
-  }
-  const actionName = fieldSchema['x-action'];
-  const path = fieldSchema['x-acl-action'] || `${name}:${actionName}`;
-  const skipScopeCheck = fieldSchema['x-acl-action-props']?.skipScopeCheck;
-  const params = getActionParams(path, { skipOwnCheck: skipScopeCheck, isOwn });
-  if (!params) {
-    return null;
-  }
-  return <ACLActionParamsContext.Provider value={params}>{props.children}</ACLActionParamsContext.Provider>;
-};
-
-export const ACLCollectionFieldProvider = (props) => {
-  return <>{props.children}</>;
-};
-
-export const ACLMenuItemProvider = (props) => {
-  const { allowAll, allowConfigure, allowMenuItemIds = [] } = useACLRoleContext();
-  const fieldSchema = useFieldSchema();
-  if (allowAll || allowConfigure) {
-    return <>{props.children}</>;
-  }
-  if (!fieldSchema['x-uid']) {
-    return <>{props.children}</>;
-  }
-  if (allowMenuItemIds.includes(fieldSchema['x-uid'])) {
-    return <>{props.children}</>;
-  }
-  return null;
-};
-
-export default ACLProvider;

package/src/acl/ACLShortcut.tsx

@@ -1,42 +0,0 @@
-import { LockOutlined } from '@ant-design/icons';
-import { ISchema } from '@formily/react';
-import { uid } from '@formily/shared';
-import React, { useState } from 'react';
-import { useTranslation } from 'react-i18next';
-import { PluginManager } from '../plugin-manager';
-import { ActionContext, SchemaComponent } from '../schema-component';
-import * as components from './Configuration';
-
-const schema: ISchema = {
-  type: 'object',
-  properties: {
-    [uid()]: {
-      'x-component': 'Action.Drawer',
-      type: 'void',
-      title: '{{t("Roles & Permissions")}}',
-      properties: {
-        hello1: {
-          type: 'void',
-          'x-component': 'RoleTable',
-        },
-      },
-    },
-  },
-};
-
-export const ACLShortcut = () => {
-  const [visible, setVisible] = useState(false);
-  const { t } = useTranslation();
-  return (
-    <ActionContext.Provider value={{ visible, setVisible }}>
-      <PluginManager.Toolbar.Item
-        icon={<LockOutlined />}
-        title={t('Roles & Permissions')}
-        onClick={() => {
-          setVisible(true);
-        }}
-      />
-      <SchemaComponent components={components} schema={schema} />
-    </ActionContext.Provider>
-  );
-};

package/src/acl/Configuration/MenuConfigure.tsx

@@ -1,110 +0,0 @@
-import { Checkbox, message, Table } from 'antd';
-import React, { useState } from 'react';
-import { useTranslation } from 'react-i18next';
-import { useAPIClient, useRequest } from '../../api-client';
-import { useRecord } from '../../record-provider';
-import { useCompile } from '../../schema-component';
-import { useMenuItems } from './RoleTable';
-
-const findUids = (items) => {
-  if (!Array.isArray(items)) {
-    return [];
-  }
-  const uids = [];
-  for (const item of items) {
-    uids.push(item.uid);
-    uids.push(...findUids(item.children));
-  }
-  return uids;
-};
-
-export const MenuConfigure = () => {
-  const record = useRecord();
-  const api = useAPIClient();
-  const items = useMenuItems();
-  const compile = useCompile();
-  const { t } = useTranslation();
-  const allUids = findUids(items);
-  const [uids, setUids] = useState([]);
-  const { loading, refresh } = useRequest(
-    {
-      resource: 'roles.menuUiSchemas',
-      resourceOf: record.name,
-      action: 'list',
-      params: {
-        paginate: false,
-      },
-    },
-    {
-      onSuccess(data) {
-        setUids(data?.data?.map((schema) => schema['x-uid']) || []);
-      },
-    },
-  );
-  const resource = api.resource('roles.menuUiSchemas', record.name);
-  const allChecked = allUids.length === uids.length;
-  return (
-    <Table
-      loading={loading}
-      rowKey={'uid'}
-      pagination={false}
-      expandable={{
-        defaultExpandAllRows: true,
-      }}
-      columns={[
-        {
-          dataIndex: 'title',
-          title: t('Menu item title'),
-        },
-        {
-          dataIndex: 'accessible',
-          title: (
-            <>
-              <Checkbox
-                checked={allChecked}
-                onChange={async (value) => {
-                  if (allChecked) {
-                    await resource.set({
-                      values: [],
-                    });
-                  } else {
-                    await resource.set({
-                      values: allUids,
-                    });
-                  }
-                  refresh();
-                  message.success(t('Saved successfully'));
-                }}
-              />{' '}
-              {t('Accessible')}
-            </>
-          ),
-          render: (_, schema) => {
-            const checked = uids.includes(schema.uid);
-            return (
-              <Checkbox
-                checked={checked}
-                onChange={async (e) => {
-                  if (checked) {
-                    const index = uids.indexOf(schema.uid);
-                    uids.splice(index, 1);
-                    setUids([...uids]);
-                  } else {
-                    setUids((prev) => [...prev, schema.uid]);
-                  }
-                  await resource.toggle({
-                    values: {
-                      tk: schema.uid,
-                    },
-                  });
-                  message.success(t('Saved successfully'));
-                }}
-              />
-            );
-          },
-        },
-      ]}
-      dataSource={items}
-    />
-  );
-};

package/src/acl/Configuration/RoleConfigure.tsx

@@ -1,68 +0,0 @@
-import { onFieldChange } from '@formily/core';
-import { message } from 'antd';
-import React from 'react';
-import { useTranslation } from 'react-i18next';
-import { useAPIClient, useRequest } from '../../api-client';
-import { useRecord } from '../../record-provider';
-import { SchemaComponent } from '../../schema-component';
-
-export const RoleConfigure = () => {
-  const api = useAPIClient();
-  const record = useRecord();
-  const { t } = useTranslation();
-  return (
-    <SchemaComponent
-      schema={{
-        type: 'void',
-        name: 'form',
-        'x-component': 'Form',
-        'x-component-props': {
-          useValues: (options) => {
-            return useRequest(
-              {
-                resource: 'roles',
-                action: 'get',
-                params: {
-                  filterByTk: record.name,
-                },
-              },
-              options,
-            );
-          },
-          effects() {
-            onFieldChange('*', async (field, form) => {
-              if (!form.modified) {
-                return;
-              }
-              await api.resource('roles').update({
-                filterByTk: record.name,
-                values: form.values,
-              });
-              message.success(t('Saved successfully'));
-            });
-          },
-        },
-        properties: {
-          allowConfigure: {
-            title: t('Configure permissions'),
-            'x-decorator': 'FormItem',
-            'x-component': 'Checkbox',
-            'x-content': t('Allows configuration of the whole system, including UI, collections, permissions, etc.'),
-          },
-          'strategy.actions': {
-            title: t('Global action permissions'),
-            description: t('All collections use general action permissions by default; permission configured individually will override the default one.'),
-            'x-component': 'StrategyActions',
-            'x-decorator': 'FormItem',
-          },
-          allowNewMenu: {
-            title: t('Menu permissions'),
-            'x-decorator': 'FormItem',
-            'x-component': 'Checkbox',
-            'x-content': t('New menu items are allowed to be accessed by default.'),
-          },
-        },
-      }}
-    />
-  );
-};

package/src/acl/Configuration/RoleTable.tsx

@@ -1,70 +0,0 @@
-import { Spin } from 'antd';
-import React, { createContext, useContext } from 'react';
-import { useRequest } from '../../api-client';
-import { useRoute } from '../../route-switch';
-import { SchemaComponent } from '../../schema-component';
-import { roleSchema } from './schemas/roles';
-
-const toItems = (properties = {}) => {
-  const items = [];
-  for (const key in properties) {
-    if (Object.prototype.hasOwnProperty.call(properties, key)) {
-      const element = properties[key];
-      const item = {
-        title: element.title,
-        uid: element['x-uid'],
-      };
-      if (element.properties) {
-        item['children'] = toItems(element.properties);
-      }
-      items.push(item);
-    }
-  }
-  return items;
-};
-
-const AvailableActionsContext = createContext(null);
-const MenuItemsContext = createContext(null);
-
-const AvailableActionsProver: React.FC = (props) => {
-  const { data, loading } = useRequest({
-    resource: 'availableActions',
-    action: 'list',
-  });
-  if (loading) {
-    return <Spin />;
-  }
-  return <AvailableActionsContext.Provider value={data?.data}>{props.children}</AvailableActionsContext.Provider>;
-};
-
-const MenuItemsProver: React.FC = (props) => {
-  const route = useRoute();
-  const { loading, data } = useRequest({
-    url: `uiSchemas:getProperties/${route.uiSchemaUid}`,
-  });
-  if (loading) {
-    return <Spin />;
-  }
-  const items = toItems(data?.data?.properties);
-  return <MenuItemsContext.Provider value={items}>{props.children}</MenuItemsContext.Provider>;
-};
-
-export const useAvailableActions = () => {
-  return useContext(AvailableActionsContext);
-};
-
-export const useMenuItems = () => {
-  return useContext(MenuItemsContext);
-};
-
-export const RoleTable = () => {
-  return (
-    <div>
-      <AvailableActionsProver>
-        <MenuItemsProver>
-          <SchemaComponent schema={roleSchema} />
-        </MenuItemsProver>
-      </AvailableActionsProver>
-    </div>
-  );
-};

package/src/acl/Configuration/RolesResourcesActions.tsx

@@ -1,214 +0,0 @@
-import { FormItem, FormLayout } from '@formily/antd';
-import { ArrayField } from '@formily/core';
-import { connect, useField, useForm } from '@formily/react';
-import { Checkbox, Table, Tag } from 'antd';
-import { isEmpty } from 'lodash';
-import React, { createContext } from 'react';
-import { useTranslation } from 'react-i18next';
-import { useCollectionManager, useCompile, useRecord } from '../..';
-import { useAvailableActions } from './RoleTable';
-import { ScopeSelect } from './ScopeSelect';
-
-const toActionMap = (arr: any[]) => {
-  const obj = {};
-  arr?.forEach?.((action) => {
-    if (action.name) {
-      obj[action.name] = action;
-      obj[action.name]['scope'] = isEmpty(action.scope) ? null : action.scope;
-    }
-  });
-  return obj;
-};
-
-export const RoleResourceCollectionContext = createContext<any>({});
-
-export const RolesResourcesActions = connect((props) => {
-  // const { onChange } = props;
-  const onChange = (values) => {
-    const items = values.map((item) => {
-      return {
-        ...item,
-        scope: isEmpty(item.scope) ? null : item.scope,
-      };
-    });
-    props.onChange(items);
-  };
-  const form = useForm();
-  const roleCollection = useRecord();
-  const availableActions = useAvailableActions();
-  const { getCollection } = useCollectionManager();
-  const collection = getCollection(roleCollection.name);
-  const compile = useCompile();
-  const { t } = useTranslation();
-  const field = useField<ArrayField>();
-  const actionMap: any = toActionMap(field.value || []);
-  const inAction = (actionName, fieldName) => {
-    const action = actionMap?.[actionName];
-    if (!action) {
-      return false;
-    }
-    return action?.fields?.includes(fieldName);
-  };
-  const availableActionsWithFields = availableActions.filter((action) => action.allowConfigureFields);
-  const fieldPermissions = collection?.fields?.filter(field => field.interface)?.map((field) => {
-    const permission = { ...field };
-    for (const action of availableActionsWithFields) {
-      permission[action.name] = inAction(action.name, field.name);
-    }
-    return permission;
-  });
-  const toggleAction = (actionName: string) => {
-    if (actionMap[actionName]) {
-      delete actionMap[actionName];
-    } else {
-      actionMap[actionName] = {
-        name: actionName,
-        fields: collection?.fields?.filter(field => field.interface)?.map?.((item) => item.name),
-      };
-    }
-    onChange(Object.values(actionMap));
-  };
-  const setScope = (actionName, scope) => {
-    if (!actionMap[actionName]) {
-      toggleAction(actionName);
-      actionMap[actionName]['scope'] = scope;
-    } else {
-      actionMap[actionName]['scope'] = scope;
-      onChange(Object.values(actionMap));
-    }
-  };
-  const allChecked = {};
-  for (const action of availableActionsWithFields) {
-    allChecked[action.name] = collection?.fields?.filter(field => field.interface)?.length === actionMap?.[action.name]?.fields?.length;
-  }
-  return (
-    <div>
-      <RoleResourceCollectionContext.Provider value={collection}>
-        <FormLayout layout={'vertical'}>
-          <FormItem label={t('Action permission')}>
-            <Table
-              size={'small'}
-              pagination={false}
-              columns={[
-                {
-                  dataIndex: 'displayName',
-                  title: t('Action display name'),
-                  render: (value) => compile(value),
-                },
-                {
-                  dataIndex: 'onNewRecord',
-                  title: t('Action type'),
-                  render: (onNewRecord) =>
-                    onNewRecord ? (
-                      <Tag color={'green'}>{t('Action on new records')}</Tag>
-                    ) : (
-                      <Tag color={'geekblue'}>{t('Action on existing records')}</Tag>
-                    ),
-                },
-                {
-                  dataIndex: 'enabled',
-                  title: t("Allow"),
-                  render: (enabled, action) => (
-                    <Checkbox
-                      checked={enabled}
-                      onChange={() => {
-                        toggleAction(action.name);
-                      }}
-                    />
-                  ),
-                },
-                {
-                  dataIndex: 'scope',
-                  title: t("Data scope"),
-                  render: (value, action) =>
-                    !action.onNewRecord && (
-                      <ScopeSelect
-                        value={value}
-                        onChange={(scope) => {
-                          setScope(action.name, scope);
-                        }}
-                      />
-                    ),
-                },
-              ]}
-              dataSource={availableActions?.map((item) => {
-                let enabled = false;
-                let scope = null;
-                if (actionMap[item.name]) {
-                  enabled = true;
-                  if (!item.onNewRecord) {
-                    scope = actionMap[item.name]['scope'];
-                  }
-                }
-                return {
-                  ...item,
-                  enabled,
-                  scope,
-                };
-              })}
-            />
-          </FormItem>
-          <FormItem label={t('Field permission')}>
-            <Table
-              pagination={false}
-              dataSource={fieldPermissions}
-              columns={[
-                {
-                  dataIndex: ['uiSchema', 'title'],
-                  title: t('Field display name'),
-                  render: (value) => compile(value),
-                },
-                ...availableActionsWithFields.map((action) => {
-                  const checked = allChecked?.[action.name];
-                  return {
-                    dataIndex: action.name,
-                    title: (
-                      <>
-                        <Checkbox
-                          checked={checked}
-                          onChange={() => {
-                            const item = actionMap[action.name] || {
-                              name: action.name,
-                            };
-                            if (checked) {
-                              item.fields = [];
-                            } else {
-                              item.fields = collection?.fields?.map?.((item) => item.name);
-                            }
-                            actionMap[action.name] = item;
-                            onChange(Object.values(actionMap));
-                          }}
-                        />{' '}
-                        {compile(action.displayName)}
-                      </>
-                    ),
-                    render: (checked, field) => (
-                      <Checkbox
-                        checked={checked}
-                        onChange={() => {
-                          const item = actionMap[action.name] || {
-                            name: action.name,
-                          };
-                          const fields: string[] = item.fields || [];
-                          if (checked) {
-                            const index = fields.indexOf(field.name);
-                            fields.splice(index, 1);
-                          } else {
-                            fields.push(field.name);
-                          }
-                          item.fields = fields;
-                          actionMap[action.name] = item;
-                          onChange(Object.values(actionMap));
-                        }}
-                      />
-                    ),
-                  };
-                }),
-              ]}
-            />
-          </FormItem>
-        </FormLayout>
-      </RoleResourceCollectionContext.Provider>
-    </div>
-  );
-});