qc-gameDataStatistics/src/components/QueryForm/index.tsx

import { Button, Checkbox, Col, DatePicker, Form, Input, InputNumber, Radio, Row, Select, Space, Tooltip } from "antd"
import React, { useEffect, useState } from "react"
import moment from "moment"
import { useAjax } from "@/Hook/useAjax"
import { getAllOfOwnerUserApi, getChannelChoiceListApi, getGameChoiceListApi, getCpChoiceListApi, getGameChoiceParentListType1Api, getPayListApi, getSubUserWithSelfListApi, getTtAllUserListApi, getUserSystemTypeChoiceListApi, getRoleUserListApi, getGameServerListApi, getGameServerUnListApi, getAccountListNewApi, getAgentListNewApi, getPitcherListNewApi, getGameListNewApi, getVipLevelApi, getGameUnMergeServerListApi } from "@/services/gameData"
import { ActiveEnum, DeviceType, LoginType, PayStatus, TYPE, gameClassifyEnum } from "./const"
import { ADSTATUSEnum as ADSTTTATUSEnum } from "@/pages/gameDataStatistics/adlist/monitor/const"
import { ADSTATUSEnum } from "@/pages/gameDataStatistics/adlist/tencentMonitor/const"
import IntervalTime from "./intervalTime"
import { RangePickerProps } from "antd/lib/date-picker"
import { QuestionCircleOutlined } from "@ant-design/icons"


interface Props {
    onChange?: (data: any) => void
    /** 默认值 */
    initialValues?: any
    /** 开启数据源搜索 */
    isSource?: boolean,
    /** 是否开启 广告账号 搜索 */
    isAccount?: boolean
    /** 是否开启 广告账户ID 搜索 */
    isAccountId?: boolean
    // 开启账号多选
    isAccountIds?: boolean,
    /** 是否开启 公司ID 搜索 */
    isCompanyId?: boolean
    /** 是否开启 CPID 搜索 */
    isCpId?: boolean
    /** 是否开启 cp名 搜索 */
    isCpName?: boolean
    /** 是否开启 CP方订单ID 搜索 */
    isCpOrderId?: boolean
    /** 是否开启 CP通知状态 搜索 */
    isCpStatus?: boolean
    /** 是否开启 订单创建日期 搜索 */
    isCreateDay?: {
        ranges?: any
    }
    /** 订单创建日期 根据消耗时间 来限制可选范围 */
    isCreateDayXz?: {
        ranges?: any
    }
    /** 是否开启 角色创建日期 搜索 */
    isCreateRoleDay?: {
        ranges?: any
    }
    /** 是否开启 最近活跃时间 搜索 */
    isLastActiveTime?: {
        ranges?: any
    }
    /** 是否开启 操作设备 搜索 */
    isDevice?: boolean
    /** 是否开启 注册游戏名 搜索 */
    isRechargeGameName?: boolean
    /** 是否开启 游戏名 搜索 */
    isGameName?: boolean
    /** 是否开启 游戏ID 搜索 */
    isGameId?: boolean
    isGameIds?: boolean
    /** 是否开启 充值游戏ID 搜索 */
    isOrderGameId?: boolean
    /** 是否开启 父游戏ID 搜索 */
    isParentId?: boolean
    isParentIds?: boolean
    /** 是否开启 超父游戏ID 搜索 */
    isSuperParentGameId?: boolean
    /** 是否开启 是否合服 搜索 */
    isIsMergeServer?: boolean
    /** 是否开启 是否未参与过合服 搜索 */
    isIsParticipateMerge?: boolean
    /** 是否开启 游戏应用类型 搜索 */
    isGameType?: boolean
    /** 是否开启 游戏角色名 搜索 */
    isGameRoleName?: boolean
    /** 是否开启 游戏角色名ID 搜索 */
    isGameRoleId?: boolean
    /** 是否开启 是否首充 搜索 */
    isFirstRecharge?: boolean
    /** 是否开启 是否切量 搜索 */
    isSwitch?: boolean
    /** 是否开启 收款商户号 搜索 */
    isMerchantNo?: boolean
    /** 是否开启 商户订单ID 搜索 */
    isOrderId?: boolean
    /** 是否开启 商户订单号 搜索 */
    isMerchantOrderNo?: boolean
    /** 是否开启 支付状态 搜索 */
    isPayStatus?: boolean
    /** 是否开启 支付方式 搜索 */
    isPayWay?: boolean
    /** 是否开启 产品名称 搜索 */
    isProductName?: boolean
    /** 是否开启 注册渠道名 搜索 */
    isRegAgent?: boolean
    /** 是否开启 渠道名称 搜索 */
    isAgentName?: boolean
    /** 是否开启 注册渠道ID 搜索 */
    isAgentId?: boolean
    /** 是否开启 渠道标识 搜索 */
    isAgentKey?: boolean
    /** 是否开启 投放渠道名 搜索 */
    isPutAgent?: boolean
    /** 是否开启 用户注册日期 搜索 */
    isRegDay?: {
        ranges?: any
    }
    /** 是否开启 投手名称 搜索 */
    isSysUserName?: boolean
    /** 是否开启 投手ID 搜索 */
    isSysUserId?: boolean
    isSysUserIds?: boolean
    /** 是否开启 玩家账号 搜索 */
    isUserName?: boolean
    /** 是否开启 用户ID 搜索 */
    isUserId?: boolean
    /** 是否开启 不同排行榜选择 搜索 */
    isSelectRanking?: boolean
    /** 是否开启 消耗日期 搜索 */
    isConsumeDay?: {
        ranges?: any
    }
    /** 是否开启 充值日期 搜索 */
    rechargeDay?: {
        ranges?: any
    }
    /** 最近充值 */
    LastRechargeDay?: {
        ranges?: any
    },
    /** 是否开启 支付时间 搜索 */
    payTimeDay?: {
        ranges?: any
    }
    /** 是否开启 下单时间 搜索 */
    placeAnOrderDay?: {
        ranges?: any
    }
    /** 是否开启布谷 游戏类型 筛选 */
    isBGGameClassify?: boolean,
    /** 是否开启 单个充值日期 选择 */
    isRechargeDate?: boolean,
    /** 是否开启 开始时间 结束时间 搜索 */
    isBeginDay?: boolean
    /** 是否开启 玩家ID 搜索 */
    isGameUserId?: boolean
    /** 是否开启 操作系统 选择 */
    isOs?: boolean
    /** 是否开启 推广媒体 选择 */
    isType?: boolean
    /** 是否开启 计划ID 搜索 */
    isProjectId?: boolean
    /** 是否开启 计划名称 搜索 */
    isProjectName?: boolean
    /** 是否开启 创意名称 搜索 */
    isDynamicCreativeName?: boolean
    isDynamicCreativeId?: boolean
    /** 是否开启 广告ID 搜索 */
    isProjectId1?: boolean
    /** 是否开启 广告ID 搜索 */
    isPromotionId?: boolean
    /** 是否开启 计划ID 搜索 */
    isPromotionId1?: boolean
    /** 是否开启 广告名称 搜索 */
    isPromotionName?: boolean
    /** 是否开启 头条广告状态 搜索 */
    isAdTTStatus?: boolean
    /** 是否开启 腾讯广告状态 搜索 */
    isAdTXStatus?: boolean
    /** 是否开启 展示数据类型（买量，自然，总） 搜索 */
    isUserEnterType?: boolean
    /** 是否开启 区服名称 搜索 */
    isServerName?: boolean
    /** 是否开启 所在原始服务器名称 搜索 */
    isSourceServerName?: boolean
    /** 是否开启区服ID 搜索 */
    isServerId?: boolean | {
        placeholder?: string
    }
    /** 是否开启 开服时间 搜索 */
    isServerDay?: {
        ranges?: any
    }
    /** 是否开启 充值到支付的间隔时间 搜索 */
    isPayIntervalTime?: {
        tips?: string
    }
    /** 是否开启 充值到支付的间隔时间 搜索 */
    isRoleCount?: {
        tips?: string
    }
    /** 是否开启 留存数据的类型 搜索 */
    isActiveTypes?: boolean
    /** 是否开启 玩家昵称 搜索 */
    isNickname?: boolean
    /** 是否开启 绑定手机 搜索 */
    isMobile?: boolean
    /** 是否开启 注册IP 搜索 */
    isRegIp?: boolean
    /** 是否开启 IP 搜索 */
    isIp?: boolean
    /** 是否开启 是否实名认证 搜索 */
    isIsAuth?: boolean
    /** 是否开启 是否绑定手机 搜索 */
    isIsBindMobile?: boolean
    /** 是否开启 是否充值 搜索 */
    isIsRecharge?: boolean
    /** 是否开启 玩家状态 搜索 */
    isUserStatus?: boolean
    /** 是否开启 是否创角 搜索 */
    isCreateRole?: boolean
    /** 是否开启 角色VIP 搜索 */
    isVipLevel?: boolean
    /** 是否开启 角色等级 搜索 */
    isRoleLevel?: boolean
    /** 是否开启 是否转端 搜索 */
    isIsChange?: boolean
    /** 是否开启 邮件是否发送 搜索 */
    isIsSendMail?: boolean
    /** 是否开启 企业微信号 搜索 */
    isWeChatCompany?: boolean
    /** 是否开启 企业微信号 搜索 */
    isWeChat?: boolean
    /** 是否开启 客服 搜索*/
    isCustomerServerId?: boolean
    /** 是否开启 运营 搜索 */
    isOperatorId?: boolean
    /** 是否开启GS 搜索 */
    isGsId?: boolean
    /** 是否开启多个区服id搜索 */
    isServerIds?: boolean
    /** 是否开启 游戏区服 搜索 */
    isGameServerName?: boolean
    /** 是否开启多个区服id搜索 */
    isRankingNum?: boolean
    /** 是否开启 客户端类型 搜索 */
    isDeviceType?: boolean
    /** 是否开启 登录类型 搜索 */
    isLoginType?: boolean
    /** 是否开启 原始区服列表 搜索 */
    isServerIdUn?: boolean
    /** 是否开启 是否退游 搜索 */
    isRemoveGame?: boolean
    /** 是否开启 是否退游系统 搜索 */
    isRemoveGameForSystem?: boolean
    isOrderLy?: boolean
    /** 是否开启 是否添加企微 搜索 */
    isAddCorpWechat?: boolean
    /** 是否开启 是否唤醒 搜索 */
    isWakeUp?: boolean
    /** 是否开启 是否绑定手机号 搜索 */
    isUserPhoneStatus?: boolean
    /** 是否开启 回传状态 搜索 */
    isBackStatus?: boolean
    /** 是否开启 选择游戏维度 搜索 */
    isGameDimension?: boolean
    /** 是否开启 玩家最新染色时间 搜索 */
    isUserLastRegTime?: boolean
    /** 是否开启 玩家最新染色渠道ID 搜索 */
    isUserLastRegAgentId?: boolean
    /** 是否开启 玩家最新染色归因投手 搜索 */
    isUserLastPitcherId?: boolean
    /** 是否开启 创角24小时内单笔充值金额 搜索 */
    isRechargeAmountWithin24h?: boolean
    /** 是否开启 创角24小时以内累计充值金额 搜索 */
    isRechargeTotalAmountWithin24h?: boolean
    /** 是否开启 玩家注册渠道类型 搜索 */
    isRegisterType?: boolean
    /** 是否开启 创意状态 搜索 */
    isConfiguredStatus?: boolean
    /** 注册城市 */
    isIpCity?: boolean
    /** 注册归属地 */
    isIpProv?: boolean
    /** 最新登录城市 */
    isLoginIpCity?: boolean
    /** 最新登录归属地 */
    isLoginIpProv?: boolean
}
/**
 * 游戏数据系统 请求参数
 * @returns 
 */
const QueryForm: React.FC<Props> = (props) => {

    /**************************/
    const {
        onChange, initialValues, isSource, isAccount, isAccountId, isAccountIds, isCompanyId, isAgentKey, isAgentName, isCpId, isCpName, isCpOrderId, isCpStatus, isCreateDay, isCreateDayXz, isDevice, isGameName, isRechargeGameName, isGameId, isGameIds, isOrderGameId, isGameRoleId,
        isGameRoleName, isFirstRecharge, isSwitch, isMerchantNo, isOrderId, isMerchantOrderNo, isPayStatus, isPayWay, isProductName, isRegAgent, isAgentId, isPutAgent, isRegDay, isOs, isParentId, isParentIds, isProjectId, isProjectName, isDynamicCreativeName, isPromotionId, isPromotionId1, isPromotionName,
        isSysUserName, isRechargeDate, LastRechargeDay, isBGGameClassify, isGameUserId, isSysUserId, isSysUserIds, isUserName, isUserId, isSelectRanking, isGameType, isConsumeDay, rechargeDay, isBeginDay, isType, isAdTTStatus, isUserEnterType, isServerName, isServerId, isServerDay, isAdTXStatus,
        payTimeDay, placeAnOrderDay, isPayIntervalTime, isActiveTypes, isNickname, isMobile, isRegIp, isIsAuth, isIsBindMobile, isIsRecharge, isUserStatus, isCreateRole, isRoleCount, isVipLevel, isRoleLevel, isCreateRoleDay, isLastActiveTime, isIsChange, isIsSendMail, isWeChatCompany, isWeChat,
        isCustomerServerId, isOperatorId, isGsId, isServerIds, isRankingNum, isIsMergeServer, isIsParticipateMerge, isSuperParentGameId, isGameServerName, isIp, isDeviceType, isLoginType, isServerIdUn, isSourceServerName, isProjectId1, isDynamicCreativeId, isRemoveGame, isRemoveGameForSystem, isOrderLy, isAddCorpWechat,
        isWakeUp, isUserPhoneStatus, isBackStatus, isGameDimension, isUserLastRegTime, isUserLastRegAgentId, isUserLastPitcherId, isRechargeAmountWithin24h, isRechargeTotalAmountWithin24h, isRegisterType, isConfiguredStatus, isIpCity, isIpProv, isLoginIpCity, isLoginIpProv
    } = props
    const [form] = Form.useForm()
    const parentId = Form.useWatch('parentId', form)
    const superParentGameId = Form.useWatch('superParentGameId', form)
    const isMergeServer = Form.useWatch('isMergeServer', form)
    const serverName = Form.useWatch('serverName', form)
    const serverIds = Form.useWatch('serverIds', form)
    const sourceSystem = Form.useWatch('sourceSystem', form)
    const parentGameIds = Form.useWatch('parentGameIds', form)
    const gameDimension = Form.useWatch('gameDimension', form)
    const consumeDay = Form.useWatch('consumeDay', form)
    const isParticipateMerge = Form.useWatch('isParticipateMerge', form)
    const [accountList, setAccountList] = useState<any[]>([])
    const [userIdList, setUserIdList] = useState<any[]>([])
    const [gsList, setGsList] = useState<any[]>([])
    const [customerList, setCustomerList] = useState<any[]>([])
    const [operateList, setOperateList] = useState<any[]>([])
    const [gameList, setGameList] = useState<any[]>([])
    const [parentGameList, setParentGameList] = useState<any[]>([])
    const [superGameList, setSuperGameList] = useState<any[]>([])
    const [agentData, setAgentData] = useState<{ label: string, value: string }[]>([])


    const getAllOfOwnerUser = useAjax(() => getAllOfOwnerUserApi())
    const getTtAllUserList = useAjax(() => getTtAllUserListApi())
    const getGameChoiceList = useAjax(() => getGameChoiceListApi())
    const getSubUserWithSelfList = useAjax(() => getSubUserWithSelfListApi())
    const getChannelChoiceList = useAjax(() => getChannelChoiceListApi())
    const getGameChoiceParentListType1 = useAjax(() => getGameChoiceParentListType1Api())
    const getUserSystemTypeChoiceList = useAjax(() => getUserSystemTypeChoiceListApi())
    const getCpChoiceList = useAjax(() => getCpChoiceListApi())
    const getPayList = useAjax(() => getPayListApi())
    const getVipLevel = useAjax(() => getVipLevelApi())
    const getRoleUserList = useAjax((params) => getRoleUserListApi(params))
    const getGameServerList = useAjax((params) => getGameServerListApi(params))
    const getGameUnMergeServerList = useAjax((params) => getGameUnMergeServerListApi(params))
    const getGameServerUnList = useAjax((params) => getGameServerUnListApi(params))
    const getAccountListNew = useAjax((params) => getAccountListNewApi(params))
    const getAgentListNew = useAjax((params) => getAgentListNewApi(params))
    const getPitcherListNew = useAjax((params) => getPitcherListNewApi(params))
    const getGameListNew = useAjax((params) => getGameListNewApi(params))
    /**************************/

    useEffect(() => {
        if (isCustomerServerId || isOperatorId || isGsId) {
            const getList = async () => {
                // 游戏GS
                let gs = await getRoleUserList.run({ authType: 'GS' })
                setGsList(gs ? Object.keys(gs)?.map(key => ({ userId: key, nickname: gs[key] })) : [])
                // 运营
                let operate = await getRoleUserList.run({ authType: 'OPERATE' })
                setOperateList(operate ? Object.keys(operate)?.map(key => ({ userId: key, nickname: operate[key] })) : [])
                // 客服
                let customer = await getRoleUserList.run({ authType: 'CUSTOMER' })
                setCustomerList(customer ? Object.keys(customer)?.map(key => ({ userId: key, nickname: customer[key] })) : [])
            }
            getList()
        }
    }, [isCustomerServerId, isOperatorId, isGsId])

    useEffect(() => {
        if (isAccountId) {
            // 请求广告账号列表
            async function getAccount() {
                if (sourceSystem === 'ZX_ONE') {
                    let data: any[] = []
                    let res1 = await getAllOfOwnerUser.run()
                    let data1 = []
                    if (res1) {
                        data1 = res1?.map((item: any) => ({ label: item.accountId, value: item.accountId, corporationName: item.corporationName }))
                    }
                    let res2 = await getTtAllUserList.run()
                    let data2 = []
                    if (res2) {
                        data2 = res2?.map((item: any) => ({ label: item.accountId, value: item.accountId, corporationName: item.accountName }))
                    }
                    data = [...data1, ...data2]
                    setAccountList(data)
                } else if (['BG_OLD', 'BG_NEW', 'ZX_SDK'].includes(sourceSystem)) {
                    let res1 = await getAccountListNew.run({ sourceSystem })
                    setAccountList(res1?.map((item: any) => ({ label: item.accountId, value: item.accountId, corporationName: '' })))
                }
            }
            getAccount()
        }
    }, [isAccountId, sourceSystem])

    /** 游戏列表 */
    useEffect(() => {
        if (isGameId || isOrderGameId || isParentId || isParentIds || isGameIds || isSuperParentGameId) {
            getGameListNew.run({ sourceSystem }).then((res: { gameList: any; parentGameList: any; superGameList: any }) => {
                if (res) {
                    const { gameList, parentGameList, superGameList } = res
                    // if (['BG_OLD', 'BG_NEW', 'ZX_SDK'].includes(sourceSystem)) {
                    setGameList(gameList?.map((item: { id: any; game_name: any }) => ({ id: item.id, name: item.game_name })) || [])
                    // }
                    // let isBg = ['289', '399', '402', '432', '445', '472'].includes(localStorage.getItem('userId') || '')
                    // let newparentGameList: { parent_game_id: number }[] = parentGameList || []
                    // if (isBg) {  //布谷过滤
                    //     newparentGameList = newparentGameList.filter(item => ![9, 1, 7, 15, 11, 16, 13].includes(item.parent_game_id))
                    // }
                    setParentGameList(parentGameList)
                    setSuperGameList(superGameList)
                }
            })

            // if (sourceSystem === 'ZX_ONE') {
            //     getGameChoiceList.run().then(res => {
            //         setGameList(res || [])
            //     })
            // }
        }
    }, [isGameId, isGameIds, isOrderGameId, isParentId, isParentIds, isSuperParentGameId, sourceSystem])

    useEffect(() => {
        if (isCpId) {
            getCpChoiceList.run()
        }
    }, [isCpId])

    useEffect(() => {
        if (isVipLevel) {
            getVipLevel.run()
        }
    }, [isVipLevel])

    /** 投手列表 */
    useEffect(() => {
        if (isSysUserId || isSysUserIds) {
            if (['BG_OLD', 'BG_NEW', 'ZX_SDK'].includes(sourceSystem)) {
                getPitcherListNew.run({ sourceSystem }).then((res: { pitcherId: any; pitcherName: any }[]) => {
                    setUserIdList(res?.map((item: { pitcherId: any; pitcherName: any }) => ({ userId: item.pitcherId, nickname: item.pitcherName })))
                })
            } else {
                getSubUserWithSelfList.run().then((res: { [x: string]: any }) => {
                    setUserIdList(res ? Object.keys(res)?.map(key => ({ userId: key, nickname: res[key] })) : [])
                })
            }
        }
    }, [isSysUserId, isSysUserIds, sourceSystem])

    /** 推广渠道 */
    useEffect(() => {
        if (isAgentId || isUserLastRegAgentId) {
            if (['BG_OLD', 'BG_NEW', 'ZX_SDK'].includes(sourceSystem)) {
                getAgentListNew.run({ sourceSystem }).then((res: { agentName: any; agentId: any }[]) => {
                    setAgentData(res?.map((item: { agentName: any; agentId: any }) => ({ label: item.agentName, value: item.agentId })))
                })
            } else {
                getChannelChoiceList.run().then((res: { agentName: any; id: any }[]) => {
                    console.log(res)
                    setAgentData(res?.map((item: { agentName: any; id: any }) => ({ label: item.agentName, value: item.id })))
                })
            }
        }
    }, [isAgentId, sourceSystem, isUserLastRegAgentId])

    /** 游戏应用类型 */
    useEffect(() => {
        if (isGameType) {
            getGameChoiceParentListType1.run()
        }
    }, [isGameType])

    /** 操作系统 */
    useEffect(() => {
        if (isOs) {
            getUserSystemTypeChoiceList.run()
        }
    }, [isOs])

    /** 支付方式 */
    useEffect(() => {
        if (isPayWay) {
            getPayList.run()
        }
    }, [isPayWay])

    const onFinish = (data: any) => {

        // 处理订单创建日期
        if (isCreateDay) {
            if (data?.createDay && data?.createDay?.length > 0) {
                data.beginOrderTime = moment(data?.createDay[0]).format('YYYY-MM-DD')
                data.endOrderTime = moment(data?.createDay[1]).format('YYYY-MM-DD')
            } else {
                data.beginOrderTime = ''
                data.endOrderTime = ''
            }
            delete data.createDay
        }
        // 处理 用户注册日期
        if (isRegDay) {
            if (data?.regDay && data?.regDay?.length > 0) {
                data.regStartDay = moment(data?.regDay[0]).format('YYYY-MM-DD')
                data.regEndDay = moment(data?.regDay[1]).format('YYYY-MM-DD')
            } else {
                data.regStartDay = ''
                data.regEndDay = ''
            }
            delete data.regDay
        }
        // 处理 消耗日期
        if (isConsumeDay) {
            if (data?.consumeDay && data?.consumeDay?.length > 0) {
                data.costBeginDay = moment(data?.consumeDay[0]).format('YYYY-MM-DD')
                data.costEndDay = moment(data?.consumeDay[1]).format('YYYY-MM-DD')
            } else {
                data.costBeginDay = ''
                data.costEndDay = ''
            }
            delete data.consumeDay
        }
        // 处理 不同排行榜 选择
        if (isSelectRanking) {
            switch (data?.dateType) {
                case 'all':
                    data.beginDay = ''
                    data.endDay = ''
                    break;
                case 'today':
                    data.beginDay = moment().format('YYYY-MM-DD')
                    data.endDay = moment().format('YYYY-MM-DD')
                    break
                case 'yesterday':
                    data.beginDay = moment().subtract(1, 'd').format('YYYY-MM-DD')
                    data.endDay = moment().subtract(1, 'd').format('YYYY-MM-DD')
                    break
                case '7days':
                    data.beginDay = moment().subtract(7, 'd').format('YYYY-MM-DD')
                    data.endDay = moment().format('YYYY-MM-DD')
                    break
                case '30days':
                    data.beginDay = moment().subtract(30, 'd').format('YYYY-MM-DD')
                    data.endDay = moment().format('YYYY-MM-DD')
                    break
            }
            delete data?.dateType
        }
        console.log('更新了字段---->', data);
        onChange && onChange(data)
    }


    const disabledDate: RangePickerProps['disabledDate'] = (current) => {
        // Can not select days before today and today
        if (consumeDay && consumeDay?.length === 2) {
            let [d1] = consumeDay
            return current && (current < moment(d1) || current > moment().endOf('day'));
        }
        return current && current > moment().endOf('day');
    };

    return <Form layout="inline" className='queryForm' initialValues={initialValues} name="basic" form={form} onFinish={onFinish}>
        <Row gutter={[0, 6]}>
            {/* 数据源搜索 */}
            {isSource && <Col><Form.Item name='sourceSystem'>
                <Select
                    showSearch
                    style={{ width: 100 }}
                    allowClear
                    placeholder={'数据源选择'}
                    filterOption={(input, option) =>
                        (option?.children as any)?.toLowerCase().indexOf(input.toLowerCase()) >= 0
                    }
                >
                    <Select.Option value="BG_OLD">布谷-old</Select.Option>
                    <Select.Option value="BG_NEW">布谷-new</Select.Option>
                    <Select.Option value="ZX_SDK">布谷-zx</Select.Option>
                    <Select.Option value="ZX_ONE">赞象</Select.Option>
                </Select>
            </Form.Item></Col>}
            {/* 展示数据类型 */}
            {isUserEnterType && <Col><Form.Item name='tableTypes'>
                <Select
                    showSearch
                    style={{ width: 130 }}
                    allowClear
                    placeholder={'展示数据类型'}
                    filterOption={(input, option) =>
                        (option?.children as any)?.toLowerCase().indexOf(input.toLowerCase()) >= 0
                    }
                >
                    <Select.Option value="buy">买量</Select.Option>
                    <Select.Option value="nature">自然量</Select.Option>
                    <Select.Option value="total">总量</Select.Option>
                </Select>
            </Form.Item></Col>}
            {/* 订单渠道类型 */}
            {isOrderLy && <Col><Form.Item name='orderAgentType'>
                <Select
                    showSearch
                    style={{ width: 130 }}
                    allowClear
                    placeholder={'订单渠道类型'}
                    filterOption={(input, option) =>
                        (option?.children as any)?.toLowerCase().indexOf(input.toLowerCase()) >= 0
                    }
                >
                    <Select.Option value="buy">买量</Select.Option>
                    <Select.Option value="nature">自然量</Select.Option>
                </Select>
            </Form.Item></Col>}
            {/* 玩家注册渠道类型 */}
            {isRegisterType && <Col><Form.Item name='registerType'>
                <Select
                    showSearch
                    style={{ width: 150 }}
                    allowClear
                    placeholder={'玩家注册渠道类型'}
                    filterOption={(input, option) =>
                        (option?.children as any)?.toLowerCase().indexOf(input.toLowerCase()) >= 0
                    }
                >
                    <Select.Option value={1}>非自然量</Select.Option>
                    <Select.Option value={0}>自然量</Select.Option>
                </Select>
            </Form.Item></Col>}
            {isActiveTypes && <Col><Form.Item name='activeTypes'>
                <Select
                    showSearch
                    style={{ width: 130 }}
                    placeholder={'留存数据的类型'}
                    filterOption={(input, option) =>
                        (option?.children as any)?.toLowerCase().indexOf(input.toLowerCase()) >= 0
                    }
                >
                    {Object.keys(ActiveEnum).map(key => <Select.Option value={key} key={key}>{ActiveEnum[key as keyof typeof ActiveEnum]}</Select.Option>)}
                </Select>
            </Form.Item></Col>}
            {/* 不同排行榜选择 */}
            {isSelectRanking && <Col><Form.Item name='dateType'>
                <Radio.Group>
                    <Radio.Button value="all">总排行</Radio.Button>
                    <Radio.Button value="today">今日排行</Radio.Button>
                    <Radio.Button value="yesterday">昨日排行</Radio.Button>
                    <Radio.Button value="7days">7日排行</Radio.Button>
                    <Radio.Button value="30days">30日排行</Radio.Button>
                </Radio.Group>
            </Form.Item></Col>}
            {/* 所在原始服务器名称 */}
            {isSourceServerName && <Col><Form.Item name='sourceServerName'>
                <Input placeholder="原始服务器名称" allowClear style={{ width: 140 }} />
            </Form.Item></Col>}
            {/* 广告区服名称 */}
            {isServerName && <Col><Form.Item name='serverName'>
                <Input placeholder="区服名称" allowClear style={{ width: 140 }} />
            </Form.Item></Col>}
            {/* 广告区服ID */}
            {isServerId && <Col><Form.Item name='serverId'>
                <Input placeholder="区服ID" allowClear style={{ width: 140 }} {...(isServerId && typeof isServerId === 'object') ? isServerId : {}} />
            </Form.Item></Col>}
            {/* 广告账户名称 */}
            {isAccount && <Col><Form.Item name='accountName'>
                <Input placeholder="广告账号名称" allowClear style={{ width: 140 }} />
            </Form.Item></Col>}
            {/* 广告账号ID */}
            {isAccountId && <Col><Form.Item name='accountId'>
                <Select
                    maxTagCount={1}
                    mode={isAccountIds ? 'multiple' : undefined}
                    showSearch
                    style={{ minWidth: 140 }}
                    allowClear
                    placeholder={'广告账号'}
                    loading={getAccountListNew.loading || getAllOfOwnerUser.loading}
                    filterOption={(input, option) =>
                        (option?.children as any)?.toLowerCase().indexOf(input.toLowerCase()) >= 0
                    }
                >
                    {accountList.map(item => <Select.Option key={item.value} value={item.value}>{item.label?.toString() + (item.corporationName ? `_${item.corporationName}` : '')}</Select.Option>)}
                </Select>
            </Form.Item></Col>}
            {/* 公司ID */}
            {isCompanyId && <Col><Form.Item name='companyId'>
                <Select
                    maxTagCount={1}
                    showSearch
                    style={{ minWidth: 140 }}
                    allowClear
                    placeholder={'请选择公司'}
                    filterOption={(input, option) =>
                        (option?.children as any)?.toLowerCase().indexOf(input.toLowerCase()) >= 0
                    }
                >
                    <Select.Option value={'1'}>公司001</Select.Option>
                    <Select.Option value={'2'}>公司002</Select.Option>
                </Select>
            </Form.Item></Col>}
            {/* cp名 */}
            {isCpName && <Col><Form.Item name='cpName'>
                <Input placeholder="CP名称" allowClear style={{ width: 140 }} />
            </Form.Item></Col>}
            {/* CPID */}
            {isCpId && <Col><Form.Item name='cpId'>
                <Select
                    maxTagCount={1}
                    showSearch
                    style={{ minWidth: 140 }}
                    allowClear
                    placeholder={'请选择CP'}
                    filterOption={(input, option) =>
                        (option?.children as any)?.toLowerCase().indexOf(input.toLowerCase()) >= 0
                    }
                >
                    {getCpChoiceList?.data?.map((item: { id: React.Key | null | undefined; cpName: boolean | React.ReactChild | React.ReactFragment | React.ReactPortal | null | undefined }) => <Select.Option value={item.id} key={item.id}>{item.cpName}</Select.Option>)}
                </Select>
            </Form.Item></Col>}
            {/* CP方订单ID */}
            {isCpOrderId && <Col><Form.Item name='cpOrderId'>
                <Input placeholder="CP订单号" style={{ width: 140 }} />
            </Form.Item></Col>}
            {/* CP通知状态 */}
            {isCpStatus && <Col><Form.Item name='cpStatus'>
                <Select
                    maxTagCount={1}
                    showSearch
                    style={{ minWidth: 140 }}
                    allowClear
                    placeholder={'CP通知状态'}
                    filterOption={(input, option) =>
                        (option?.children as any)?.toLowerCase().indexOf(input.toLowerCase()) >= 0
                    }
                >
                    <Select.Option value={'1'}>待处理</Select.Option>
                    <Select.Option value={'2'}>成功</Select.Option>
                    <Select.Option value={'3'}>失败</Select.Option>
                </Select>
            </Form.Item></Col>}

            {/* 计划名称 */}
            {isProjectName && <Col><Form.Item name='projectName'>
                <Input placeholder="项目名称" allowClear style={{ width: 140 }} />
            </Form.Item></Col>}
            {/* 计划ID */}
            {isProjectId && <Col><Form.Item name='projectId'>
                <Input placeholder="项目ID" allowClear style={{ width: 140 }} />
            </Form.Item></Col>}
            {/* 广告名称 */}
            {isPromotionName && <Col><Form.Item name='promotionName'>
                <Input placeholder="广告名称" allowClear style={{ width: 140 }} />
            </Form.Item></Col>}
            {/* 广告ID */}
            {isProjectId1 && <Col><Form.Item name='projectId'>
                <Input placeholder="广告ID" allowClear style={{ width: 140 }} />
            </Form.Item></Col>}
            {/* 广告ID */}
            {isPromotionId && <Col><Form.Item name='promotionId'>
                <Input placeholder="广告ID" allowClear style={{ width: 140 }} />
            </Form.Item></Col>}
            {/* 计划ID */}
            {isPromotionId1 && <Col><Form.Item name='promotionId'>
                <Input placeholder="计划ID" allowClear style={{ width: 140 }} />
            </Form.Item></Col>}
            {/* 创意名称 */}
            {isDynamicCreativeName && <Col><Form.Item name='dynamicCreativeName'>
                <Input placeholder="创意名称" allowClear style={{ width: 140 }} />
            </Form.Item></Col>}
            {/* 创意ID */}
            {isDynamicCreativeId && <Col><Form.Item name='dynamicCreativeId'>
                <Input placeholder="创意ID" allowClear style={{ width: 140 }} />
            </Form.Item></Col>}
            {/* 广告状态 */}
            {isAdTTStatus && <Col><Form.Item name='status'>
                <Select
                    maxTagCount={1}
                    showSearch
                    style={{ width: 140 }}
                    allowClear
                    dropdownMatchSelectWidth={false}
                    placeholder={'请选择广告状态'}
                    filterOption={(input, option) =>
                        (option?.children as any)?.toLowerCase().indexOf(input.toLowerCase()) >= 0
                    }
                >
                    {Object.keys(ADSTTTATUSEnum).map(key => <Select.Option value={key} key={key}>{ADSTTTATUSEnum[key as keyof typeof ADSTTTATUSEnum]}</Select.Option>)}
                </Select>
            </Form.Item></Col>}

            {isAdTXStatus && <Col><Form.Item name='status'>
                <Select
                    maxTagCount={1}
                    showSearch
                    style={{ width: 140 }}
                    allowClear
                    dropdownMatchSelectWidth={false}
                    placeholder={'请选择广告状态'}
                    filterOption={(input, option) =>
                        (option?.children as any)?.toLowerCase().indexOf(input.toLowerCase()) >= 0
                    }
                >
                    {Object.keys(ADSTATUSEnum).map(key => <Select.Option value={key} key={key}>{ADSTATUSEnum[key as keyof typeof ADSTATUSEnum]}</Select.Option>)}
                </Select>
            </Form.Item></Col>}

            {/* 客户端类型 */}
            {isDeviceType && <Col><Form.Item name='deviceType'>
                <Select
                    maxTagCount={1}
                    showSearch
                    style={{ width: 140 }}
                    allowClear
                    dropdownMatchSelectWidth={false}
                    placeholder={'请选择客户端类型'}
                    filterOption={(input, option) =>
                        (option?.children as any)?.toLowerCase().indexOf(input.toLowerCase()) >= 0
                    }
                >
                    {Object.keys(DeviceType).map(key => <Select.Option value={key} key={key}>{DeviceType[key as keyof typeof DeviceType]}</Select.Option>)}
                </Select>
            </Form.Item></Col>}

            {/* 登录类型 */}
            {isLoginType && <Col><Form.Item name='type'>
                <Select
                    maxTagCount={1}
                    showSearch
                    style={{ width: 140 }}
                    allowClear
                    dropdownMatchSelectWidth={false}
                    placeholder={'请选择登录类型'}
                    filterOption={(input, option) =>
                        (option?.children as any)?.toLowerCase().indexOf(input.toLowerCase()) >= 0
                    }
                >
                    {Object.keys(LoginType).map(key => <Select.Option value={key} key={key}>{LoginType[key as keyof typeof LoginType]}</Select.Option>)}
                </Select>
            </Form.Item></Col>}

            {/* 操作设备 */}
            {isDevice && <Col><Form.Item name='device'>
                <Input placeholder="操作设备" allowClear style={{ width: 140 }} />
            </Form.Item></Col>}
            {/* 游戏名 */}
            {isRechargeGameName && <Col><Form.Item name='rechargeGameName'>
                <Input placeholder="游戏名" allowClear style={{ width: 140 }} />
            </Form.Item></Col>}
            {/* 玩家ID */}
            {isGameUserId && <Col><Form.Item name='gameUserId'>
                <Input placeholder="玩家ID" allowClear style={{ width: 140 }} />
            </Form.Item></Col>}
            {/* 游戏名 */}
            {isGameName && <Col><Form.Item name='gameName'>
                <Input placeholder="游戏名" allowClear style={{ width: 140 }} />
            </Form.Item></Col>}
            {/* 是否 开启 添加父游戏维度筛选 */}
            {isGameDimension && <Col><Form.Item name='gameDimension'>
                <Select
                    maxTagCount={1}
                    showSearch
                    style={{ width: 110 }}
                    allowClear
                    placeholder={'游戏维度'}
                    filterOption={(input, option) =>
                        (option?.children as any)?.toLowerCase().indexOf(input.toLowerCase()) >= 0
                    }
                    onChange={() => form.setFieldsValue({ gameId: undefined })}
                >
                    <Select.Option value={1}>子游戏维度</Select.Option>
                    <Select.Option value={2}>父游戏维度</Select.Option>
                </Select>
            </Form.Item></Col>}
            {/* 游戏ID搜索 */}
            {isGameId && <Col><Form.Item name='gameId'>
                <Select
                    maxTagCount={1}
                    showSearch
                    style={{ minWidth: 140 }}
                    allowClear
                    loading={getGameListNew.loading || getGameChoiceList.loading}
                    placeholder={'请选择游戏'}
                    filterOption={(input, option) =>
                        (option?.children as any)?.toLowerCase().indexOf(input.toLowerCase()) >= 0
                    }
                >
                    {gameList?.map((item: any) => <Select.Option value={item.id} key={item.id}>{item.name}</Select.Option>)}
                </Select>
            </Form.Item></Col>}
            {isGameIds && <Col><Form.Item name='gameId'>
                <Select
                    maxTagCount={1}
                    mode="multiple"
                    showSearch
                    style={{ minWidth: 140 }}
                    allowClear
                    loading={getGameListNew.loading || getGameChoiceList.loading}
                    placeholder={'请选择游戏'}
                    filterOption={(input, option) =>
                        (option?.children as any)?.toLowerCase().indexOf(input.toLowerCase()) >= 0
                    }
                >
                    {/* {gameDimension === 2 ? parentGameList?.map((item: any) => <Select.Option value={item.parent_game_id} key={item.parent_game_id} data-super-id={item.super_game_id}>{item.parent_game_name}</Select.Option>) : getGameChoiceList?.data?.map((item: any) => <Select.Option value={item.id} key={item.id}>{item.name}</Select.Option>)} */}
                    {gameDimension === 2 ? parentGameList?.map((item: any) => <Select.Option value={item.parent_game_id} key={item.parent_game_id} data-super-id={item.super_game_id}>{item.parent_game_name}</Select.Option>) : gameList?.map((item: any) => <Select.Option value={item.id} key={item.id}>{item.name}</Select.Option>)}
                </Select>
            </Form.Item></Col>}
            {/* 充值游戏ID */}
            {isOrderGameId && <Col><Form.Item name='orderGameId'>
                <Select
                    maxTagCount={1}
                    showSearch
                    style={{ minWidth: 140 }}
                    allowClear
                    placeholder={'请选择充值游戏'}
                    filterOption={(input, option) =>
                        (option?.children as any)?.toLowerCase().indexOf(input.toLowerCase()) >= 0
                    }
                >
                    {/* {getGameChoiceList?.data?.map((item: any) => <Select.Option value={item.id} key={item.id}>{item.name}</Select.Option>)} */}
                    {gameList?.map((item: any) => <Select.Option value={item.id} key={item.id}>{item.name}</Select.Option>)}
                </Select>
            </Form.Item></Col>}

            {/* 超父游戏ID */}
            {isSuperParentGameId && <Col><Form.Item name='superParentGameId'>
                <Select
                    maxTagCount={1}
                    showSearch
                    style={{ minWidth: 140 }}
                    allowClear
                    disabled={parentId || parentGameIds?.length > 0}
                    placeholder={'请选择超父游戏'}
                    filterOption={(input, option) =>
                        (option?.children as any)?.toLowerCase().indexOf(input.toLowerCase()) >= 0
                    }
                    onChange={(e) => {
                        if (isServerIds && e) {
                            form.setFieldsValue({ serverIds: undefined })
                            getGameServerList.run({ gameId: e })
                            getGameUnMergeServerList.run({ gameId: e })
                        } else {
                            getGameServerList?.data && getGameServerList.mutate([])
                            getGameUnMergeServerList?.data && getGameUnMergeServerList.mutate([])
                        }
                    }}
                >
                    {superGameList?.map((item: any) => <Select.Option value={item.super_game_id} key={item.super_game_id}>{item.super_game_name}</Select.Option>)}
                </Select>
            </Form.Item></Col>}

            {/* 父游戏ID */}
            {isParentId && <Col><Form.Item name='parentId'>
                <Select
                    maxTagCount={1}
                    showSearch
                    style={{ minWidth: 140 }}
                    allowClear
                    disabled={superParentGameId}
                    placeholder={'请选择父游戏'}
                    filterOption={(input, option) =>
                        (option?.children as any)?.toLowerCase().indexOf(input.toLowerCase()) >= 0
                    }
                    onChange={(e, option: any) => {
                        if (isServerIds) {
                            form.setFieldsValue({ serverIds: undefined })
                            if (option?.['data-super-id']) {
                                getGameServerList.run({ gameId: option['data-super-id'] })
                            } else {
                                getGameServerList?.data && getGameServerList.mutate([])
                            }
                        }
                        if (isServerIdUn) {
                            form.setFieldsValue({ serverId: undefined })
                            if (option?.['data-super-id']) {
                                getGameServerUnList.run({ gameId: option['data-super-id'] })
                            } else {
                                getGameServerUnList?.data && getGameServerUnList.mutate([])
                            }
                        }
                    }}
                >
                    {parentGameList?.map((item: any) => <Select.Option value={item.parent_game_id} key={item.parent_game_id} data-super-id={item.super_game_id}>{item.parent_game_name}</Select.Option>)}
                </Select>
            </Form.Item></Col>}
            {isParentIds && <Col><Form.Item name='parentGameIds'>
                <Select
                    maxTagCount={1}
                    mode="multiple"
                    showSearch
                    style={{ minWidth: 140 }}
                    allowClear
                    disabled={superParentGameId}
                    placeholder={'请选择父游戏'}
                    filterOption={(input, option) =>
                        (option?.children as any)?.toLowerCase().indexOf(input.toLowerCase()) >= 0
                    }
                    onChange={(e, option) => {
                        if (isServerIds) {
                            form.setFieldsValue({ serverIds: undefined })
                        }
                        if (isServerIdUn) {
                            form.setFieldsValue({ serverId: undefined })
                        }
                    }}
                >
                    {parentGameList?.map((item: any) => <Select.Option value={item.parent_game_id} key={item.parent_game_id}>{item.parent_game_name}</Select.Option>)}
                </Select>
            </Form.Item></Col>}

            {(parentId || superParentGameId) && <>
                {/* 广告区服名称 */}
                {isGameServerName && <Col><Form.Item name='serverName'>
                    <Input placeholder="区服名称" allowClear style={{ width: 140 }} disabled={serverIds?.length > 0} />
                </Form.Item></Col>}

                {/* 区服id */}
                {isServerIds && <Col><Form.Item name='serverIds'>
                    <Select
                        maxTagCount={1}
                        mode="multiple"
                        showSearch
                        disabled={serverName}
                        style={{ minWidth: 140 }}
                        allowClear
                        placeholder={'请选择区服'}
                        filterOption={(input, option) =>
                            (option?.children as any)?.toLowerCase().indexOf(input.toLowerCase()) >= 0
                        }
                        loading={getGameServerList.loading}
                    >
                        {(isIsParticipateMerge && isParticipateMerge)
                            ? getGameUnMergeServerList?.data?.filter((item: { isSourceServer: any }) => (isIsMergeServer && ((!isMergeServer && item.isSourceServer) || (isMergeServer && !item.isSourceServer))) || !isIsMergeServer)?.map((item: any) => <Select.Option value={item.serverId} key={item.serverId}>{item.serverName}</Select.Option>)
                            : getGameServerList?.data?.filter((item: { isSourceServer: any }) => (isIsMergeServer && ((!isMergeServer && item.isSourceServer) || (isMergeServer && !item.isSourceServer))) || !isIsMergeServer)?.map((item: any) => <Select.Option value={item.serverId} key={item.serverId}>{item.serverName}</Select.Option>)}
                    </Select>
                </Form.Item></Col>}

                {/* 是否合服 */}
                {isIsMergeServer && <Col><Form.Item name='isMergeServer' valuePropName="checked">
                    <Checkbox onChange={() => form.setFieldsValue({ serverIds: undefined })}>是否合服</Checkbox>
                </Form.Item></Col>}

                {/* 是否参与过合服 */}
                {isIsParticipateMerge && <Col><Form.Item name='isParticipateMerge' valuePropName="checked">
                    <Checkbox onChange={() => form.setFieldsValue({ serverIds: undefined })}>未参与过合服</Checkbox>
                </Form.Item></Col>}

                {/* 区服id */}
                {isServerIdUn && <Col><Form.Item name='serverId'>
                    <Select
                        maxTagCount={1}
                        mode="multiple"
                        showSearch
                        disabled={serverName}
                        style={{ minWidth: 140 }}
                        allowClear
                        placeholder={'请选择区服'}
                        filterOption={(input, option) =>
                            (option?.children as any)?.toLowerCase().indexOf(input.toLowerCase()) >= 0
                        }
                        loading={getGameServerUnList.loading}
                    >
                        {getGameServerUnList?.data?.filter((item: { isSourceServer: any }) => item.isSourceServer)?.map((item: any) => <Select.Option value={item.serverId} key={item.serverId}>{item.serverName}</Select.Option>)}
                    </Select>
                </Form.Item></Col>}
            </>}

            {/* 游戏应用类型搜索 */}
            {isGameType && <Col><Form.Item name='gameType'>
                <Select
                    maxTagCount={1}
                    showSearch
                    style={{ minWidth: 140 }}
                    allowClear
                    placeholder={'请选择游戏应用类型'}
                    filterOption={(input, option) =>
                        (option?.children as any)?.toLowerCase().indexOf(input.toLowerCase()) >= 0
                    }
                >
                    {getGameChoiceParentListType1?.data?.map((item: any) => <Select.Option value={item.id} key={item.id}>{item.name}</Select.Option>)}
                </Select>
            </Form.Item></Col>}
            {/* 布谷游戏应用类型搜索 */}
            {isBGGameClassify && <Col><Form.Item name='gameClassify'>
                <Select
                    maxTagCount={1}
                    showSearch
                    style={{ width: 140 }}
                    allowClear
                    placeholder={'游戏应用类型'}
                    filterOption={(input, option) =>
                        (option?.children as any)?.toLowerCase().indexOf(input.toLowerCase()) >= 0
                    }
                >
                    {Object.keys(gameClassifyEnum).map(key => <Select.Option value={key} key={key}>{gameClassifyEnum[key as keyof typeof gameClassifyEnum]}</Select.Option>)}
                </Select>
            </Form.Item></Col>}
            {/* 游戏角色名 */}
            {isGameRoleName && <Col><Form.Item name='roleName'>
                <Input placeholder="游戏角色名" allowClear style={{ width: 140 }} />
            </Form.Item></Col>}

            {/* 游戏角色名id搜索 */}
            {isGameRoleId && <Col><Form.Item name='roleId'>
                <Input placeholder="角色ID" allowClear style={{ width: 140 }} />
            </Form.Item></Col>}

            {/* 客户微信号 */}
            {isWeChat && <Col><Form.Item name='weChat'>
                <Input placeholder="客户微信号" allowClear style={{ width: 140 }} />
            </Form.Item></Col>}

            {/* 客户微信号 */}
            {isWeChatCompany && <Col><Form.Item name='weChatCompany'>
                <Input placeholder="企业微信号" allowClear style={{ width: 140 }} />
            </Form.Item></Col>}

            {/* 是否首充 */}
            {isFirstRecharge && <Col><Form.Item name='isFirstRecharge'>
                <Select
                    maxTagCount={1}
                    showSearch
                    style={{ width: 100 }}
                    allowClear
                    placeholder={'是否首充'}
                    filterOption={(input, option) =>
                        (option?.children as any)?.toLowerCase().indexOf(input.toLowerCase()) >= 0
                    }
                >
                    <Select.Option value={'0'}>否</Select.Option>
                    <Select.Option value={'1'}>是</Select.Option>
                </Select>
            </Form.Item></Col>}
            {/* 是否切量 */}
            {isSwitch && <Col><Form.Item name='isSwitch'>
                <Select
                    maxTagCount={1}
                    showSearch
                    style={{ minWidth: 140 }}
                    allowClear
                    placeholder={'请选择是否切量'}
                    filterOption={(input, option) =>
                        (option?.children as any)?.toLowerCase().indexOf(input.toLowerCase()) >= 0
                    }
                >
                    <Select.Option value={'0'}>否</Select.Option>
                    <Select.Option value={'1'}>是</Select.Option>
                </Select>
            </Form.Item></Col>}
            {/* 收款商户号 */}
            {isMerchantNo && <Col><Form.Item name='merchantNo'>
                <Input placeholder="收款商户号" allowClear style={{ width: 140 }} />
            </Form.Item></Col>}
            {/* 收款商户号 */}
            {isMerchantOrderNo && <Col><Form.Item name='merchantOrderNo'>
                <Input placeholder="第三方支付订单号" allowClear style={{ width: 140 }} />
            </Form.Item></Col>}
            {/* 收款商户号 */}
            {isOrderId && <Col><Form.Item name='orderId'>
                <Input placeholder="商户订单号" allowClear style={{ width: 140 }} />
            </Form.Item></Col>}

            {/* 支付状态 */}
            {isPayStatus && <Col><Form.Item name='orderStatus'>
                <Select
                    showSearch
                    style={{ width: 100 }}
                    allowClear
                    placeholder={'支付状态'}
                    filterOption={(input, option) =>
                        (option?.children as any)?.toLowerCase().indexOf(input.toLowerCase()) >= 0
                    }
                >
                    {Object.keys(PayStatus).map(key => <Select.Option value={key} key={key}>{PayStatus[key as keyof typeof PayStatus]}</Select.Option>)}
                </Select>
            </Form.Item></Col>}

            {/* 支付方式 */}
            {isPayWay && <Col><Form.Item name='payWay'>
                <Select
                    showSearch
                    style={{ width: 100 }}
                    allowClear
                    placeholder={'支付方式'}
                    filterOption={(input, option) =>
                        (option?.children as any)?.toLowerCase().indexOf(input.toLowerCase()) >= 0
                    }
                >
                    {getPayList?.data?.map((item: any) => <Select.Option value={item.id} key={item.id}>{item.payName}</Select.Option>)}
                </Select>
            </Form.Item></Col>}

            {/* 推广媒体 */}
            {isType && <Col><Form.Item name='type'>
                <Select
                    showSearch
                    style={{ width: 100 }}
                    allowClear
                    placeholder={'推广媒体'}
                    filterOption={(input, option) =>
                        (option?.children as any)?.toLowerCase().indexOf(input.toLowerCase()) >= 0
                    }
                >
                    {Object.keys(TYPE).map(key => <Select.Option value={key} key={key}>{TYPE[key as keyof typeof TYPE]}</Select.Option>)}
                </Select>
            </Form.Item></Col>}

            {/* 产品名称 */}
            {isProductName && <Col><Form.Item name='productName'>
                <Input placeholder="产品名称" allowClear style={{ width: 140 }} />
            </Form.Item></Col>}

            {/* 注册渠道名 */}
            {isRegAgent && <Col><Form.Item name='regAgent'>
                <Input placeholder="注册渠道名" allowClear style={{ width: 140 }} />
            </Form.Item></Col>}

            {/* 渠道标识 */}
            {isAgentKey && <Col><Form.Item name='agentKey'>
                <Input placeholder="渠道标识" allowClear style={{ width: 140 }} />
            </Form.Item></Col>}

            {/* 渠道名称 */}
            {isAgentName && <Col><Form.Item name='agentName'>
                <Input placeholder="渠道名称" allowClear style={{ width: 140 }} />
            </Form.Item></Col>}

            {/* 推广渠道id */}
            {isAgentId && <Col><Form.Item name='agentId'>
                <Select
                    maxTagCount={1}
                    mode="multiple"
                    showSearch
                    style={{ minWidth: 140 }}
                    allowClear
                    placeholder={'请选择渠道'}
                    loading={getChannelChoiceList.loading || getAgentListNew.loading}
                    filterOption={(input, option) =>
                        (option?.children as any)?.toLowerCase().indexOf(input.toLowerCase()) >= 0
                    }
                >
                    {agentData?.map((item: any) => <Select.Option value={item.value} key={item.value}>{item.label}</Select.Option>)}
                </Select>
            </Form.Item></Col>}

            {/* 投放渠道名 */}
            {isPutAgent && <Col><Form.Item name='putAgent'>
                <Input placeholder="投放渠道名" allowClear style={{ width: 140 }} />
            </Form.Item></Col>}

            {/* 投手名 */}
            {isSysUserName && <Col><Form.Item name='sysUserName'>
                <Input placeholder="投手名" allowClear style={{ width: 140 }} />
            </Form.Item></Col>}

            {/* 投手ID */}
            {isSysUserId && <Col><Form.Item name='pitcherId'>
                <Select
                    maxTagCount={1}
                    showSearch
                    style={{ width: 120 }}
                    allowClear
                    loading={getSubUserWithSelfList.loading || getPitcherListNew.loading}
                    placeholder={'请选择投手'}
                    filterOption={(input, option) =>
                        (option?.children as any)?.toLowerCase().indexOf(input.toLowerCase()) >= 0
                    }
                >
                    {userIdList.map((item: any) => <Select.Option value={item.userId} key={item.userId}>{item.nickname}</Select.Option>)}
                </Select>
            </Form.Item></Col>}
            {isSysUserIds && <Col><Form.Item name='pitcherId'>
                <Select
                    maxTagCount={1}
                    showSearch
                    style={{ minWidth: 120 }}
                    allowClear
                    mode="multiple"
                    loading={getSubUserWithSelfList.loading || getPitcherListNew.loading}
                    placeholder={'请选择投手'}
                    filterOption={(input, option) =>
                        (option?.children as any)?.toLowerCase().indexOf(input.toLowerCase()) >= 0
                    }
                >
                    {userIdList.map((item: any) => <Select.Option value={item.userId} key={item.userId}>{item.nickname}</Select.Option>)}
                </Select>
            </Form.Item></Col>}
            {/* 客服ID */}
            {isCustomerServerId && <Col><Form.Item name='customerServerId'>
                <Select
                    maxTagCount={1}
                    showSearch
                    style={{ width: 120 }}
                    allowClear
                    placeholder={'请选择客服'}
                    filterOption={(input, option) =>
                        (option?.children as any)?.toLowerCase().indexOf(input.toLowerCase()) >= 0
                    }
                >
                    <Select.Option value={0}>未操作</Select.Option>
                    {customerList.map((item: any) => <Select.Option value={item.userId} key={item.userId}>{item.nickname}</Select.Option>)}
                </Select>
            </Form.Item></Col>}
            {/* 运营ID */}
            {isOperatorId && <Col><Form.Item name='operatorId'>
                <Select
                    maxTagCount={1}
                    showSearch
                    style={{ width: 120 }}
                    allowClear
                    placeholder={'请选择运营'}
                    filterOption={(input, option) =>
                        (option?.children as any)?.toLowerCase().indexOf(input.toLowerCase()) >= 0
                    }
                >
                    <Select.Option value={0}>未操作</Select.Option>
                    {operateList.map((item: any) => <Select.Option value={item.userId} key={item.userId}>{item.nickname}</Select.Option>)}
                </Select>
            </Form.Item></Col>}
            {/* GSID */}
            {isGsId && <Col><Form.Item name='gsId'>
                <Select
                    maxTagCount={1}
                    showSearch
                    style={{ width: 120 }}
                    allowClear
                    placeholder={'请选择GS'}
                    filterOption={(input, option) =>
                        (option?.children as any)?.toLowerCase().indexOf(input.toLowerCase()) >= 0
                    }
                >
                    <Select.Option value={0}>未操作</Select.Option>
                    {gsList.map((item: any) => <Select.Option value={item.userId} key={item.userId}>{item.nickname}</Select.Option>)}
                </Select>
            </Form.Item></Col>}

            {/* 玩家账号 */}
            {isUserName && <Col><Form.Item name='username'>
                <Input placeholder="玩家账号" allowClear style={{ width: 140 }} />
            </Form.Item></Col>}

            {/* 用户id */}
            {isUserId && <Col><Form.Item name='userId'>
                <Input placeholder="用户ID" allowClear style={{ width: 140 }} />
            </Form.Item></Col>}

            {/* 玩家昵称 */}
            {isNickname && <Col><Form.Item name='nickname'>
                <Input placeholder="玩家昵称" allowClear style={{ width: 140 }} />
            </Form.Item></Col>}

            {/* 绑定手机 */}
            {isMobile && <Col><Form.Item name='mobile'>
                <Input placeholder="绑定手机" allowClear style={{ width: 140 }} />
            </Form.Item></Col>}

            {/* 注册IP */}
            {isRegIp && <Col><Form.Item name='regIp'>
                <Input placeholder="注册IP" allowClear style={{ width: 140 }} />
            </Form.Item></Col>}

            {/* 注册IP */}
            {isIp && <Col><Form.Item name='ip'>
                <Input placeholder="IP" allowClear style={{ width: 140 }} />
            </Form.Item></Col>}

            {/* 注册IP */}
            {isRankingNum && <Col><Form.Item name='rankingNum'>
                <InputNumber placeholder="排名范围" min={1} />
            </Form.Item></Col>}

            {/* 是否充值 */}
            {isIsRecharge && <Col><Form.Item name='isRecharge'>
                <Select
                    showSearch
                    style={{ width: 98 }}
                    allowClear
                    placeholder={'是否充值'}
                    filterOption={(input, option) =>
                        (option?.children as any)?.toLowerCase().indexOf(input.toLowerCase()) >= 0
                    }
                >
                    <Select.Option value={false}>否</Select.Option>
                    <Select.Option value={true}>是</Select.Option>
                </Select>
            </Form.Item></Col>}

            {/* 实名状态 */}
            {isIsAuth && <Col><Form.Item name='isAuth'>
                <Select
                    showSearch
                    allowClear
                    style={{ width: 98 }}
                    placeholder={'实名状态'}
                    filterOption={(input, option) =>
                        (option?.children as any)?.toLowerCase().indexOf(input.toLowerCase()) >= 0
                    }
                >
                    <Select.Option value={false}>未实名</Select.Option>
                    <Select.Option value={true}>已实名</Select.Option>
                </Select>
            </Form.Item></Col>}

            {/* 是否绑定手机 */}
            {isIsBindMobile && <Col><Form.Item name='isBindMobile'>
                <Select
                    showSearch
                    allowClear
                    style={{ width: 126 }}
                    placeholder={'是否绑定手机'}
                    filterOption={(input, option) =>
                        (option?.children as any)?.toLowerCase().indexOf(input.toLowerCase()) >= 0
                    }
                >
                    <Select.Option value={false}>未绑定</Select.Option>
                    <Select.Option value={true}>已绑定</Select.Option>
                </Select>
            </Form.Item></Col>}

            {/* 玩家状态 */}
            {isUserStatus && <Col><Form.Item name='userStatus'>
                <Select
                    showSearch
                    allowClear
                    style={{ width: 110 }}
                    placeholder={'玩家状态'}
                    filterOption={(input, option) =>
                        (option?.children as any)?.toLowerCase().indexOf(input.toLowerCase()) >= 0
                    }
                >
                    <Select.Option value={'1'}>试玩</Select.Option>
                    <Select.Option value={'2'}>正常</Select.Option>
                    <Select.Option value={'3'}>冻结</Select.Option>
                </Select>
            </Form.Item></Col>}

            {/* 是否创角 */}
            {isCreateRole && <Col><Form.Item name='createRole'>
                <Select
                    showSearch
                    allowClear
                    style={{ width: 110 }}
                    placeholder={'是否创角'}
                    filterOption={(input, option) =>
                        (option?.children as any)?.toLowerCase().indexOf(input.toLowerCase()) >= 0
                    }
                >
                    <Select.Option value={true}>是</Select.Option>
                    <Select.Option value={false}>否</Select.Option>
                </Select>
            </Form.Item></Col>}

            {/* 是否转端 */}
            {isIsChange && <Col><Form.Item name='isChange'>
                <Select
                    showSearch
                    allowClear
                    mode="multiple"
                    style={{ width: 110 }}
                    placeholder={'是否转端'}
                    filterOption={(input, option) =>
                        (option?.children as any)?.toLowerCase().indexOf(input.toLowerCase()) >= 0
                    }
                >
                    <Select.Option value="2">未操作</Select.Option>
                    <Select.Option value="1">是</Select.Option>
                    <Select.Option value="0">不转端</Select.Option>
                </Select>
            </Form.Item></Col>}

            {/* 邮件是否发送 */}
            {isIsSendMail && <Col><Form.Item name='isSendMail'>
                <Select
                    showSearch
                    allowClear
                    style={{ width: 140 }}
                    placeholder={'邮件是否发送'}
                    filterOption={(input, option) =>
                        (option?.children as any)?.toLowerCase().indexOf(input.toLowerCase()) >= 0
                    }
                >
                    <Select.Option value="1">发送</Select.Option>
                    <Select.Option value="0">不发送</Select.Option>
                </Select>
            </Form.Item></Col>}

            {/* 是否退游 */}
            {isRemoveGameForSystem && <Col><Form.Item name='isRemoveGameForSystem'>
                <Select
                    showSearch
                    allowClear
                    placeholder={'系统判定是否退游'}
                    filterOption={(input, option) =>
                        (option?.children as any)?.toLowerCase().indexOf(input.toLowerCase()) >= 0
                    }
                >
                    <Select.Option value="1">退游</Select.Option>
                    <Select.Option value="0">未退游</Select.Option>
                </Select>
            </Form.Item></Col>}

            {/* 是否退游 */}
            {isRemoveGame && <Col><Form.Item name='isRemoveGame'>
                <Select
                    showSearch
                    allowClear
                    mode="multiple"
                    style={{ width: 110 }}
                    placeholder={'是否退游'}
                    filterOption={(input, option) =>
                        (option?.children as any)?.toLowerCase().indexOf(input.toLowerCase()) >= 0
                    }
                >
                    <Select.Option value="2">未操作</Select.Option>
                    <Select.Option value="1">退游</Select.Option>
                    <Select.Option value="0">未退游</Select.Option>
                </Select>
            </Form.Item></Col>}

            {/* 是否添加企微 */}
            {isAddCorpWechat && <Col><Form.Item name='isAddCorpWechat'>
                <Select
                    showSearch
                    allowClear
                    mode="multiple"
                    style={{ width: 135 }}
                    placeholder={'是否添加企微'}
                    filterOption={(input, option) =>
                        (option?.children as any)?.toLowerCase().indexOf(input.toLowerCase()) >= 0
                    }
                >
                    <Select.Option value="2">未操作</Select.Option>
                    <Select.Option value="1">是</Select.Option>
                    <Select.Option value="0">否</Select.Option>
                </Select>
            </Form.Item></Col>}

            {/* 是否唤醒 */}
            {isWakeUp && <Col><Form.Item name='isWakeUp'>
                <Select
                    showSearch
                    allowClear
                    style={{ width: 110 }}
                    placeholder={'是否唤醒'}
                    mode="multiple"
                    filterOption={(input, option) =>
                        (option?.children as any)?.toLowerCase().indexOf(input.toLowerCase()) >= 0
                    }
                >
                    <Select.Option value="2">未操作</Select.Option>
                    <Select.Option value="1">是</Select.Option>
                    <Select.Option value="0">否</Select.Option>
                </Select>
            </Form.Item></Col>}

            {/* 是否绑定手机号 */}
            {isUserPhoneStatus && <Col><Form.Item name='userPhoneStatus'>
                <Select
                    showSearch
                    allowClear
                    style={{ width: 170 }}
                    placeholder={'客户是否绑定手机号'}
                    filterOption={(input, option) =>
                        (option?.children as any)?.toLowerCase().indexOf(input.toLowerCase()) >= 0
                    }
                >
                    <Select.Option value={1}>绑定</Select.Option>
                    <Select.Option value={0}>未绑定</Select.Option>
                </Select>
            </Form.Item></Col>}

            {/* vip等级 */}
            {isVipLevel && <Col><Form.Item name='vipLevel'>
                <Select
                    showSearch
                    allowClear
                    maxTagCount={1}
                    mode="multiple"
                    style={{ minWidth: 98 }}
                    placeholder={'角色VIP'}
                    filterOption={(input, option) =>
                        (option?.children as any)?.toLowerCase().indexOf(input.toLowerCase()) >= 0
                    }
                >
                    {Array(getVipLevel?.data || 0).fill('').map((_item, index) => <Select.Option value={index + 1} key={index + 1}>{index + 1}</Select.Option>)}
                </Select>
            </Form.Item></Col>}

            {/* 角色等级 */}
            {isRoleLevel && <Col><Form.Item>
                <Space>
                    <Form.Item name='roleLevelMin' noStyle>
                        <InputNumber style={{ width: 130 }} placeholder="角色等级最小值" />
                    </Form.Item>
                    <span>~</span>
                    <Form.Item name='roleLevelMax' noStyle>
                        <InputNumber style={{ width: 130 }} placeholder="角色等级最小值" />
                    </Form.Item>
                </Space>
            </Form.Item></Col>}

            {/* 操作系统 */}
            {isOs && <Col><Form.Item name='os'>
                <Select
                    maxTagCount={1}
                    showSearch
                    style={{ width: 110 }}
                    allowClear
                    placeholder={'操作系统'}
                    filterOption={(input, option) =>
                        (option?.children as any)?.toLowerCase().indexOf(input.toLowerCase()) >= 0
                    }
                >
                    {getUserSystemTypeChoiceList?.data?.map((item: any) => <Select.Option value={item.os} key={item.os}>{item.os}</Select.Option>)}
                </Select>
            </Form.Item></Col>}

            {/* 支付状态 */}
            {isBackStatus && <Col><Form.Item name='backStatus'>
                <Select
                    showSearch
                    style={{ width: 100 }}
                    allowClear
                    placeholder={'回传状态'}
                    filterOption={(input, option) =>
                        (option?.children as any)?.toLowerCase().indexOf(input.toLowerCase()) >= 0
                    }
                >
                    <Select.Option value={-1}>回传失败</Select.Option>
                    <Select.Option value={0}>未回传</Select.Option>
                    <Select.Option value={1}>回传成功</Select.Option>
                    <Select.Option value={2}>部分成功</Select.Option>
                </Select>
            </Form.Item></Col>}

            {/* 玩家最新染色归因投手 */}
            {isUserLastPitcherId && <Col><Form.Item name='userLastPitcherId'>
                <Select
                    maxTagCount={1}
                    showSearch
                    style={{ width: 160 }}
                    allowClear
                    loading={getSubUserWithSelfList.loading || getPitcherListNew.loading}
                    placeholder={'最新染色归因投手'}
                    filterOption={(input, option) =>
                        (option?.children as any)?.toLowerCase().indexOf(input.toLowerCase()) >= 0
                    }
                >
                    {userIdList.map((item: any) => <Select.Option value={item.userId} key={item.userId}>{item.nickname}</Select.Option>)}
                </Select>
            </Form.Item></Col>}

            {/* 玩家最新染色渠道ID */}
            {isUserLastRegAgentId && <Col><Form.Item name='userLastRegAgentId'>
                <Select
                    showSearch
                    style={{ minWidth: 140 }}
                    allowClear
                    placeholder={'玩家最新染色渠道'}
                    loading={getChannelChoiceList.loading || getAgentListNew.loading}
                    filterOption={(input, option) =>
                        (option?.children as any)?.toLowerCase().indexOf(input.toLowerCase()) >= 0
                    }
                >
                    {agentData?.map((item: any) => <Select.Option value={item.value} key={item.value}>{item.label}</Select.Option>)}
                </Select>
            </Form.Item></Col>}

            {/* 创意状态 */}
            {isConfiguredStatus && <Col><Form.Item name='creativeStatus'>
                <Select
                    showSearch
                    style={{ width: 100 }}
                    allowClear
                    placeholder={'创意状态'}
                    filterOption={(input, option) =>
                        (option?.children as any)?.toLowerCase().indexOf(input.toLowerCase()) >= 0
                    }
                >
                    <Select.Option value={'AD_STATUS_NORMAL'}>有效</Select.Option>
                    <Select.Option value={'AD_STATUS_SUSPEND'}>暂停</Select.Option>
                </Select>
            </Form.Item></Col>}

            {/* 玩家最新染色时间 */}
            {isUserLastRegTime && <Col><Form.Item name='userLastRegTime'>
                <DatePicker placeholder={'最新染色时间'} />
            </Form.Item></Col>}

            {/* 用户注册日期搜索 */}
            {isRegDay && <Col><Form.Item name='regDay'>
                <DatePicker.RangePicker style={{ width: 230 }} placeholder={['注册开始日期', '注册结束日期']} {...isRegDay} />
            </Form.Item></Col>}

            {/* 消耗日期 搜索 */}
            {isConsumeDay && <Col><Form.Item name='consumeDay'>
                <DatePicker.RangePicker style={{ width: 230 }} placeholder={['消耗开始日期', '消耗结束日期']} {...isConsumeDay} />
            </Form.Item></Col>}

            {/* 消耗日期 搜索 */}
            {isBeginDay && <Col><Form.Item name='beginDay'>
                <DatePicker.RangePicker style={{ width: 230 }} placeholder={['开始日期', '结束日期']} />
            </Form.Item></Col>}

            {/* 订单创建日期搜索 */}
            {isCreateDay && <Col><Form.Item name='createDay'>
                <DatePicker.RangePicker style={{ width: 230 }} placeholder={['订单创建开始日期', '订单创建结束日期']} {...isCreateDay} />
            </Form.Item></Col>}

            {isCreateDayXz && <Col><Form.Item name='createDay'>
                <DatePicker.RangePicker style={{ width: 230 }} disabledDate={disabledDate} placeholder={['订单创建开始日期', '订单创建结束日期']} {...isCreateDay} />
            </Form.Item></Col>}

            {/* 充值日期搜索 */}
            {rechargeDay && <Col><Form.Item name='rechargeDay'>
                <DatePicker.RangePicker style={{ width: 230 }} placeholder={['充值开始日期', '充值结束日期']} {...rechargeDay} />
            </Form.Item></Col>}

            {LastRechargeDay && <Col><Form.Item name='LastRechargeDay'>
                <DatePicker.RangePicker style={{ width: 230 }} placeholder={['最近充值开始日期', '最近充值结束日期']} {...LastRechargeDay} />
            </Form.Item></Col>}

            {/* 单个充值日期搜索 */}
            {payTimeDay && <Col><Form.Item name='payTime'>
                <DatePicker.RangePicker style={{ width: 230 }} placeholder={['支付开始日期', '支付结束日期']} {...payTimeDay} />
            </Form.Item></Col>}
            {/* 单个充值日期搜索 */}
            {placeAnOrderDay && <Col><Form.Item name='placeAnOrderTime'>
                <DatePicker.RangePicker style={{ width: 230 }} placeholder={['下单开始日期', '下单结束日期']} {...placeAnOrderDay} />
            </Form.Item></Col>}

            {/* 开服日期搜索 */}
            {isServerDay && <Col><Form.Item name='serverDay'>
                <DatePicker.RangePicker style={{ width: 230 }} placeholder={['开服开始日期', '开服结束日期']} {...isServerDay} />
            </Form.Item></Col>}

            {/* 角色创建日期搜索 */}
            {isCreateRoleDay && <Col><Form.Item name='createRoleDay'>
                <DatePicker.RangePicker style={{ width: 230 }} placeholder={['角色创建开始日期', '角色创建结束日期']} {...isCreateRoleDay} />
            </Form.Item></Col>}

            {/* 最近活跃 */}
            {isLastActiveTime && <Col><Form.Item name='lastActiveTime'>
                <DatePicker.RangePicker style={{ width: 230 }} placeholder={['最近活跃开始日期', '最近活跃结束日期']} {...isLastActiveTime} />
            </Form.Item></Col>}

            {/* 单个充值日期搜索 */}
            {isRechargeDate && <Col><Form.Item name='rechargeDate'>
                <DatePicker placeholder={'充值日期'} />
            </Form.Item></Col>}

            {/* 单个充值日期搜索 */}
            {isPayIntervalTime && <Col><Form.Item name='regPayIntervalTime'>
                <IntervalTime {...isPayIntervalTime} />
            </Form.Item></Col>}

            {isRoleCount && <Col><Form.Item name='roleCount'>
                <IntervalTime {...isRoleCount} />
            </Form.Item></Col>}

            {/* 创角24小时内单笔充值金额 */}
            {isRechargeAmountWithin24h && <Col><Form.Item name='roleCount'>
                <Space size={0}>
                    <Form.Item name={'rechargeAmountWithin24hUnit'} noStyle>
                        <Select placeholder="条件" style={{ width: 70 }} allowClear>
                            {/* <Select.Option value=">=">{`>=`}</Select.Option>
                            <Select.Option value="<=">{`<=`}</Select.Option> */}
                            <Select.Option value="=">{`=`}</Select.Option>
                            <Select.Option value=">">{`>`}</Select.Option>
                            <Select.Option value="<">{`<`}</Select.Option>
                        </Select>
                    </Form.Item>
                    <Form.Item name={'rechargeAmountWithin24h'} noStyle>
                        <Input placeholder="创角24小时内单笔充值金额" allowClear />
                    </Form.Item>
                    <Tooltip title={'创角24小时内单笔充值金额，条件默认">="'}>
                        <QuestionCircleOutlined style={{ marginLeft: 10 }} />
                    </Tooltip>
                </Space>
            </Form.Item></Col>}

            {/* 创角24小时以内累计充值金额 */}
            {isRechargeTotalAmountWithin24h && <Col><Form.Item name='roleCount'>
                <Space size={0}>
                    <Form.Item name={'rechargeTotalAmountWithin24hUnit'} noStyle>
                        <Select placeholder="条件" style={{ width: 70 }} allowClear>
                            <Select.Option value=">=">{`>=`}</Select.Option>
                            <Select.Option value="<=">{`<=`}</Select.Option>
                            <Select.Option value="=">{`=`}</Select.Option>
                            <Select.Option value=">">{`>`}</Select.Option>
                            <Select.Option value="<">{`<`}</Select.Option>
                        </Select>
                    </Form.Item>
                    <Form.Item name={'rechargeTotalAmountWithin24h'} noStyle>
                        <Input placeholder="创角24小时以内累计充值金额" allowClear />
                    </Form.Item>
                    <Tooltip title={'创角24小时以内累计充值金额，条件默认">="'}>
                        <QuestionCircleOutlined style={{ marginLeft: 10 }} />
                    </Tooltip>
                </Space>
            </Form.Item></Col>}

            {/* isIpCity, isIpProv, isLoginIpCity, isLoginIpProv */}
            {isIpCity && <Col><Form.Item name='ipCity'>
                <Input placeholder="注册城市" allowClear style={{ width: 140 }} />
            </Form.Item></Col>}
            {isIpProv && <Col><Form.Item name='ipProv'>
                <Input placeholder="注册归属地" allowClear style={{ width: 140 }} />
            </Form.Item></Col>}
            {isLoginIpCity && <Col><Form.Item name='loginIpCity'>
                <Input placeholder="最新登录城市" allowClear style={{ width: 140 }} />
            </Form.Item></Col>}
            {isLoginIpProv && <Col><Form.Item name='loginIpProv'>
                <Input placeholder="最新登录归属地" allowClear style={{ width: 140 }} />
            </Form.Item></Col>}

            <Col>
                <Space>
                    <Button type="primary" htmlType="submit">搜索</Button>
                    <Button onClick={() => form.resetFields()}>重置</Button>
                </Space>
            </Col>
        </Row>
    </Form>
}


export default React.memo(QueryForm)