admin2 1.0.0

package/src/pages/pageComponents/historyPage/TypeThree/index.jsx

@@ -0,0 +1,2158 @@
+/**
+ * 天网历史记录（登录、注册、事件、短信通道、羊毛党）
+ */
+
+import React, { Component } from 'react';
+import { connect } from 'umi';
+import moment from 'moment';
+import _ from 'lodash';
+import {SMTable, SMModal} from 'sm-antd';
+import {
+    Tooltip,
+    message,
+    Button,
+    Spin,
+    Select,
+    Popconfirm,
+} from 'antd';
+import { CopyToClipboard } from 'react-copy-to-clipboard';
+
+import {
+    formatSearchParams,
+    exportFile,
+    getUrlParams,
+    backTop,
+    getDisabledDate,
+    Storage,
+    isPrivate,
+    formatArrayParams,
+    formatAppList,
+    arrayMove,
+    formatDataToString,
+} from '@/utils/utils';
+import { PAGE_SIZE } from '@/contants/pageSize';
+import {
+    FieldMessageModal,
+    SMSearchForm,
+    TotalCount,
+    GlobalFilterListener,
+    SMText,
+    SMRiskLevel,
+    SMIcon,
+    SMBackTop,
+    SMImage,
+} from '@/components';
+import {
+    MODEL_TYPE,
+    HISTORY_COLUMN,
+    FIELD_SOURCE_TYPE,
+    SM_FIELD_SORT,
+    SERVICEID_LIST,
+    FILED_SET_DETAIL,
+    DEFAULT_SCREEN,
+    SM_ACCOUNT,
+    KEYBOARD_CODER,
+    AUTH_FUNCTION,
+    tableText,
+    STORAGE_LIST_NAME,
+} from '@/contants';
+import {getIntlTableColums} from '@/utils/helpers';
+import withIntlComponents from '@/hoc/withIntlComponents';
+
+import { getAuthFunction } from '@/utils/AuthorityManage';
+
+import {AddListModal, ExportTask, GroupFilter, NewHistoryDetailDrawer} from '../components';
+import {
+    HIDDEN_SERVICES,
+    TOKENID_SERVICES,
+    TOKENID_DATA,
+    DEFAULT_DATA,
+} from './constants';
+import {
+    RENDER_TYPE,
+    FIELD_NAME_LIST,
+    FILTER_MAX_NUMBER,
+    SEARCH_METHOD,
+    METHOD_TYPE,
+    FILTRATE_LIST,
+    HINT_TEXT,
+} from '../constants';
+import formatSpecialFeature from '../components/NewHistoryDetailDrawer/formatSpecialFeature';
+
+import styles from './index.less';
+import { SHOW_DISPOSAL_ACCOUNT } from '@/contants/account';
+import DisposalModal from '../DisposalModal';
+
+
+const {ModalType} = SMModal;
+const Option = Select.Option;
+const OPERATION = '操作';
+const VERIFY = 'VERIFY'; // 二次验证
+const ALL = 'all';
+// 快速导出 正常1W；全局：5000；
+const DOWNLOAD_NUMBER = {
+    NORMAL: 10000,
+    GLOBAL: 5000,
+};
+
+class History extends Component {
+    constructor(props) {
+        super(props);
+        this.state = {
+            ...FILTRATE_LIST,
+            defaultRiskLevelData: {
+                type: 'cascader',
+                name: 'riskLevel',
+                data: {
+                    selectData: {
+                        optionData: [],
+                        title: '识别结果',
+                        labelId: 'riskLevel',
+                        defaultValue: ['all'],
+                        allowClear: false,
+                    },
+                },
+            },
+            defaultEventData: {
+                type: 'select',
+                name: 'eventId',
+                data: {
+                    selectData: {
+                        optionData: [],
+                        title: '事件',
+                        labelId: 'eventId',
+                        isAddAll: true,
+                        defaultValue: 'all',
+                    },
+                },
+            },
+            defaultChannelEventData: {
+                type: 'newSelect',
+                name: 'channel',
+                data: {
+                    selectData: {
+                        optionData: [],
+                        title: '渠道',
+                        labelId: 'channel',
+                        mode: 'multiple',
+                        isAddAll: true,
+                        isAllowClear: true,
+                        isMaxTagCount: 3,
+                        style: {'min-width': 150},
+                    },
+                },
+            },
+            defaultRiskReasonData: {
+                type: 'newSelect',
+                name: 'reason',
+                data: {
+                    selectData: {
+                        optionData: [],
+                        title: '风险原因',
+                        labelId: 'reason',
+                        mode: 'multiple',
+                        isAddAll: true,
+                        isAllowClear: true,
+                        isMaxTagCount: 3,
+                        style: {'min-width': 150},
+                    },
+                },
+            },
+            queryParams: {
+                startTime: Number(moment().startOf('day').format('x')),
+                endTime: Number(moment().endOf('day').format('x')),
+            },
+            orgAppChange: false,
+            resetValue: 0,
+            globalExportParams: {},
+            isDisabled: true,
+            isGlobalSearch: location.pathname.includes('new/manage'),
+            tableDataSource: [],
+            tableColumns: [],
+            detailData: {}, // 当前详情数据
+            detailVisible: false,
+            detailIndex: 0, // 当前详情数据的index
+            listLoading: true,
+            listData: [], // 历史记录列表数据
+            listTotalCount: 0,
+            listRealTotalCount: 0,
+            isFirstLoading: true,
+            currentPage: 1,
+            pageSize: 20,
+            pageSizeOptions: PAGE_SIZE,
+            currentGlobalFilter: {
+                organization: '',
+                appId: '',
+                clusterId: '',
+            },
+            channelMap: {},
+            eventIdMap: {},
+            serviceIdMap: {},
+            riskLevelMap: {}, // 识别结果
+            verifyTypeMap: {}, // 二次验证下的验证方式
+            exportTaskVisible: false, // 控制导出历史任务弹窗的显隐
+            tokenIdBlackList: [], // 账号黑名单列表
+            ipBlackList: [], //  ip黑名单列表
+            phoneBlackList: [], // 手机号黑名单列表
+            phoneMd5BlackList: [], // 加密手机号黑名单列表
+            deviceIdBlackList: [], // 设备标识黑名单列表
+            ignoreList: [], // 忽略词名单
+            sensitiveList: [], // 敏感词名单
+            currentListData: [], // 当前选择名单列表
+            listModalVisible: false, // 展示选择名单弹窗
+            currentListValue: '', // 当前要加名单的值
+            resetCount: 0,
+            serviceIdChangeCount: 0,
+            modelText: '',
+            headerData: {}, // 字段配置表头
+            disabledDate: {}, // 限制选择时间
+            exportLoading: false,
+            filterData: [], // 高级筛选项
+            searchList: [], // 筛选
+        };
+    }
+
+    UNSAFE_componentWillMount() {
+        const { stateConfig } = this.props;
+        const {defaultServiceData} = this.state;
+        const newDefaultServiceData = _.cloneDeep(defaultServiceData);
+        newDefaultServiceData.data.selectData.doSearch = this.reDoSearch;
+        this.setState({
+            defaultServiceData: newDefaultServiceData,
+        });
+        if (stateConfig) {
+            this.setState({...stateConfig});
+        }
+    }
+
+    componentDidMount() {
+        window.addEventListener('keydown', this.changeDetailData);
+    }
+
+    componentWillUnmount() {
+        window.removeEventListener('keydown', this.changeDetailData);
+    }
+
+    shouldComponentUpdate = (nextProps, nextState) => nextState.isrRefresh === this.state.isrRefresh;
+
+    // 设置url携带的默认参数（筛选/排行榜跳转）
+    setDefaultSearchParams = () => {
+        const url = location.href;
+        const urlParams = getUrlParams(url);
+        const {
+            defaultLabelSearchData,
+            defaultRiskLevelData,
+            defaultChannelEventData,
+            defaultRangeTimeData,
+            defaultRiskReasonData,
+            queryParams,
+            searchList,
+            filterData,
+            isGlobalSearch,
+            defaultEventData,
+        } = this.state;
+        const newLabelSearchData = _.cloneDeep(defaultLabelSearchData);
+        const newRiskLevelData = _.cloneDeep(defaultRiskLevelData);
+        const newChannelEventData = _.cloneDeep(defaultChannelEventData);
+        const newRiskReasonData = _.cloneDeep(defaultRiskReasonData);
+        const newRangeTimeData = _.cloneDeep(defaultRangeTimeData);
+        const newQueryParams = _.cloneDeep(queryParams);
+        const newFilterData = _.cloneDeep(filterData);
+        const newSearchList = _.cloneDeep(searchList);
+        const newEventData = _.cloneDeep(defaultEventData);
+        if (urlParams.startTime && urlParams.endTime) {
+            let dateRange = [];
+            dateRange = [
+                moment.unix(urlParams.startTime / 1000).toDate(),
+                moment.unix(urlParams.endTime / 1000).toDate(),
+            ];
+            newRangeTimeData.data.defaultDateRange = dateRange;
+            newQueryParams.startTime = Number(urlParams.startTime);
+            newQueryParams.endTime = Number(urlParams.endTime);
+        }
+        if (urlParams.eventId) {
+            newEventData.data.selectData.defaultValue = urlParams.eventId;
+            newQueryParams.eventId = urlParams.eventId;
+        }
+        if (urlParams.searchKey) {
+            try {
+                newSearchList.map(item => {
+                    let methodIndex  = 0;
+                    if (item.fieldTag === urlParams.searchKey) {
+                        const obj = {
+                            fieldTag: urlParams.searchKey,
+                            method: item.method[methodIndex]?.key,
+                            type: item.method[methodIndex]?.type,
+                            enum: item.method[methodIndex]?.enum,
+                            value: item.method[methodIndex] === METHOD_TYPE
+                                ? [decodeURIComponent(urlParams.searchContent)]
+                                : decodeURIComponent(urlParams.searchContent),
+                        };
+                        newFilterData.push(obj);
+                    }
+                });
+            } catch (error) {
+                console.error(error);
+            }
+        }
+        else {
+            newSearchList.map(item => {
+                if (item.fieldTag === HISTORY_COLUMN.TOKENID) {
+                    newFilterData.push({
+                        fieldTag: item.fieldTag,
+                        method: item.method[0]?.key,
+                        type: item.method[0]?.type,
+                        value: undefined,
+                        enum: item.enum || [],
+                    });
+                }
+            });
+        }
+
+        this.setState({
+            defaultRangeTimeData: newRangeTimeData,
+            defaultLabelSearchData: newLabelSearchData,
+            defaultRiskLevelData: newRiskLevelData,
+            defaultRiskReasonData: newRiskReasonData,
+            defaultChannelEventData: newChannelEventData,
+            defaultEventData: newEventData,
+            queryParams: newQueryParams,
+            filterData: newFilterData,
+            resetCount: _.random(100000),
+        }, () => {
+            if (!isGlobalSearch) {
+                this.doSearch();
+            }
+        });
+    };
+
+    // 获取名单列表
+    getMDList = async () => {
+        const { route, dispatch } = this.props;
+        const { currentGlobalFilter } = this.state;
+        let { organization, appId } = currentGlobalFilter;
+        let listContent = [];
+        if (appId === 'all') {
+            appId = '';
+        }
+        listContent = await dispatch({
+            type: 'history/fetchListService',
+            payload: {
+                organization,
+                appId,
+                product: 'P_TIAN_WANG',
+                type: 1,
+                offset: 0,
+                count: 1000,
+            },
+        });
+        let tokenIdBlackList = [];
+        let ignoreList = [];
+        let sensitiveList = [];
+        let ipBlackList = [];
+        let deviceIdBlackList = [];
+        let phoneMd5BlackList = [];
+        let phoneBlackList = [];
+        listContent.forEach(item => {
+            let config = item.config;
+
+            if (config.checkItems.includes('tokenId')) {
+                if (config.action === 'REJECT') {
+                    tokenIdBlackList.push({
+                        name: item.name,
+                        value: item.listId,
+                    });
+                }
+            }
+            if (config.checkItems.includes('ip')) {
+                if (config.action === 'REJECT') {
+                    ipBlackList.push({
+                        name: item.name,
+                        value: item.listId,
+                    });
+                }
+            }
+            if (config.checkItems.includes('phone')) {
+                if (config.action === 'REJECT') {
+                    phoneBlackList.push({
+                        name: item.name,
+                        value: item.listId,
+                    });
+                }
+            }
+            if (config.checkItems.includes('smid')) {
+                if (config.action === 'REJECT') {
+                    deviceIdBlackList.push({
+                        name: item.name,
+                        value: item.listId,
+                    });
+                }
+            }
+            if (config.checkItems.includes('phoneMd5')) {
+                if (config.action === 'REJECT') {
+                    phoneMd5BlackList.push({
+                        name: item.name,
+                        value: item.listId,
+                    });
+                }
+            }
+            if (
+                config.checkItems.includes('text')
+                && config.checkItems.length === 1
+            ) {
+                if (config.action === 'IGNORE') {
+                    ignoreList.push({
+                        name: item.name,
+                        value: item.listId,
+                    });
+                } else if (config.action === 'REJECT') {
+                    sensitiveList.push({
+                        name: item.name,
+                        value: item.listId,
+                    });
+                }
+            }
+        });
+        this.setState({
+            tokenIdBlackList,
+            ipBlackList,
+            deviceIdBlackList,
+            phoneMd5BlackList,
+            ignoreList,
+            sensitiveList,
+            phoneBlackList,
+        });
+    };
+    getCurrentOrgServiceId = async () => {
+        const { dispatch } = this.props;
+        const { organization } = this.state.currentGlobalFilter;
+        let serviceList = await dispatch({
+            type: 'history/fetchOrgService',
+            payload: {
+                organization: organization,
+            },
+        });
+        const newServiceData = _.cloneDeep(this.state.defaultServiceData);
+        let newOptionData = [];
+        let serviceIdMap = {};
+        if (serviceList && serviceList.length) {
+            serviceList.map(item =>
+                newOptionData.push({
+                    value: item.serviceId,
+                    name: item.name,
+                })
+            );
+        }
+        serviceIdMap = newOptionData;
+        let newArr = [];
+        serviceIdMap.map(item => {
+            newArr.push({
+                [item.value]: item.name,
+            });
+        });
+        newServiceData.data.selectData.optionData = newOptionData;
+        this.setState({
+            defaultServiceData: newServiceData,
+            serviceIdMap: newArr,
+        });
+    };
+    globalFilterChange = obj => {
+        const { isGlobalSearch, queryParams, orgAppChange } = this.state;
+        const {
+            orgChange,
+            appIdChange,
+            clusterIdChange,
+            currentGlobalFilter,
+        } = obj;
+        this.setState(
+            {
+                currentGlobalFilter,
+                listLoading: true,
+            },
+            async () => {
+                if (orgChange) {
+                    const { route } = this.props;
+                    const serviceId = isGlobalSearch
+                        ? 'globalServiceId'
+                        : route.routeData.serviceId;
+                    switch (serviceId) {
+                        case 'globalServiceId':
+                            this.getRiskLevelList();
+                            this.getCurrentOrgServiceId();
+                            this.getOpenOrganization();
+                            break;
+                        case 'POST_EVENT':
+                            // 获取事件列表
+                            this.getEventList();
+                            // 获取识别结果列表
+                            this.getRiskLevelList();
+                            await this.getOpenOrganization();
+                            break;
+                        case 'ANTI_ROBOT_SMS':
+                            // 获取识别结果列表
+                            this.getRiskLevelList();
+                            // 获取风险原因列表
+                            this.getRiskReasonList();
+                            await this.getOpenOrganization();
+                            break;
+                        case 'ANTI_ROBOT_MARKETING':
+                            // 获取识别结果列表
+                            this.getRiskLevelList();
+                            // 获取渠道列表
+                            this.getChannelEventList();
+                            await this.getOpenOrganization();
+                            break;
+                        case 'ACCOUNT_REGISTER':
+                        case 'ACCOUNT_LOGIN':
+                            this.getRiskLevelList();
+                            this.getOpenOrganization();
+                            break;
+                        default:
+                            // 获取识别结果列表
+                            this.getRiskLevelList();
+                    }
+
+                    this.getMDList();
+                    if (isGlobalSearch) {
+                        this.setState({
+                            currentPage: 1,
+                            listLoading: true,
+                        });
+                        setTimeout(() => {
+                            this.setState({
+                                listLoading: false,
+                            });
+                        }, 500);
+                    }
+                    // 不是第一次搜索
+                    if (!this.state.isFirstLoading) {
+                        // 公司改变 重置搜索筛选项
+                        const { queryParams, resetCount } = this.state;
+                        const newQueryParams = _.cloneDeep(queryParams);
+                        newQueryParams.eventId = '';
+                        newQueryParams.channel = '';
+                        if (isGlobalSearch) {
+                            newQueryParams.tokenId = '';
+                            newQueryParams.ip = '';
+                            newQueryParams.deviceId = '';
+                            newQueryParams.requestId = '';
+                            newQueryParams.serviceId = '';
+                            this.setState({
+                                orgAppChange: true,
+                                isDisabled: true,
+                                queryParams: newQueryParams,
+                                currentPage: 1,
+                                resetCount: resetCount + 1,
+                            });
+                            return;
+                        }
+                        this.setState(
+                            {
+                                queryParams: newQueryParams,
+                                filterData: [],
+                                currentPage: 1,
+                            },
+                            () => {
+                                this.getFieldSetHeader(true);
+                            }
+                        );
+                    } else {
+                        this.setState(
+                            {
+                                isFirstLoading: false,
+                            },
+                            () => {
+                                this.getFieldSetHeader();
+                            }
+                        );
+                    }
+                } else if (appIdChange) {
+                    const { route } = this.props;
+                    const serviceId = route.routeData.serviceId;
+                    switch (serviceId) {
+                        case 'ANTI_ROBOT_SMS':
+                            // 获取风险原因列表
+                            this.getRiskReasonList();
+                            break;
+                    }
+                    if (isGlobalSearch) {
+                        this.setState({
+                            orgAppChange: true,
+                            filterData: [],
+                            currentPage: 1,
+                        });
+                        setTimeout(() => {
+                            this.setState({
+                                listLoading: false,
+                            });
+                        }, 500);
+                        return;
+                    }
+                    this.setState(
+                        {
+                            currentPage: 1,
+                            filterData: [],
+                        },
+                        () => {
+                            this.getFieldSetHeader(true);
+                        }
+                    );
+                } else {
+                    this.setState(
+                        {
+                            currentPage: 1,
+                        },
+                        () => {
+                            this.getFieldSetHeader();
+                        }
+                    );
+                }
+            }
+        );
+    };
+    resetParams = () => {
+        const {
+            queryParams,
+            resetCount,
+            defaultChannelEventData,
+            defaultEventData,
+            defaultLabelSearchData,
+        } = this.state;
+        const newQueryParams = _.cloneDeep(queryParams);
+        const newChannelEventData = _.cloneDeep(defaultChannelEventData);
+        const newEventData = _.cloneDeep(defaultEventData);
+        const newDefaultLabelSearchData = _.cloneDeep(defaultLabelSearchData);
+        newDefaultLabelSearchData.data.optionData = DEFAULT_DATA;
+        newChannelEventData.data.selectData.optionData = [];
+        newEventData.data.selectData.optionData = [];
+        newQueryParams.channel = '';
+        newQueryParams.eventId = '';
+        newQueryParams.serviceId = '';
+        newQueryParams.tokenId = '';
+        newQueryParams.deviceId = '';
+        newQueryParams.requestId = '';
+        newQueryParams.ip = '';
+        this.setState({
+            queryParams: newQueryParams,
+            currentPage: 1,
+            resetCount: resetCount + 1,
+            defaultChannelEventData: newChannelEventData,
+            defaultEventData: newEventData,
+            defaultLabelSearchData: newDefaultLabelSearchData,
+        });
+    };
+    serviceIdChangeParams = value => {
+        const { serviceIdChangeCount, defaultLabelSearchData, resetValue } = this.state;
+        const newDefaultLabelSearchData = _.cloneDeep(defaultLabelSearchData);
+        newDefaultLabelSearchData.data.optionData = TOKENID_SERVICES.includes(value) ? TOKENID_DATA : DEFAULT_DATA;
+        this.setState({
+            serviceIdChangeCount: serviceIdChangeCount + 1,
+            resetValue: resetValue + 1,
+            defaultLabelSearchData: newDefaultLabelSearchData,
+        });
+    };
+
+    imgRender = (text, record, index) => {
+        if (text) {
+            return <SMImage url={text} width={100} height={100} />;
+        }
+        return '-';
+    };
+
+    // 格式化表头渲染方式
+    formatTableColumn = (dataSource = []) => {
+        const newData = [
+            ...dataSource,
+            {
+                name: HISTORY_COLUMN.OPERATION,
+                uuid: moment().format('x'),
+                key: OPERATION,
+                [RENDER_TYPE.DETAIL]: true,
+            },
+        ];
+        const tableColumns = newData.map(item => {
+            item.title = item.name || item.title;
+            item.key = item.fieldTag || item.key;
+            item.dataIndex = item.fieldTag || item.key;
+            item.width = item.width || 100;
+            item.ellipsis = true;
+            switch (item.dataIndex) {
+                case HISTORY_COLUMN.TEXT:
+                case HISTORY_COLUMN.AUDIO_TEXT:
+                    item.width = item.width || 200;
+                    item.render = this.newHighLightRender;
+                    break;
+                case HISTORY_COLUMN.RISK_LEVEL:
+                    item.render = this.riskLevelRender;
+                    break;
+                case HISTORY_COLUMN.OPERATION:
+                    item.render = this.detailRender;
+                    item.fixed = 'right';
+                    break;
+                case HISTORY_COLUMN.FEEDBACK:
+                    item.render = this.feedbackRender;
+                    item.width = item.width || 200;
+                    break;
+                case HISTORY_COLUMN.REQUESTID:
+                case HISTORY_COLUMN.TIMESTAMP:
+                case HISTORY_COLUMN.TOKENID:
+                    item.render = this.textRender;
+                    item.width = item.width || 150;
+                    break;
+                case HISTORY_COLUMN.AUDIO_URL:
+                    item.render = this.audioRender;
+                    item.width = item.width || 150;
+                    break;
+                case HISTORY_COLUMN.PHONE_RISK:
+                case HISTORY_COLUMN.DEVICE_RISK:
+                    item.render = (text, record, index) => this.textRender(formatSpecialFeature(text), record, index);
+                    break;
+                case HISTORY_COLUMN.IMG_URL:
+                    item.render = this.imgRender;
+                    break;
+                default:
+                    item.render = this.textRender;
+                    break;
+            }
+
+            return item;
+        });
+
+        return tableColumns;
+    };
+
+    // 获取表头
+    getFieldSetHeader = async isRest => {
+        const {dispatch, route, currentUser, specialServiceId} = this.props;
+        const serviceId = specialServiceId || route.routeData.serviceId;
+        const contents = await dispatch({
+            type: 'manage/queryFieldSetPage',
+            payload: {
+                organization: this.state.currentGlobalFilter.organization,
+                serviceId,
+                pageCategory: FIELD_SOURCE_TYPE.HISTORY_DETAIL,
+            },
+        });
+        const account = currentUser.account;
+        // 音频、音频流serviceId 和其他地方不一致
+        const fieldSort = Storage.get(`${SM_FIELD_SORT}_${serviceId}_${account}`);
+        const list =  [];
+        const detailData = {}; // 详情中的数据
+        const tableColumnList = []; // 表头数据
+        const searchList = []; // 筛选条件
+        const newFilterData = []; // 默认高级模式
+        let isFirst = false;
+        const fieldList = await this.getFieldList();
+        if (_.isArray(fieldSort)) {
+            fieldSort.forEach(item => {
+                const key = item.key || item.name;
+                fieldList.forEach(cItem => {
+                    if (key === cItem.fieldTag || key === cItem.uuid) {
+                        item.uuid = cItem.uuid;
+                        item.fieldTag = cItem.fieldTag;
+                        item.name = cItem.name;
+                        list.push(item);
+                    }
+                });
+            });
+            Storage.set(`${SM_FIELD_SORT}_${serviceId}_${account}`, list);// 更新缓存，缓存中数据和接口请求数据保持一致
+        }
+        contents.map(item => {
+            switch (item.name) {
+                case FILED_SET_DETAIL.LIST:
+                    item.value.forEach(item => {
+                        if (item.fieldTag === FIELD_NAME_LIST.REQUESTID) {
+                            tableColumnList.unshift(item);
+                        }
+                        else {
+                            tableColumnList.push(item);
+                        }
+                    });
+                    break;
+                case FILED_SET_DETAIL.INPUT:
+                case FILED_SET_DETAIL.OUTPUT:
+                    detailData[item.name] = item.value;
+                    break;
+                case FILED_SET_DETAIL.SEARCH:
+                    const value = [];
+                    item.value.map(item => {
+                        if (HISTORY_COLUMN.TOKENID === item.fieldTag) {
+                            value.unshift(item);
+                        }
+                        else {
+                            value.push(item);
+                        }
+                    });
+                    arrayMove(value, 'fieldTag', HISTORY_COLUMN.REQUESTID, 1).map(item => {
+                        // 过滤默认字段
+                        if (!DEFAULT_SCREEN.includes(item.fieldTag)) {
+                            item.value = item.fieldTag;
+                            searchList.push(item);
+                            // 默认新增一个筛选，并保留已有的条件
+                            if (!isFirst && isRest) {
+                                newFilterData.push({
+                                    fieldTag: item.fieldTag,
+                                    method: item.method[0]?.key,
+                                    type: item.method[0]?.type,
+                                    value: undefined,
+                                });
+                                isFirst = true;
+                            }
+                        }
+                    });
+                    break;
+                case FILED_SET_DETAIL.FEATURE:
+                    detailData[item.name] = item.value;
+                    break;
+                default:
+                    break;
+            }
+        });
+        const tableColumns = this.formatTableColumn((fieldSort && fieldSort.length) ? list : tableColumnList);
+        this.setState({
+            headerData: detailData,
+            tableColumns,
+            searchList,
+            filterData: newFilterData,
+            listLoading: false,
+        }, () => {
+            // 切换公司、应用顶部搜索不需要带上url上面的条件查询
+            if (isRest) {
+                this.doSearch();
+            }
+            else {
+                this.setDefaultSearchParams();
+            }
+        });
+    };
+
+    // 获取所有字段
+    getFieldList = async () => {
+        const {currentGlobalFilter} = this.state;
+        const {dispatch} = this.props;
+        let fieldList = [];
+        const result = await dispatch({
+            type: MODEL_TYPE.FIELD_URL_LIST.FIELD_SET_ADD_LIST,
+            payload: {organization: currentGlobalFilter.organization},
+        });
+        if (result && result.length) {
+            result.forEach(item => {
+                fieldList.push(...item.value);
+            });
+        }
+
+        return fieldList;
+    };
+
+    // 保持字段设置
+    formatField = data => {
+        const {route, specialServiceId, t} =  this.props;
+        const serviceId = specialServiceId || route.routeData.serviceId;
+        const acccount = this.props.currentUser.account;
+        const storageName = `${SM_FIELD_SORT}_${serviceId}_${acccount}`;
+        Storage.set(storageName, data);
+        message.success(t('字段顺序调整已保存在浏览器缓存中，清除缓存会以系统默认顺序展示。'));
+        this.setState({
+            tableColumns: this.formatTableColumn(data) || [],
+        }, () => global.modal.pop());
+    };
+
+    // 添加信息字段
+    detailField = () => {
+        const {organization} = this.state.currentGlobalFilter;
+        const {route, currentUser, specialServiceId, t} = this.props;
+        const serviceId = specialServiceId || route.routeData.serviceId;
+        const acccount = currentUser.account;
+        const data = _.cloneDeep(this.state.tableColumns);
+        const storageName = `${SM_FIELD_SORT}_${serviceId}_${acccount}`;
+        const newData = [];
+        data.filter(item => {
+            if (![HISTORY_COLUMN.OPERATION, HISTORY_COLUMN.AUDIO_URL].includes(item.key)) {
+                newData.push({
+                    name: item.name,
+                    key: item.key,
+                    uuid: item.uuid,
+                    title: `${item.name}(${item.key})`,
+                });
+            }
+        });
+        global.modal.show(ModalType.MODAL_ALERT, {
+            width: 676,
+            modalTitle: t('设置列表字段'),
+            renderChildren: () => {
+                return (
+                    <div className={styles.hint}>
+                        <FieldMessageModal
+                            {...this.props}
+                            serviceId={serviceId}
+                            organization={organization}
+                            storageName={storageName}
+                            dataSource={newData}
+                            source={FIELD_SOURCE_TYPE.HISTORY_DETAIL}
+                            handleSubmit={this.formatField}
+                        />
+                    </div>
+                );
+            },
+        });
+    };
+
+
+    // 请求搜索
+    doSearch = () => {
+        backTop();
+        this.setState({
+            listLoading: true,
+        }, () => {
+            this.getHistoryList();
+        });
+    };
+
+    setNewTableColumns = () => {
+        const { getOtherColumns } = this.props;
+        const { tableDataSource, tableColumns } = this.state;
+        if (tableColumns) {
+            let newArr = [];
+            if (tableDataSource.length > 0 && getOtherColumns) {
+                tableDataSource.map(item => item = item.currentData)
+                    .map(item => item = getOtherColumns(item))
+                    .map(item => item.map(key => newArr.push(key)));
+                newArr = _.uniqWith(newArr, _.isEqual);
+                newArr.map(item => item.render = this.textRender);
+                this.setState({
+                    tableColumns: _.unionWith(tableColumns, newArr, _.isEqual),
+                });
+            }
+        }
+    };
+
+    // 列表导出
+    exportData = callback => {
+        const {route, t} = this.props;
+        const {isGlobalSearch, tableColumns} = this.state;
+        this.setState({
+            exportLoading: true,
+        });
+        let newSearchParams = this.getSearchParams();
+        newSearchParams.count = isGlobalSearch ? DOWNLOAD_NUMBER.GLOBAL : DOWNLOAD_NUMBER.NORMAL;
+        newSearchParams.fieldSet = tableColumns.filter(item => item.name !== HISTORY_COLUMN.OPERATION)
+            .map(item => item.uuid);
+        const titleMap = {
+            ACCOUNT_REGISTER: '注册风险趋势',
+            ACCOUNT_LOGIN: '登录风险趋势',
+            POST_EVENT: '事件风险趋势',
+            ANTI_ROBOT_MARKETING: '羊毛党防刷',
+            ANTI_ROBOT_SMS: '短信通道保护',
+        };
+        let downloadTitle = t(titleMap[route.routeData.serviceId]);
+        let downloadUrl = '/webapi/v2/history/download';
+
+        let title = isGlobalSearch
+            ? `${t('全局检索')}-${t('历史记录表')}`
+            : `${t('天网')}-${t(downloadTitle)}-${t('历史记录表')}.xlsx`;
+
+        exportFile(downloadUrl, title, newSearchParams).then(() => {
+            this.setState({
+                exportLoading: false,
+            });
+        });
+    };
+
+    timeRender = (text, record, index) => {
+        const contentText = text.slice(5);
+        const toolTipTitle = <span className={styles.tooltip}>{text}</span>;
+        return (
+            <Tooltip title={toolTipTitle} placement="left">
+                <span className={styles.text}>{contentText}</span>
+            </Tooltip>
+        );
+    };
+
+    textRender = (text, record, index) => {
+        text = formatDataToString(text);
+        const toolTipTitle = <span className={styles.tooltip}>{text}</span>;
+        return (
+            <Tooltip title={toolTipTitle} placement="left">
+                <CopyToClipboard
+                    className={styles.copy}
+                    text={text || '-'}
+                    onCopy={() => message.success('复制成功')}
+                >
+                    <span>{_.isNil(text) ? '-' : text}</span>
+                </CopyToClipboard>
+            </Tooltip>
+        );
+    };
+
+    riskLevelRender = (text, record, index) => {
+        const riskLevelStr = text;
+        const riskLevel = record.rawValue?.riskLevel;
+        return (
+            <SMRiskLevel riskLevel={riskLevel} riskLevelStr={riskLevelStr} />
+        );
+    };
+
+    detailRender = (text, record, index) => {
+        const {t, currentUser} = this.props;
+        const account = currentUser?.account;
+        // 特殊账号展示处置按钮
+        const showDisposalButton = SHOW_DISPOSAL_ACCOUNT.includes(account);
+        // 全局历史记录  有一部分服务不显示详情
+        const isHidden = HIDDEN_SERVICES.includes(record.rawValue?.serviceId || ALL);
+        /* 2025-01-20 旧代码 */
+        return getAuthFunction(AUTH_FUNCTION.DETAIL) && (
+            isHidden ? (
+                <span>-</span>
+            ) : (
+                <span
+                    className={styles.action}
+                    onClick={() => {
+                        this.clickDetail(index);
+                    }}
+                >
+                    {t(record.detail || '详情')}
+                </span>
+            )
+        );
+        /* 2025-01-20 旧代码 */
+
+        /* 2025-01-20 新代码 */
+        // return (
+        //     <span>
+        //         {
+        //             getAuthFunction(AUTH_FUNCTION.DETAIL) && (
+        //                 isHidden ? (
+        //                     <span>-</span>
+        //                 ) : (
+        //                     <span
+        //                         className={styles.action}
+        //                         onClick={() => {
+        //                             this.clickDetail(index);
+        //                         }}
+        //                     >
+        //                         {t(record.detail || '详情')}
+        //                     </span>
+        //                 )
+        //             )
+        //         }
+        //         {showDisposalButton && (
+        //             <DisposalModal
+        //                 style={{marginLeft: 15}}
+        //             >
+        //                 <span
+        //                     className={styles.action}
+        //                 >
+        //                     {t('处置')}
+        //                 </span>
+        //             </DisposalModal>
+        //         )}
+        //     </span>
+        // );
+        /* 2025-01-20 新代码 */
+    };
+
+    // 文本飘红
+    newHighLightRender = (text, record, index) => {
+        const keywords = record[HISTORY_COLUMN.MATCHED_ITEM];
+        const {t} = this.props;
+        const toolTipTitle = (
+            <span className={styles.tooltip}>
+                <SMText content={text} keywords={keywords} />
+            </span>
+        );
+
+        return (
+            <Tooltip title={toolTipTitle} placement="left">
+                <CopyToClipboard
+                    onCopy={() => message.success(t('复制成功'))}
+                    text={text}
+                    className={styles.copy}
+                >
+                    <span>
+                        <SMText
+                            content={text}
+                            keywords={keywords}
+                            ellipsis
+                        />
+                    </span>
+                </CopyToClipboard>
+
+            </Tooltip>
+        );
+    };
+
+    highLightRender = (text, record, index) => {
+        const matchedItem = record.currentData.output.matchedItem || '';
+        const toolTipTitle = (
+            <span className={styles.tooltip}>
+                <SMText content={text} keywords={matchedItem} />
+            </span>
+        );
+        return (
+            <Tooltip title={toolTipTitle} placement="left">
+                <span>
+                    <SMText content={text} keywords={matchedItem} ellipsis />
+                </span>
+            </Tooltip>
+        );
+    };
+
+    feedbackRender = (text, record, index) => {
+        const {t} = this.props;
+        const feedback = record.feedback;
+        const errorDisabled
+            = feedback || record.rawValue.riskLevel === 'PASS';
+        const missDisabled
+            = feedback || record.rawValue.riskLevel === 'REJECT';
+
+        return getAuthFunction(AUTH_FUNCTION.FEEDBACK) && (
+            <div>
+                <Popconfirm
+                    title="当前操作会将账号加入白名单，是否确认提交?"
+                    onConfirm={() => {
+                        if (!errorDisabled) {
+                            this.errorFeedback(record, index);
+                        }
+                    }}
+                >
+                    <span
+                        className={[styles.action, errorDisabled ? styles.disabled : ''].join(' ')}
+                        style={{ marginRight: '5px' }}
+                    >
+                        {t('误杀')}
+                    </span>
+                </Popconfirm>
+                <Popconfirm
+                    title="当前操作会将账号加入黑名单，是否确认提交?"
+                    onConfirm={() => {
+                        if (!missDisabled) {
+                            this.missFeedback(record, index);
+                        }
+                    }}
+                >
+                    <span
+                        className={[styles.action, missDisabled ? styles.disabled : ''].join(' ')}
+                    >
+                        {t('漏杀')}
+                    </span>
+                </Popconfirm>
+
+            </div>
+        );
+    };
+
+    /**
+     * 误杀
+     * @param {*} currentData 当前项数据
+     * @param {*} index  当前数据在列表中的index
+     */
+    errorFeedback = async (currentData, index) => {
+        const {dispatch, route, formatData, t} = this.props;
+        const { organization } = this.state.currentGlobalFilter;
+        let result = await dispatch({
+            type: 'history/fetchCorrection',
+            payload: {
+                organization: organization,
+                serviceId: route.routeData.serviceId,
+                riskLevel: 'PASS',
+                type: 'error',
+                tokenId: currentData.tokenId,
+                eventId: currentData.rawValue.eventId,
+                requestId: currentData.requestId,
+                timestamp: currentData.rawValue.timestamp,
+            },
+        });
+        if (result === 1100) {
+            const { listData, channelMap } = this.state;
+            const newListData = _.cloneDeep(listData);
+            newListData[index].feedback = 1;
+            this.setState(
+                {
+                    listData: newListData,
+                    tableDataSource: newListData,
+                },
+                () => {
+                    message.success(t('提交成功'));
+                }
+            );
+        }
+    };
+
+    /**
+     * 漏杀
+     * @param {*} currentData 当前项数据
+     * @param {*} index  当前数据在列表中的index
+     */
+    missFeedback = async (currentData, index) => {
+        const {dispatch, route, formatData, t} = this.props;
+        const { organization } = this.state.currentGlobalFilter;
+        let result = await dispatch({
+            type: 'history/fetchCorrection',
+            payload: {
+                organization: organization,
+                serviceId: route.routeData.serviceId,
+                riskLevel: 'REJECT',
+                type: 'miss',
+                tokenId: currentData.tokenId,
+                eventId: currentData.rawValue.eventId,
+                requestId: currentData.requestId,
+                timestamp: currentData.rawValue.timestamp,
+            },
+        });
+        if (result === 1100) {
+            const { listData, channelMap } = this.state;
+            let newListData = _.cloneDeep(listData);
+            newListData[index].feedback = 1;
+            this.setState(
+                {
+                    listData: newListData,
+                    tableDataSource: newListData,
+                },
+                () => {
+                    message.success(t('提交成功'));
+                }
+            );
+        }
+    };
+
+    changeDetailData = e => {
+        // 没有打开详情时 不做处理
+        if (!this.state.detailVisible) {
+            return;
+        }
+        const {
+            detailIndex,
+            listData,
+            currentPage,
+            pageSize,
+            listTotalCount,
+        } = this.state;
+        const {t} =  this.props;
+        let newIndex = 0;
+        let newDetailData = {};
+        if (e && e.keyCode === 37) {
+            if (currentPage === 1 && detailIndex === 0) {
+                message.info(t('已经是第一条数据了'));
+                return;
+            } else if (detailIndex === 0) {
+                this.setState(
+                    {
+                        currentPage: currentPage - 1,
+                        detailIndex: pageSize - 1,
+                    },
+                    () => {
+                        this.doSearch();
+                    }
+                );
+            } else {
+                newIndex = detailIndex - 1;
+                newDetailData = listData[newIndex];
+                this.setState({
+                    detailIndex: newIndex,
+                    detailData: newDetailData,
+                });
+            }
+        } else if (e && e.keyCode === 39) {
+            if (
+                (currentPage - 1) * pageSize + detailIndex + 1
+                === listTotalCount
+            ) {
+                message.info(t('已经是最后一条数据了'));
+                return;
+            } else if (detailIndex === pageSize - 1) {
+                this.setState(
+                    {
+                        currentPage: currentPage + 1,
+                        detailIndex: 0,
+                    },
+                    () => {
+                        this.doSearch();
+                    }
+                );
+            } else {
+                newIndex = detailIndex + 1;
+                newDetailData = listData[newIndex];
+                this.setState({
+                    detailIndex: newIndex,
+                    detailData: newDetailData,
+                });
+            }
+        }
+    };
+
+    clickDetail = index => {
+        const {
+            listData,
+            currentPage,
+            isGlobalSearch,
+            pageSize,
+        } = this.state;
+
+        const newIndex = index + (currentPage - 1) * pageSize;
+        const currentData = isGlobalSearch ? listData[newIndex] : listData[index];
+        // 格式化 详情数据
+        this.setState({
+            detailIndex: index,
+            detailData: currentData,
+            detailVisible: true,
+        });
+    };
+
+    closeDetail = () => {
+        this.setState({
+            detailVisible: false,
+            detailIndex: 0,
+        });
+    };
+
+    // 获取策略解释窗口信息
+    strategyModel = async model => {
+        const {route} = this.props;
+        const {listData, detailIndex} = this.state;
+        const activityData = listData[detailIndex];
+        this.setState({ // 体验优化，接口未返回数据时候先清空文本内容；
+            modelText: ' ',
+        });
+        const content = await this.props.dispatch({
+            type: 'strategy/getRuleDetail',
+            payload: {
+                clientEventId: activityData.rawValue?.eventId,
+                ruleId: model,
+                serviceId: route.routeData.serviceId,
+            },
+        }) || {};
+        this.setState({
+            modelText: content?.marker,
+        });
+    };
+
+    /**
+     * 详情抽屉中的 点击事件（筛选，重置画像之类的）
+     * @param {*} actionType 行为类型
+     * @param {*} key 字段名
+     * @param {*} value 对应字段的值
+     * @param {*} otherData 其余data对象
+     */
+    onActionClick = async (actionType, key, value, otherData) => {
+        const {t} = this.props;
+        switch (actionType) {
+            case 'screen':
+                const { queryParams } = this.state;
+                // const { startTime, endTime, riskType = '', description = '', riskLevel = '' } = queryParams;
+                const encodeValue = encodeURIComponent(value);
+                let searchQuery = `isScreen=true&searchKey=${key}&searchContent=${encodeValue}`;
+                for (let i in queryParams) {
+                    searchQuery += `&${i}=${queryParams[i]}`;
+                }
+                // 从配置中读取要跳转的路由
+                let searchPath = otherData.path;
+                let newUrl = encodeURI(`${searchPath}?${searchQuery}`);
+                window.open(__ASSETS_PREFIX__ + newUrl);
+                break;
+            case 'resetPortrait':
+                const { currentGlobalFilter } = this.state;
+                const { organization } = currentGlobalFilter;
+                const { dispatch, route } = this.props;
+                let code = await dispatch({
+                    type: 'history/fetchResetProfile',
+                    payload: {
+                        organization,
+                        key: `${organization}_${value}`,
+                        type: otherData.type,
+                        serviceId: route.routeData.serviceId,
+                    },
+                });
+                if (code === 1100) {
+                    message.success(t('重置画像成功'));
+                } else {
+                    message.error(t('重置画像失败,请重试'));
+                }
+                break;
+            case 'addList':
+                const { type } = otherData;
+                const {
+                    ignoreList,
+                    sensitiveList,
+                    tokenIdBlackList,
+                    ipBlackList,
+                    deviceIdBlackList,
+                    phoneBlackList,
+                    phoneMd5BlackList,
+                } = this.state;
+                let newCurrentListData = [];
+                switch (type) {
+                    case 'ignore':
+                        newCurrentListData = ignoreList;
+                        break;
+                    case 'sensitive':
+                        newCurrentListData = sensitiveList;
+                        break;
+                    case 'tokenId':
+                        newCurrentListData = tokenIdBlackList;
+                        break;
+                    case 'ip':
+                        newCurrentListData = ipBlackList;
+                        break;
+                    case 'deviceId':
+                    case 'smid':
+                        newCurrentListData = deviceIdBlackList;
+                        break;
+                    case 'phone':
+                        newCurrentListData = phoneBlackList;
+                        break;
+                    case 'phoneMd5':
+                        newCurrentListData = phoneMd5BlackList;
+                        break;
+                }
+                this.setState({
+                    currentListData: newCurrentListData,
+                    listModalVisible: true,
+                    currentListValue: value,
+                });
+                break;
+            case 'model':
+                this.strategyModel(value);
+                break;
+        }
+    };
+
+    listOnSearch = (pagination, filters, sorter) => {
+        const { isGlobalSearch } = this.state;
+        const { current, pageSize } = pagination;
+        let { order } = sorter;
+        order = order === 'ascend' ? 'asc' : 'desc';
+        const { queryParams } = this.state;
+        const newQueryParams = _.cloneDeep(queryParams);
+        newQueryParams.sort = order;
+        this.setState(
+            {
+                currentPage: current,
+                pageSize: pageSize,
+                queryParams: newQueryParams,
+                detailIndex: 0,
+            },
+            () => {
+                if (!isGlobalSearch) {
+                    this.doSearch();
+                }
+            }
+        );
+    };
+
+    // 通过字段配置的方式获取数据
+    getFieldSetList = async parameter => {
+        const {dispatch} = this.props;
+        return await dispatch({
+            type: MODEL_TYPE.HISTORY_LIST.TEXT_LIST,
+            payload: parameter,
+        });
+    };
+
+    // 获取历史记录列表数据
+    getHistoryList = async () => {
+        const newParams = this.getSearchParams();
+        const {listData, totalCount, realTotalCount} = await this.getFieldSetList(newParams);
+        this.setState({
+            orgAppChange: false,
+            listLoading: false,
+            tableDataSource: listData,
+            listData,
+            listTotalCount: totalCount,
+            listRealTotalCount: _.isNil(realTotalCount) ? undefined : realTotalCount,
+            detailData: listData[this.state.detailIndex],
+        });
+    };
+
+    // 获取查询接口参数
+    getSearchParams = () => {
+        const { route, specialServiceId = '' } = this.props;
+        const {
+            currentGlobalFilter,
+            isGlobalSearch,
+            queryParams,
+            currentPage,
+            pageSize,
+            filterData,
+        } = this.state;
+        const { organization, appId } = currentGlobalFilter;
+
+        const serviceId = specialServiceId || route.routeData.serviceId;
+        const search = _.cloneDeep(filterData).filter(item => item.value && item.value.length).map(item => {
+            delete item.enum;
+            return item;
+        }) || [];
+        let searchParams = {
+            organization: organization,
+            appId: appId,
+            count: isGlobalSearch ? 5000 : pageSize,
+            offset: (currentPage - 1) * pageSize,
+            isAll: isGlobalSearch ? 1 : 0,
+            search,
+            ...queryParams,
+            // 全局历史记录检索 如果没有选择服务，serviceId 传GLOBAL
+            serviceId: isGlobalSearch
+                ? queryParams.serviceId && !(queryParams.serviceId === ALL)
+                    ? queryParams.serviceId
+                    : SM_ACCOUNT
+                : serviceId,
+        };
+        // 处理一下searchParams，如果为'' || 'all', 则删除该项
+        let newSearchParams = formatArrayParams(formatSearchParams(searchParams));
+        return newSearchParams;
+    };
+
+    // 获取渠道事件列表
+    getChannelEventList = async value => {
+        const { isGlobalSearch } = this.state;
+        const { dispatch, route } = this.props;
+        if (dispatch) {
+            let channelEventList = await dispatch({
+                type: 'base/fetchChannelEventList',
+                payload: {
+                    organization: this.state.currentGlobalFilter.organization,
+                    serviceId: isGlobalSearch
+                        ? value
+                        : route.routeData.serviceId,
+                },
+            });
+            if (channelEventList) {
+                this.setState({
+                    channelEventList,
+                });
+                let channelMap = {};
+                let newOptionData = [];
+                const channels = [];
+                const newChannelEventData = _.cloneDeep(
+                    this.state.defaultChannelEventData
+                );
+                channelEventList.forEach(item => {
+                    newOptionData.push({
+                        value: `${item.channel}`,
+                        name: item.displayName,
+                    });
+                    if (item.channel !== '') {
+                        channelMap[item.channel] = item.channelName;
+                    }
+                    channels.push(item.channel);
+                });
+                newChannelEventData.data.selectData.optionData = newOptionData;
+                newChannelEventData.data.selectData.doSearch = this.doSearch;
+                this.setState({
+                    defaultChannelEventData: newChannelEventData,
+                    channelMap,
+                });
+            }
+        }
+    };
+
+    // 获取事件列表
+    getEventList = async value => {
+        const { isGlobalSearch, queryParams } = this.state;
+        const { dispatch, route } = this.props;
+        let eventList = await dispatch({
+            type: 'base/fetchOpenEvent',
+            payload: {
+                organization: this.state.currentGlobalFilter.organization,
+                serviceId: isGlobalSearch ? value : route.routeData.serviceId,
+                isGlobalEvent: 0,
+            },
+        });
+        const newEventData = _.cloneDeep(this.state.defaultEventData);
+        let newOptionData = [];
+        let eventIdMap = {};
+        if (eventList.length) {
+            eventList[0].events.forEach(item => {
+                newOptionData.push({
+                    value: item.clientEventId,
+                    name: item.eventName,
+                });
+                if (item.eventId !== '') {
+                    eventIdMap[item.clientEventId] = item.eventName;
+                }
+            });
+        }
+        newEventData.data.selectData.optionData = newOptionData;
+        newEventData.data.selectData.doSearch = this.doSearch;
+        this.setState({
+            defaultEventData: newEventData,
+            eventIdMap,
+        });
+    };
+
+    // 获取识别结果列表
+    getRiskLevelList = async () => {
+        const { dispatch, route } = this.props;
+        if (dispatch) {
+            let riskLevelList = await dispatch({
+                type: 'base/fetchRiskLevelList',
+                payload: {
+                    organization: this.state.currentGlobalFilter.organization,
+                    serviceId: route.routeData.serviceId,
+                },
+            });
+            const newRiskLevelData = _.cloneDeep(
+                this.state.defaultRiskLevelData
+            );
+            let newOptionData = [{
+                value: 'all',
+                label: '全部',
+            }];
+            let riskLevelMap = {};
+            let verifyTypeMap = {};
+            if (riskLevelList) {
+                riskLevelList.forEach(item => {
+                    let children
+                        = item.son
+                        && item.son.map(data => {
+                            verifyTypeMap[data.risk_level]
+                                = data.risk_level_name;
+                            return {
+                                value: data.risk_level,
+                                label: data.risk_level_name,
+                            };
+                        });
+                    let itemOption = {
+                        value: item.risk_level,
+                        label: item.risk_level_name,
+                    };
+
+                    riskLevelMap[item.risk_level] = item.risk_level_name;
+
+                    if (children && children.length) {
+                        children.unshift({
+                            value: '',
+                            label: '全部',
+                        });
+                        itemOption.children = children;
+                    }
+                    newOptionData.push(itemOption);
+                });
+            }
+            newRiskLevelData.data.selectData.optionData = newOptionData;
+            newRiskLevelData.data.selectData.doSearch = this.reDoSearch;
+            this.setState({
+                defaultRiskLevelData: newRiskLevelData,
+                riskLevelMap,
+                verifyTypeMap,
+            });
+        }
+    };
+    // 获取当前公司是否开通30天以上的数据
+    getOpenOrganization = async () => {
+        const {dispatch, route, specialServiceId} = this.props;
+        const serviceId = specialServiceId || route.routeData.serviceId;
+        const newRangeTimeData = _.cloneDeep(this.state.defaultRangeTimeData);
+        if (dispatch) {
+            let {storageTime} = await dispatch({
+                type: 'history/getOpenOrganization',
+                payload: {
+                    organization: this.state.currentGlobalFilter.organization,
+                    serviceId,
+                },
+            });
+            // 全局只能查30天
+            storageTime = serviceId === SM_ACCOUNT ? 30 : storageTime;
+            const {disabledDateEnd} = getDisabledDate(storageTime);
+            newRangeTimeData.data.disabledDateFeedback = disabledDateEnd;
+            this.setState({
+                defaultRangeTimeData: newRangeTimeData,
+                storageTime,
+            });
+        }
+    };
+    // 获取风险原因列表
+    getRiskReasonList = async () => {
+        const { dispatch, route } = this.props;
+        let riskReasonList = await dispatch({
+            type: 'base/fetchRiskReasonList',
+            payload: {
+                organization: this.state.currentGlobalFilter.organization,
+                serviceId: route.routeData.serviceId,
+                appId: this.state.currentGlobalFilter.appId,
+                eventId: 'sms',
+            },
+        });
+        const riskAllList = [];
+        const newRiskReasonData = _.cloneDeep(
+            this.state.defaultRiskReasonData
+        );
+        let newOptionData = [];
+        if (riskReasonList.length) {
+            riskReasonList.forEach(item => {
+                newOptionData.push({
+                    value: item,
+                    name: item,
+                });
+                riskAllList.push(item);
+            });
+        }
+        newRiskReasonData.data.selectData.optionData = newOptionData;
+        newRiskReasonData.data.selectData.doSearch = this.doSearch;
+        this.setState({
+            defaultRiskReasonData: newRiskReasonData,
+            riskList: riskAllList,
+        });
+    };
+
+    // 获取搜索菜单
+    getFormData() {
+        let formData = [];
+        const {
+            defaultRangeTimeData,
+            defaultRiskLevelData,
+            defaultEventData,
+            defaultChannelEventData,
+            defaultRiskReasonData,
+            defaultServiceData,
+        } = this.state;
+
+        const {route} = this.props;
+        const serviceId = route.routeData.serviceId;
+        switch (serviceId) {
+            case 'ACCOUNT_REGISTER':
+                formData.push(
+                    defaultRangeTimeData,
+                    defaultRiskLevelData
+                );
+                break;
+            case 'ACCOUNT_LOGIN':
+                formData.push(
+                    defaultRangeTimeData,
+                    defaultRiskLevelData
+                );
+                break;
+            case 'POST_EVENT':
+                formData.push(
+                    defaultRangeTimeData,
+                    defaultRiskLevelData,
+                    defaultEventData
+                );
+                break;
+            case 'ANTI_ROBOT_MARKETING':
+                formData.push(
+                    defaultRangeTimeData,
+                    defaultRiskLevelData,
+                    defaultChannelEventData
+                );
+                break;
+            case 'ANTI_ROBOT_SMS':
+                formData.push(
+                    defaultRangeTimeData,
+                    defaultRiskLevelData,
+                    defaultRiskReasonData
+                );
+                break;
+            case SM_ACCOUNT:
+                formData.push(
+                    defaultRangeTimeData,
+                    defaultServiceData,
+                    defaultEventData,
+                    defaultRiskLevelData,
+                    defaultChannelEventData
+                );
+        }
+
+        return formData;
+    }
+
+
+    /**
+     * 搜索筛选项更改
+     * @param {*} name   更改筛选项类型名称
+     * @param {*} value  更改后的值
+     */
+    changeQueryParams(name, value) {
+        const {
+            queryParams,
+            isGlobalSearch,
+            channelMap,
+            riskList = [],
+        } = this.state;
+        const {defaultRiskLevelData} = this.state;
+        const newRiskLevelData = _.cloneDeep(defaultRiskLevelData);
+        const newQueryParams = _.cloneDeep(queryParams);
+        switch (name) {
+            case 'serviceId':
+                newQueryParams.serviceId = value;
+                this.getEventList(value);
+                this.getChannelEventList(value);
+                this.serviceIdChangeParams(value);
+                newQueryParams.channel = '';
+                newQueryParams.eventId = '';
+                newQueryParams.tokenId = '';
+                newQueryParams.ip = '';
+                newQueryParams.deviceId = '';
+                newQueryParams.requestId = '';
+                break;
+            case 'time':
+                let startTime = Number(value[0].format('x'));
+                let endTime = Number(value[1].format('x'));
+                newQueryParams.startTime = startTime;
+                newQueryParams.endTime = endTime;
+                break;
+            case 'riskLevel':
+                const newValue = value || [];
+                newQueryParams.riskLevel = newQueryParams.riskLevel = !newValue[0] || newValue[0] === ALL
+                    ? ''
+                    : [newValue[0]];
+                newQueryParams.verifyType = newValue[1] || '';
+                newRiskLevelData.data.selectData.defaultValue = newValue;
+                break;
+            case 'eventId':
+                newQueryParams.eventId = value;
+                break;
+            case 'labelSearch':
+                const { defaultLabelSearchData } = this.state;
+                defaultLabelSearchData.data.optionData.forEach(item => {
+                    newQueryParams[item.value] = '';
+                });
+                newQueryParams[value.searchId] = value.searchText || '';
+                break;
+            default:
+                newQueryParams[name] = value;
+        }
+        this.setState(
+            {
+                queryParams: newQueryParams,
+                defaultRiskLevelData: newRiskLevelData,
+                currentPage: 1,
+                detailIndex: 0,
+            },
+            () => {
+                if (isGlobalSearch) {
+                    this.handleGlobalSearchDisable();
+                }
+            }
+        );
+    }
+
+    // 全局历史记录必须有值 查询按钮才能用
+    handleGlobalSearchDisable() {
+        const {queryParams} = this.state;
+        const {serviceId} = queryParams;
+        if (serviceId && serviceId !== 'all') {
+            this.setState({
+                isDisabled: false,
+            });
+        }
+        else if (this.isFilterValue()) {
+            this.setState({
+                isDisabled: false,
+            });
+        }
+        else {
+            this.setState({
+                isDisabled: true,
+            });
+        }
+    }
+
+    /**
+     * 组合查询是否输入已查询的值
+     */
+    isFilterValue = () => {
+        const {filterData, isGlobalSearch} = this.state;
+        // 历史数据全局检索 组合查询如果有值查询按钮 取消禁止状态
+        let isValue = false;
+        filterData.forEach(item => {
+            if (
+                isGlobalSearch
+                && ((_.isArray(item.value) && item.value.length) || (_.isString(item.value) && item.value))
+            ) {
+                isValue = true;
+            }
+        });
+        return isValue;
+    };
+
+    /**
+     * 按钮点击事件
+     * @param {*} val
+     */
+    onButtonClick(name) {
+        switch (name) {
+            case 'exportHistory': // 历史数据提取
+                this.setState({
+                    exportTaskVisible: true,
+                });
+                break;
+            case 'historySearch':
+                this.setState(
+                    {
+                        orgAppChange: false,
+                        listLoading: true,
+                    },
+                    () => {
+                        this.doSearch();
+                    }
+                );
+                break;
+            case 'historyReset':
+                this.resetParams();
+                break;
+        }
+    }
+
+    // 输入框绑定按钮事件
+    onFilterKeyDown = e => {
+        if (e && e.key === KEYBOARD_CODER.ENTER) {
+            this.setState({currentPage: 1}, () => this.doSearch());
+        }
+    };
+
+    // 组合查询赋值
+    filterSetState = (stateList, isrRefresh) => {
+        const {isGlobalSearch} = this.state;
+        const stateObj = {};
+        _.forEach(stateList, item => {
+            stateObj[item.key] = item.value;
+        });
+        this.setState({...stateObj, isrRefresh: isrRefresh || this.state.isrRefresh}, () => {
+            // zhangzhe 2022-12-14 全局搜索组合查询修改后 也随之检查查询按钮禁用状态，否则查询按钮不能点亮
+            if (isGlobalSearch) {
+                this.handleGlobalSearchDisable();
+            }
+        });
+    };
+
+    // table 表头自定义dom
+    showExtraDom = () => {
+        const {route, t, isIntl} = this.props;
+        const {isGlobalSearch, isDisabled} = this.state;
+        const serviceId = route.routeData.serviceId;
+        const domData = [];
+        const exportList = [
+            SERVICEID_LIST.ACCOUNT_REGISTER,
+            SERVICEID_LIST.ACCOUNT_LOGIN,
+            SERVICEID_LIST.POST_EVENT,
+            SERVICEID_LIST.ANTI_ROBOT_SMS,
+        ];// 注册、登录、事件、短信 显示历史数据导出按钮
+        if (
+            exportList.includes(serviceId)
+            && !isPrivate()
+            && getAuthFunction(AUTH_FUNCTION.EXPORT_HISTORY)
+            && !isIntl
+        ) {
+            domData.push(
+                <Button
+                    onClick={() => this.setState({exportTaskVisible: true})}
+                >
+                    {t('历史数据导出')}
+                </Button>);
+        }
+        if (getAuthFunction(AUTH_FUNCTION.EXPORT)) {
+            domData.push(
+                <Spin
+                    spinning={this.state.exportLoading}
+                >
+                    <SMIcon
+                        type="icon-daochu"
+                        onClick={() => {
+                            if (!(isGlobalSearch && isDisabled)) {
+                                this.exportData();
+                            }
+                            else {
+                                message.warning(t('请选择条件'));
+                            }
+                        }}
+                    />
+                </Spin>
+            );
+        }
+        return (
+            <div className={styles['extra-dom']}>
+                {domData}
+                <SMIcon type="icon-yingyongguanlilanse" onClick={this.detailField} />
+            </div>
+        );
+    };
+
+    // 返回第一页并且重写查询
+    reDoSearch = () => {
+        this.setState({currentPage: 1}, () => this.doSearch());
+    };
+
+    // 保存操作列
+    saveColumns = _.debounce(column => {
+        const {route, currentUser, specialServiceId} = this.props;
+        const serviceId = specialServiceId || route.routeData.serviceId;
+        const acccount = currentUser.account;
+        Storage.set(`${SM_FIELD_SORT}_${serviceId}_${acccount}`, column);// 更新缓存，缓存中数据和接口请求数据保持一致
+        this.setState({tableColumns: column});
+    }, 1000);
+
+    render() {
+        const {t} = this.props;
+        const formData = this.getFormData();
+        const {
+            listLoading,
+            tableDataSource,
+            tableColumns,
+            detailData,
+            detailVisible,
+            listTotalCount,
+            listRealTotalCount,
+            currentPage,
+            pageSize,
+            pageSizeOptions,
+            currentListData,
+            currentListValue,
+            listModalVisible,
+            currentGlobalFilter,
+            exportTaskVisible,
+            defaultChannelEventData,
+            defaultRiskLevelData,
+            defaultEventData,
+            defaultRiskReasonData,
+            channelMap,
+            eventIdMap,
+            riskLevelMap,
+            verifyTypeMap,
+            defaultAppIdData,
+            resetCount,
+            isGlobalSearch,
+            isDisabled,
+            serviceIdMap,
+            orgAppChange,
+            storageTime,
+            modelText,
+            filterData,
+            headerData,
+            serviceIdChangeCount,
+            searchList,
+        } = this.state;
+        defaultAppIdData.data.selectData.optionData = formatAppList();
+        const {
+            route,
+            formatHistoryTaskFormColumns = () => {},
+            buildHistoryTaskDetail = () => {},
+            currentUser,
+        } = this.props;
+        const serviceId = route.routeData.serviceId;
+        const { appId, organization } = currentGlobalFilter;
+        const newTableColumns = tableColumns.filter(item => {
+            if (organization === SM_ACCOUNT) {
+                return item.key !== 'feedback';
+            }
+            return true;
+        });
+        return (
+            <div>
+                <GlobalFilterListener onChange={this.globalFilterChange} />
+                <SMBackTop />
+                <div className={styles['content-top']}>
+                    <SMSearchForm
+                        formData={formData}
+                        resetCount={resetCount}
+                        serviceIdChangeCount={serviceIdChangeCount}
+                        onChange={(name, value) => {
+                            this.changeQueryParams(name, value);
+                        }}
+                    />
+                    <GroupFilter
+                        filterData={filterData} // 新增的筛选条件
+                        searchList={searchList} // 接口返回的 可以筛选的字段
+                        doSearch={this.reDoSearch} // 查询
+                        setState={this.filterSetState} //  查询条件赋值
+                        isQueryDisabled={isGlobalSearch && isDisabled} // 查询按钮是否禁止
+                        onFilterKeyDown={this.onFilterKeyDown} // 按下回车
+                    />
+                </div>
+                <div className={styles['table-list']}>
+                    <SMTable
+                        columns={getIntlTableColums(newTableColumns, t)}
+                        isDrag
+                        getNewTableColumn={this.saveColumns}
+                        extraDom={this.showExtraDom()}
+                        dataSource={!orgAppChange ? tableDataSource : []}
+                        loading={listLoading}
+                        totalCount={!orgAppChange ? listTotalCount : 0}
+                        wrapperStyle={{
+                            margin: 0,
+                        }}
+                        scroll={{ x: 300, y: 'auto' }}
+                        popoverStyle={{ width: 250 }}
+                        showTotal={() => `${t('共')}${listTotalCount}${t('条')}`}
+                        i18nText={tableText(t)}
+                        setLocalTable
+                        customLoadingUrl={this.props.customLoadingIcon}
+                        antdProps={{
+                            pagination: {
+                                showQuickJumper: true,
+                                defaultPageSize: pageSize,
+                                pageSizeOptions: pageSizeOptions,
+                                total: !orgAppChange ? listTotalCount : 0,
+                                current: currentPage,
+                                showSizeChanger: true,
+                            },
+                            onChange: this.listOnSearch,
+                        }}
+                    />
+                </div>
+                {tableDataSource.length && !orgAppChange ? (
+                    <TotalCount
+                        count={listRealTotalCount ?? listTotalCount}
+                        isShowRealTotalCount={!!listRealTotalCount}
+                    />
+                ) : null}
+                <NewHistoryDetailDrawer
+                    visible={detailVisible}
+                    headerData={headerData}
+                    detailData={detailData}
+                    serviceId={serviceId}
+                    modelText={modelText}
+                    onClose={() => this.setState({detailVisible: false})}
+                    onActionClick={this.onActionClick}
+                />
+                <AddListModal
+                    visible={listModalVisible}
+                    listData={currentListData}
+                    serviceId={serviceId}
+                    organization={organization}
+                    currentValue={currentListValue}
+                    onCancel={() =>
+                        this.setState({
+                            listModalVisible: false,
+                        })
+                    }
+                />
+
+                <ExportTask
+                    formatHistoryTaskFormColumns={formatHistoryTaskFormColumns}
+                    buildHistoryTaskDetail={buildHistoryTaskDetail}
+                    organization={organization}
+                    serviceId={serviceId}
+                    currentUser={currentUser}
+                    appId={appId}
+                    title={t('历史数据导出')}
+                    visible={exportTaskVisible}
+                    storageTime={storageTime}
+                    selectListMap={{
+                        defaultRiskLevelData,
+                        defaultChannelEventData,
+                        defaultEventData,
+                        defaultRiskReasonData,
+                        defaultAppIdData,
+                    }}
+                    exportDetailMap={{
+                        channelMap,
+                        eventIdMap,
+                        riskLevelMap,
+                        verifyTypeMap,
+                        serviceIdMap,
+                    }}
+                    onCancel={() => {
+                        this.setState({
+                            exportTaskVisible: false,
+                        });
+                    }}
+                />
+            </div>
+        );
+    }
+}
+
+export default connect(({ user, login }) => ({
+    currentUser: user.currentUser,
+    isIntl: login?.loginModeObj?.isIntl,
+}))(withIntlComponents(History));