@nocobase/client 0.7.0-alpha.9 → 0.7.1-alpha.6

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>
-  );
-});

package/src/acl/Configuration/ScopeSelect.tsx

@@ -1,44 +0,0 @@
-import { createForm } from '@formily/core';
-import React, { createContext, useContext, useMemo, useState } from 'react';
-import { FormProvider, SchemaComponent } from '../../schema-component';
-import { scopesSchema } from './schemas/scopes';
-
-const RolesResourcesScopesSelectedRowKeysContext = createContext(null);
-
-const RolesResourcesScopesSelectedRowKeysProvider: React.FC = (props) => {
-  const [keys, setKeys] = useState([]);
-  return (
-    <RolesResourcesScopesSelectedRowKeysContext.Provider value={[keys, setKeys]}>
-      {props.children}
-    </RolesResourcesScopesSelectedRowKeysContext.Provider>
-  );
-};
-
-export const useRolesResourcesScopesSelectedRowKeys = () => {
-  return useContext(RolesResourcesScopesSelectedRowKeysContext);
-};
-
-export const ScopeSelect = (props) => {
-  const form = useMemo(
-    () =>
-      createForm({
-        values: {
-          scope: props.value,
-        },
-      }),
-    [],
-  );
-  return (
-    <FormProvider form={form}>
-      <SchemaComponent
-        components={{ RolesResourcesScopesSelectedRowKeysProvider }}
-        scope={{
-          onChange(value) {
-            props?.onChange?.(value);
-          },
-        }}
-        schema={scopesSchema}
-      />
-    </FormProvider>
-  );
-};

package/src/acl/Configuration/StrategyActions.tsx

@@ -1,117 +0,0 @@
-import { ArrayField } from '@formily/core';
-import { connect, useField } from '@formily/react';
-import { Checkbox, Select, Table, Tag } from 'antd';
-import React from 'react';
-import { useTranslation } from 'react-i18next';
-import { useCompile } from '../..';
-import { useAvailableActions } from './RoleTable';
-
-const toScopes = (value) => {
-  if (!value) {
-    return {};
-  }
-  const scopes = {};
-  value?.forEach?.((item) => {
-    const [name, scope] = item.split(':');
-    scopes[name] = scope || 'all';
-  });
-  return scopes;
-};
-
-const toFieldValue = (scopes) => {
-  const values = [];
-  for (const name in scopes) {
-    if (Object.prototype.hasOwnProperty.call(scopes, name)) {
-      const scope = scopes[name];
-      if (scope === 'all') {
-        values.push(name);
-      } else {
-        values.push(`${name}:${scope}`);
-      }
-    }
-  }
-  return values;
-};
-
-export const StrategyActions = connect((props) => {
-  const { onChange } = props;
-  const availableActions = useAvailableActions();
-  const compile = useCompile();
-  const { t } = useTranslation();
-  const field = useField<ArrayField>();
-  const scopes = toScopes(field.value);
-  return (
-    <div>
-      <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={(e) => {
-                  if (enabled) {
-                    delete scopes[action.name];
-                  } else {
-                    scopes[action.name] = 'all';
-                  }
-                  onChange(toFieldValue(scopes));
-                }}
-              />
-            ),
-          },
-          {
-            dataIndex: 'scope',
-            title: t('Data scope'),
-            render: (scope, action) =>
-              !action.onNewRecord && (
-                <Select
-                  size={'small'}
-                  value={scope}
-                  options={[
-                    { label: t('All records'), value: 'all' },
-                    { label: t('Own records'), value: 'own' },
-                  ]}
-                  onChange={(value) => {
-                    scopes[action.name] = value;
-                    onChange(toFieldValue(scopes));
-                  }}
-                />
-              ),
-          },
-        ]}
-        dataSource={availableActions?.map((item) => {
-          let scope = 'all';
-          let enabled = false;
-          if (scopes[item.name]) {
-            enabled = true;
-            scope = scopes[item.name];
-          }
-          return {
-            ...item,
-            enabled,
-            scope,
-          };
-        })}
-      />
-    </div>
-  );
-});

package/src/acl/Configuration/index.tsx

@@ -1,6 +0,0 @@
-export { MenuConfigure } from './MenuConfigure';
-export { RoleConfigure } from './RoleConfigure';
-export { RolesResourcesActions } from './RolesResourcesActions';
-export { RoleTable } from './RoleTable';
-export { StrategyActions } from './StrategyActions';
-

package/src/acl/Configuration/schemas/roleCollections.ts

@@ -1,211 +0,0 @@
-import { ISchema } from '@formily/react';
-import { useRoleResourceValues } from './useRoleResourceValues';
-import { useSaveRoleResourceAction } from './useSaveRoleResourceAction';
-
-const collection = {
-  name: 'collections',
-  targetKey: 'name',
-  filterTargetKey: 'name',
-  fields: [
-    {
-      type: 'integer',
-      name: 'title',
-      interface: 'input',
-      uiSchema: {
-        title: '{{t("Collection display name")}}',
-        type: 'number',
-        'x-component': 'Input',
-        required: true,
-      } as ISchema,
-    },
-    // {
-    //   type: 'string',
-    //   name: 'name',
-    //   interface: 'input',
-    //   uiSchema: {
-    //     title: '数据表标识',
-    //     type: 'string',
-    //     'x-component': 'Input',
-    //     description: '使用英文',
-    //   } as ISchema,
-    // },
-    {
-      type: 'string',
-      name: 'usingConfig',
-      interface: 'input',
-      uiSchema: {
-        title: '{{t("Permission policy")}}',
-        type: 'string',
-        'x-component': 'Select',
-        enum: [
-          { label: '{{t("Individual")}}', value: 'resourceAction', color: 'orange' },
-          { label: '{{t("General")}}', value: 'strategy', color: 'default' },
-        ],
-      } as ISchema,
-    },
-    {
-      type: 'hasMany',
-      name: 'fields',
-      target: 'fields',
-      collectionName: 'collections',
-      sourceKey: 'name',
-      targetKey: 'name',
-      uiSchema: {},
-    },
-  ],
-};
-
-export const roleCollectionsSchema: ISchema = {
-  type: 'void',
-  'x-decorator': 'ResourceActionProvider',
-  'x-decorator-props': {
-    collection,
-    association: {
-      sourceKey: 'name',
-      targetKey: 'name',
-    },
-    resourceName: 'roles.collections',
-    request: {
-      resource: 'roles.collections',
-      action: 'list',
-      params: {
-        pageSize: 20,
-        filter: { inherit: false },
-        sort: ['sort'],
-        appends: [],
-      },
-    },
-  },
-  properties: {
-    table1: {
-      type: 'void',
-      'x-uid': 'input',
-      'x-component': 'Table.Void',
-      'x-component-props': {
-        rowKey: 'name',
-        // rowSelection: {
-        //   type: 'checkbox',
-        // },
-        useDataSource: '{{ cm.useDataSourceFromRAC }}',
-      },
-      properties: {
-        column1: {
-          type: 'void',
-          'x-decorator': 'Table.Column.Decorator',
-          'x-component': 'Table.Column',
-          properties: {
-            title: {
-              type: 'number',
-              'x-component': 'CollectionField',
-              'x-read-pretty': true,
-            },
-          },
-        },
-        column2: {
-          type: 'void',
-          'x-decorator': 'Table.Column.Decorator',
-          'x-component': 'Table.Column',
-          properties: {
-            name: {
-              type: 'string',
-              'x-component': 'CollectionField',
-              'x-read-pretty': true,
-            },
-          },
-        },
-        column3: {
-          type: 'void',
-          'x-decorator': 'Table.Column.Decorator',
-          'x-component': 'Table.Column',
-          properties: {
-            usingConfig: {
-              type: 'string',
-              'x-component': 'CollectionField',
-              'x-read-pretty': true,
-            },
-          },
-        },
-        column4: {
-          type: 'void',
-          title: '{{t("Actions")}}',
-          'x-component': 'Table.Column',
-          properties: {
-            actions: {
-              type: 'void',
-              'x-component': 'Space',
-              'x-component-props': {
-                split: '|',
-              },
-              properties: {
-                configure: {
-                  type: 'void',
-                  title: '{{t("Configure")}}',
-                  'x-component': 'Action.Link',
-                  'x-component-props': {
-                    type: 'primary',
-                  },
-                  properties: {
-                    drawer: {
-                      type: 'void',
-                      'x-component': 'Action.Drawer',
-                      'x-decorator': 'Form',
-                      'x-decorator-props': {
-                        useValues: useRoleResourceValues,
-                      },
-                      title: '{{t("Configure permission")}}',
-                      properties: {
-                        usingActionsConfig: {
-                          title: '{{t("Permission policy")}}',
-                          'x-component': 'Radio.Group',
-                          'x-decorator': 'FormItem',
-                          default: false,
-                          enum: [
-                            { value: false, label: '{{t("General")}}' },
-                            { value: true, label: '{{t("Individual")}}' },
-                          ],
-                          'x-reactions': {
-                            target: 'actions',
-                            fulfill: {
-                              state: {
-                                hidden: '{{!$self.value}}',
-                              },
-                            },
-                          },
-                        },
-                        actions: {
-                          'x-component': 'RolesResourcesActions',
-                          'x-decorator': 'FormItem',
-                        },
-                        footer: {
-                          type: 'void',
-                          'x-component': 'Action.Drawer.Footer',
-                          properties: {
-                            cancel: {
-                              title: '{{t("Cancel")}}',
-                              'x-component': 'Action',
-                              'x-component-props': {
-                                useAction: '{{ cm.useCancelAction }}',
-                              },
-                            },
-                            submit: {
-                              title: '{{t("Submit")}}',
-                              'x-component': 'Action',
-                              'x-component-props': {
-                                type: 'primary',
-                                useAction: useSaveRoleResourceAction,
-                              },
-                            },
-                          },
-                        },
-                      },
-                    },
-                  },
-                },
-              },
-            },
-          },
-        },
-      },
-    },
-  },
-};