-
-
Admin Settings
-
+
+
+
+
+ {{ loadError }}
-
-
-
-
-
-
-
+
+
+
+
+
All Objects
+
{{ formatCount(totalObjects) }}
-
+
+
+
{{ summary.label }}
+
{{ formatCount(summary.count) }}
+
+
+
+
+
+
+
Objects by Domain
+ {{ selectedPathLabel }}
+
+
+
+
+
+
+
+
+
+
Relationships by Type
+ {{ selectedRelationshipPathLabel }}
+
+
+
+
+
+
+
+
+
+
+
+
+
Timeline Analytics
+
+
+
+
+
+
+
Object Growth Over Time
+
+
+
+
+
+
{{ formatCount(objectGrowthTotal) }}
+
+
+
+
+
+
+
+
+
+
+
+
+
+ No domain-scoped ATT&CK objects were found.
+
+
+
+ No relationships were found.
+
+
+
+ No dated objects found.
+
diff --git a/src/app/views/dashboard-page/dashboard-page.component.scss b/src/app/views/dashboard-page/dashboard-page.component.scss
index 37788dde9..cffc68beb 100644
--- a/src/app/views/dashboard-page/dashboard-page.component.scss
+++ b/src/app/views/dashboard-page/dashboard-page.component.scss
@@ -1,23 +1,639 @@
-@use '../../../style/globals';
+@use 'sass:color';
@use '../../../style/colors';
.dashboard-page {
- .display-icon .mat-icon {
- font-size: 48px;
- width: 48px;
- height: 48px;
+ width: min(1180px, 100%);
+ max-width: calc(100vw - 32px);
+
+ .dashboard-header,
+ .dashboard-actions,
+ .sunburst-card-heading,
+ .timeline-card-heading,
+ .timeline-legend,
+ .domain-filter,
+ .drilldown-label {
+ display: flex;
+ align-items: center;
+ }
+
+ .dashboard-header {
+ justify-content: space-between;
+ gap: 20px;
+ margin-bottom: 18px;
+
+ h1 {
+ margin: 0;
+ font-size: 28px;
+ line-height: 34px;
+ text-align: left;
+ }
+ }
+
+ .dashboard-actions {
+ flex-wrap: wrap;
+ justify-content: flex-end;
+ gap: 8px 16px;
+ }
+
+ .summary-grid {
+ display: grid;
+ grid-template-columns: repeat(auto-fit, minmax(160px, 1fr));
+ gap: 12px;
+ margin-bottom: 16px;
+ }
+
+ .summary-card {
+ min-width: 0;
+ border-top: 4px solid var(--summary-color, #{colors.color(info)});
+ border-radius: 4px;
+ padding: 14px 16px 12px;
+
+ &.total {
+ border-top-color: colors.color(primary);
+ }
+
+ &.object-type {
+ border-top-color: var(--summary-color, #{colors.color(info)});
+ }
+ }
+
+ .summary-label,
+ .sunburst-card-heading span,
+ .breadcrumb-list button,
+ .breadcrumb-separator,
+ .chart-empty {
+ font-size: 13px;
+ line-height: 18px;
}
- button {
- width: 225px;
- height: fit-content !important;
- margin: 10px;
+
+ .summary-label {
+ font-weight: 700;
+ }
+
+ .summary-value {
+ margin-top: 8px;
+ font-size: 30px;
+ font-weight: 800;
+ line-height: 34px;
+ }
+
+ .sunburst-grid {
+ display: grid;
+ grid-template-columns: repeat(2, minmax(0, 1fr));
+ gap: 16px;
+ align-items: start;
+ }
+
+ .sunburst-card {
+ min-width: 0;
+ border: 1px solid;
+ border-radius: 4px;
+ padding: 16px;
+ }
+
+ .sunburst-card-heading {
+ justify-content: space-between;
+ align-items: flex-start;
+ gap: 12px;
+ margin-bottom: 12px;
h2 {
- white-space: normal;
+ margin: 0;
+ font-size: 20px;
+ line-height: 26px;
+ text-align: left;
+ }
+
+ span {
+ min-width: 0;
+ overflow-wrap: anywhere;
+ text-align: right;
+ }
+ }
+
+ .sunburst-card-body {
+ display: grid;
+ gap: 12px;
+ align-items: start;
+ }
+
+ .sunburst-card,
+ .summary-card,
+ .empty-state,
+ .dashboard-error {
+ border: 1px solid;
+ }
+
+ .sunburst-panel {
+ display: flex;
+ justify-content: center;
+ min-width: 0;
+ }
+
+ .sunburst {
+ width: min(100%, 420px);
+ height: auto;
+ aspect-ratio: 1;
+ }
+
+ .sunburst-segment {
+ stroke: #ffffff;
+ stroke-width: 1;
+ cursor: pointer;
+ transition:
+ opacity 120ms ease,
+ filter 120ms ease,
+ stroke-width 120ms ease;
+
+ &:hover,
+ &:focus-visible,
+ &.selected {
+ filter: brightness(1.08);
+ stroke-width: 2.5;
+ outline: none;
+ }
+ }
+
+ .sunburst-center {
+ cursor: pointer;
+
+ circle {
+ stroke-width: 1;
+ }
+
+ text {
+ font-size: 11px;
+ font-weight: 700;
+ text-anchor: middle;
+ pointer-events: none;
+ }
+
+ .sunburst-center-count {
+ font-size: 15px;
+ font-weight: 800;
+ }
+ }
+
+ .drilldown-panel {
+ min-width: 0;
+ }
+
+ .drilldown-summary {
+ display: flex;
+ align-items: center;
+ justify-content: space-between;
+ gap: 12px;
+ min-width: 0;
+ }
+
+ .breadcrumb-list {
+ display: flex;
+ flex: 1 1 auto;
+ flex-wrap: wrap;
+ align-items: center;
+ gap: 2px 6px;
+ min-width: 0;
+
+ button {
+ min-width: 0;
+ height: 30px;
+ padding: 0;
+ font-weight: 700;
+ }
+ }
+
+ .breadcrumb-separator {
+ font-weight: 800;
+ }
+
+ .selected-total {
+ flex: 0 0 auto;
+ font-size: 28px;
+ font-weight: 800;
+ line-height: 34px;
+ text-align: right;
+ }
+
+ .drilldown-list {
+ display: grid;
+ gap: 8px;
+ margin-top: 12px;
+ }
+
+ .drilldown-item {
+ display: flex;
+ justify-content: space-between;
+ align-items: center;
+ gap: 12px;
+ width: 100%;
+ border: 1px solid;
+ border-radius: 4px;
+ padding: 9px 10px;
+ font: inherit;
+ text-align: left;
+ cursor: pointer;
+ }
+
+ .drilldown-label {
+ min-width: 0;
+ gap: 8px;
+ }
+
+ .drilldown-swatch {
+ flex: 0 0 auto;
+ width: 10px;
+ height: 10px;
+ border-radius: 50%;
+ }
+
+ .timeline-section {
+ margin-top: 16px;
+ }
+
+ .timeline-heading {
+ margin-bottom: 12px;
+
+ h2 {
+ margin: 0;
+ font-size: 22px;
+ line-height: 28px;
+ text-align: left;
+ }
+ }
+
+ .timeline-grid {
+ display: grid;
+ grid-template-columns: 1fr;
+ gap: 16px;
+ }
+
+ .timeline-card {
+ min-width: 0;
+ border: 1px solid;
+ border-radius: 4px;
+ padding: 16px;
+ }
+
+ .timeline-card-heading {
+ justify-content: space-between;
+ align-items: flex-start;
+ gap: 12px;
+ margin-bottom: 14px;
+
+ h3 {
+ margin: 0;
+ font-size: 18px;
+ line-height: 24px;
+ text-align: left;
+ }
+
+ strong {
+ flex: 0 0 auto;
+ font-size: 18px;
+ line-height: 24px;
+ text-align: right;
+ }
+ }
+
+ .growth-heading {
+ margin-bottom: 10px;
+ }
+
+ .timeline-chart-layout {
+ display: grid;
+ grid-template-columns: minmax(0, 1fr) minmax(180px, 240px);
+ gap: 16px;
+ align-items: start;
+ }
+
+ .domain-filter {
+ flex-wrap: wrap;
+ gap: 6px;
+ margin-top: 8px;
+
+ button {
+ border: 1px solid;
+ border-radius: 4px;
+ padding: 4px 8px;
+ font: inherit;
+ font-size: 11px;
+ line-height: 15px;
+ cursor: pointer;
+ }
+ }
+
+ .timeline-chart {
+ display: block;
+ width: 100%;
+ height: auto;
+ margin-top: 4px;
+ }
+
+ .chart-grid-line {
+ stroke-width: 0.45;
+ }
+
+ .chart-axis {
+ stroke-width: 0.6;
+ }
+
+ .chart-axis-tick {
+ stroke-width: 0.55;
+ }
+
+ .chart-axis-label {
+ font-size: 7.25px;
+ font-weight: 700;
+ }
+
+ .chart-year-line {
+ stroke-width: 0.5;
+ stroke-dasharray: 3 4;
+ }
+
+ .chart-year-label {
+ text-anchor: middle;
+ }
+
+ .timeline-line {
+ cursor: pointer;
+ opacity: 1;
+ pointer-events: stroke;
+ stroke-linecap: round;
+ stroke-linejoin: round;
+ stroke-width: 1.6;
+ transition:
+ filter 120ms ease,
+ opacity 120ms ease,
+ stroke-width 120ms ease;
+
+ &.dimmed {
+ opacity: 0.18;
+ }
+
+ &.selected,
+ &:focus-visible {
+ filter: brightness(1.08);
+ outline: none;
+ stroke-width: 2.1;
+ }
+ }
+
+ .timeline-legend {
+ display: grid;
+ gap: 8px;
+ margin-top: 4px;
+ font-size: 11px;
+ line-height: 15px;
+ }
+
+ .timeline-legend-item {
+ width: 100%;
+ border: 1px solid transparent;
+ border-radius: 4px;
+ background: transparent;
+ display: grid;
+ grid-template-columns: auto minmax(0, 1fr) auto;
+ align-items: center;
+ gap: 6px;
+ padding: 4px 5px;
+ color: inherit;
+ font: inherit;
+ text-align: left;
+ cursor: pointer;
+ transition:
+ background 120ms ease,
+ border-color 120ms ease,
+ opacity 120ms ease;
+
+ &.dimmed {
+ opacity: 0.48;
+ }
+
+ &.selected {
+ font-weight: 700;
+ opacity: 1;
}
+
+ &:focus-visible {
+ outline: 2px solid currentColor;
+ outline-offset: 2px;
+ }
+
+ strong {
+ font-weight: 800;
+ text-align: right;
+ }
+ }
+
+ .timeline-swatch {
+ flex: 0 0 auto;
+ width: 9px;
+ height: 9px;
+ border-radius: 50%;
}
- .mat-badge-content.mat-badge-active {
- color: colors.on-color(pending);
- background-color: colors.color(pending);
+
+ .chart-empty {
+ padding: 12px;
+ text-align: center;
+ }
+
+ .empty-state,
+ .dashboard-error {
+ border-radius: 4px;
+ padding: 18px 12px;
+ text-align: center;
+ }
+
+ .dashboard-error {
+ color: colors.color(error);
+ }
+
+ .light & {
+ .sunburst-card-heading span,
+ .breadcrumb-separator,
+ .chart-axis-label,
+ .chart-empty {
+ color: colors.on-color-deemphasis(light);
+ }
+
+ .sunburst-card,
+ .timeline-card,
+ .summary-card,
+ .empty-state,
+ .dashboard-error {
+ border-color: colors.border-color(light);
+ background: #ffffff;
+ }
+
+ .summary-card,
+ .drilldown-item,
+ .chart-empty {
+ background: rgba(colors.color(mitre-black), 0.025);
+ }
+
+ .chart-grid-line {
+ stroke: rgba(colors.color(mitre-black), 0.12);
+ }
+
+ .chart-year-line {
+ stroke: rgba(colors.color(mitre-black), 0.14);
+ }
+
+ .chart-axis,
+ .chart-axis-tick {
+ stroke: colors.border-color(light);
+ }
+
+ .timeline-legend-item {
+ &:hover,
+ &.selected {
+ border-color: rgba(colors.color(primary), 0.18);
+ background: color.mix(colors.color(mitre-light-blue), #ffffff, 24%);
+ }
+ }
+
+ .domain-filter button {
+ border-color: colors.border-color(light);
+ background: #ffffff;
+ color: colors.color(dark);
+
+ &.selected,
+ &:hover {
+ background: color.mix(colors.color(mitre-light-blue), #ffffff, 28%);
+ }
+ }
+
+ .sunburst-center circle {
+ fill: #ffffff;
+ stroke: colors.border-color(light);
+ }
+
+ .sunburst-center text {
+ fill: colors.color(dark);
+ }
+
+ .drilldown-item {
+ border-color: colors.border-color(light);
+ color: colors.color(dark);
+ }
+ }
+
+ .dark & {
+ .sunburst-card-heading span,
+ .breadcrumb-separator,
+ .chart-axis-label,
+ .chart-empty {
+ color: colors.on-color-deemphasis(dark);
+ }
+
+ .sunburst-card,
+ .timeline-card,
+ .summary-card,
+ .empty-state,
+ .dashboard-error {
+ border-color: colors.border-color(dark);
+ background: color.mix(colors.color(dark), #ffffff, 94%);
+ }
+
+ .summary-card,
+ .drilldown-item,
+ .chart-empty {
+ background: rgba(colors.color(mitre-silver), 0.06);
+ }
+
+ .chart-grid-line {
+ stroke: rgba(colors.color(mitre-silver), 0.12);
+ }
+
+ .chart-year-line {
+ stroke: rgba(colors.color(mitre-silver), 0.16);
+ }
+
+ .chart-axis,
+ .chart-axis-tick {
+ stroke: colors.border-color(dark);
+ }
+
+ .timeline-legend-item {
+ &:hover,
+ &.selected {
+ border-color: rgba(colors.color(mitre-light-blue), 0.28);
+ background: rgba(colors.color(mitre-light-blue), 0.14);
+ }
+ }
+
+ .domain-filter button {
+ border-color: colors.border-color(dark);
+ background: color.mix(colors.color(dark), #ffffff, 94%);
+ color: colors.color(light);
+
+ &.selected,
+ &:hover {
+ background: rgba(colors.color(mitre-light-blue), 0.16);
+ }
+ }
+
+ .sunburst-segment {
+ stroke: colors.color(dark);
+ }
+
+ .sunburst-center circle {
+ fill: colors.color(dark);
+ stroke: colors.border-color(dark);
+ }
+
+ .sunburst-center text {
+ fill: colors.color(light);
+ }
+
+ .drilldown-item {
+ border-color: colors.border-color(dark);
+ color: colors.color(light);
+ }
+ }
+
+ @media (max-width: 1080px) {
+ .sunburst-grid {
+ grid-template-columns: 1fr;
+ }
+ }
+
+ @media (max-width: 720px) {
+ max-width: calc(100vw - 20px);
+
+ .dashboard-header {
+ align-items: stretch;
+ flex-direction: column;
+ }
+
+ .dashboard-actions {
+ justify-content: flex-start;
+ }
+
+ .sunburst-card {
+ padding: 12px;
+ }
+
+ .timeline-card {
+ padding: 12px;
+ }
+
+ .timeline-chart-layout {
+ grid-template-columns: 1fr;
+ }
+
+ .sunburst-card-heading {
+ flex-direction: column;
+ align-items: flex-start;
+
+ span {
+ text-align: left;
+ }
+ }
+
+ .drilldown-summary {
+ align-items: flex-start;
+ }
}
}
diff --git a/src/app/views/dashboard-page/dashboard-page.component.spec.ts b/src/app/views/dashboard-page/dashboard-page.component.spec.ts
index c65f0995f..ac142d536 100644
--- a/src/app/views/dashboard-page/dashboard-page.component.spec.ts
+++ b/src/app/views/dashboard-page/dashboard-page.component.spec.ts
@@ -1,36 +1,94 @@
import { NO_ERRORS_SCHEMA } from '@angular/core';
import { ComponentFixture, TestBed } from '@angular/core/testing';
-import { provideHttpClient } from '@angular/common/http';
+import { of } from 'rxjs';
import { DashboardPageComponent } from './dashboard-page.component';
import { RestApiConnectorService } from 'src/app/services/connectors/rest-api/rest-api-connector.service';
-import {
- createAsyncObservable,
- createMockRestApiConnector,
- createPaginatedResponse,
-} from 'src/app/testing/mocks/rest-api-connector.mock';
describe('DashboardPageComponent', () => {
let component: DashboardPageComponent;
let fixture: ComponentFixture
;
+ let mockRestApiConnector: any;
+
+ const attackObjects = [
+ {
+ stix: {
+ created: '2024-01-10T00:00:00.000Z',
+ id: 'attack-pattern--001',
+ modified: '2024-03-15T00:00:00.000Z',
+ type: 'attack-pattern',
+ x_mitre_domains: ['enterprise-attack'],
+ },
+ },
+ {
+ stix: {
+ created: '2024-01-10T00:00:00.000Z',
+ id: 'attack-pattern--001',
+ modified: '2025-01-15T00:00:00.000Z',
+ type: 'attack-pattern',
+ x_mitre_domains: ['enterprise-attack'],
+ },
+ },
+ {
+ stix: {
+ created: '2024-02-10T00:00:00.000Z',
+ id: 'attack-pattern--002',
+ modified: '2024-04-15T00:00:00.000Z',
+ type: 'attack-pattern',
+ x_mitre_domains: ['enterprise-attack', 'mobile-attack'],
+ },
+ },
+ {
+ stix: {
+ created: '2024-03-10T00:00:00.000Z',
+ id: 'intrusion-set--001',
+ modified: '2024-05-15T00:00:00.000Z',
+ type: 'intrusion-set',
+ x_mitre_domains: ['enterprise-attack'],
+ },
+ },
+ {
+ stix: {
+ created: '2024-02-01T00:00:00.000Z',
+ id: 'relationship--001',
+ modified: '2024-04-20T00:00:00.000Z',
+ type: 'relationship',
+ relationship_type: 'uses',
+ },
+ },
+ {
+ stix: {
+ created: '2024-02-01T00:00:00.000Z',
+ id: 'relationship--001',
+ modified: '2025-01-20T00:00:00.000Z',
+ type: 'relationship',
+ relationship_type: 'uses',
+ },
+ },
+ {
+ stix: {
+ created: '2024-04-01T00:00:00.000Z',
+ id: 'relationship--002',
+ modified: '2024-05-20T00:00:00.000Z',
+ type: 'relationship',
+ relationship_type: 'mitigates',
+ },
+ },
+ ];
beforeEach(async () => {
- const mockRestApiConnector = createMockRestApiConnector({
- getAllUserAccounts: () =>
- createAsyncObservable(createPaginatedResponse([])),
- });
+ mockRestApiConnector = {
+ getAllObjects: vi.fn(() => of(attackObjects)),
+ };
await TestBed.configureTestingModule({
declarations: [DashboardPageComponent],
providers: [
{ provide: RestApiConnectorService, useValue: mockRestApiConnector },
- provideHttpClient(),
],
schemas: [NO_ERRORS_SCHEMA],
}).compileComponents();
- });
- beforeEach(() => {
fixture = TestBed.createComponent(DashboardPageComponent);
component = fixture.componentInstance;
fixture.detectChanges();
@@ -39,4 +97,343 @@ describe('DashboardPageComponent', () => {
it('should create', () => {
expect(component).toBeTruthy();
});
+
+ it('should aggregate objects by object type', () => {
+ const techniques = component.objectTypeSummary.find(
+ summary => summary.typeKey === 'technique'
+ );
+ const enterprise = component.sunburstSegments.find(
+ node => node.id === 'domain:enterprise-attack'
+ );
+ const mobile = component.sunburstSegments.find(
+ node => node.id === 'domain:mobile-attack'
+ );
+
+ expect(component.totalObjects).toBe(3);
+ expect(component.totalAssignments).toBe(4);
+ expect(component.totalRelationships).toBe(2);
+ expect(techniques?.count).toBe(2);
+ expect(enterprise?.value).toBe(3);
+ expect(mobile?.value).toBe(1);
+ expect(
+ component.objectTypeSummary.some(
+ summary => summary.typeKey === 'relationship'
+ )
+ ).toBe(false);
+ });
+
+ it('should use x_mitre_domains for matrix domains', () => {
+ component.buildDashboard([
+ {
+ stix: {
+ created: '2024-01-10T00:00:00.000Z',
+ id: 'x-mitre-matrix--enterprise',
+ type: 'x-mitre-matrix',
+ x_mitre_domains: ['enterprise-attack'],
+ },
+ },
+ {
+ stix: {
+ created: '2024-01-10T00:00:00.000Z',
+ id: 'mobile-attack',
+ type: 'x-mitre-matrix',
+ x_mitre_domains: ['mobile-attack'],
+ },
+ },
+ {
+ stix: {
+ created: '2024-01-10T00:00:00.000Z',
+ id: 'x-mitre-matrix--ics',
+ type: 'x-mitre-matrix',
+ x_mitre_domains: ['ics-attack'],
+ },
+ },
+ ]);
+
+ const enterprise = component.sunburstSegments.find(
+ node => node.id === 'domain:enterprise-attack'
+ );
+ const mobile = component.sunburstSegments.find(
+ node => node.id === 'domain:mobile-attack'
+ );
+ const ics = component.sunburstSegments.find(
+ node => node.id === 'domain:ics-attack'
+ );
+ const matrixSummary = component.objectTypeSummary.find(
+ summary => summary.typeKey === 'matrix'
+ );
+
+ expect(component.totalObjects).toBe(3);
+ expect(component.totalAssignments).toBe(3);
+ expect(matrixSummary?.count).toBe(3);
+ expect(enterprise?.value).toBe(1);
+ expect(mobile?.value).toBe(1);
+ expect(ics?.value).toBe(1);
+ expect(
+ component.sunburstSegments.some(node => node.id === 'domain:no-domain')
+ ).toBe(false);
+ });
+
+ it('should summarize totals by object type across all domains', () => {
+ expect(component.objectTypeSummary.map(summary => summary.typeKey)).toEqual(
+ [
+ 'matrix',
+ 'tactic',
+ 'technique',
+ 'group',
+ 'software',
+ 'campaign',
+ 'mitigation',
+ 'asset',
+ 'detection-strategy',
+ 'analytic',
+ 'data-component',
+ ]
+ );
+ expect(
+ component.objectTypeSummary.find(
+ summary => summary.typeKey === 'technique'
+ )
+ ).toEqual(expect.objectContaining({ label: 'Techniques', count: 2 }));
+ expect(
+ component.objectTypeSummary.find(summary => summary.typeKey === 'group')
+ ).toEqual(expect.objectContaining({ label: 'Groups', count: 1 }));
+ expect(
+ component.objectTypeSummary.find(summary => summary.typeKey === 'matrix')
+ ).toEqual(expect.objectContaining({ label: 'Matrices', count: 0 }));
+ });
+
+ it('should aggregate relationships by relationship type', () => {
+ const usesRelationships = component.relationshipSunburstSegments.find(
+ node => node.id === 'relationship-type:uses'
+ );
+ const mitigatesRelationships = component.relationshipSunburstSegments.find(
+ node => node.id === 'relationship-type:mitigates'
+ );
+
+ expect(usesRelationships?.value).toBe(1);
+ expect(mitigatesRelationships?.value).toBe(1);
+ });
+
+ it('should deduplicate object and relationship versions by stix id', () => {
+ const techniques = component.objectTypeSummary.find(
+ summary => summary.typeKey === 'technique'
+ );
+ const enterprise = component.sunburstSegments.find(
+ node => node.id === 'domain:enterprise-attack'
+ );
+ const enterpriseTechniques = component.sunburstSegments.find(
+ node => node.id === 'domain:enterprise-attack/type:technique'
+ );
+ const usesRelationships = component.relationshipSunburstSegments.find(
+ node => node.id === 'relationship-type:uses'
+ );
+ const timelineTechniques = component.objectGrowthLineSeries.find(
+ series => series.key === 'technique'
+ );
+
+ expect(component.totalObjects).toBe(3);
+ expect(component.totalRelationships).toBe(2);
+ expect(techniques?.count).toBe(2);
+ expect(enterprise?.value).toBe(3);
+ expect(enterpriseTechniques?.value).toBe(2);
+ expect(timelineTechniques?.total).toBe(2);
+ expect(usesRelationships?.value).toBe(1);
+ });
+
+ it('should build timeline chart data from dated objects', () => {
+ const techniques = component.objectGrowthLineSeries.find(
+ series => series.key === 'technique'
+ );
+ const groups = component.objectGrowthLineSeries.find(
+ series => series.key === 'group'
+ );
+
+ expect(component.objectGrowthYearTicks).toEqual([
+ expect.objectContaining({ label: '2024', x: '30.00' }),
+ ]);
+ expect(component.objectGrowthYAxisLabels).toEqual(['2', '1', '0']);
+ expect(techniques).toEqual(
+ expect.objectContaining({ label: 'Techniques', total: 2 })
+ );
+ expect(techniques?.markers).toHaveLength(3);
+ expect(groups).toEqual(
+ expect.objectContaining({ label: 'Groups', total: 1 })
+ );
+ expect(component.objectGrowthTotal).toBe(3);
+ expect(
+ component.objectGrowthLineSeries.some(
+ series => series.key === 'relationship'
+ )
+ ).toBe(false);
+
+ component.selectObjectGrowthDomain('mobile-attack');
+ expect(
+ component.objectGrowthLineSeries.map(series => [series.key, series.total])
+ ).toEqual([['technique', 1]]);
+ });
+
+ it('should render a selected timeline series above other object types', () => {
+ const techniques = component.objectGrowthLineSeries.find(
+ series => series.key === 'technique'
+ );
+ const groups = component.objectGrowthLineSeries.find(
+ series => series.key === 'group'
+ );
+
+ component.selectObjectGrowthType('technique');
+
+ const displaySeries = component.objectGrowthLineSeriesForDisplay;
+
+ expect(component.selectedObjectGrowthType).toBe('technique');
+ expect(displaySeries[displaySeries.length - 1]?.key).toBe('technique');
+ expect(component.isObjectGrowthSeriesSelected(techniques!)).toBe(true);
+ expect(component.isObjectGrowthSeriesDimmed(groups!)).toBe(true);
+
+ component.selectObjectGrowthType('technique');
+
+ expect(component.selectedObjectGrowthType).toBeUndefined();
+ expect(component.isObjectGrowthSeriesDimmed(groups!)).toBe(false);
+ });
+
+ it('should assign unique timeline colors for known object types', () => {
+ const objectTypes = [
+ ['x-mitre-matrix', 'matrix'],
+ ['x-mitre-tactic', 'tactic'],
+ ['attack-pattern', 'technique'],
+ ['intrusion-set', 'group'],
+ ['malware', 'software'],
+ ['campaign', 'campaign'],
+ ['course-of-action', 'mitigation'],
+ ['x-mitre-asset', 'asset'],
+ ['x-mitre-detection-strategy', 'detection-strategy'],
+ ['x-mitre-analytic', 'analytic'],
+ ['x-mitre-data-component', 'data-component'],
+ ['marking-definition', 'marking-definition'],
+ ];
+ component.buildDashboard(
+ objectTypes.map(([stixType], index) => ({
+ stix: {
+ created: '2024-01-10T00:00:00.000Z',
+ id: `${stixType}--${index}`,
+ type: stixType,
+ x_mitre_domains: ['enterprise-attack'],
+ },
+ }))
+ );
+
+ const colors = component.objectGrowthLineSeries.map(series => series.color);
+
+ expect(
+ component.objectGrowthLineSeries.map(series => series.key).sort()
+ ).toEqual(objectTypes.map(([, typeKey]) => typeKey).sort());
+ expect(new Set(colors).size).toBe(colors.length);
+ });
+
+ it('should exclude notes, collections, data sources, and identities from dashboard object charts', () => {
+ component.buildDashboard([
+ {
+ stix: {
+ created: '2024-01-10T00:00:00.000Z',
+ id: 'attack-pattern--tracked',
+ type: 'attack-pattern',
+ x_mitre_domains: ['enterprise-attack'],
+ },
+ },
+ {
+ stix: {
+ created: '2024-01-10T00:00:00.000Z',
+ id: 'x-mitre-collection--excluded',
+ type: 'x-mitre-collection',
+ x_mitre_domains: ['enterprise-attack'],
+ },
+ },
+ {
+ stix: {
+ created: '2024-01-10T00:00:00.000Z',
+ id: 'note--excluded',
+ type: 'note',
+ x_mitre_domains: ['enterprise-attack'],
+ },
+ },
+ {
+ stix: {
+ created: '2024-01-10T00:00:00.000Z',
+ id: 'x-mitre-data-source--excluded',
+ type: 'x-mitre-data-source',
+ x_mitre_domains: ['enterprise-attack'],
+ },
+ },
+ {
+ stix: {
+ created: '2024-01-10T00:00:00.000Z',
+ id: 'identity--excluded',
+ type: 'identity',
+ x_mitre_domains: ['enterprise-attack'],
+ },
+ },
+ ]);
+
+ const chartTypeKeys = [
+ ...component.sunburstSegments.map(segment => segment.key),
+ ...component.objectGrowthLineSeries.map(series => series.key),
+ ];
+
+ expect(component.totalObjects).toBe(1);
+ expect(component.totalAssignments).toBe(1);
+ expect(component.objectGrowthTotal).toBe(1);
+ expect(chartTypeKeys).not.toContain('collection');
+ expect(chartTypeKeys).not.toContain('note');
+ expect(chartTypeKeys).not.toContain('data-source');
+ expect(chartTypeKeys).not.toContain('identity');
+ });
+
+ it('should use the same object type colors in the sunburst and timeline', () => {
+ const timelineTechnique = component.objectGrowthLineSeries.find(
+ series => series.key === 'technique'
+ );
+ const enterpriseTechnique = component.sunburstSegments.find(
+ node => node.id === 'domain:enterprise-attack/type:technique'
+ );
+ const mobileTechnique = component.sunburstSegments.find(
+ node => node.id === 'domain:mobile-attack/type:technique'
+ );
+
+ expect(enterpriseTechnique?.color).toBe(timelineTechnique?.color);
+ expect(mobileTechnique?.color).toBe(timelineTechnique?.color);
+ });
+
+ it('should drill into domain and type without status nodes', () => {
+ component.selectNodeById('domain:enterprise-attack');
+
+ expect(component.selectedPathLabel).toBe('ATT&CK Objects / Enterprise');
+ expect(component.selectedChildren.map(child => child.label)).toEqual([
+ 'Techniques',
+ 'Groups',
+ ]);
+
+ component.selectNodeById('domain:enterprise-attack/type:technique');
+
+ expect(component.selectedPathLabel).toBe(
+ 'ATT&CK Objects / Enterprise / Techniques'
+ );
+ expect(component.selectedChildren).toEqual([]);
+ expect(
+ component.sunburstSegments.some(node => node.id.includes('/status:'))
+ ).toBe(false);
+ });
+
+ it('should drill into a selected relationship type without status nodes', () => {
+ component.selectRelationshipNodeById('relationship-type:uses');
+
+ expect(component.selectedRelationshipPathLabel).toBe(
+ 'Relationships / Uses'
+ );
+ expect(component.selectedRelationshipChildren).toEqual([]);
+ expect(
+ component.relationshipSunburstSegments.some(node =>
+ node.id.includes('/status:')
+ )
+ ).toBe(false);
+ });
});
diff --git a/src/app/views/dashboard-page/dashboard-page.component.ts b/src/app/views/dashboard-page/dashboard-page.component.ts
index f49d7ea5c..dd853f611 100644
--- a/src/app/views/dashboard-page/dashboard-page.component.ts
+++ b/src/app/views/dashboard-page/dashboard-page.component.ts
@@ -1,7 +1,171 @@
import { Component, OnInit, ViewEncapsulation } from '@angular/core';
+import { finalize, take } from 'rxjs/operators';
import { RestApiConnectorService } from 'src/app/services/connectors/rest-api/rest-api-connector.service';
-import { AuthenticationService } from 'src/app/services/connectors/authentication/authentication.service';
-import { Role } from 'src/app/classes/authn/role';
+import {
+ AttackTypeToPlural,
+ StixTypeToAttackType,
+} from 'src/app/utils/type-mappings';
+import { AttackType, StixType } from 'src/app/utils/types';
+
+type DashboardLevel = 'root' | 'domain' | 'type' | 'relationship-type';
+
+interface RawAttackObject {
+ stix?: {
+ created?: string;
+ id?: string;
+ modified?: string;
+ type?: string | StixType;
+ relationship_type?: string;
+ x_mitre_domains?: string[];
+ };
+}
+
+interface DashboardNode {
+ id: string;
+ key: string;
+ label: string;
+ value: number;
+ level: DashboardLevel;
+ depth: number;
+ children: DashboardNode[];
+ parent?: DashboardNode;
+ path?: string;
+ color?: string;
+ startAngle?: number;
+ endAngle?: number;
+ innerRadius?: number;
+ outerRadius?: number;
+}
+
+interface ObjectTypeSummary {
+ typeKey: AttackType;
+ label: string;
+ count: number;
+ color: string;
+}
+
+interface DomainFilterOption {
+ key: string;
+ label: string;
+}
+
+interface TimelineObject {
+ typeKey: AttackType;
+ domains: string[];
+ created?: Date;
+}
+
+interface DashboardObjectRecord {
+ object: RawAttackObject;
+ typeKey: AttackType;
+ created?: Date;
+}
+
+interface TimelineBucket {
+ key: string;
+ objects: TimelineObject[];
+}
+
+interface TimelineSeries {
+ key: string;
+ label: string;
+ color: string;
+ points?: string;
+ markers: TimelineMarker[];
+ total: number;
+}
+
+interface TimelineMarker {
+ x: string;
+ y: string;
+ count: number;
+}
+
+interface TimelineAxisTick {
+ x: string;
+ label: string;
+}
+
+const NO_DOMAIN_KEY = 'no-domain';
+const NO_RELATIONSHIP_TYPE_KEY = 'unspecified';
+const ROOT_ID = 'root';
+const RELATIONSHIP_ROOT_ID = 'relationships-root';
+const CHART_VIEW_BOX = '0 0 320 180';
+const OBJECT_SUNBURST_ROOT_LABEL = 'ATT&CK Objects';
+const RELATIONSHIP_SUNBURST_ROOT_LABEL = 'Relationships';
+const RING_INNER_RADIUS = 50;
+const RING_WIDTH = 56;
+const RING_GAP = 1.5;
+
+const CHART_PLOT = {
+ left: 30,
+ right: 10,
+ top: 12,
+ bottom: 30,
+};
+
+const DOMAIN_LABELS: Record = {
+ 'enterprise-attack': 'Enterprise',
+ 'mobile-attack': 'Mobile',
+ 'ics-attack': 'ICS',
+ [NO_DOMAIN_KEY]: 'No Domain',
+};
+
+const DOMAIN_PALETTE = [
+ '#005b94',
+ '#599e2f',
+ '#eb6635',
+ '#6d5bd0',
+ '#00838f',
+ '#b26a00',
+ '#455a64',
+];
+
+const RELATIONSHIP_TYPE_PALETTE = [
+ '#6d5bd0',
+ '#00838f',
+ '#b26a00',
+ '#005b94',
+ '#599e2f',
+ '#eb6635',
+ '#455a64',
+];
+
+const OBJECT_TYPE_PALETTE: Partial> = {
+ 'matrix': '#0072b2',
+ 'tactic': '#d55e00',
+ 'technique': '#009e73',
+ 'group': '#aa4499',
+ 'software': '#e69f00',
+ 'campaign': '#56b4e9',
+ 'mitigation': '#882255',
+ 'asset': '#332288',
+ 'detection-strategy': '#44aa99',
+ 'analytic': '#cc6677',
+ 'data-component': '#999933',
+ 'marking-definition': '#6699cc',
+};
+
+const EXCLUDED_ATTACK_TYPES = new Set([
+ 'collection',
+ 'note',
+ 'data-source',
+ 'identity',
+]);
+
+const SUMMARY_OBJECT_TYPES: AttackType[] = [
+ 'matrix',
+ 'tactic',
+ 'technique',
+ 'group',
+ 'software',
+ 'campaign',
+ 'mitigation',
+ 'asset',
+ 'detection-strategy',
+ 'analytic',
+ 'data-component',
+];
@Component({
selector: 'app-dashboard-page',
@@ -11,30 +175,941 @@ import { Role } from 'src/app/classes/authn/role';
standalone: false,
})
export class DashboardPageComponent implements OnInit {
- public pendingUsers;
+ public loadingObjects = false;
+ public loadError?: string;
+ public includeRevoked = false;
+ public includeDeprecated = false;
+
+ public totalObjects = 0;
+ public totalAssignments = 0;
+ public totalRelationships = 0;
+ public objectTypeSummary: ObjectTypeSummary[] = [];
+ public objectGrowthLineSeries: TimelineSeries[] = [];
+ public objectGrowthYearTicks: TimelineAxisTick[] = [];
+ public objectGrowthYAxisLabels: string[] = [];
+ public timelineDomainOptions: DomainFilterOption[] = [];
+ public selectedObjectGrowthDomain = 'all';
+ public selectedObjectGrowthType?: string;
+ public readonly chartViewBox = CHART_VIEW_BOX;
+ public sunburstSegments: DashboardNode[] = [];
+ public selectedNode?: DashboardNode;
+ public selectedBreadcrumb: DashboardNode[] = [];
+ public selectedChildren: DashboardNode[] = [];
+ public selectedPathLabel = OBJECT_SUNBURST_ROOT_LABEL;
+ public selectedNodeIds = new Set();
+ public sunburstViewBox = '-164 -164 328 328';
+
+ public relationshipSunburstSegments: DashboardNode[] = [];
+ public selectedRelationshipNode?: DashboardNode;
+ public selectedRelationshipBreadcrumb: DashboardNode[] = [];
+ public selectedRelationshipChildren: DashboardNode[] = [];
+ public selectedRelationshipPathLabel = RELATIONSHIP_SUNBURST_ROOT_LABEL;
+ public selectedRelationshipNodeIds = new Set();
+ public relationshipSunburstViewBox = '-108 -108 216 216';
+
+ private readonly nodeById = new Map();
+ private readonly relationshipNodeById = new Map();
+ private timelineObjects: TimelineObject[] = [];
+ private rootNode?: DashboardNode;
+ private relationshipRootNode?: DashboardNode;
- constructor(
- private restApiConnector: RestApiConnectorService,
- private authenticationService: AuthenticationService
- ) {}
+ constructor(private restApiConnector: RestApiConnectorService) {}
ngOnInit(): void {
- const userSubscription = this.restApiConnector
- .getAllUserAccounts({ status: ['pending'] })
+ this.loadObjects();
+ }
+
+ public loadObjects(): void {
+ this.loadingObjects = true;
+ this.loadError = undefined;
+
+ this.restApiConnector
+ .getAllObjects({
+ revoked: this.includeRevoked,
+ deprecated: this.includeDeprecated,
+ })
+ .pipe(
+ take(1),
+ finalize(() => {
+ this.loadingObjects = false;
+ })
+ )
.subscribe({
- next: results => {
- const users = results as any;
- if (users && users.length) this.pendingUsers = users.length;
+ next: response => {
+ this.buildDashboard(this.unwrapObjects(response));
},
- complete: () => userSubscription.unsubscribe(),
+ error: () => {
+ this.loadError = 'Unable to load knowledge base dashboard data.';
+ this.resetDashboard();
+ },
+ });
+ }
+
+ public toggleRevoked(includeRevoked: boolean): void {
+ this.includeRevoked = includeRevoked;
+ this.loadObjects();
+ }
+
+ public toggleDeprecated(includeDeprecated: boolean): void {
+ this.includeDeprecated = includeDeprecated;
+ this.loadObjects();
+ }
+
+ public buildDashboard(objects: RawAttackObject[]): void {
+ const aggregates = new Map>();
+ const objectTypeAggregates = new Map();
+ const relationshipAggregates = new Map();
+ const timelineObjects: TimelineObject[] = [];
+ let assignmentCount = 0;
+ const {
+ objectRecords,
+ relationshipRecords,
+ totalObjects,
+ totalRelationships,
+ } = this.deduplicateObjectsByStixId(objects);
+
+ for (const record of relationshipRecords) {
+ this.incrementCount(
+ relationshipAggregates,
+ this.relationshipTypeForObject(record.object)
+ );
+ }
+
+ for (const record of objectRecords) {
+ this.incrementCount(objectTypeAggregates, record.typeKey);
+
+ const domains = this.domainsForObject(record.object);
+ timelineObjects.push(this.timelineObjectForObject(record, domains));
+ for (const domain of domains) {
+ this.incrementAggregate(aggregates, domain, record.typeKey);
+ assignmentCount += 1;
+ }
+ }
+
+ this.totalObjects = totalObjects;
+ this.totalAssignments = assignmentCount;
+ this.totalRelationships = totalRelationships;
+ this.objectTypeSummary = this.buildObjectTypeSummary(objectTypeAggregates);
+ this.timelineObjects = timelineObjects;
+ this.timelineDomainOptions = this.buildTimelineDomainOptions(aggregates);
+ if (
+ this.selectedObjectGrowthDomain !== 'all' &&
+ !this.timelineDomainOptions.some(
+ option => option.key === this.selectedObjectGrowthDomain
+ )
+ ) {
+ this.selectedObjectGrowthDomain = 'all';
+ }
+ this.objectGrowthLineSeries = this.buildObjectGrowthLineSeries(
+ this.timelineObjects,
+ this.selectedObjectGrowthDomain
+ );
+ this.ensureSelectedObjectGrowthTypeIsAvailable();
+ this.rootNode = this.buildSunburstTree(aggregates);
+ this.layoutSunburst(this.rootNode);
+ this.nodeById.clear();
+ this.indexNodes(this.rootNode);
+ this.sunburstSegments = this.flattenNodes(this.rootNode).filter(
+ node => node.level !== 'root'
+ );
+ this.sunburstViewBox = this.sunburstViewBoxForSegments(
+ this.sunburstSegments
+ );
+ this.selectNode(this.rootNode);
+
+ this.relationshipRootNode = this.buildRelationshipSunburstTree(
+ relationshipAggregates
+ );
+ this.layoutSunburst(this.relationshipRootNode);
+ this.relationshipNodeById.clear();
+ this.indexNodes(this.relationshipRootNode, this.relationshipNodeById);
+ this.relationshipSunburstSegments = this.flattenNodes(
+ this.relationshipRootNode
+ ).filter(node => node.level !== 'root');
+ this.relationshipSunburstViewBox = this.sunburstViewBoxForSegments(
+ this.relationshipSunburstSegments
+ );
+ this.selectRelationshipNode(this.relationshipRootNode);
+ }
+
+ public selectNode(node?: DashboardNode): void {
+ if (!node) return;
+ this.selectedNode = node;
+ this.selectedBreadcrumb = this.buildBreadcrumb(node);
+ this.selectedChildren = [...node.children].sort(
+ (a, b) => b.value - a.value
+ );
+ this.selectedPathLabel = this.selectedBreadcrumb
+ .map(crumb => crumb.label)
+ .join(' / ');
+ this.selectedNodeIds = this.buildSelectedNodeSet(node);
+ }
+
+ public selectNodeById(id: string): void {
+ this.selectNode(this.nodeById.get(id));
+ }
+
+ public selectRelationshipNode(node?: DashboardNode): void {
+ if (!node) return;
+ this.selectedRelationshipNode = node;
+ this.selectedRelationshipBreadcrumb = this.buildBreadcrumb(node);
+ this.selectedRelationshipChildren = [...node.children].sort(
+ (a, b) => b.value - a.value
+ );
+ this.selectedRelationshipPathLabel = this.selectedRelationshipBreadcrumb
+ .map(crumb => crumb.label)
+ .join(' / ');
+ this.selectedRelationshipNodeIds = this.buildSelectedNodeSet(node);
+ }
+
+ public selectRelationshipNodeById(id: string): void {
+ this.selectRelationshipNode(this.relationshipNodeById.get(id));
+ }
+
+ public isSegmentDimmed(segment: DashboardNode): boolean {
+ return (
+ this.selectedNode?.level !== 'root' &&
+ !this.selectedNodeIds.has(segment.id)
+ );
+ }
+
+ public isRelationshipSegmentDimmed(segment: DashboardNode): boolean {
+ return (
+ this.selectedRelationshipNode?.level !== 'root' &&
+ !this.selectedRelationshipNodeIds.has(segment.id)
+ );
+ }
+
+ public formatCount(count: number): string {
+ return count.toLocaleString();
+ }
+
+ public segmentTooltip(segment: DashboardNode): string {
+ return `${this.buildBreadcrumb(segment)
+ .map(crumb => crumb.label)
+ .join(' / ')}: ${this.formatCount(segment.value)}`;
+ }
+
+ public trackNode(_index: number, node: DashboardNode): string {
+ return node.id;
+ }
+
+ public trackObjectTypeSummary(
+ _index: number,
+ summary: ObjectTypeSummary
+ ): string {
+ return summary.typeKey;
+ }
+
+ public trackTimelineSeries(_index: number, series: TimelineSeries): string {
+ return series.key;
+ }
+
+ public trackDomainFilter(_index: number, option: DomainFilterOption): string {
+ return option.key;
+ }
+
+ public get objectGrowthTotal(): number {
+ return this.objectGrowthLineSeries.reduce(
+ (sum, series) => sum + series.total,
+ 0
+ );
+ }
+
+ public get objectGrowthLineSeriesForDisplay(): TimelineSeries[] {
+ if (!this.selectedObjectGrowthType) return this.objectGrowthLineSeries;
+ const selectedSeries = this.objectGrowthLineSeries.find(
+ series => series.key === this.selectedObjectGrowthType
+ );
+ if (!selectedSeries) return this.objectGrowthLineSeries;
+ return [
+ ...this.objectGrowthLineSeries.filter(
+ series => series.key !== this.selectedObjectGrowthType
+ ),
+ selectedSeries,
+ ];
+ }
+
+ public selectObjectGrowthDomain(domainKey: string): void {
+ this.selectedObjectGrowthDomain = domainKey;
+ this.objectGrowthLineSeries = this.buildObjectGrowthLineSeries(
+ this.timelineObjects,
+ domainKey
+ );
+ this.ensureSelectedObjectGrowthTypeIsAvailable();
+ }
+
+ public selectObjectGrowthType(typeKey: string): void {
+ this.selectedObjectGrowthType =
+ this.selectedObjectGrowthType === typeKey ? undefined : typeKey;
+ }
+
+ public isObjectGrowthSeriesSelected(series: TimelineSeries): boolean {
+ return this.selectedObjectGrowthType === series.key;
+ }
+
+ public isObjectGrowthSeriesDimmed(series: TimelineSeries): boolean {
+ return (
+ !!this.selectedObjectGrowthType &&
+ this.selectedObjectGrowthType !== series.key
+ );
+ }
+
+ private resetDashboard(): void {
+ this.totalObjects = 0;
+ this.totalAssignments = 0;
+ this.totalRelationships = 0;
+ this.objectTypeSummary = [];
+ this.objectGrowthLineSeries = [];
+ this.objectGrowthYearTicks = [];
+ this.objectGrowthYAxisLabels = [];
+ this.timelineDomainOptions = [];
+ this.selectedObjectGrowthDomain = 'all';
+ this.selectedObjectGrowthType = undefined;
+ this.timelineObjects = [];
+ this.sunburstSegments = [];
+ this.rootNode = this.createNode(
+ ROOT_ID,
+ 'root',
+ OBJECT_SUNBURST_ROOT_LABEL
+ );
+ this.selectedNode = this.rootNode;
+ this.selectedBreadcrumb = [this.rootNode];
+ this.selectedChildren = [];
+ this.selectedPathLabel = OBJECT_SUNBURST_ROOT_LABEL;
+ this.selectedNodeIds = new Set([ROOT_ID]);
+ this.sunburstViewBox = this.sunburstViewBoxForSegments([]);
+ this.relationshipSunburstSegments = [];
+ this.relationshipRootNode = this.createNode(
+ RELATIONSHIP_ROOT_ID,
+ 'root',
+ RELATIONSHIP_SUNBURST_ROOT_LABEL
+ );
+ this.selectedRelationshipNode = this.relationshipRootNode;
+ this.selectedRelationshipBreadcrumb = [this.relationshipRootNode];
+ this.selectedRelationshipChildren = [];
+ this.selectedRelationshipPathLabel = RELATIONSHIP_SUNBURST_ROOT_LABEL;
+ this.selectedRelationshipNodeIds = new Set([RELATIONSHIP_ROOT_ID]);
+ this.relationshipSunburstViewBox = this.sunburstViewBoxForSegments([]);
+ }
+
+ private unwrapObjects(response: any): RawAttackObject[] {
+ if (Array.isArray(response)) return response;
+ if (Array.isArray(response?.data)) return response.data;
+ return [];
+ }
+
+ private objectTypeKey(object: RawAttackObject): AttackType | undefined {
+ const stixType = object?.stix?.type;
+ if (!stixType) return undefined;
+ if (!(stixType in StixTypeToAttackType)) return undefined;
+
+ const attackType = StixTypeToAttackType[stixType as StixType];
+ if (EXCLUDED_ATTACK_TYPES.has(attackType)) return undefined;
+ return attackType;
+ }
+
+ private domainsForObject(object: RawAttackObject): string[] {
+ const domains = object?.stix?.x_mitre_domains;
+ if (!domains?.length) return [NO_DOMAIN_KEY];
+ return [...new Set(domains.filter(domain => !!domain))];
+ }
+
+ private relationshipTypeForObject(object: RawAttackObject): string {
+ return object?.stix?.relationship_type || NO_RELATIONSHIP_TYPE_KEY;
+ }
+
+ private timelineObjectForObject(
+ record: DashboardObjectRecord,
+ domains: string[]
+ ): TimelineObject {
+ return {
+ typeKey: record.typeKey,
+ domains,
+ created: record.created,
+ };
+ }
+
+ private deduplicateObjectsByStixId(objects: RawAttackObject[]): {
+ objectRecords: DashboardObjectRecord[];
+ relationshipRecords: DashboardObjectRecord[];
+ totalObjects: number;
+ totalRelationships: number;
+ } {
+ const objectRecordsById = new Map();
+ const relationshipRecordsById = new Map();
+ const fallbackObjectRecords: DashboardObjectRecord[] = [];
+ const fallbackRelationshipRecords: DashboardObjectRecord[] = [];
+
+ for (const object of objects) {
+ const typeKey = this.objectTypeKey(object);
+ if (!typeKey) continue;
+
+ const record = this.dashboardObjectRecord(object, typeKey);
+ const stixId = object?.stix?.id;
+ if (!stixId) {
+ if (typeKey === 'relationship')
+ fallbackRelationshipRecords.push(record);
+ else fallbackObjectRecords.push(record);
+ continue;
+ }
+
+ const records =
+ typeKey === 'relationship'
+ ? relationshipRecordsById
+ : objectRecordsById;
+ const existing = records.get(stixId);
+ if (!existing) {
+ records.set(stixId, record);
+ continue;
+ }
+
+ if (this.isNewerVersion(record.object, existing.object)) {
+ existing.object = record.object;
+ existing.typeKey = record.typeKey;
+ }
+ if (
+ record.created &&
+ (!existing.created || record.created < existing.created)
+ ) {
+ existing.created = record.created;
+ }
+ }
+
+ return {
+ objectRecords: [
+ ...Array.from(objectRecordsById.values()),
+ ...fallbackObjectRecords,
+ ],
+ relationshipRecords: [
+ ...Array.from(relationshipRecordsById.values()),
+ ...fallbackRelationshipRecords,
+ ],
+ totalObjects: objectRecordsById.size + fallbackObjectRecords.length,
+ totalRelationships:
+ relationshipRecordsById.size + fallbackRelationshipRecords.length,
+ };
+ }
+
+ private dashboardObjectRecord(
+ object: RawAttackObject,
+ typeKey: AttackType
+ ): DashboardObjectRecord {
+ return {
+ object,
+ typeKey,
+ created: this.parseDate(object?.stix?.created),
+ };
+ }
+
+ private isNewerVersion(
+ candidate: RawAttackObject,
+ current: RawAttackObject
+ ): boolean {
+ const candidateDate =
+ this.parseDate(candidate?.stix?.modified) ||
+ this.parseDate(candidate?.stix?.created);
+ const currentDate =
+ this.parseDate(current?.stix?.modified) ||
+ this.parseDate(current?.stix?.created);
+ if (!candidateDate) return false;
+ if (!currentDate) return true;
+ return candidateDate > currentDate;
+ }
+
+ private parseDate(value?: string): Date | undefined {
+ if (!value) return undefined;
+ const date = new Date(value);
+ return Number.isNaN(date.getTime()) ? undefined : date;
+ }
+
+ private incrementAggregate(
+ aggregates: Map>,
+ domainKey: string,
+ typeKey: AttackType
+ ): void {
+ let typeMap = aggregates.get(domainKey);
+ if (!typeMap) {
+ typeMap = new Map();
+ aggregates.set(domainKey, typeMap);
+ }
+ typeMap.set(typeKey, (typeMap.get(typeKey) || 0) + 1);
+ }
+
+ private incrementCount(aggregates: Map, key: TKey): void {
+ aggregates.set(key, (aggregates.get(key) || 0) + 1);
+ }
+
+ private buildObjectTypeSummary(
+ aggregates: Map
+ ): ObjectTypeSummary[] {
+ return SUMMARY_OBJECT_TYPES.map(typeKey => ({
+ typeKey,
+ label: this.objectTypeLabel(typeKey),
+ count: aggregates.get(typeKey) || 0,
+ color: this.colorForObjectType(typeKey),
+ }));
+ }
+
+ private buildTimelineDomainOptions(
+ aggregates: Map