admin2 1.0.0

package/src/pages/pageComponents/StrategyPage/index.js

@@ -0,0 +1,864 @@
+/**
+ *策略管理中心
+ * @param {} props
+ * @returns
+ * tangjian
+ */
+
+import { useState, useEffect, useCallback, useRef } from 'react';
+import { Button, Spin, message, Dropdown, Menu, Modal, Switch, Tooltip } from 'antd';
+import { InfoCircleOutlined } from '@ant-design/icons';
+import {history, connect, getAllLocales, useIntl, SelectLang} from 'umi';
+import moment from 'moment';
+import _ from 'lodash';
+import { useUpdateEffect } from 'ahooks';
+import { SMModal, SMForm } from 'sm-antd';
+
+import { ROUTE_PATH } from '@/configure';
+import GlobalFilterListener from '@/components/GlobalFilterListener';
+import SMSearchForm from '@/components/SMSearchForm';
+import { PRODUCT_TYPE, MODEL_TYPE, AUTH_FUNCTION, SM_ACCOUNT } from '@/contants';
+import { Storage, exportFile } from '@/utils/utils';
+import { strategyStroageName } from '@/pages/constants';
+import SMIcon from '@/components/SMIcon';
+import {useLanguage} from '@/hooks';
+import { getAuthFunction } from '@/utils/AuthorityManage';
+import {formatUs} from '@/utils/helpers';
+
+import RuleTable from './components/RuleTable';
+import OneKeyLabModal from './components/OneKeyLabModal';
+import {
+    getSearchData,
+    SERVICEID_LIST,
+    FILTER_ID,
+    ruleListFromData,
+    SPECIAL_SERVICEID,
+    DEFAULT_GROUP,
+} from './contants';
+
+import styles from './index.less';
+import {
+    ruleEventScene,
+    openCloseApply,
+    getOpenStatus,
+    updateDegradeMode,
+    getDegradeModeStatus,
+} from '@/services/strategy';
+
+
+const { ModalType } = SMModal;
+
+const RULE_LOG_NAME = '规则日志';
+
+const StrategyPage = props => {
+    const {route, dispatch, currentUser, user} = props;
+    const {apps} = user;
+    const isGlobal = route.routeData.serviceId === 'GLOBAL_STRATEGY';
+    const isSingle =  route.routeData.isSingle === true;
+    const isCurrentSM = currentUser.organization === SM_ACCOUNT && isSingle;
+    const isCurrentCustomer = currentUser.organization !== SM_ACCOUNT && isSingle;
+
+
+    const firstRequestRuleList = useRef(false);
+    const firstRiskMapSelectList = useRef(false);
+    const firstSingleList = useRef(false);
+
+    const [currentGlobalFilter, setCurrentGlobalFilter] = useState({});
+    const [productList, setProductList] = useState([]);
+    const [riskTypeList, setRiskTypeList] = useState([]);
+    const [productId, setProductId] = useState();
+    const [eventList, setEventList] = useState([]);
+    const [ruleSetList, setRuleSetList] = useState([]);
+    const [ruleList, setRuleList] = useState({});
+    const [loading, setLoading] = useState(false);
+    const [eventId, setEventId] = useState('');
+    const [parameter, setParameter] = useState();
+    const [risklevelList, setRisklevelList] = useState([]);
+    const [riskMapList, setRiskMapList] = useState({});
+    const [activeKey, setActiveKey] = useState([]);
+    const [sceneList, setSceneList] = useState([]);
+
+    const [selectedRowKeys, setSelectedRowKeys] =  useState([]);
+    const [resetCount, setResetCount] = useState(moment().format('x'));
+    const [groupList, setGroupList] = useState([]);
+    const [changeCount, setChangeCount] =  useState(moment().format('x'));
+    const [group, setGroup] = useState(DEFAULT_GROUP);
+    const [isOpenStatus, setIsOpenStatus] = useState(0);
+    const [degradeMode, setDegradeMode] = useState(false);
+    const [oneKeyLabVisible, setOneKeyLabVisible] = useState(false);
+
+    const {t} = useLanguage();
+
+    const getSceneId = useCallback(async params => {
+        if (!isSingle) {
+            return;
+        }
+        try {
+            const {code, contents} = await ruleEventScene({
+                ...params,
+                count: 1,
+                offset: 0,
+                status: 1,
+            });
+            const defaultList = [{sceneName: t('默认场景'), sceneId: 'default'}];
+            if (code === 1100) {
+                setSceneList(_.isEmpty(contents) ? defaultList : contents);
+            } else {
+                setSceneList([]);
+            }
+        } catch (error) {
+
+        }
+    }, [isSingle, t]);
+
+    // 获取规则开放状态
+    const fetchOpenStatus = useCallback(async (organization, appId, eventIdParam) => {
+        if (!organization || !eventIdParam) {
+            return;
+        }
+        try {
+            const result = await getOpenStatus({
+                organization,
+                appId: appId,
+                eventId: eventIdParam,
+            });
+            if (result && result.code === 1100) {
+                const contents = result.contents;
+                if (contents && contents.isOpen !== undefined) {
+                    setIsOpenStatus(contents.isOpen);
+                } else {
+                    setIsOpenStatus(0);
+                }
+            } else {
+                setIsOpenStatus(0);
+            }
+        } catch (error) {
+            setIsOpenStatus(0);
+        }
+    }, []);
+
+    // 获取事件列表
+    const getEventList = useCallback(async (organization, appId) => {
+        if (isCurrentSM && organization === SM_ACCOUNT) {
+            return;
+        }
+        setLoading(true);
+        const result = await dispatch({
+            type: 'base/fetchOpenEvent',
+            payload: {
+                organization,
+                serviceId: SERVICEID_LIST.join(','),
+                isGlobalEvent: route.routeData.isGlobalEvent ? 1 : 0,
+            },
+        });
+        setLoading(false);
+        if (result && result.length) {
+            try {
+                const data = result.filter(item => item.serviceId !== 'DEVICE_PROFILE');
+                setResetCount(moment().format('x'));
+                setProductList(data);
+                setEventList(data[0].events);
+                setEventId(data[0] && data[0].events && data[0].events[0].eventId);
+                setProductId(data[0].serviceId);
+                setParameter({});
+                getSceneId({
+                    serviceId: data[0].serviceId,
+                    eventId: data[0] && data[0].events && data[0].events[0].eventId,
+                    organization,
+                    appId,
+                });
+            } catch (error) {
+            }
+        }
+    }, [route, dispatch, isCurrentSM, getSceneId]);
+
+    const getRiskTypeList =  useCallback(async () => {
+        const relsut = await dispatch({
+            type: 'strategy/getRiskTypeList',
+            payload: {serviceId: productId},
+        });
+        if (_.isArray(relsut)) {
+            setRiskTypeList(relsut);
+        }
+    }, [productId, dispatch]);
+
+    const globalFilterChange = useCallback(obj => {
+        let {
+            orgChange,
+            appIdChange,
+            currentGlobalFilter,
+        } = obj;
+        if (isGlobal) {
+            currentGlobalFilter = {organization: SM_ACCOUNT, appId: 'default'};
+        }
+        setCurrentGlobalFilter(currentGlobalFilter);
+        if (orgChange || appIdChange) {
+            getEventList(currentGlobalFilter.organization, currentGlobalFilter.appId);
+        }
+    }, [isGlobal, getEventList]);
+
+    const getRuleList = useCallback(async (val, type) => {
+        setLoading(true);
+        const params = {
+            organization: currentGlobalFilter.organization,
+            appId: currentGlobalFilter.appId,
+            eventId: eventId || (eventList.length && eventList[0].eventId),
+            environment: 'online',
+            group_code: group,
+        };
+        if (type === 'ruleId') {
+            if (val) {
+                params.ruleId = val;
+            }
+        }
+        else {
+            if (val && val.length) {
+                params.ruleSetId = val;
+            }
+        }
+        if (parameter.riskLevel !== 'all' && parameter.riskLevel) {
+            params.riskLevel = parameter.riskLevel;
+        }
+        if (parameter.enabled !== 'all' && parameter.enabled) {
+            params.enabled = parameter.enabled;
+        }
+        const result = await dispatch({
+            type: 'strategy/getRuleList',
+            payload: params,
+        });
+
+        if (result && !result.contents.length) {
+            message.warning(t('没有查询到对应的规则!'));
+        }
+        setRuleList(result);
+        setLoading(false);
+    }, [currentGlobalFilter, parameter, eventId, eventList, dispatch, group, t]);
+
+    // 筛选
+    const handleChange = useCallback((name, value) => {
+        const params = {};
+        switch (name) {
+            case FILTER_ID.PORDUCT_ID:
+                setProductId(value);
+                const result =  productList.filter(item => item.serviceId === value);
+                if (result.length) {
+                    setEventList(result[0].events);
+                    setEventId(result[0].events.length && result[0].events[0].eventId);
+                    setActiveKey([]);
+                    setSelectedRowKeys([]);
+                    setChangeCount(moment().format('x'));
+                    setGroup(DEFAULT_GROUP);
+                    getSceneId({
+                        serviceId: value,
+                        eventId: result[0].events.length && result[0].events[0].eventId,
+                        organization: currentGlobalFilter.organization,
+                        appId: currentGlobalFilter.appId,
+                    });
+                }
+                break;
+            case FILTER_ID.EVENT_ID:
+                setEventId(value);
+                setActiveKey([]);
+                setSelectedRowKeys([]);
+                getSceneId({
+                    serviceId: productId,
+                    eventId: value,
+                    organization: currentGlobalFilter.organization,
+                    appId: currentGlobalFilter.appId,
+                });
+                break;
+            case FILTER_ID.RULE_ID :
+                if (value) {
+                    getRuleList(value, 'ruleId');
+                }
+                else {
+                    if (activeKey && activeKey.length) {
+                        getRuleList(activeKey);
+                    }
+                    else {
+                        getRuleSetList();
+                    }
+                }
+                params[name] = value;
+                setSelectedRowKeys([]);
+                setParameter({...parameter, ...params});
+                break;
+            case FILTER_ID.GROUP :
+                setActiveKey([]);
+                setSelectedRowKeys([]);
+                setGroup(value);
+                break;
+            default :
+                if (parameter.ruleId) {
+                    getRuleList(parameter.ruleId, 'ruleId');
+                }
+                else {
+                    getRuleSetList();
+                }
+                params[name] = value;
+                setParameter({...parameter, ...params});
+                break;
+        }
+    }, [productList, parameter, activeKey, getSceneId, currentGlobalFilter, productId]);
+    // 查询策略集
+    const getRuleSetList = useCallback(async () => {
+        setLoading(true);
+        const result = await dispatch({
+            type: 'strategy/getRuleSetList',
+            payload: {
+                organization: currentGlobalFilter.organization,
+                appId: currentGlobalFilter.appId,
+                eventId: eventId,
+                environment: 'online',
+                group_code: group,
+            },
+        });
+        setLoading(false);
+        if (result.length) {
+            setRuleSetList(result);
+        }
+    }, [currentGlobalFilter.organization, currentGlobalFilter.appId, eventId, dispatch, group]);
+    const getRuleEngineRisklevel = useCallback(async () => {
+        const result = await dispatch({
+            type: 'base/fetchRiskLevelList',
+            payload: {product: PRODUCT_TYPE.TIANWANG},
+        });
+
+        if (result && result.length) {
+            setRisklevelList(result);
+        }
+    }, [dispatch]);
+    const addRuleListSubmit = useCallback(async val => {
+        const result = await dispatch({
+            type: 'strategy/addRuleSet',
+            payload: {
+                ...val,
+                eventId: eventId,
+                group_code: group,
+            },
+        });
+        if (result) {
+            getRuleSetList();
+            global.modal.pop();
+        }
+    }, [eventId, dispatch, getRuleSetList, group]);
+    const addRuleList = useCallback(() => {
+        global.modal.show(ModalType.MODAL_ALERT, {
+            width: 576,
+            modalTitle: t('新增规则集'),
+            renderChildren: () => {
+                return (
+                    <SMForm
+                        title={t('添加规则集')}
+                        formData={formatUs(ruleListFromData(), ['label', 'placeholder'], t)}
+                        isShowSubmitBtn
+                        onCancel={() => global.modal.pop()}
+                        onSubmit={addRuleListSubmit}
+                    />
+                );
+            },
+        });
+    }, [addRuleListSubmit, t]);
+    const updateRuleSetSubmit =  useCallback(async val => {
+        const result =  await dispatch({
+            type: 'strategy/updateRuleSet',
+            payload: val,
+        });
+        if (result) {
+            global.modal.pop();
+            getRuleSetList();
+        }
+    }, [getRuleSetList, dispatch]);
+    const updateRuleSet = useCallback(async (e, item) => {
+        e.stopPropagation();
+        global.modal.show(ModalType.MODAL_ALERT, {
+            width: 576,
+            modalTitle: t('修改规则集'),
+            renderChildren: () => {
+                return (
+                    <SMForm
+                        title={t('修改规则集')}
+                        formData={formatUs(ruleListFromData('update'), ['label', 'placeholder'], t)}
+                        initialValues={item}
+                        isShowSubmitBtn
+                        submitText={t('确定')}
+                        cancelText={t('取消')}
+                        onCancel={() => global.modal.pop()}
+                        onSubmit={val => updateRuleSetSubmit({...val, id: item.id})}
+                    />
+                );
+            },
+        });
+    }, [updateRuleSetSubmit, t]);
+        // 风险类型、风险原因
+    const riskMapSelectList = useCallback(async () => {
+        const obj = {};
+        ['riskReasons', 'riskTypeName'].forEach(async item => {
+            const result = await dispatch({
+                type: 'strategy/riskMapSelectList',
+                payload: {
+                    serviceId: 'TIANWANG',
+                    type: item,
+                },
+            });
+
+            obj[item] = result;
+        });
+        setRiskMapList(obj);
+    }, [dispatch]);
+    // 查询分组列表
+    const getRuleUserGroup = useCallback(async () => {
+        const result = await dispatch({
+            type: MODEL_TYPE.STRATEGY_LIST.GROUP_LIST,
+            payload: {service_id: productId},
+        });
+        if (result) {
+            setGroupList(result);
+        }
+    }, [productId, dispatch]);
+    // 跳转到规则日志
+    const jumpRuleLog = useCallback(ruleId => {
+        let url = isGlobal ? ROUTE_PATH.STRATEGY_POLICY_GLOBAL_RULELOG : ROUTE_PATH.STRATEGY_POLICY_RULELOG;
+        url = ruleId ? `${url}?ruleId=${ruleId}` : url;
+        history.push(__ASSETS_PREFIX__ + url);
+        const strategyList = {
+            path: [
+                {
+                    name: `${props.route.name}`,
+                    url: `${props.route.path}`,
+                    link: true,
+                },
+                {
+                    name: RULE_LOG_NAME,
+                },
+            ],
+            params: {
+                organization: currentGlobalFilter.organization,
+                appId: currentGlobalFilter.appId,
+                eventId,
+            },
+            riskMapList: riskMapList,
+            risklevelList: risklevelList,
+
+        };
+        Storage.set(strategyStroageName, strategyList);
+    }, [isGlobal, props.route, currentGlobalFilter, eventId, riskMapList, risklevelList]);
+
+    const jumpLabRecord = useCallback(() => {
+        const query = new URLSearchParams({
+            organization: currentGlobalFilter.organization,
+            appId: currentGlobalFilter.appId,
+            eventId,
+        }).toString();
+        history.push({
+            pathname: `${__ASSETS_PREFIX__}${ROUTE_PATH.STRATEGY_POLICY_LAB_RECORD}`,
+            search: `?${query}`,
+        });
+    }, [currentGlobalFilter, eventId]);
+
+    const checkDegradeModeStatus = useCallback(async () => {
+        if (!currentGlobalFilter.organization || !eventId || !isSingle) {
+            return;
+        }
+        try {
+            const result = await getDegradeModeStatus({
+                organization: currentGlobalFilter.organization,
+                appId: currentGlobalFilter.appId,
+                eventId,
+            });
+            if (result.code === 1100 && result.contents && result.contents.length > 0) {
+                setDegradeMode(result.contents[0].mode === 1);
+            } else {
+                setDegradeMode(false);
+            }
+        } catch (error) {
+            setDegradeMode(false);
+        }
+    }, [currentGlobalFilter.organization, currentGlobalFilter.appId, eventId, isSingle]);
+
+    const handleDegradeModeChange = useCallback(checked => {
+        const config = checked
+            ? {
+                content: (
+                    <span>
+                        {t('确定开启策略降级模式?')}
+                        <br />
+                        {t('开启后所有策略处置建议改为通过并生效,且所有策略为只读状态,不可修改。')}
+                    </span>
+                ),
+                mode: 1,
+                successMsg: t('开启成功'),
+                errorMsg: t('开启失败'),
+            }
+            : {
+                content: (
+                    <span>
+                        {t('确定关闭策略降级模式?')}
+                        <br />
+                        {t('关闭后所有策略处置建议恢复为原来线上版本。')}
+                    </span>
+                ),
+                mode: 2,
+                successMsg: t('关闭成功'),
+                errorMsg: t('关闭失败'),
+            };
+
+        Modal.confirm({
+            title: t('提示'),
+            content: config.content,
+            okText: t('是'),
+            cancelText: t('否'),
+            cancelButtonProps: {style: {borderColor: '#d9d9d9', background: '#fff', color: '#000000d9'}},
+            onOk: async () => {
+                try {
+                    const result = await updateDegradeMode({
+                        organization: currentGlobalFilter.organization,
+                        appId: currentGlobalFilter.appId,
+                        eventId,
+                        mode: config.mode,
+                    });
+                    if (result.code === 1100) {
+                        message.success(config.successMsg);
+                        await checkDegradeModeStatus();
+                    } else {
+                        message.error(config.errorMsg);
+                    }
+                } catch (error) {
+                    message.error(config.errorMsg);
+                }
+            },
+        });
+    }, [t, currentGlobalFilter.organization, currentGlobalFilter.appId, eventId, checkDegradeModeStatus]);
+
+    // 导出
+    const exportData = useCallback(callback => {
+        const title = props.route.name;
+        const newSearchParams = {
+            environment: 'online',
+            organization: currentGlobalFilter.organization,
+            appId: currentGlobalFilter.appId,
+            eventId,
+            ruleId: parameter.ruleId,
+            riskLevel: parameter.riskLevel,
+            group_code: group,
+        };
+        if (parameter.enabled !== 'all' || parameter.enabled !== '') {
+            newSearchParams.enabled = parameter.enabled;
+        }
+        if (parameter.riskLevel !== 'all' || parameter.riskLevel !== '') {
+            newSearchParams.enabled = parameter.enabled;
+        }
+        exportFile(MODEL_TYPE.STRATEGY_LIST.STRATEGY_EXPORT, t(title), newSearchParams);
+    }, [props.route, parameter, eventId, currentGlobalFilter, group]);
+
+    // 全量开放/收回规则
+    const handleOpenCloseApply = useCallback(status => {
+        const questionText = status === 0 ? '是否全量收回规则？' : '是否全量开放规则？';
+        const detailText = status === 0
+            ? '收回规则后，客户将只能查看不能修改该公司_应用_事件下的规则，是否继续？'
+            : status === 1
+                ? '开放后客户可以修改该公司_应用_事件下的规则的处置建议，是否继续？'
+                : '开放后客户可以修改该公司_应用_事件下规则的处置建议、风险类型、风险原因、得分、备注、规则条件、灰度比例等详细信息，是否继续？';
+        Modal.confirm({
+            title: t('提示'),
+            content: (
+                <div className={styles['open-close-modal-content']}>
+                    <div className={styles['open-close-modal-question']}>{t(questionText)}</div>
+                    <div className={styles['open-close-modal-detail']}>{t(detailText)}</div>
+                </div>
+            ),
+            cancelButtonProps: {style: {color: '#000000d9', borderColor: '#d9d9d9', background: '#fff'}},
+            okText: t('确认'),
+            cancelText: t('取消'),
+            onOk: async () => {
+                const params = {
+                    eventId: eventId,
+                    appId: currentGlobalFilter.appId,
+                    organization: currentGlobalFilter.organization,
+                    serviceId: productId,
+                    isOpen: status,
+                };
+                const result = await openCloseApply(params);
+                if (result && result.code === 1100) {
+                    message.success(t('开放规则进入审批流成功。'));
+                    fetchOpenStatus(currentGlobalFilter.organization, currentGlobalFilter.appId, eventId);
+                }
+            },
+        });
+    }, [t, eventId, currentGlobalFilter.appId, currentGlobalFilter.organization, productId, fetchOpenStatus]);
+
+    const renderIndex = useCallback(() => {
+
+        return (
+            <div>
+                <Spin spinning={loading}>
+                    <GlobalFilterListener onChange={globalFilterChange} />
+                    <SMSearchForm
+                        resetCount={resetCount}
+                        serviceIdChangeCount={changeCount}
+                        formData={getSearchData(productList, eventList, risklevelList, groupList, t,
+                            isSingle, sceneList)}
+                        onChange={handleChange}
+                    />
+                    <div className={styles['top-btn']}>
+                        <div className={styles['btn-group-left']}>
+                            {
+                                isGlobal
+                            && getAuthFunction(AUTH_FUNCTION.CREATE_RULE_SET)
+                            && <Button type="primary" onClick={addRuleList}>{t('新增规则集')}</Button>
+                            }
+                            {getAuthFunction(AUTH_FUNCTION.REDIRECT_RULE_LOG) && (
+                                <Button type="primary" onClick={() => jumpRuleLog()}>{t('规则修改日志')}</Button>
+                            )}
+                        </div>
+                        <div className={styles['btn-group-right']}>
+                            {isSingle && getAuthFunction(AUTH_FUNCTION.DEGRADE_MODE) && (
+                                <div className={styles['degrade-mode-wrapper']}>
+                                    <Switch
+                                        checked={degradeMode}
+                                        size="small"
+                                        onChange={handleDegradeModeChange}
+                                    />
+                                    <span className={styles['degrade-mode-text']}>{t('策略降级模式')}</span>
+                                    <Tooltip title={t('开启策略降级模式后，所有线上策略的处置建议将返回通过（PASS），且所有策略为只读状态直到关闭策略降级模式。')}>
+                                        <InfoCircleOutlined className={styles['degrade-mode-icon']} />
+                                    </Tooltip>
+                                </div>
+                            )}
+                            {isCurrentSM && getAuthFunction(AUTH_FUNCTION.ALL_OPEN_OR_RECOVER_RULE) && (
+                                <Dropdown
+                                    overlay={
+                                        <Menu onClick={({key}) => handleOpenCloseApply(Number(key))}>
+                                            <Menu.Item
+                                                key="1"
+                                                disabled={isOpenStatus === 1}
+                                            >
+                                                {t('仅开放修改处置建议功能')}
+                                            </Menu.Item>
+                                            <Menu.Item key="2" disabled={isOpenStatus === 2}>
+                                                {t('开放全部修改规则功能')}
+                                            </Menu.Item>
+                                        </Menu>
+                                    }
+                                >
+                                    <span className={styles['open-rule-btn']}>{t('全量开放规则')}</span>
+                                </Dropdown>
+                            )}
+                            {isCurrentSM && getAuthFunction(AUTH_FUNCTION.ALL_OPEN_OR_RECOVER_RULE) && (
+                                <span
+                                    className={
+                                        isOpenStatus === 0
+                                            ? styles['open-rule-btn-disabled']
+                                            : styles['open-rule-btn']
+                                    }
+                                    onClick={isOpenStatus === 0 ? undefined : () => handleOpenCloseApply(0)}
+                                >
+                                    {t('全量收回规则')}
+                                </span>
+                            )}
+                            {isSingle && getAuthFunction(AUTH_FUNCTION.ONE_KEY_LAB_RECORD) && (
+                                <Button type="link" onClick={jumpLabRecord}>{t('全量进实验室操作记录')}</Button>
+                            )}
+                            {isSingle && getAuthFunction(AUTH_FUNCTION.ONE_KEY_LAB) && (
+                                <div className={styles['onekey-lab-btn']}>
+                                    {degradeMode ? (
+                                        <Tooltip title={t('请关闭策略降级模式后进行操作。')}>
+                                            <Button disabled style={{ backgroundColor: '#f5f5f5'}}>
+                                                {t('全量进实验室')}
+                                                <InfoCircleOutlined style={{ color: '#999', cursor: 'pointer' }} />
+                                            </Button>
+                                        </Tooltip>
+                                    ) : (
+                                        <Button onClick={() => setOneKeyLabVisible(true)}>
+                                            {t('全量进实验室')}
+                                            <Tooltip title={t('可将策略一键进入实验室观察效果，对应线上策略返回自定义处置。')}>
+                                                <InfoCircleOutlined style={{ color: '#999', cursor: 'pointer' }} />
+                                            </Tooltip>
+                                        </Button>
+                                    )}
+                                </div>
+                            )}
+                            {getAuthFunction(AUTH_FUNCTION.EXPORT_RULE) && (
+                                <div className={styles.export}>
+                                    <SMIcon
+                                        type={'icon-daochu'}
+                                        onClick={exportData}
+                                    />
+                                </div>
+                            )}
+                        </div>
+
+                    </div>
+                    <RuleTable
+                        listData={{
+                            dataSource: ruleSetList,
+                            risklevelList,
+                            ruleList,
+                            productList,
+                            riskMapList,
+                            riskTypeList,
+                            groupList,
+                        }}
+                        isCurrentCustomer={isCurrentCustomer}
+                        isOpenStatus={isOpenStatus}
+                        degradeMode={degradeMode}
+                        eventId={eventId}
+                        activeKey={activeKey}
+                        setActiveKey={setActiveKey}
+                        selectedRowKeys={selectedRowKeys}
+                        setSelectedRowKeys={setSelectedRowKeys}
+                        currentGlobalFilter={currentGlobalFilter}
+                        isGlobal={isGlobal}
+                        ruleLoading={false}
+                        productId={productId}
+                        currentUser={currentUser}
+                        group={group}
+                        method={
+                            {
+                                updateRuleSet,
+                                getRuleSetList,
+                                getRuleList,
+                                jumpRuleLog,
+                            }
+                        }
+                        collapseChange={async val => {
+                            if (val) {
+                                getRuleList(val);
+                            }
+                        }}
+                    />
+                </Spin>
+            </div>
+        );
+    }, [
+        activeKey,
+        addRuleList,
+        currentGlobalFilter,
+        currentUser,
+        eventId,
+        eventList,
+        getRuleList,
+        getRuleSetList,
+        globalFilterChange,
+        handleChange,
+        isGlobal,
+        jumpRuleLog,
+        loading,
+        productId,
+        productList,
+        resetCount,
+        riskMapList,
+        riskTypeList,
+        risklevelList,
+        ruleList,
+        ruleSetList,
+        selectedRowKeys,
+        updateRuleSet,
+        exportData,
+        groupList,
+        changeCount,
+        group,
+        t,
+        isCurrentCustomer,
+        isOpenStatus,
+        handleOpenCloseApply,
+        isSingle,
+        sceneList,
+        degradeMode,
+        handleDegradeModeChange,
+        jumpLabRecord,
+        isCurrentSM,
+    ]);
+
+    useEffect(() => {
+        const getAppData = (appId, apps) => {
+            const defauleAppData = {
+                appId: apps[0].appId,
+                appName: apps[0].appName,
+            };
+            let currentAppData = apps.find(app => app.appId === appId);
+            currentAppData = currentAppData || defauleAppData;
+            return currentAppData;
+        };
+        if (!firstSingleList.current && apps.length > 0 && isCurrentCustomer) {
+            firstSingleList.current = true;
+            let newApps = [].concat(apps);
+            newApps.unshift({
+                appId: '',
+                appName: '全部应用',
+            });
+            // 拿到缓存中的appId，若不在当前应用列表中则视为无效
+            let appIdCache = Storage.get('SM_APPID') || '';
+            if (appIdCache && !apps.some(app => app.appId === appIdCache)) {
+                appIdCache = '';
+            }
+            let currentAppData = getAppData(appIdCache, newApps);
+            // 缓存appId即为空，也就是全部时，策略页面没有全部，特殊处理,取第一项
+            if (appIdCache === '' && location && location.pathname && location.pathname.indexOf('policy') > -1) {
+                currentAppData = {
+                    appId: apps[0].appId,
+                    appName: apps[0].appName,
+                };
+            }
+            dispatch({
+                type: 'user/changeCurrentAppData',
+                currentAppData,
+            });
+        }
+    }, [apps, dispatch, isCurrentCustomer]);
+
+    useEffect(() => {
+        if (!firstRequestRuleList.current || !eventId) {
+            firstRequestRuleList.current = true;
+            return;
+        }
+        getRuleSetList();
+    }, [currentGlobalFilter, getRuleSetList, eventId]);
+
+    useEffect(() => {
+        if (!currentGlobalFilter.organization) {
+            return;
+        }
+        getRuleEngineRisklevel();
+    }, [currentGlobalFilter.organization, getRuleEngineRisklevel]);
+
+    useEffect(() => {
+        if (!firstRiskMapSelectList.current) {
+            riskMapSelectList();
+            firstRiskMapSelectList.current = true;
+            return;
+        }
+    }, []);
+    useEffect(() => {
+        if (SPECIAL_SERVICEID.includes(productId)) {
+            getRiskTypeList();
+        }
+    }, [productId]);
+
+    useUpdateEffect(() => {
+        getRuleUserGroup();
+    }, [productId]);
+
+    useEffect(() => {
+        if (eventId && currentGlobalFilter && isSingle) {
+            fetchOpenStatus(currentGlobalFilter.organization, currentGlobalFilter.appId, eventId);
+            checkDegradeModeStatus();
+        }
+    }, [eventId, currentGlobalFilter, fetchOpenStatus, checkDegradeModeStatus, isSingle]);
+
+    return (
+        <div>
+            {location.pathname === route.path ? renderIndex() : props.children}
+            <OneKeyLabModal
+                visible={oneKeyLabVisible}
+                onCancel={() => setOneKeyLabVisible(false)}
+                risklevelList={risklevelList}
+                organization={currentGlobalFilter.organization}
+                appId={currentGlobalFilter.appId}
+                eventId={eventId}
+            />
+        </div>
+    );
+};
+
+export default connect(({user}) => ({currentUser: user.currentUser, user}))(StrategyPage);