constants.js

import React from 'react';
import { classNames, expandable, sortable, nowrap, wrappable, fitContent } from '@patternfly/react-table';
import StatusColumn from '../Components/PresentationalComponents/StatusColumn/StatusColumn';
import AdvisoryColumn from '../Components/PresentationalComponents/AdvisoryColumn/AdvisoryColumn';
import SystemNameColumn from '../Components/PresentationalComponents/TableColumns/SystemNameColumn';
import RemediationColumn from '../Components/PresentationalComponents/TableColumns/RemediationColumn';
import CvssCustomFilter from '../Components/PresentationalComponents/Filters/CustomFilters/CvssCustomFilter';
import CheckboxCustomFilter from '../Components/PresentationalComponents/Filters/CustomFilters/CheckboxCustomFilter';
import SelectCustomFilter from '../Components/PresentationalComponents/Filters/CustomFilters/SelectCustomFilter';
import messages from '../Messages';
import { intl } from '../Utilities/IntlProvider';
import { intlFormatWithBold } from './ReportsHelper';
import { Icon, Label as Pflabel, Tooltip } from '@patternfly/react-core';
import { Fragment } from 'react';
import TagFilter from '../Components/PresentationalComponents/Filters/CustomFilters/TagFilter';
import NotVulnerableLabel from '../Components/PresentationalComponents/Snippets/NotVulnerableLabel';
import { isEmpty } from 'lodash';
import { OutlinedQuestionCircleIcon } from '@patternfly/react-icons';
import { InsightsLink } from '@redhat-cloud-services/frontend-components/InsightsLink';
import { groupOrWorkspace } from './MiscHelper';

export const SERVICE_NAME = 'Vulnerability';
export const DEFAULT_PAGE_SIZE = 20;
export const RH_KB_URL = 'https://access.redhat.com/node';
export const CVES_PATH = `${document.baseURI}insights/vulnerability/cves`;
export const PATCHMAN_ADVISORY_PATH = `${document.baseURI}insights/patch/advisories`;
export const CUSTOMER_PORTAL_ADVISORY_PATH = `https://access.redhat.com/errata`;
export const CUSTOMER_PORTAL_CVE_PATH = `https://access.redhat.com/security/cve`;
export const PATCHMAN_ADVISORY_DOCS_PATH = 'https://access.redhat.com/support/policy/updates/errata';

export const impactTextList = {
    low: intl.formatMessage(messages.impactTextListLow),
    moderate: intl.formatMessage(messages.impactTextListModerate),
    important: intl.formatMessage(messages.impactTextListImportant),
    critical: intl.formatMessage(messages.impactTextListCritical)
};

export const PATHS = {
    home: {
        title: 'Vulnerability',
        to: 'cves'
    },
    cvesPage: {
        title: 'CVEs',
        to: 'cves'
    },
    cveDetailsPage: {
        title: 'CVE',
        to: 'cves/:cve'
    },
    cveDetailsEdgePage: {
        title: 'CVE',
        to: 'cves/:cve/manage-edge-inventory'
    },
    systemsPage: {
        title: 'Systems',
        to: 'systems'
    },
    systemDetailsPage: {
        title: 'Inventory Detail',
        to: 'systems/:inventoryId'
    },
    cvepagePath: {
        title: 'CVE Page',
        to: 'cves/:cve/:inventoryId'
    },
    upgrade: {
        title: 'Upgrade',
        to: 'upgrade'
    },
    reports: {
        title: 'Reports',
        to: 'reports'
    }
};

export const impactList = {
    Critical: {
        title: intl.formatMessage(messages.impactListCritical),
        color: 'var(--pf-v5-global--danger-color--100)',
        text: impactTextList.critical,
        iconColor: 'var(--pf-v5-global--palette--red-200)'
    },
    Important: {
        title: intl.formatMessage(messages.impactListImportant),
        color: 'var(--pf-v5-global--palette--orange-400)',
        text: impactTextList.important,
        iconColor: 'var(--pf-v5-global--palette--orange-300)'
    },
    Moderate: {
        title: intl.formatMessage(messages.impactListModerate),
        color: 'var(--pf-v5-global--warning-color--200)',
        text: impactTextList.moderate,
        iconColor: 'var(--pf-v5-global--palette--gold-400)'
    },
    Low: {
        title: intl.formatMessage(messages.impactListLow),
        color: 'var(--pf-v5-global--default-color--300)',
        text: impactTextList.low,
        iconColor: 'var(--pf-v5-global--palette--black-600)'
    }
};

export const ReadOnlyNotification = {
    variant: 'danger',
    autoDismiss: false,
    title: intl.formatMessage(messages.readOnlyNotificationTitle),
    description: (
        <Fragment>
            <span>{intl.formatMessage(messages.readOnlyNotificationBody)}</span>
            <br /><br />
            <a
                href="https://status.redhat.com/"
                target="_blank"
                rel="noopener noreferrer"
            >
                {intl.formatMessage(messages.readOnlyNotificationLink)}
            </a>
        </Fragment>)
};

export const NotAuthorizedNotification = {
    variant: 'danger',
    autoDismiss: false,
    title: intl.formatMessage(messages.notAuthorizedNotificationTitle)
};

export const ONLY_NON_VULNERABLE_SYSTEMS = 'affected_not_vulnerable';

export const RULE_PRESENCE_OPTIONS = [
    {
        value: 'true',
        label: intl.formatMessage(messages.withSecurityRule)
    },
    {
        value: ONLY_NON_VULNERABLE_SYSTEMS,
        label: intl.formatMessage(messages.notVulnerableBoxTitle)
    },
    {
        value: 'false',
        label: intl.formatMessage(messages.withoutSecurityRule)
    }
];

// NOTE value is passed as string cause there is a bug in ConditionalFilter
// when you pass boolean (true, false) onChange returns 1 instead of false
export const KNOWN_EXPLOIT_FILTER_OPTIONS = [
    {
        value: 'true',
        label: intl.formatMessage(messages.hasKnownExploit)
    },
    {
        value: 'false',
        label: intl.formatMessage(messages.noKnownExploit)
    }
];

export const getAffectingFilterOptions = (shouldUseHybridSystemFilter = false) => (shouldUseHybridSystemFilter ?
    [
        {
            value: 'rpmdnf',
            label: intl.formatMessage(messages.filterAffectedTraditionalSystems)
        },
        {
            value: 'edge',
            label: intl.formatMessage(messages.filterAffectedEdgeDevices)
        },
        {
            value: 'none',
            label: intl.formatMessage(messages.systemsNotAffected)
        }
    ] :
    [
        {
            value: 'true',
            label: intl.formatMessage(messages.systemsAffected)
        },
        {
            value: 'false',
            label: intl.formatMessage(messages.systemsNotAffected)
        }
    ]
);

export const EXCLUDED_FILTER_OPTIONS = [
    {
        value: 'false',
        label: intl.formatMessage(messages.systemsEnabled)
    },
    {
        value: 'true',
        label: intl.formatMessage(messages.systemsDisabled)
    }
];

export const ADVISORY_AVAILABILITY_FILTER_OPTIONS = [
    {
        value: 'true',
        label: intl.formatMessage(messages.available)
    },
    {
        value: 'false',
        label: intl.formatMessage(messages.notAvailable)
    }
];

export const subtractDays = (toSubtract, currDate = new Date()) => {
    return currDate.setDate(currDate.getDate() - toSubtract);
};

export const subtractYears = (toSubtract, currDate = new Date()) => {
    return currDate.setFullYear(currDate.getFullYear() - toSubtract);
};

//Public date labels to value
export const PUBLIC_DATE_OPTIONS = [
    {
        value: 'all',
        label: intl.formatMessage(messages.optionsAll),
        timespan_label: intlFormatWithBold(messages.customReportTimespanAnytime)
    },
    {
        value: 'last7',
        label: intl.formatMessage(messages.lastxdays, { days: 7 }),
        timespan_label: intlFormatWithBold(messages.customReportTimespanWithinLastXDays, { count: 7 }),
        from: subtractDays(7)
    },
    {
        value: 'last30',
        label: intl.formatMessage(messages.lastxdays, { days: 30 }),
        timespan_label: intlFormatWithBold(messages.customReportTimespanWithinLastXDays, { count: 30 }),
        from: subtractDays(30)
    },
    {
        value: 'last90',
        label: intl.formatMessage(messages.lastxdays, { days: 90 }),
        timespan_label: intlFormatWithBold(messages.customReportTimespanWithinLastXDays, { count: 90 }),
        from: subtractDays(90)
    },
    {
        value: 'lastYear',
        label: intl.formatMessage(messages.lastYear),
        timespan_label: intlFormatWithBold(messages.customReportTimespanWithinLastYear),
        from: subtractYears(1)
    },
    {
        value: 'MoreThanYear',
        label: intl.formatMessage(messages.moreThanYear),
        timespan_label: intlFormatWithBold(messages.customReportTimespanMoreThanOneYear),
        to: subtractYears(1)
    }
];

export const CUSTOM_REPORT_SORT_OPTIONS = [
    {
        value: '-business_risk',
        label: intl.formatMessage(messages.businessRiskHighToLow)
    },
    {
        value: 'business_risk',
        label: intl.formatMessage(messages.businessRiskLowToHigh)
    },
    {
        value: '-cvss_score',
        label: intl.formatMessage(messages.cvssBaseScoreHighToLow)
    },
    {
        value: 'cvss_score',
        label: intl.formatMessage(messages.cvssBaseScoreLowToHigh)
    },
    {
        value: '-impact',
        label: intl.formatMessage(messages.severityHighToLow)
    },
    {
        value: 'impact',
        label: intl.formatMessage(messages.severityLowToHigh)
    }
];

export const IMPACT_OPTIONS = [
    {
        label: intl.formatMessage(messages.impactListCritical),
        value: '7',
        hasIcon: true,
        iconColor: 'var(--pf-v5-global--danger-color--100)'
    },
    {
        label: intl.formatMessage(messages.impactListImportant),
        value: '5',
        hasIcon: true,
        iconColor: 'var(--pf-v5-global--palette--orange-300)'
    },
    {
        label: intl.formatMessage(messages.impactListModerate),
        value: '4',
        hasIcon: true,
        iconColor: 'var(--pf-v5-global--warning-color--100)'
    },
    {
        label: intl.formatMessage(messages.impactListLow),
        value: '2',
        hasIcon: true,
        iconColor: 'var(--pf-v5-global--Color--200)'
    },
    {
        label: intl.formatMessage(messages.impactListUnknown),
        value: '1',
        hasIcon: false
    }
];

export const STATUS_OPTIONS = [
    { label: intl.formatMessage(messages.notReviewed), value: '0' },
    { label: intl.formatMessage(messages.inReview), value: '1' },
    { label: intl.formatMessage(messages.onHold), value: '2' },
    { label: intl.formatMessage(messages.scheduledPatch), value: '3' },
    { label: intl.formatMessage(messages.resolved), value: '4' },
    { label: intl.formatMessage(messages.noAction), value: '5' },
    { label: intl.formatMessage(messages.resolvedViaMitigation), value: '6' }
];

export const BUSINESS_RISK_OPTIONS = [
    {
        value: '4',
        label: intl.formatMessage(messages.critical)
    },
    {
        value: '3',
        label: intl.formatMessage(messages.high)
    },
    {
        value: '2',
        label: intl.formatMessage(messages.medium)
    },
    {
        value: '1',
        label: intl.formatMessage(messages.low)
    },
    {
        value: '0',
        label: intl.formatMessage(messages.notDefined)
    }
];

export const MANUAL_REMEDIATION = 1;

export const REMEDIATION_OPTIONS = [
    {
        value: '2',
        label: intl.formatMessage(messages.remediationOptionAnsible)
    },
    {
        value: '1',
        label: intl.formatMessage(messages.remediationOptionManual)
    },
    {
        value: '0',
        label: intl.formatMessage(messages.remediationOptionNotAvailable)
    }
];

export const ANSIBLE_REMEDIATION = 2;

export const getFilters = (shouldUseHybridSystemFilter) => ({
    publish_date: {
        title: intl.formatMessage(messages.publishDate),
        items: PUBLIC_DATE_OPTIONS
    },
    impact: {
        title: intl.formatMessage(messages.impact),
        items: IMPACT_OPTIONS
    },
    cvss_filter: {
        title: intl.formatMessage(messages.cvssBaseScore)
    },
    affecting: {
        title: intl.formatMessage(messages.systemsExposedTableHeader),
        items: getAffectingFilterOptions(shouldUseHybridSystemFilter)
    },
    business_risk_id: {
        title: intl.formatMessage(messages.businessRisk),
        items: BUSINESS_RISK_OPTIONS
    },
    status_id: {
        title: intl.formatMessage(messages.status),
        items: STATUS_OPTIONS
    },
    rule_presence: {
        title: intl.formatMessage(messages.securityRules),
        items: RULE_PRESENCE_OPTIONS
    },
    excluded: {
        title: intl.formatMessage(messages.systemsWithEnabledAnalysis),
        items: EXCLUDED_FILTER_OPTIONS
    },
    known_exploit: {
        title: intl.formatMessage(messages.knownExploit),
        items: KNOWN_EXPLOIT_FILTER_OPTIONS
    },
    rhel_version: {
        title: intl.formatMessage(messages.osFilterLabel)
    },
    remediation: {
        title: intl.formatMessage(messages.remediationFilterLabel),
        items: REMEDIATION_OPTIONS
    },
    advisory_available: {
        title: intl.formatMessage(messages.advisory),
        items: ADVISORY_AVAILABILITY_FILTER_OPTIONS
    }
});

export const getCveReportFilters = (shouldUseHybridSystemFilter = false) => ({
    rule_presence: {
        title: intl.formatMessage(messages.customReportSecurityRuleCheckbox),
        items: RULE_PRESENCE_OPTIONS.filter(item => item.value !== ONLY_NON_VULNERABLE_SYSTEMS),
        component: CheckboxCustomFilter
    },
    known_exploit: {
        title: intl.formatMessage(messages.knownExploit),
        items: KNOWN_EXPLOIT_FILTER_OPTIONS,
        component: CheckboxCustomFilter
    },
    impact: {
        title: intl.formatMessage(messages.impact),
        items: IMPACT_OPTIONS,
        component: CheckboxCustomFilter
    },
    cvss_filter: {
        title: intl.formatMessage(messages.cvssBaseScore),
        component: CvssCustomFilter
    },
    business_risk_id: {
        title: intl.formatMessage(messages.businessRisk),
        items: BUSINESS_RISK_OPTIONS,
        component: CheckboxCustomFilter
    },
    affecting: {
        title: intl.formatMessage(messages.customReportSystemsExposed),
        items: getAffectingFilterOptions(shouldUseHybridSystemFilter),
        component: CheckboxCustomFilter
    },
    publish_date: {
        title: intl.formatMessage(messages.publishDate),
        items: PUBLIC_DATE_OPTIONS,
        component: SelectCustomFilter
    },
    status_id: {
        title: intl.formatMessage(messages.status),
        items: STATUS_OPTIONS,
        component: CheckboxCustomFilter
    },
    rhel_version: {
        title: intl.formatMessage(messages.osFilterLabelReport),
        component: CheckboxCustomFilter,
        selectProps: { style: { maxHeight: '250px', overflow: 'auto' } },
        allSelectedText: intl.formatMessage(messages.optionsAny)
    },
    advisory_available: {
        title: intl.formatMessage(messages.advisory),
        items: ADVISORY_AVAILABILITY_FILTER_OPTIONS,
        component: CheckboxCustomFilter
    },
    tags: {
        title: 'Tags',
        component: TagFilter,
        hasColumn: false
    }
});

export const SYSTEM_REPORT_FILTERS = {
    excluded: {
        title: intl.formatMessage(messages.filterSystemsWithEnabledAnalysis),
        items: EXCLUDED_FILTER_OPTIONS,
        component: CheckboxCustomFilter
    },
    rhel_version: {
        title: intl.formatMessage(messages.osFilterLabelReport),
        component: CheckboxCustomFilter
    },
    filter: {
        title: intl.formatMessage(messages.searchFilterByName),
        component: CheckboxCustomFilter
    },
    tags: {
        title: 'tags'
    }
};

export const rulesHeader = [
    intl.formatMessage(messages.executiveReportSecurityPanelSeverity),
    intl.formatMessage(messages.executiveReportSecurityNumRules),
    intl.formatMessage(messages.executiveReportSecurityNumAffected)
];

export const CVSSHeader = [
    intl.formatMessage(messages.cvssScoreRange),
    intl.formatMessage(messages.numberOfCves),
    intl.formatMessage(messages.knownExploits)
];

export const recentCvesHeader = [
    intl.formatMessage(messages.timeFrame),
    intl.formatMessage(messages.numberOfCves)
];

export const CVSSMapping = {
    '8to10': '8.0 - 10.0',
    '4to7.9': '4.0 - 7.9',
    '0to3.9': '0.0 - 3.9'
};

export const recentCvesMapping = {
    last7days: intl.formatMessage(messages.lastxdays, { days: 7 }),
    last30days: intl.formatMessage(messages.lastxdays, { days: 30 }),
    last90days: intl.formatMessage(messages.lastxdays, { days: 90 })
};

export const RISK_OF_CHANGE_TOOLTIP = {
    1: intl.formatMessage(messages.riskOfChangeTooltipVeryLow),
    2: intl.formatMessage(messages.riskOfChangeTooltipLow),
    3: intl.formatMessage(messages.riskOfChangeTooltipModerate),
    4: intl.formatMessage(messages.riskOfChangeTooltipHigh)
};

export const RISK_OF_CHANGE_LABEL = {
    1: (
        <Pflabel color="blue">
            {intl.formatMessage(messages.impactListVeryLow)}
        </Pflabel>
    ),
    2: (
        <Pflabel color="gold">
            {intl.formatMessage(messages.impactListLow)}
        </Pflabel>
    ),
    3: (
        <Pflabel color="orange">
            {intl.formatMessage(messages.impactListModerate)}
        </Pflabel>
    ),
    4: (
        <Pflabel color="red">
            {intl.formatMessage(messages.impactListHigh)}
        </Pflabel>
    )
};

export const VULNERABILITIES_HEADER = [
    {
        title: intl.formatMessage(messages.cveId),
        key: 'synopsis',
        transforms: [sortable],
        columnTransforms: [wrappable],
        cellFormatters: [expandable],
        isShownByDefault: true,
        isUnhidable: true
    },
    {
        title: intl.formatMessage(messages.publishDate),
        key: 'public_date',
        transforms: [sortable, wrappable],
        columnTransforms: [classNames('hide-description')],
        isShownByDefault: true
    },
    {
        title: intl.formatMessage(messages.impact),
        key: 'impact',
        transforms: [sortable],
        columnTransforms: [nowrap],
        isShownByDefault: true
    },
    {
        title: intl.formatMessage(messages.cvssBaseScore),
        key: 'cvss_score',
        transforms: [sortable, wrappable],
        isShownByDefault: true
    },
    {
        title: intl.formatMessage(messages.systemsExposed),
        key: 'systems_affected',
        transforms: [sortable, wrappable],
        isShownByDefault: true
    },
    {
        title: intl.formatMessage(messages.businessRisk),
        key: 'business_risk',
        transforms: [sortable, wrappable],
        isShownByDefault: true
    },
    {
        title: intl.formatMessage(messages.status),
        key: 'status',
        transforms: [sortable, wrappable],
        isShownByDefault: true
    },
    {
        title: <span>
            {intl.formatMessage(messages.advisory)}
            <Tooltip content={intl.formatMessage(messages.advisoryColumnTooltip)}>
                <Icon>
                    <OutlinedQuestionCircleIcon
                        className="pf-v5-u-ml-sm"
                        color="var(--pf-v5-global--secondary-color--100)"
                        style={{ verticalAlign: -2 }}
                    />
                </Icon>
            </Tooltip>
        </span>,
        dataLabel: intl.formatMessage(messages.advisory),
        key: 'advisory_available',
        transforms: [sortable, wrappable],
        isShownByDefault: true
    }
];

export const getSystemsExposedHeader = (isWorkspaceEnabled) => [
    {
        key: 'display_name',
        title: intl.formatMessage(messages.systemsColumnHeaderName),
        composed: ['facts.os_release', 'display_name'],
        transforms: [sortable],
        isShownByDefault: true,
        isUnhidable: true,
        renderFunc: (
            _value,
            _id,
            system,
            { mitigation_reason: mitigationReason }) => {
            return (
                <span>
                    <InsightsLink to={`/systems/${system.id}`}>
                        {system.display_name}
                    </InsightsLink>
                    {/* "Affected but not vulnerable" is when mitigation reason is set */}
                    {mitigationReason && <NotVulnerableLabel isCompact />}
                </span>
            );
        }

    },
    {
        key: 'groups',
        title: groupOrWorkspace(isWorkspaceEnabled),
        isShownByDefault: true,
        inventoryGroupsFeatureFlag: true,
        renderFunc: (data, value, { inventory_group: group }) =>
            <span>
                {isEmpty(group) ?
                    <span className="pf-v5-u-disabled-color-200">No {groupOrWorkspace(groupOrWorkspace).toLowerCase()}</span>
                    : group[0].name} {/* currently, one group at maximum is supported */}
            </span>
    },
    {
        key: 'tags',
        title: intl.formatMessage(messages.systemsColumnHeaderTags),
        props: { isStatic: true },
        isShownByDefault: true
    },
    {
        key: 'os',
        sortKey: 'os',
        dataLabel: intl.formatMessage(messages.systemsColumnHeaderOS),
        title: (
            <Tooltip content={intl.formatMessage(messages.systemsColumnHeaderOSFull)}>
                <span>
                    {intl.formatMessage(messages.systemsColumnHeaderOS)}
                </span>
            </Tooltip>
        ),
        cellTransforms: [nowrap],
        isShownByDefault: true
    },
    {
        key: 'advisories_list',
        sortKey: 'advisories_list',
        title: intl.formatMessage(messages.advisory),
        renderFunc: (
            value,
            _id,
            { advisories_list: advisoriesList, remediation, immutable }
        ) =>  (
            <AdvisoryColumn
                advisoriesList={advisoriesList}
                linkToCustomerPortal={remediation === MANUAL_REMEDIATION || immutable}
            />
        ),
        isShownByDefault: true
    },
    {
        key: 'status',
        sortKey: 'status',
        title: intl.formatMessage(messages.status),
        renderFunc: (
            value,
            _id,
            { cve_status_id: cveStatusId, status_id: systemStatusId }
        ) => <StatusColumn cveStatusId={cveStatusId} systemStatusId={systemStatusId} />,
        isShownByDefault: true
    },
    {
        key: 'updated',
        title: intl.formatMessage(messages.systemsColumnHeaderUpdated),
        transforms: [nowrap],
        cellTransforms: [nowrap],
        isShownByDefault: true
    },
    {
        key: 'remediation',
        sortKey: 'remediation',
        title: (
            <span>
                {intl.formatMessage(messages.systemsExposedColumnRemediation)}
                <Tooltip content="Red Hat usually provides Playbooks for CVEs with Security rules,
                    regardless of an undetermined Advisory, due to the severity of Security rules.">
                    <Icon>
                        <OutlinedQuestionCircleIcon
                            className="pf-v5-u-ml-sm"
                            color="var(--pf-v5-global--secondary-color--100)"
                            style={{ verticalAlign: -2 }}
                        />
                    </Icon>
                </Tooltip>
            </span>
        ),
        dataLabel: 'Remediation',
        cellTransforms: [nowrap],
        columnTransforms: [fitContent],
        transforms: [sortable],
        renderFunc: (
            value,
            _id,
            { remediation: fixable }
        ) => <RemediationColumn fixable={fixable} />,
        props: {
            isStatic: true
        },
        isShownByDefault: true
    }
];

//TODO: remove feature flag and convert back to static array of objects
export const getSystemsHeader = (isWorkspaceEnabled) => [
    {
        key: 'display_name',
        title: intl.formatMessage(messages.systemsColumnHeaderName),
        composed: ['facts.os_release', 'display_name'],
        cellTransforms: [nowrap],
        renderFunc: (item, _id, system, { opt_out: optOut }) => <SystemNameColumn item={item} system={system} optOut={optOut} />,
        props: {
            width: 40
        },
        isShownByDefault: true,
        isUnhidable: true
    },
    {
        key: 'groups',
        title: groupOrWorkspace(isWorkspaceEnabled),
        inventoryGroupsFeatureFlag: true,
        isShownByDefault: true,
        renderFunc: (data, value, { inventory_group: group }) =>
            <span>
                {isEmpty(group) ?
                    <span className="pf-v5-u-disabled-color-200">No {groupOrWorkspace(isWorkspaceEnabled).toLowerCase()}</span>
                    : group[0].name} {/* currently, one group at maximum is supported */}
            </span>
    },
    {
        key: 'tags',
        title: intl.formatMessage(messages.systemsColumnHeaderTags),
        props: { isStatic: true },
        isShownByDefault: true
    },
    {
        key: 'os',
        sortKey: 'os',
        dataLabel: intl.formatMessage(messages.systemsColumnHeaderOS),
        title: (
            <Tooltip content={intl.formatMessage(messages.systemsColumnHeaderOSFull)}>
                <span>
                    {intl.formatMessage(messages.systemsColumnHeaderOS)}
                </span>
            </Tooltip>
        ),
        cellTransforms: [nowrap],
        isShownByDefault: true
    },
    {
        key: 'cve_count',
        sortKey: 'cve_count',
        title: intl.formatMessage(messages.systemsColumnHeaderCveCount),
        renderFunc: value => (value !== null ? String(value) : intl.formatMessage(messages.systemsTableDisabled)),
        isShownByDefault: true
    },
    {
        key: 'updated',
        title: intl.formatMessage(messages.systemsColumnHeaderUpdated),
        transforms: [nowrap],
        cellTransforms: [nowrap],
        props: {
            width: 20
        },
        isShownByDefault: true
    }
];

export const SYSTEM_DETAILS_HEADER = [
    {
        title: intl.formatMessage(messages.cveId),
        key: 'synopsis',
        transforms: [sortable],
        columnTransforms: [wrappable],
        cellFormatters: [expandable],
        isShownByDefault: true,
        isUnhidable: true
    },
    {
        title: intl.formatMessage(messages.publishDate),
        key: 'public_date',
        transforms: [sortable, wrappable],
        isShownByDefault: true
    },
    {
        title: intl.formatMessage(messages.impact),
        key: 'impact',
        transforms: [sortable, wrappable],
        columnTransforms: [nowrap],
        isShownByDefault: true
    },
    {
        title: intl.formatMessage(messages.cvssBaseScore),
        key: 'cvss_score',
        transforms: [sortable, wrappable],
        isShownByDefault: true
    },
    {
        title: intl.formatMessage(messages.advisory),
        key: 'advisories_list',
        transforms: [sortable],
        isShownByDefault: true
    },
    {
        title: intl.formatMessage(messages.businessRisk),
        key: 'business_risk',
        transforms: [sortable, wrappable],
        isShownByDefault: true
    },
    {
        title: intl.formatMessage(messages.status),
        key: 'status',
        transforms: [sortable, wrappable],
        isShownByDefault: true
    },
    {
        title: (
            <span>
                {intl.formatMessage(messages.systemsExposedColumnRemediation)}
                <Tooltip content="Red Hat usually provides Playbooks for CVEs with Security rules,
                    regardless of an undetermined Advisory, due to the severity of Security rules.">
                    <Icon>
                        <OutlinedQuestionCircleIcon
                            className="pf-v5-u-ml-sm"
                            color="var(--pf-v5-global--secondary-color--100)"
                            style={{ verticalAlign: -2 }}
                        />
                    </Icon>
                </Tooltip>
            </span>
        ),
        dataLabel: 'Remediation',
        key: 'remediation',
        transforms: [sortable],
        columnTransforms: [fitContent],
        isShownByDefault: true
    }
];

export const CVES_FILTER_PARAMS = [
    'cvss_from',
    'cvss_to',
    'publish_date',
    'filter',
    'impact',
    'business_risk_id',
    'status_id',
    'rule_presence',
    'affecting',
    'show_advisories',
    'advisory',
    'known_exploit',
    'advisory_available'
];

export const CVES_ALLOWED_PARAMS = [
    ...CVES_FILTER_PARAMS,
    'limit',
    'offset',
    'page',
    'page_size',
    'sort',
    'tags',
    'sap_sids',
    'sap_system',
    'remediation',
    'ansible',
    'mssql',
    'appName'
];

export const SYSTEMS_EXPOSED_ALLOWED_PARAMS = [
    'filter',
    'page',
    'page_size',
    'status_id',
    'sort',
    'tags',
    'uuid',
    'rule_key',
    'rule_presence',
    'rule',
    'tags',
    'sap_sids',
    'sap_system',
    'show_advisories',
    'advisory',
    'rhel_version',
    'advisory_available',
    'remediation',
    'ansible',
    'mssql',
    'host_type',
    'ignore_default_params'
];

export const SYSTEMS_ALLOWED_PARAMS = [
    'filter',
    'page',
    'page_size',
    'opt_out',
    'sort',
    'tags',
    'sap_sids',
    'sap_system',
    'excluded',
    'rhel_version',
    'ansible',
    'mssql'
];

export const SYSTEMS_FILTER_PARAMS = [
    'excluded',
    'filter',
    'rhel_version'
];

export const CVE_DETAILS_FILTER_PARAMS = [
    'filter',
    'rule',
    'status_id',
    'advisory_available',
    'advisory',
    'rhel_version',
    'remediation'
];

export const SYSTEM_DETAILS_FILTER_PARAMS = [
    'filter',
    'rule',
    'known_exploit',
    'impact',
    'cvss_from',
    'cvss_to',
    'business_risk_id',
    'publish_date',
    'status_id',
    'advisory_available',
    'advisory',
    'remediation'
];

export const SYSTEMS_DEFAULT_FILTERS = {
    excluded: 'false'
};

export const TRUNCATE_TEXT_THRESHOLD = 230;

export const CUSTOM_REPORT_DEFAULT_SORT = '-cvss_score';

export const PDF_REPORT_USER_NOTE_MAX_LENGTH = 1000;

export const PDF_REPORT_PER_PAGE = {
    firstPageWithNote: 5,
    firstPageWithoutNote: 10,
    otherPages: 18,
    labelsHeightMultiplier: 2.0,
    systemsReportRestPages: 24,
    systemsReportFirstPage: 22
};

export const EXEC_RULES_SEVERITY_MAP = {
    1: impactList.Low.title,
    2: impactList.Moderate.title,
    3: impactList.Important.title,
    4: impactList.Critical.title
};

export const PERMISSIONS = {
    accessApplication: 'vulnerability:*:*',
    advancedReporting: 'vulnerability:advanced_report:read',
    setCveStatusAndBusinessRisk: 'vulnerability:cve.business_risk_and_status:write',
    basicReporting: 'vulnerability:report_and_export:read',
    setPairStatus: 'vulnerability:system.cve.status:write',
    readExcluded: 'vulnerability:system.opt_out:read',
    setExcludedIncluded: 'vulnerability:system.opt_out:write',
    readVulnerabilityResults: 'vulnerability:vulnerability_results:read',
    toggleCvesWithoutErrata: 'vulnerability:toggle_cves_without_errata:write',
    readHosts: 'inventory:hosts:read'
};