admin2 1.0.0

package/src/pages/tw/strategy/experiment/components/ExperimentRuleTable/index.jsx

@@ -0,0 +1,1219 @@
+/**
+ * 实验室专用规则表格组件
+ * 操作列与 admin2 strategyManage 页面对齐
+ */
+import { useCallback, useEffect, useState, useRef, useMemo } from 'react';
+import { Collapse, Popconfirm, message, Empty, Spin, Switch, Tooltip, Popover } from 'antd';
+import _ from 'lodash';
+import { connect } from 'umi';
+import { SMTable } from 'sm-antd';
+
+import SMIcon from '@/components/SMIcon';
+import { SMTips } from '@/components';
+import { useLanguage } from '@/hooks';
+import { formatVariableList } from '@/utils/utils';
+import { AUTH_FUNCTION, SM_ACCOUNT, tableText, RISK_LEVEL_LIST } from '@/contants';
+import { getAuthFunction } from '@/utils/AuthorityManage';
+import { formatUs } from '@/utils/helpers';
+import {
+    defaultVariable,
+    OPERATOR_EXTRA,
+    operaeType,
+} from '@/pages/pageComponents/StrategyPage/contants';
+
+import RuleMdoal from '@/pages/pageComponents/StrategyPage/components/RuleModal';
+import AddListModal from '@/pages/pageComponents/StrategyPage/components/AddRuleMdoal';
+
+import RuleOnlineModal from '../RuleOnlineModal';
+import RuleEventModal from '../RuleEventModal';
+import RuleDiffModal from '../RuleDiffModal';
+import RuleGroupCopyModal from '../RuleGroupCopyModal';
+
+import styles from './index.less';
+
+const { Panel } = Collapse;
+
+const ENVIRONMENT = 'experiment';
+const OPERATE_ONLINE = 'ONLINE';
+
+const RISK_LEVEL_ICON = {
+    PASS: 'tongguo1',
+    REVIEW: 'shenhe',
+    REJECT: 'cuowu',
+};
+
+const formatSubmitData = ({ applyReason, attachment, isCurrentCustomer } = {}) => {
+    if (isCurrentCustomer) {
+        return {};
+    }
+    let files = [];
+    if (attachment && !_.isEmpty(attachment)) {
+        files = _.map(attachment, file => _.get(file, 'response.content.fileUrl'));
+    }
+    return {
+        auditInfo: !_.isNil(applyReason) ? { applyReason, attachment: files } : undefined,
+    };
+};
+
+const ExperimentRuleTable = props => {
+    const {
+        collapseChange,
+        eventId,
+        dispatch,
+        currentUser,
+        currentGlobalFilter,
+        ruleLoading,
+        listData,
+        isGlobal,
+        isSingle,
+        isScene,
+        activeKey,
+        setActiveKey,
+        setSelectedRowKeys,
+        selectedRowKeys,
+        productId,
+        route,
+        group,
+        method,
+        isCurrentCustomer,
+        appSelectList,
+    } = props;
+
+    const {
+        dataSource,
+        risklevelList,
+        ruleList = {},
+        productList,
+        riskMapList,
+        riskTypeList,
+        groupList,
+    } = listData;
+
+    const { contents } = ruleList;
+    const isSM = currentUser.organization === SM_ACCOUNT || isGlobal;
+    const groupData = groupList.filter(item => item.group_code === group);
+
+    const { t } = useLanguage();
+
+    // === States ===
+    const [data, setData] = useState([]);
+    const [loading, setLoading] = useState(false);
+
+    // 模态框状态
+    const [ruleOnlineVisible, setRuleOnlineVisible] = useState(false);
+    const [ruleEventVisible, setRuleEventVisible] = useState(false);
+    const [ruleModalVisible, setRuleModalVisible] = useState(false);
+    const [ruleDiffVisible, setRuleDiffVisible] = useState(false);
+    const [ruleGroupVisible, setRuleGroupVisible] = useState(false);
+
+    const [opType, setOpType] = useState('');
+    const [ruleDetail, setRuleDetail] = useState({});
+    const [ruleSetDetail, setRuleSetDetail] = useState({});
+    const [formParams, setFormParams] = useState({});
+    const [ruleDiffInfo, setRuleDiffInfo] = useState({});
+    const [submitLoading, setSubmitLoading] = useState(false);
+
+    // RuleModal 相关状态
+    const [variableData, setVariableData] = useState([]);
+    const [conditions, setConditions] = useState([]);
+    const [ruleType, setRuleType] = useState(operaeType.ADD);
+    const [record, setRecord] = useState({});
+    const [activityEvent, setActivityEvent] = useState([eventId]);
+    const [activityAppId, setActivityAppId] = useState([]);
+    const [modalLoading, setModalLoading] = useState(false);
+
+    // === 权限 ===
+    const authList = useMemo(() => ({
+        enableOrDisableRule: getAuthFunction(AUTH_FUNCTION.ENABLE_OR_DISABLE_RULE),
+        ruleOnline: getAuthFunction(AUTH_FUNCTION.RULE_ONLINE),
+        updateRule: getAuthFunction(AUTH_FUNCTION.UPDATE_RULE),
+        deleteRule: getAuthFunction(AUTH_FUNCTION.GLOBAL_DELETE_RULE),
+    }), []);
+
+    const listParams = useMemo(() => ({
+        organization: currentGlobalFilter.organization,
+        appId: currentGlobalFilter.appId,
+        eventId,
+        group_code: group,
+        sceneId: undefined,
+    }), [currentGlobalFilter, eventId, group]);
+
+    // === 获取变量列表 ===
+    const getVariableList = useCallback(async () => {
+        setLoading(true);
+        const result = await dispatch({
+            type: 'strategy/variableList',
+            payload: {
+                appId: currentGlobalFilter.appId,
+                enabled: 1,
+                eventId: eventId,
+                organization: currentGlobalFilter.organization,
+            },
+        });
+        setLoading(false);
+        if (result && result.length) {
+            const list = formatVariableList(result);
+            setVariableData(list);
+            return list;
+        }
+        return [];
+    }, [currentGlobalFilter, dispatch, eventId]);
+
+    // === 格式化 meta 为条件数据 ===
+    const getMeta = useCallback((item, list) => {
+        const meta = item.meta;
+        let number = 0;
+        _.keys(meta).forEach(key => {
+            if (key.includes('left')) {
+                number++;
+            }
+        });
+        const lists = list || variableData;
+        const defaultData = defaultVariable(lists, t);
+        const condiatesData = [];
+        for (let i = 0; i < number; i++) {
+            const varItem = lists.filter(v => v.id === (meta[`left${i}_0`] || meta[`left${i}`]));
+            const newData = _.cloneDeep(defaultData);
+            const type = varItem[0] && varItem[0].type;
+            newData.left.definition.default = meta[`left${i}_0`] || meta[`left${i}`];
+            newData.left.definition.var = `left${i}_0`;
+            newData.left.definition.type = type;
+            newData.operator.definition.default = meta[`operator${i}_0`] || meta[`operator${i}`];
+            newData.operator.definition.var = `operator${i}_0`;
+            newData.operator.definition.condiates = OPERATOR_EXTRA[type];
+            newData.rightVal.definition.default = meta[`right${i}_0`] || meta[`right${i}`];
+            newData.rightVal.definition.var = `right${i}_0`;
+            if ((meta[`inputType${i}_0`] || meta[`inputType${i}`]) === 'val') {
+                condiatesData.push([newData.left, newData.operator, newData.rightVal]);
+            } else {
+                newData.rightVar.definition.default = meta[`right${i}_0`] || meta[`right${i}`];
+                newData.rightVar.definition.var = `right${i}_0`;
+                newData.rightVar.definition.condiates = variableData;
+                condiatesData.push([newData.left, newData.operator, newData.rightVar]);
+            }
+        }
+        setConditions(condiatesData);
+    }, [variableData, t]);
+
+    // === 操作: 上线（与 admin strategyManage 一致）===
+    const handleOnline = useCallback(rule => {
+        setOpType(OPERATE_ONLINE);
+        setRuleDetail(rule);
+        setRuleOnlineVisible(true);
+    }, []);
+
+    // 上线提交 -> checkDiffRule -> 打开 DiffModal
+    const toOnline = useCallback(async values => {
+        const { ruleId } = ruleDetail;
+        const { appIds = ['default'], eventIds } = values;
+        const difRule = ruleId.replace('E', 'M');
+        const { sceneId } = listParams;
+        setSubmitLoading(true);
+        const params = {
+            organization: currentGlobalFilter.organization,
+            appId: currentGlobalFilter.appId,
+            eventId,
+            ruleId: difRule,
+            appIds,
+            eventIds,
+            environment: 'online',
+            sceneId: isScene ? sceneId : undefined,
+        };
+        const contents = await dispatch({
+            type: 'strategy/ruleCheckDiffRule',
+            payload: params,
+        });
+        if (contents) {
+            setFormParams(values);
+            setRuleDiffInfo(contents);
+            setRuleDiffVisible(true);
+        }
+        setSubmitLoading(false);
+    }, [ruleDetail, currentGlobalFilter, eventId, dispatch, isScene, listParams]);
+
+    // DiffModal 确认提交
+    const handleDiffSubmit = useCallback(async () => {
+        if (opType !== OPERATE_ONLINE) {
+            return;
+        }
+        const { organization, appId } = currentGlobalFilter;
+        const { eventId: listEventId, sceneId } = listParams;
+        const { ruleId } = ruleDetail;
+        const str = ruleId.replace('E', 'M');
+        const { ratio, appIds = ['default'], eventIds, remark, attachment = [] } = formParams;
+
+        const cRule = _.cloneDeep(ruleDetail);
+        _.set(cRule, 'meta.ruleId', str);
+        _.set(cRule, 'ruleId', str);
+        const operands = _.get(cRule, 'meta._condition.operands', []);
+        const { meta } = cRule;
+        let number = 0;
+        let idx = 0;
+        let isAdd = true;
+        _.keys(meta).forEach(item => {
+            if (item.includes('left')) {
+                number++;
+            }
+        });
+        operands.map((item, index) => {
+            const operandsArr = item.operands;
+            const profile = operandsArr[0].operands[0];
+            if (profile === 'profile.randomid') {
+                idx = index;
+                operandsArr[1].operands[0] = ratio;
+                isAdd = false;
+                item.operator = '<=';
+                cRule.meta[`operator${idx}_0`] = '<=';
+            }
+        });
+        if (isAdd) {
+            const left = { operands: ['profile.randomid'], operator: 'var', type: 'int' };
+            const right = { operands: [ratio], operator: 'val', type: 'int' };
+            operands.push({ operands: [left, right], operator: '<=', type: 'boolean' });
+            cRule.meta[`left${number}_0`] = 'profile.randomid';
+            cRule.meta[`operator${number}_0`] = '<=';
+            cRule.meta[`varType${number}_0`] = 'int';
+            cRule.meta[`inputType${number}_0`] = 'val';
+            cRule.meta[`right${number}_0`] = ratio;
+        } else {
+            cRule.meta[`left${idx}_0`] = 'profile.randomid';
+            cRule.meta[`operator${idx}_0`] = '<=';
+            cRule.meta[`varType${idx}_0`] = 'int';
+            cRule.meta[`inputType${idx}_0`] = 'val';
+            cRule.meta[`right${idx}_0`] = ratio;
+        }
+        for (let i = 0; i < operands.length; i++) {
+            cRule.meta[`boxItemLength${i}`] = '1';
+        }
+        const newParams = {
+            organization,
+            eventIds,
+            appIds,
+            oldRule: ruleDetail,
+            newRule: {
+                ...cRule,
+                organization,
+                appId,
+                eventId: listEventId,
+                ...(isScene ? { sceneId } : {}),
+            },
+            ...formatSubmitData({ applyReason: remark, attachment, isCurrentCustomer }),
+        };
+        const result = await dispatch({
+            type: 'strategy/ruleToOnline',
+            payload: newParams,
+        });
+        if (result) {
+            setRuleDiffVisible(false);
+            setRuleOnlineVisible(false);
+            method.getRuleList && method.getRuleList(ruleDetail.ruleSetId);
+        }
+    }, [opType, ruleDetail, formParams, currentGlobalFilter, dispatch, isScene, listParams, isCurrentCustomer, method]);
+
+    // === 操作: 查看 ===
+    const handleView = useCallback(async rule => {
+        setRecord(rule);
+        setRuleType(operaeType.VIEW);
+        const list = await getVariableList();
+        getMeta(rule, list);
+        setRuleModalVisible(true);
+    }, [getVariableList, getMeta]);
+
+    // === 操作: 修改（先选事件，再编辑规则） ===
+    const handleModify = useCallback((rule, ruleSet) => {
+        setOpType('modify');
+        setRuleDetail(rule);
+        setRecord(rule);
+        setRuleSetDetail(ruleSet);
+        setRuleType(operaeType.UPDATE);
+        setActivityEvent([eventId]);
+        setRuleEventVisible(true);
+    }, [eventId]);
+
+    // 启用/禁用：选范围后直接生效（与 admin strategyManage 一致）
+    const updateRuleStatus = useCallback(async (detail, values) => {
+        const { organization, appId } = currentGlobalFilter;
+        const { appIds = ['default'], eventIds } = values;
+        const params = {
+            organization,
+            eventIds,
+            appIds,
+            rule: {
+                ...detail,
+                organization,
+                appId,
+                eventId,
+            },
+            environment: ENVIRONMENT,
+        };
+        const result = await dispatch({
+            type: 'strategy/updateRule',
+            payload: params,
+        });
+        if (result) {
+            setRuleEventVisible(false);
+            method.getRuleList && method.getRuleList(detail.ruleSetId);
+        }
+        return result;
+    }, [currentGlobalFilter, eventId, dispatch, method]);
+
+    // 事件选择提交
+    const handleEventSubmit = useCallback(async values => {
+        if (opType === 'disable' || opType === 'enable') {
+            setModalLoading(true);
+            try {
+                await updateRuleStatus(ruleDetail, values);
+            } finally {
+                setModalLoading(false);
+            }
+            return;
+        }
+
+        if (opType === 'DEL') {
+            setModalLoading(true);
+            try {
+                const { eventIds } = values;
+                const { organization, appId, ruleId } = ruleDetail;
+                const list = _.map(eventIds, item => {
+                    const [evtId, sceneId] = _.split(item, '#');
+                    return {
+                        organization,
+                        appId,
+                        eventId: evtId,
+                        ruleId,
+                        group_code: group,
+                        sceneId,
+                    };
+                });
+                const result = await dispatch({
+                    type: 'strategy/deleteRule',
+                    payload: list,
+                });
+                if (result) {
+                    setRuleEventVisible(false);
+                    method.getRuleList && method.getRuleList(ruleDetail.ruleSetId);
+                }
+            } finally {
+                setModalLoading(false);
+            }
+            return;
+        }
+
+        setModalLoading(true);
+        setFormParams({
+            environment: ENVIRONMENT,
+            rule: ruleDetail,
+            ...values,
+        });
+        setActivityAppId(values.appIds || [currentGlobalFilter.appId]);
+        setActivityEvent(values.eventIds || [eventId]);
+
+        // 获取变量列表
+        const defaultEventId = values.eventIds && values.eventIds.length === 1
+            ? values.eventIds[0] : eventId;
+        const result = await dispatch({
+            type: 'strategy/variableList',
+            payload: {
+                appId: currentGlobalFilter.appId,
+                enabled: 1,
+                eventId: defaultEventId,
+                organization: currentGlobalFilter.organization,
+            },
+        });
+        if (result && result.length) {
+            const list = formatVariableList(result);
+            setVariableData(list);
+            if (opType === 'modify') {
+                getMeta(ruleDetail, list);
+            }
+        }
+        setRuleEventVisible(false);
+        setRuleModalVisible(true);
+        setModalLoading(false);
+    }, [currentGlobalFilter, eventId, dispatch, opType, ruleDetail, getMeta, updateRuleStatus, group, method]);
+
+    // === 操作: 删除（非场景：直接删；场景：先弹框选范围）===
+    const handleDelete = useCallback(async rule => {
+        const result = await dispatch({
+            type: 'strategy/deleteRule',
+            payload: [{
+                organization: currentGlobalFilter.organization,
+                appId: currentGlobalFilter.appId,
+                eventId,
+                ruleId: rule.ruleId,
+                group_code: group,
+            }],
+        });
+        if (result) {
+            method.getRuleList && method.getRuleList(rule.ruleSetId);
+        }
+    }, [dispatch, currentGlobalFilter, eventId, group, method]);
+
+    const handleDeleteClick = useCallback((rule, ruleSet) => {
+        if (rule.enabled !== 0) {
+            message.warning('请先禁用再删除~');
+            return;
+        }
+        setOpType('DEL');
+        setRuleDetail(rule);
+        setRuleSetDetail(ruleSet);
+        setRuleEventVisible(true);
+    }, []);
+
+    // === 操作: 复制分组规则 ===
+    const handleCopyGroup = useCallback(rule => {
+        setOpType('copy');
+        setRuleDetail(rule);
+        setRuleGroupVisible(true);
+    }, []);
+
+    const handleCopyGroupSubmit = useCallback(async values => {
+        const { meta } = ruleDetail;
+        const { organization } = currentGlobalFilter;
+        const { ruleId } = values;
+        const list = groupList.filter(item => item.group_code === values.group_code);
+        const params = {
+            organization,
+            appIds: [currentGlobalFilter.appId],
+            eventIds: [eventId],
+            environment: ENVIRONMENT,
+            ruleId,
+            rule: {
+                ..._.omit(ruleDetail, 'id'),
+                meta: {
+                    ...meta,
+                    group_variable: _.get(list, '0.group_variable', ''),
+                    group_value: _.get(list, '0.group_value', ''),
+                    ruleId,
+                },
+                ..._.omit(values, 'results'),
+            },
+        };
+        const result = await dispatch({
+            type: 'strategy/addRule',
+            payload: params,
+        });
+        if (result) {
+            setRuleGroupVisible(false);
+            method.getRuleSetList && method.getRuleSetList();
+        }
+        return result;
+    }, [ruleDetail, currentGlobalFilter, eventId, groupList, dispatch, method]);
+
+    // === 操作: 状态切换（启用/禁用）- 先弹框选范围 ===
+    const handleStatusClick = useCallback((rule, ruleSet) => {
+        const checked = +rule.enabled === 1;
+        const newRule = _.cloneDeep(rule);
+        newRule.enabled = checked ? 0 : 1;
+        setRuleSetDetail(ruleSet);
+        setRuleDetail(newRule);
+        setOpType(checked ? 'disable' : 'enable');
+        setRuleEventVisible(true);
+    }, []);
+
+    // === 规则提交 (新增/修改) ===
+    const getRiskReasons = riskReasons => {
+        let result = { operator: 'concat', operands: [], type: 'string' };
+        if (riskReasons) {
+            riskReasons = String(riskReasons);
+            riskReasons = _.trim(riskReasons);
+            if (!riskReasons) {
+                result = {};
+            } else {
+                const reg = /\${[\w\d\.\-_$]+}/ig;
+                const matches = riskReasons.match(reg);
+                const riskReasonArr = riskReasons.split(reg);
+                const operands = [];
+                for (let i = 0; i < riskReasonArr.length; i++) {
+                    const word = riskReasonArr[i];
+                    let variable = matches ? matches[i] : null;
+                    if (word) {
+                        operands.push({ operator: 'val', operands: [word] });
+                    }
+                    if (variable) {
+                        variable = variable.replace(/(\${)|(})/ig, '');
+                        operands.push({ operator: 'var', operands: [variable] });
+                    }
+                }
+                result.operands = operands;
+            }
+        } else {
+            result = {};
+        }
+        return result;
+    };
+
+    const getBaseInfo = useCallback(originData => {
+        const { score, riskTypeName, riskReasons, ruleName } = originData;
+        const riskTypeNameIsNum = /^\d+$/.test(riskTypeName);
+        let baseInfo = {
+            score: { operator: 'val', operands: score, type: 'int' },
+        };
+        if (!riskTypeNameIsNum && riskTypeName) {
+            baseInfo.ruleNameDesc = getRiskReasons(ruleName);
+            baseInfo.riskReasons = riskReasons
+                ? getRiskReasons(`${riskTypeName}：${riskReasons}`)
+                : getRiskReasons(riskTypeName);
+        }
+        if (riskTypeNameIsNum) {
+            baseInfo.ruleNameDesc = getRiskReasons(ruleName);
+            baseInfo.riskReasons = getRiskReasons(ruleName);
+        }
+        return baseInfo;
+    }, []);
+
+    const formatCondition = useCallback(originData => {
+        let conds = [];
+        for (let key in originData) {
+            const reg = /left(\d+(?:_\d+)?)/;
+            const matches = key.match(reg);
+            if (matches && matches.length) {
+                const index = matches[1];
+                const rightValue = (originData[`right${index}`] || '').replace(/\s+/g, '');
+                conds.push([{
+                    left: originData[`left${index}`],
+                    operator: originData[`operator${index}`],
+                    right: rightValue,
+                    varType: originData[`varType${index}`],
+                    inputType: originData[`inputType${index}`],
+                }]);
+            }
+        }
+        return conds;
+    }, []);
+
+    const getOperands = (_condition, _operands) => {
+        let rightVal = _condition.right;
+        let isArrayString = rightVal.indexOf(',') !== -1;
+        if (_condition.inputType === 'val' && _condition.varType === 'string' && !isArrayString) {
+            rightVal = _condition.right;
+        }
+        if (_condition.inputType === 'val' && _condition.varType === 'boolean') {
+            rightVal = _condition.right.toUpperCase();
+        }
+        if (_condition.operator === 'notSubsetp') {
+            _operands.push({
+                operator: 'not',
+                operands: [{
+                    operator: 'subsetp',
+                    operands: [{
+                        operator: 'var', operands: [_condition.left], type: _condition.varType,
+                    }, {
+                        operator: _condition.inputType, operands: rightVal.split(','), type: _condition.varType,
+                    }],
+                    type: 'boolean',
+                }],
+                type: 'blooean',
+            });
+        } else {
+            _operands.push({
+                operator: _condition.operator,
+                operands: [{
+                    operator: 'var', operands: [_condition.left], type: _condition.varType,
+                }, {
+                    operator: _condition.inputType, operands: rightVal.split(','), type: _condition.varType,
+                }],
+                type: 'boolean',
+            });
+        }
+        return _operands;
+    };
+
+    const getCondition = useCallback(originData => {
+        const conds = formatCondition(originData);
+        let operands = [];
+        conds.forEach(condition => {
+            if (condition.length === 1) {
+                operands = getOperands(condition[0], operands);
+            } else {
+                let orOperands = [];
+                for (let i = 0; i < condition.length; i++) {
+                    orOperands = getOperands(condition[i], orOperands);
+                }
+                operands.push({ operator: 'or', operands: orOperands, type: 'blooean' });
+            }
+        });
+        return { operator: 'and', operands, type: 'blooean' };
+    }, [formatCondition]);
+
+    const ruleSubmit = useCallback(async val => {
+        // 构建 meta
+        const example = {};
+        let outerExample = {};
+        let isNull = false;
+        conditions.forEach((item, index) => {
+            const rightValue = item[2].definition.default;
+            const leftValue = item[0].definition.default;
+            const operatorValue = item[1].definition.default;
+            const inputType = item[2].definition.inputType;
+            const leftType = item[0].definition.type;
+            if (!rightValue || !leftValue || !operatorValue) {
+                isNull = true;
+                return;
+            }
+            let rightForCondition = rightValue;
+            if (inputType === 'val' && leftType === 'string' && !rightValue.includes(',')) {
+                rightForCondition = `"${rightValue}"`;
+            }
+            example[`left${index}_0`] = leftValue;
+            example[`varType${index}_0`] = leftType;
+            example[`operator${index}_0`] = operatorValue;
+            example[`right${index}_0`] = rightForCondition;
+            example[`boxItemLength${index}`] = '1';
+            example[`inputType${index}_0`] = inputType;
+            outerExample[`boxItemLength${index}`] = '1';
+            outerExample[`left${index}_0`] = leftValue;
+            outerExample[`varType${index}_0`] = leftType;
+            outerExample[`operator${index}_0`] = operatorValue;
+            outerExample[`right${index}_0`] = rightValue;
+            outerExample[`inputType${index}_0`] = inputType;
+        });
+        if (isNull) {
+            message.warning(t('条件不能为空'));
+            return;
+        }
+        const meta = {
+            const: [],
+            _result: [],
+            _phase: 'common',
+            _customTemplate: 1,
+            _baseInfo: getBaseInfo(val),
+            _condition: getCondition(example),
+            ruleId: val.ruleId,
+            score: val.score,
+            marker: val.marker,
+            pullBlack: (val.isBlack === '0' || !val.isBlack) ? '0' : '1',
+            riskLevel: val.riskLevel,
+            riskType: val.riskType,
+            ruleName: val.ruleName,
+            riskReasons: val.riskReasons,
+            riskTypeName: val.riskTypeName,
+            group_value: _.get(groupData, '0.group_value', ''),
+            group_variable: _.get(groupData, '0.group_variable', ''),
+            ...outerExample,
+        };
+        if (val.verifytype) {
+            meta.verifyType = val.verifytype;
+        }
+        if (val?.blackFields?.fields?.length > 0 && val.isBlack === '1') {
+            meta.blackFields = val.blackFields;
+        }
+
+        // 修改规则：参数结构与 admin strategyManage addOrModifyRule(modify) 一致
+        if (opType === 'modify') {
+            const { meta: originalMeta = {}, enabled } = ruleDetail;
+            const { blackFields } = originalMeta;
+            const { organization, appId } = currentGlobalFilter;
+            const { appIds = ['default'], eventIds } = formParams;
+            const { ruleId, ruleName, riskLevel, riskType, marker } = val;
+            const group_variable = _.get(groupData, '0.group_variable', '');
+            const group_value = _.get(groupData, '0.group_value', '');
+
+            let params = {
+                appIds,
+                eventIds,
+                rule: {
+                    ruleId,
+                    ruleName,
+                    riskLevel,
+                    riskType,
+                    marker,
+                    ruleSetId: ruleSetDetail.ruleSetId,
+                    enabled,
+                    group_code: group,
+                    templateId: 'T0000',
+                    meta: {
+                        ...meta,
+                        blackFields,
+                        group_variable,
+                        group_value,
+                    },
+                },
+                ruleId,
+                environment: ENVIRONMENT,
+            };
+            params = {
+                id: ruleDetail.id,
+                organization,
+                ...params,
+                rule: {
+                    organization,
+                    appId,
+                    eventId,
+                    ...params.rule,
+                },
+            };
+
+            const result = await dispatch({
+                type: 'strategy/updateRule',
+                payload: params,
+            });
+            if (result) {
+                setRuleModalVisible(false);
+                method.getRuleList && method.getRuleList(ruleSetDetail.ruleSetId);
+            }
+            return;
+        }
+
+        let obj = {
+            appId: currentGlobalFilter.appId,
+            creator: currentUser.account,
+            enabled: 1,
+            eventId,
+            isFinalCounter: 0,
+            isOpen: 0,
+            marker: val.marker,
+            organization: currentGlobalFilter.organization,
+            riskLevel: val.riskLevel,
+            riskType: val.riskType,
+            ruleName: val.ruleName,
+            templateId: 'T0000',
+            ruleSetId: record.ruleSetId,
+            group_code: group,
+            ruleId: val.ruleId,
+            meta,
+        };
+        if (val.verifytype) {
+            obj.verifyType = val.verifytype;
+        }
+        const params = {
+            organization: currentGlobalFilter.organization,
+            appIds: activityAppId.length ? activityAppId : [currentGlobalFilter.appId],
+            eventIds: activityEvent,
+            ruleId: val.ruleId,
+            environment: ENVIRONMENT,
+            rule: obj,
+        };
+        const result = await dispatch({
+            type: 'strategy/addRule',
+            payload: params,
+        });
+        if (result) {
+            setRuleModalVisible(false);
+            method.getRuleSetList && method.getRuleSetList();
+        }
+    }, [
+        conditions, getBaseInfo, getCondition, currentGlobalFilter,
+        currentUser, eventId, record, group, groupData,
+        activityAppId, activityEvent, dispatch, method, t,
+        opType, ruleDetail, ruleSetDetail, formParams,
+    ]);
+
+    // === 变量变化回调 ===
+    const variableChange = useCallback(val => {
+        let number = 0;
+        const data = _.cloneDeep(conditions);
+        _.keys(val).forEach(item => {
+            if (item.includes('left')) {
+                number++;
+            }
+        });
+        for (let i = 0; i < number; i++) {
+            const obj = variableData.filter(item => item.id === val[`left${i}_0`])[0];
+            try {
+                data[i][1].definition.condiates = OPERATOR_EXTRA[obj.type];
+                data[i][0].definition.type = obj.type;
+                data[i][0].definition.default = val[`left${i}_0`];
+                data[i][1].definition.default = val[`operator${i}_0`];
+                data[i][2].definition.default = val[`right${i}_0`];
+            } catch (error) {}
+        }
+        setConditions(data);
+    }, [conditions, variableData]);
+
+    // 操作弹窗事件选项：汇总所有产品下的事件（与 admin2 strategyManage allEventSelectList 一致）
+    const allEventSelectList = useMemo(() => {
+        let list = [];
+        productList.map(item => {
+            list = list.concat(item.events || []);
+        });
+        return list;
+    }, [productList]);
+
+    const ruleSetDiff = useCallback(async val => {
+        if (!activityEvent.length) {
+            message.error(t('事件不能为空'));
+            return;
+        }
+        setModalLoading(true);
+        setActivityAppId(val.appId || [currentGlobalFilter.appId]);
+        setActivityEvent(val.eventId || [eventId]);
+        const result = await dispatch({
+            type: 'strategy/ruleSetIsExist',
+            payload: {
+                appIds: val.appId || [currentGlobalFilter.appId],
+                eventIds: val.eventId || activityEvent,
+                organization: currentGlobalFilter.organization,
+                ruleSetId: record.ruleSetId,
+            },
+        });
+        if (result && result.length) {
+            message.warning('以下情况不存在该策略集，请重新调整');
+        } else {
+            const defaultEventId = (val.eventId && val.eventId.length === 1)
+                ? val.eventId[0] : eventId;
+            const varResult = await dispatch({
+                type: 'strategy/variableList',
+                payload: {
+                    appId: currentGlobalFilter.appId,
+                    enabled: 1,
+                    eventId: defaultEventId,
+                    organization: currentGlobalFilter.organization,
+                },
+            });
+            if (varResult && varResult.length) {
+                const list = formatVariableList(varResult);
+                setVariableData(list);
+                if (ruleType === operaeType.UPDATE) {
+                    getMeta(record, list);
+                }
+            }
+            setRuleModalVisible(true);
+        }
+        setModalLoading(false);
+    }, [activityEvent, dispatch, record, currentGlobalFilter, getMeta, ruleType, eventId, t]);
+
+    // === 新增规则（面板头部按钮触发）===
+    const addRule = useCallback((e, item) => {
+        e.stopPropagation();
+        setRecord(item);
+        setRuleType(operaeType.ADD);
+        const data = defaultVariable(variableData, t);
+        setConditions([[data.left, data.operator, data.rightVal]]);
+        setRuleEventVisible(true);
+        setOpType('add');
+        setRuleSetDetail(item);
+        setActivityEvent([eventId]);
+    }, [eventId, variableData, t]);
+
+    // 处置建议展示（与策略管理 policy/list 一致）
+    const riskLevelRender = useCallback((text, record) => {
+        const result = RISK_LEVEL_LIST.filter(
+            item => item.value === record.riskLevel || item.name === text
+        );
+        if (result.length) {
+            return (
+                <div>
+                    <SMIcon type={`icon-${RISK_LEVEL_ICON[result[0].value] || 'shenhe'}`} />
+                    <span style={{ marginLeft: 10 }}>{t(result[0].name)}</span>
+                </div>
+            );
+        }
+        return <span>{text}</span>;
+    }, [t]);
+
+    // === 表格列定义 ===
+    const getRuleColumns = useCallback(ruleSet => {
+        const style = { marginLeft: 5 };
+        return [
+            {
+                title: t('规则名称'),
+                dataIndex: 'ruleName',
+                key: 'ruleName',
+                ellipsis: true,
+                render: ruleName => (
+                    <Popover content={ruleName} trigger="hover">
+                        {ruleName}
+                    </Popover>
+                ),
+            },
+            {
+                title: t('规则标识'),
+                dataIndex: 'ruleId',
+                key: 'ruleId',
+                render: ruleId => <span>{ruleId}</span>,
+            },
+            {
+                title: t('处置建议'),
+                dataIndex: 'riskLevelStr',
+                key: 'riskLevelStr',
+                render: (text, record) => riskLevelRender(text, record),
+            },
+            {
+                title: t('状态'),
+                dataIndex: 'enabledStr',
+                key: 'enabledStr',
+                render: (enabledStr, rule) => {
+                    const checked = +rule.enabled === 1;
+                    const hasPermission = authList.enableOrDisableRule;
+                    return (
+                        <Tooltip placement="top" title={t('启用/关闭规则')}>
+                            <a
+                                href="###"
+                                style={style}
+                                onClick={e => {
+                                    e.preventDefault();
+                                    if (hasPermission) {
+                                        handleStatusClick(rule, ruleSet);
+                                    }
+                                }}
+                            >
+                                <Switch
+                                    checkedChildren={t('启用中')}
+                                    unCheckedChildren={t('关闭中')}
+                                    checked={checked}
+                                    disabled={!hasPermission}
+                                />
+                            </a>
+                        </Tooltip>
+                    );
+                },
+            },
+            {
+                title: t('规则类型'),
+                dataIndex: 'ruleStatusStr',
+                key: 'ruleStatusStr',
+                render: ruleStatusStr => <span>{ruleStatusStr}</span>,
+            },
+            {
+                title: t('备注'),
+                dataIndex: 'marker',
+                key: 'marker',
+                ellipsis: true,
+                render: marker => (
+                    <Popover content={marker || '-'} trigger="hover">
+                        {marker || '-'}
+                    </Popover>
+                ),
+            },
+            {
+                title: t('操作'),
+                dataIndex: 'operator',
+                key: 'operator',
+                align: 'center',
+                render: (_, rule) => {
+                    const { ruleStatus, enabled } = rule;
+                    const canClose = (isGlobal && ruleStatus === 0)
+                        || (isSingle && ruleStatus === 1)
+                        || (isScene && ruleStatus === 2)
+                        || (productId && ruleStatus === 3);
+                    return (
+                        <>
+                            {authList.ruleOnline && (
+                                <a
+                                    href="###"
+                                    style={style}
+                                    onClick={e => {
+                                        e.preventDefault();
+                                        handleOnline(rule);
+                                    }}
+                                >
+                                    {t('上线')}
+                                </a>
+                            )}
+                            <a
+                                href="###"
+                                style={style}
+                                onClick={e => {
+                                    e.preventDefault();
+                                    handleView(rule);
+                                }}
+                            >
+                                {t('查看')}
+                            </a>
+                            {authList.updateRule && (
+                                <a
+                                    href="###"
+                                    style={style}
+                                    onClick={e => {
+                                        e.preventDefault();
+                                        handleModify(rule, ruleSet);
+                                    }}
+                                >
+                                    {t('修改')}
+                                </a>
+                            )}
+                            {authList.deleteRule && canClose && (
+                                isScene ? (
+                                    <a
+                                        href="###"
+                                        style={style}
+                                        onClick={e => {
+                                            e.preventDefault();
+                                            handleDeleteClick(rule, ruleSet);
+                                        }}
+                                    >
+                                        {t('删除')}
+                                    </a>
+                                ) : (
+                                    <Popconfirm
+                                        placement="topRight"
+                                        title={t('确认删除规则吗?')}
+                                        okText={t('确认')}
+                                        cancelText={t('取消')}
+                                        onConfirm={() => {
+                                            if (enabled !== 0) {
+                                                message.warning('请先禁用再删除~');
+                                                return;
+                                            }
+                                            handleDelete(rule);
+                                        }}
+                                    >
+                                        <a href="###" style={style}>
+                                            {t('删除')}
+                                        </a>
+                                    </Popconfirm>
+                                )
+                            )}
+                        </>
+                    );
+                },
+            },
+        ];
+    }, [
+        t, authList, handleOnline, handleView, handleModify, handleDelete,
+        handleDeleteClick, handleStatusClick, isGlobal, isSingle, isScene, productId,
+        riskLevelRender,
+    ]);
+
+    // === 面板头部 ===
+    const headerDom = useCallback(item => {
+        return (
+            <div className={styles['header-content']}>
+                <div>
+                    {item.ruleSetName}({t('规则总数')}:{item.ruleCount}, {t('运行中规则')}:{item.enableRuleCount})
+                </div>
+                <div>
+                    {isGlobal && authList.createRule && (
+                        <SMIcon type="icon-xinzeng" onClick={e => addRule(e, item)} />
+                    )}
+                </div>
+            </div>
+        );
+    }, [addRule, isGlobal, authList, t]);
+
+    // === 面板渲染 ===
+    const getCollapse = useCallback(() => {
+        if (!dataSource.length) {
+            return <Empty className={styles.empty} />;
+        }
+        return dataSource.map(item => (
+            <Panel key={item.ruleSetId} showArrow={false} header={headerDom(item)}>
+                <SMTable
+                    dataSource={data}
+                    columns={getRuleColumns(item)}
+                    loading={ruleLoading}
+                    i18nText={tableText(t)}
+                    isHidePagination
+                    totalCount={data && data.length}
+                />
+            </Panel>
+        ));
+    }, [dataSource, data, getRuleColumns, headerDom, ruleLoading, t]);
+
+    // === Effects ===
+    useEffect(() => {
+        setData(contents || []);
+        setActiveKey(contents && contents.length && contents[0].ruleSetId);
+    }, [contents, setActiveKey]);
+
+    useEffect(() => {
+        setActivityEvent([eventId]);
+    }, [eventId]);
+
+    useEffect(() => {
+        setActivityAppId([currentGlobalFilter.appId]);
+    }, [currentGlobalFilter]);
+
+    return (
+        <div className={styles['experiment-rule-table']}>
+            <div className={styles['experiment-tips']}>
+                <SMTips
+                    background
+                    style={{ padding: '6px 14px' }}
+                    title="温馨提示：实验室仅保留近20天调整的规则，请您及时上线。"
+                />
+            </div>
+            <Spin spinning={loading}>
+                <Collapse
+                    activeKey={activeKey}
+                    onChange={val => {
+                        setSelectedRowKeys([]);
+                        const newVal = val.length ? val[val.length - 1] : '';
+                        setActiveKey(newVal);
+                        collapseChange(newVal);
+                    }}
+                >
+                    {getCollapse()}
+                </Collapse>
+
+                {/* 上线模态框 */}
+                {ruleOnlineVisible && (
+                    <RuleOnlineModal
+                        isVisible={ruleOnlineVisible}
+                        opType={opType}
+                        ruleDetail={ruleDetail}
+                        loading={submitLoading}
+                        organization={currentGlobalFilter.organization}
+                        listParams={listParams}
+                        appSelectList={appSelectList}
+                        allEventSelectList={allEventSelectList}
+                        isScene={isScene}
+                        showRemark={!isCurrentCustomer}
+                        onSubmit={toOnline}
+                        onCancel={() => setRuleOnlineVisible(false)}
+                    />
+                )}
+
+                {/* 策略对比模态框 */}
+                {ruleDiffVisible && (
+                    <RuleDiffModal
+                        isVisible={ruleDiffVisible}
+                        organization={currentGlobalFilter.organization}
+                        ruleDiffInfo={ruleDiffInfo}
+                        onSubmit={handleDiffSubmit}
+                        onCancel={() => setRuleDiffVisible(false)}
+                    />
+                )}
+
+                {/* 事件选择模态框 */}
+                {ruleEventVisible && (
+                    <RuleEventModal
+                        isVisible={ruleEventVisible}
+                        opType={opType}
+                        loading={modalLoading}
+                        organization={currentGlobalFilter.organization}
+                        listParams={listParams}
+                        ruleSetDetail={ruleSetDetail}
+                        appSelectList={appSelectList}
+                        allEventSelectList={allEventSelectList}
+                        onCancel={() => setRuleEventVisible(false)}
+                        onSubmit={handleEventSubmit}
+                    />
+                )}
+
+                {/* 复制分组规则模态框 */}
+                {ruleGroupVisible && (
+                    <RuleGroupCopyModal
+                        isVisible={ruleGroupVisible}
+                        ruleDetail={ruleDetail}
+                        ruleSetList={dataSource}
+                        groupList={groupList}
+                        onSubmit={handleCopyGroupSubmit}
+                        onCancel={() => setRuleGroupVisible(false)}
+                    />
+                )}
+
+                {/* 规则编辑/查看模态框 (复用 portal2 现有) */}
+                <RuleMdoal
+                    visible={ruleModalVisible}
+                    record={record}
+                    riskMapList={riskMapList}
+                    risklevelList={risklevelList}
+                    variableData={variableData}
+                    setConditions={setConditions}
+                    variableChange={variableChange}
+                    ruleType={ruleType}
+                    conditions={conditions}
+                    productId={productId}
+                    riskTypeList={riskTypeList}
+                    onCancel={() => setRuleModalVisible(false)}
+                    onClose={() => setRuleModalVisible(false)}
+                    ruleSubmit={ruleSubmit}
+                />
+            </Spin>
+        </div>
+    );
+};
+
+export default connect(({}) => ({}))(ExperimentRuleTable);