@giteeteam/apps-team-components 0.3.13 → 1.0.0

package/dist/lib/workflow.d.ts

@@ -1,15 +1,24 @@
+import { CurrentUser } from './contexts/currentUser';
 import { ItemResultProps } from './types/item';
-import { ResultType, TransitionProps } from './types/workflow';
-export declare const StatusTypeKey: {
-    Start: string;
-    InProgress: string;
-    Finished: string;
-};
-export declare enum StatusType {
-    Start = "\u672A\u5F00\u59CB",
-    InProgress = "\u8FDB\u884C\u4E2D",
-    Finished = "\u5DF2\u5B8C\u6210"
+import { ObjectId } from './types/models';
+import { ResultType, TransitionProps, WorkflowPermissionType } from './types/workflow';
+export declare enum ElementEnum {
+    Node = "Node",
+    Edge = "Edge"
+}
+export declare enum NodeEnum {
+    Start = "Start",
+    Task = "Task"
 }
+export type userType = {
+    objectId: string;
+    username: string;
+    nickname: string;
+    email: string;
+    createdAt: string;
+    updatedAt: string;
+};
+export declare const getScriptUser: (user: CurrentUser) => userType;
 export declare const EmptyConditionList: {
     key: string;
     name: string;
@@ -86,26 +95,17 @@ export declare const DropdownConditions: {
         name: string;
     };
 };
-export declare const CustomFieldComponentTypes: {
-    Date: string;
-    Dropdown: string;
-    User: string;
-    Assignee: string;
-    Number: string;
-    LongText: string;
-    Text: string;
-    File: string;
-};
 export declare function isEmptyCondition(key: string): boolean;
-/** 校验用户是否有状态流转操作权限 */
-export declare function checkUserPermission(transition: TransitionProps, userId: string, roleIds: string[], groupIds: string[], values: Record<string, any>): ResultType;
-/** 校验事项 value 字段是否可流转 */
+interface CheckUserPermissionParams {
+    transition: TransitionProps;
+    userId: ObjectId;
+    roleIds: ObjectId[];
+    groupIds: ObjectId[];
+    item: ItemResultProps;
+    workspaceRoleIds: ObjectId[];
+}
+export declare function checkUserPermission({ transition, userId, roleIds, groupIds, item, workspaceRoleIds, }: CheckUserPermissionParams): ResultType;
 export declare function checkItemCondition(transition: TransitionProps, item: ItemResultProps): ResultType;
-/** 校验事项状态是否可流转 */
-export declare function checkTransition(item: ItemResultProps, transition: TransitionProps, userId: string, roleIds: string[], groupIds: string[]): ResultType;
-export declare function checkTransitionScript(scriptText: string, params: {
-    itemId: string;
-    itemType: string;
-    workspace: string;
-    status: string;
-}, sessionToken: string): Promise<ResultType>;
+export declare function checkTransition(item: ItemResultProps, transition: TransitionProps, permissions: WorkflowPermissionType): ResultType;
+export declare const useWorkflowPermission: (workspaceId: ObjectId) => [ObjectId[], ObjectId[], ObjectId[]];
+export {};

package/dist/lib/workflow.js

@@ -0,0 +1,371 @@
+import { useEffect, useState } from 'react';
+import { pick } from 'lodash-es';
+import { SUPPORT_USER_KEYS } from '../components/field-behavior/fields/type';
+import useWorkflowConfig from './hooks/useWorkflowConfig';
+import { getDateType, getFormat } from './date';
+import { CustomFieldComponentTypes } from './global';
+import { i18n } from './i18n';
+export var ElementEnum;
+(function (ElementEnum) {
+    ElementEnum["Node"] = "Node";
+    ElementEnum["Edge"] = "Edge";
+})(ElementEnum || (ElementEnum = {}));
+export var NodeEnum;
+(function (NodeEnum) {
+    NodeEnum["Start"] = "Start";
+    NodeEnum["Task"] = "Task";
+})(NodeEnum || (NodeEnum = {}));
+export const getScriptUser = (user) => {
+    if (!user)
+        return null;
+    return pick(user.toJSON(), [
+        'objectId',
+        'username',
+        'email',
+        'nickname',
+        'createdAt',
+        'updatedAt',
+    ]);
+};
+const EmptyCondition = { key: 'isEmpty', name: '为空' };
+const NotEmptyCondition = { key: 'notEmpty', name: '非空' };
+export const EmptyConditionList = [EmptyCondition, NotEmptyCondition];
+export const NumberConditions = {
+    equalTo: { key: 'equalTo', name: '等于' },
+    greaterThan: { key: 'greaterThan', name: '大于' },
+    greaterThanOrEqualTo: { key: 'greaterThanOrEqualTo', name: '大于等于' },
+    lessThan: { key: 'lessThan', name: '小于' },
+    lessThanOrEqualTo: { key: 'lessThanOrEqualTo', name: '小于等于' },
+    notEqualTo: { key: 'notEqualTo', name: '不等于' },
+    isEmpty: EmptyCondition,
+    notEmpty: NotEmptyCondition,
+};
+export const StringConditions = {
+    equalTo: { key: 'equalTo', name: '等于' },
+    notEqualTo: { key: 'notEqualTo', name: '不等于' },
+    isEmpty: EmptyCondition,
+    notEmpty: NotEmptyCondition,
+};
+export const DropdownConditions = {
+    containedIn: { key: 'containedIn', name: '包含', not: 'File' },
+    notContainedIn: { key: 'notContainedIn', name: '不包含', not: 'File' },
+    isEmpty: EmptyCondition,
+    notEmpty: NotEmptyCondition,
+};
+const ItemFieldType = {
+    name: 'name',
+    itemType: 'itemType',
+    status: 'status',
+    workspace: 'workspace',
+    reporter: 'reporter',
+};
+export function isEmptyCondition(key) {
+    return EmptyConditionList.map(d => d.key).includes(key);
+}
+function numberToCompare(num1, num2, compareString) {
+    switch (compareString) {
+        case NumberConditions.isEmpty.key:
+            return num1 !== 0 && !num1;
+        case NumberConditions.notEmpty.key:
+            return num1 === 0 || !!num1;
+        case NumberConditions.equalTo.key:
+            return num1 === num2;
+        case NumberConditions.greaterThan.key:
+            return num1 > num2;
+        case NumberConditions.greaterThanOrEqualTo.key:
+            return num1 >= num2;
+        case NumberConditions.lessThan.key:
+            return num1 < num2;
+        case NumberConditions.lessThanOrEqualTo.key:
+            return num1 <= num2;
+        case NumberConditions.notEqualTo.key:
+            return num1 !== num2;
+        default:
+            return false;
+    }
+}
+function stringToCompare(str1, str2, compareString) {
+    switch (compareString) {
+        case StringConditions.isEmpty.key:
+            return !str1;
+        case StringConditions.notEmpty.key:
+            return !!str1;
+        case StringConditions.equalTo.key:
+            return str1 === str2;
+        case StringConditions.notEqualTo.key:
+            return str1 !== str2;
+        default:
+            return false;
+    }
+}
+function listToCompare(list1, list2, compareString) {
+    switch (compareString) {
+        case DropdownConditions.isEmpty.key:
+            return !(list1 === null || list1 === void 0 ? void 0 : list1.length);
+        case DropdownConditions.notEmpty.key:
+            return !!(list1 === null || list1 === void 0 ? void 0 : list1.length);
+        case DropdownConditions.containedIn.key:
+            return list2.every(item => list1.includes(item));
+        case DropdownConditions.notContainedIn.key:
+            return list2.every(item => {
+                const r = !list1.includes(item);
+                return r;
+            });
+        default:
+            return false;
+    }
+}
+export function checkUserPermission({ transition, userId, roleIds, groupIds, item, workspaceRoleIds, }) {
+    var _a, _b, _c;
+    const values = (item === null || item === void 0 ? void 0 : item.values) || {};
+    const { users: authUsers, roles: authRoles, groups: authGroups, customFields: authUserFields, workspaceRoles: authWorkspaceRoles, creatorAuth, } = ((_a = transition.parameters) === null || _a === void 0 ? void 0 : _a.permissionType) || {};
+    const hasUsers = (authUsers === null || authUsers === void 0 ? void 0 : authUsers.length) > 0;
+    const hasRoles = (authRoles === null || authRoles === void 0 ? void 0 : authRoles.length) > 0;
+    const hasGroups = (authGroups === null || authGroups === void 0 ? void 0 : authGroups.length) > 0;
+    const hasUserFields = (authUserFields === null || authUserFields === void 0 ? void 0 : authUserFields.length) > 0;
+    const hasWorkspaceRoles = (authWorkspaceRoles === null || authWorkspaceRoles === void 0 ? void 0 : authWorkspaceRoles.length) > 0;
+    const tipText = [];
+    if (!hasUsers && !hasRoles && !hasGroups && !hasUserFields && !hasWorkspaceRoles && !creatorAuth) {
+        return { result: true };
+    }
+    if (creatorAuth) {
+        if (![(_b = item.createdBy) === null || _b === void 0 ? void 0 : _b.objectId, (_c = item.createdBy) === null || _c === void 0 ? void 0 : _c.id].includes(userId)) {
+            tipText.push(i18n.t('pages.workflow.default.userType.creatorAuth'));
+        }
+        else {
+            return { result: true };
+        }
+    }
+    if (hasUsers) {
+        const hasAuth = authUsers.map(user => user.value).includes(userId);
+        if (!hasAuth) {
+            const tipUsers = authUsers.map(user => (user === null || user === void 0 ? void 0 : user.label) || (user === null || user === void 0 ? void 0 : user.children)).join('、');
+            tipText.push(`${i18n.t('libs.workflow.user')}：${tipUsers}`);
+        }
+        else {
+            return { result: true };
+        }
+    }
+    if (hasRoles) {
+        const hasAuth = authRoles.some(role => roleIds.includes(role.value || role.key));
+        if (!hasAuth) {
+            const tipRoles = authRoles.map(role => role.label || role.children).join('、');
+            tipText.push(`${i18n.t('libs.workflow.role')}：${tipRoles}`);
+        }
+        else {
+            return { result: true };
+        }
+    }
+    if (hasGroups) {
+        const hasAuth = authGroups.some(group => groupIds.includes(group.value || group.key));
+        if (!hasAuth) {
+            const tipGroup = authGroups.map(group => group.label || group.children).join('、');
+            tipText.push(`${i18n.t('libs.workflow.group')}：${tipGroup}`);
+        }
+        else {
+            return { result: true };
+        }
+    }
+    if (hasUserFields) {
+        const userFieldObj = pick(values, authUserFields.map(field => field.value || field.key));
+        let hasAuth = false;
+        const keys = Object.keys(userFieldObj);
+        for (let i = 0; i < keys.length; i++) {
+            const fieldObj = userFieldObj[keys[i]];
+            if (fieldObj && fieldObj.length) {
+                hasAuth = fieldObj.map(user => user.value).includes(userId);
+                if (hasAuth)
+                    break;
+            }
+        }
+        if (!hasAuth) {
+            const tipRoles = authUserFields.map(field => field.label || field.children).join('、');
+            tipText.push(`${i18n.t('libs.workflow.userFields')}：${tipRoles}`);
+        }
+        else {
+            return { result: true };
+        }
+    }
+    if (hasWorkspaceRoles) {
+        const hasAuth = authWorkspaceRoles.some(workspaceRole => workspaceRoleIds.includes(workspaceRole.value || workspaceRole.key));
+        if (!hasAuth) {
+            const tipWorkspaceRoles = authWorkspaceRoles
+                .map(workspaceRole => workspaceRole.label || workspaceRole.children)
+                .join('、');
+            tipText.push(`${i18n.t('libs.workflow.workspaceRoles')}：${tipWorkspaceRoles}`);
+        }
+        else {
+            return { result: true };
+        }
+    }
+    if (tipText.length) {
+        return { result: false, message: i18n.t('libs.default.tipText', { text: tipText.join('; ') }) };
+    }
+    return { result: true };
+}
+export function checkItemCondition(transition, item) {
+    var _a, _b;
+    const conditions = ((_a = transition.parameters) === null || _a === void 0 ? void 0 : _a.fieldType) || [];
+    for (const i in conditions) {
+        const { comparedValue, numberCompare, stringCompare, dropDownCompare, field, pickerType } = conditions[i];
+        let fieldValue;
+        if (field.key === ItemFieldType.name) {
+            fieldValue = item.name;
+        }
+        else if (field.key === ItemFieldType.reporter) {
+            const reporter = item[field.key];
+            fieldValue = { label: reporter.username, value: reporter.objectId };
+        }
+        else if ([ItemFieldType.itemType, ItemFieldType.workspace, ItemFieldType.status].includes(field.key)) {
+            fieldValue = item[field.key].objectId;
+        }
+        else {
+            fieldValue = (_b = item.values) === null || _b === void 0 ? void 0 : _b[field.key];
+        }
+        let sourceValue = null, targetValue = null;
+        switch (field.componentType) {
+            case CustomFieldComponentTypes.Number:
+            case CustomFieldComponentTypes.Date:
+                targetValue = comparedValue;
+                if (field.componentType === CustomFieldComponentTypes.Date && NumberConditions.equalTo.key === numberCompare) {
+                    targetValue = getFormat(targetValue || null, getDateType(pickerType));
+                    fieldValue = getFormat(fieldValue || null, getDateType(pickerType));
+                    if (targetValue !== fieldValue) {
+                        return {
+                            result: false,
+                            message: i18n.t('libs.default.flowTextTip.0', {
+                                field: field.children,
+                                condition: i18n.t(`pages.workflow.condition.${NumberConditions[numberCompare].key}`),
+                                target: targetValue,
+                            }),
+                        };
+                    }
+                }
+                else if (!numberToCompare(fieldValue, Number(targetValue), numberCompare)) {
+                    if (isEmptyCondition(numberCompare)) {
+                        return {
+                            result: false,
+                            message: i18n.t('libs.default.flowTextTip.1', {
+                                field: field.children,
+                                condition: i18n.t(`pages.workflow.condition.${NumberConditions[numberCompare].key}`),
+                            }),
+                        };
+                    }
+                    let showValue = comparedValue;
+                    if (field.componentType === CustomFieldComponentTypes.Date) {
+                        showValue = getFormat(comparedValue, getDateType('dateTime'));
+                    }
+                    return {
+                        result: false,
+                        message: i18n.t('libs.default.flowTextTip.0', {
+                            field: field.children,
+                            condition: i18n.t(`pages.workflow.condition.${NumberConditions[numberCompare].key}`),
+                            target: showValue,
+                        }),
+                    };
+                }
+                break;
+            case CustomFieldComponentTypes.Text:
+            case CustomFieldComponentTypes.LongText:
+                targetValue = comparedValue;
+                if (!stringToCompare(fieldValue, targetValue, stringCompare)) {
+                    let message = '';
+                    if (isEmptyCondition(stringCompare)) {
+                        message = i18n.t('libs.default.flowTextTip.1', {
+                            field: field.children,
+                            condition: i18n.t(`pages.workflow.condition.${StringConditions[stringCompare].key}`),
+                        });
+                    }
+                    else {
+                        message = i18n.t('libs.default.flowTextTip.0', {
+                            field: field.children,
+                            condition: i18n.t(`pages.workflow.condition.${StringConditions[stringCompare].key}`),
+                            target: targetValue,
+                        });
+                    }
+                    return {
+                        result: false,
+                        message,
+                    };
+                }
+                break;
+            case CustomFieldComponentTypes.User:
+            case CustomFieldComponentTypes.Dropdown:
+            case CustomFieldComponentTypes.File:
+            case CustomFieldComponentTypes.Assignee:
+            case CustomFieldComponentTypes.Reporter:
+            case CustomFieldComponentTypes.Radio:
+            case CustomFieldComponentTypes.Checkbox:
+                sourceValue = fieldValue || [];
+                if (!(sourceValue instanceof Array)) {
+                    sourceValue = [sourceValue];
+                }
+                if (SUPPORT_USER_KEYS.includes(field.componentType)) {
+                    sourceValue = sourceValue.map(item => item.value);
+                }
+                targetValue = comparedValue ? comparedValue.map(item => item.value) : [];
+                if (!listToCompare(sourceValue, targetValue, dropDownCompare)) {
+                    if (isEmptyCondition(dropDownCompare)) {
+                        return {
+                            result: false,
+                            message: i18n.t('libs.default.flowTextTip.1', {
+                                field: field.children,
+                                condition: i18n.t(`pages.workflow.condition.${DropdownConditions[dropDownCompare].key}`),
+                            }),
+                        };
+                    }
+                    const targetText = comparedValue
+                        ? comparedValue.map(c => (c === null || c === void 0 ? void 0 : c.label) || c.children).join(',')
+                        : '';
+                    return {
+                        result: false,
+                        message: i18n.t('libs.default.flowTextTip.0', {
+                            field: field.children,
+                            condition: i18n.t(`pages.workflow.condition.${DropdownConditions[dropDownCompare].key}`),
+                            target: targetText,
+                        }),
+                    };
+                }
+                break;
+            default:
+                break;
+        }
+    }
+    return { result: true };
+}
+export function checkTransition(item, transition, permissions) {
+    if (!item || !transition)
+        return { result: false };
+    const roleCheck = checkUserPermission({
+        transition,
+        item,
+        ...permissions,
+    });
+    if (!roleCheck.result)
+        return roleCheck;
+    const conditionCheck = checkItemCondition(transition, item);
+    if (!conditionCheck.result)
+        return conditionCheck;
+    return { result: true };
+}
+export const useWorkflowPermission = (workspaceId) => {
+    const [roles, setRoles] = useState([]);
+    const [groups, setGroups] = useState([]);
+    const [workspaceRoles, setWorkspaceRoles] = useState([]);
+    const { fetchRole } = useWorkflowConfig();
+    useEffect(() => {
+        const _fetchRole = async () => {
+            try {
+                const { groups, roles, workspaceRoles } = await fetchRole(workspaceId);
+                setGroups(groups);
+                setWorkspaceRoles(workspaceRoles);
+                setRoles(roles);
+            }
+            catch (error) {
+                console.error(error.message);
+            }
+        };
+        workspaceId && _fetchRole();
+    }, [workspaceId, fetchRole]);
+    return [groups, roles, workspaceRoles];
+};

package/dist/locales/index.d.ts

@@ -0,0 +1,117 @@
+export declare const en: {
+    'pages.users.default.delete': string;
+    'pages.users.default.forbidden': string;
+    'views.common.emptyField.user': string;
+    'views.common.emptyField.null': string;
+    'data.format.week': string;
+    'pages.fields.default.toWorkspacePage': string;
+    'pages.fields.view.noWorkflowOrAuth': string;
+    'pages.fields.view.viewWorkflow': string;
+    'pages.fields.view.unrestrictedStatus': string;
+    'pages.fields.view.approvalStatus': string;
+    'pages.fields.view.checkInStatus': string;
+    'pages.fields.view.readonlyStatus': string;
+    'pages.workflow.default.userType.creatorAuth': string;
+    'pages.workflow.condition.isEmpty': string;
+    'pages.workflow.condition.notEmpty': string;
+    'pages.workflow.condition.equal': string;
+    'pages.workflow.condition.equalTo': string;
+    'pages.workflow.condition.greaterThan': string;
+    'pages.workflow.condition.greaterThanOrEqualTo': string;
+    'pages.workflow.condition.lessThan': string;
+    'pages.workflow.condition.lessThanOrEqualTo': string;
+    'pages.workflow.condition.notEqualTo': string;
+    'pages.workflow.condition.containedIn': string;
+    'pages.workflow.condition.notContainedIn': string;
+    'global.stateless': string;
+    'global.haveDelete': string;
+    'global.columns.forbiddenActive': string;
+    'message.fields.stateFlowSuccess': string;
+    'message.fields.stateFlowFailure': string;
+    'libs.workflow.user': string;
+    'libs.workflow.role': string;
+    'libs.workflow.group': string;
+    'libs.workflow.userFields': string;
+    'libs.workflow.workspaceRoles': string;
+    'libs.default.tipText': string;
+    'libs.default.flowTextTip.0': string;
+    'libs.default.flowTextTip.1': string;
+};
+export declare const zh: {
+    'pages.users.default.delete': string;
+    'pages.users.default.forbidden': string;
+    'views.common.emptyField.user': string;
+    'views.common.emptyField.null': string;
+    'data.format.week': string;
+    'pages.fields.default.toWorkspacePage': string;
+    'pages.fields.view.noWorkflowOrAuth': string;
+    'pages.fields.view.viewWorkflow': string;
+    'pages.fields.view.unrestrictedStatus': string;
+    'pages.fields.view.approvalStatus': string;
+    'pages.fields.view.checkInStatus': string;
+    'pages.fields.view.readonlyStatus': string;
+    'pages.workflow.default.userType.creatorAuth': string;
+    'pages.workflow.condition.isEmpty': string;
+    'pages.workflow.condition.notEmpty': string;
+    'pages.workflow.condition.equal': string;
+    'pages.workflow.condition.equalTo': string;
+    'pages.workflow.condition.greaterThan': string;
+    'pages.workflow.condition.greaterThanOrEqualTo': string;
+    'pages.workflow.condition.lessThan': string;
+    'pages.workflow.condition.lessThanOrEqualTo': string;
+    'pages.workflow.condition.notEqualTo': string;
+    'pages.workflow.condition.containedIn': string;
+    'pages.workflow.condition.notContainedIn': string;
+    'global.stateless': string;
+    'global.haveDelete': string;
+    'global.columns.forbiddenActive': string;
+    'message.fields.stateFlowSuccess': string;
+    'message.fields.stateFlowFailure': string;
+    'libs.workflow.user': string;
+    'libs.workflow.role': string;
+    'libs.workflow.group': string;
+    'libs.workflow.userFields': string;
+    'libs.workflow.workspaceRoles': string;
+    'libs.default.tipText': string;
+    'libs.default.flowTextTip.0': string;
+    'libs.default.flowTextTip.1': string;
+};
+export declare const ru: {
+    'pages.users.default.delete': string;
+    'pages.users.default.forbidden': string;
+    'views.common.emptyField.user': string;
+    'views.common.emptyField.null': string;
+    'data.format.week': string;
+    'pages.fields.default.toWorkspacePage': string;
+    'pages.fields.view.noWorkflowOrAuth': string;
+    'pages.fields.view.viewWorkflow': string;
+    'pages.fields.view.unrestrictedStatus': string;
+    'pages.fields.view.approvalStatus': string;
+    'pages.fields.view.checkInStatus': string;
+    'pages.fields.view.readonlyStatus': string;
+    'pages.workflow.default.userType.creatorAuth': string;
+    'pages.workflow.condition.isEmpty': string;
+    'pages.workflow.condition.notEmpty': string;
+    'pages.workflow.condition.equal': string;
+    'pages.workflow.condition.equalTo': string;
+    'pages.workflow.condition.greaterThan': string;
+    'pages.workflow.condition.greaterThanOrEqualTo': string;
+    'pages.workflow.condition.lessThan': string;
+    'pages.workflow.condition.lessThanOrEqualTo': string;
+    'pages.workflow.condition.notEqualTo': string;
+    'pages.workflow.condition.containedIn': string;
+    'pages.workflow.condition.notContainedIn': string;
+    'global.stateless': string;
+    'global.haveDelete': string;
+    'global.columns.forbiddenActive': string;
+    'message.fields.stateFlowSuccess': string;
+    'message.fields.stateFlowFailure': string;
+    'libs.workflow.user': string;
+    'libs.workflow.role': string;
+    'libs.workflow.group': string;
+    'libs.workflow.userFields': string;
+    'libs.workflow.workspaceRoles': string;
+    'libs.default.tipText': string;
+    'libs.default.flowTextTip.0': string;
+    'libs.default.flowTextTip.1': string;
+};