Add more subject types.

Closes #3130.

components/api_server/src/model/defaults.py

@@ -37,5 +37,5 @@ def default_report_attributes() -> dict[str, str | dict]:
 
 def default_subject_attributes(subject_type: str) -> dict[str, Any]:
     """Return the default attributes with their default values for the specified subject type."""
-    subject = DATA_MODEL.subjects[subject_type]
+    subject = DATA_MODEL.all_subjects[subject_type]
     return {"type": subject_type, "name": None, "description": subject.description, "metrics": {}}

components/frontend/src/metric/MetricType.js

@@ -6,6 +6,7 @@ import { DataModel } from "../context/DataModel"
 import { EDIT_REPORT_PERMISSION } from "../context/Permissions"
 import { SingleChoiceInput } from "../fields/SingleChoiceInput"
 import { Header } from "../semantic_ui_react_wrappers"
+import { getSubjectTypeMetrics } from "../utils"
 
 export function metricTypeOption(key, metricType) {
     return {
@@ -18,7 +19,9 @@ export function metricTypeOption(key, metricType) {
 
 export function metricTypeOptions(dataModel, subjectType) {
     // Return menu options for all metric that support the subject type
-    return dataModel.subjects[subjectType].metrics.map((key) => metricTypeOption(key, dataModel.metrics[key]))
+    return getSubjectTypeMetrics(subjectType, dataModel.subjects).map((key) =>
+        metricTypeOption(key, dataModel.metrics[key]),
+    )
 }
 
 export function allMetricTypeOptions(dataModel) {

components/frontend/src/sharedPropTypes.js

@@ -184,9 +184,15 @@ export const metricTypePropType = shape({
     name: string,
 })
 
+export const subjectTypePropType = shape({
+    description: string,
+    name: string,
+})
+
 export const dataModelPropType = shape({
     metrics: objectOf(metricTypePropType),
     sources: objectOf(sourceTypePropType),
+    subjects: objectOf(subjectTypePropType),
 })
 
 export const destinationPropType = shape({

components/frontend/src/subject/SubjectTitle.js

@@ -10,7 +10,7 @@ import { EDIT_REPORT_PERMISSION, ReadOnlyOrEditable } from "../context/Permissio
 import { Header, Tab } from "../semantic_ui_react_wrappers"
 import { Share } from "../share/Share"
 import { reportPropType, settingsPropType } from "../sharedPropTypes"
-import { slugify } from "../utils"
+import { getSubjectType, slugify } from "../utils"
 import { DeleteButton, ReorderButtonGroup } from "../widgets/Button"
 import { FocusableTab } from "../widgets/FocusableTab"
 import { HeaderWithDetails } from "../widgets/HeaderWithDetails"
@@ -76,7 +76,7 @@ export function SubjectTitle({
 }) {
     const dataModel = useContext(DataModel)
     const tabIndex = activeTabIndex(settings.expandedItems, subject_uuid)
-    const subjectType = dataModel.subjects[subject.type] || { name: "Unknown subject type" }
+    const subjectType = getSubjectType(subject.type, dataModel.subjects) || { name: "Unknown subject type" }
     const subjectName = subject.name || subjectType.name
     const subjectTitle = (atReportsOverview ? report.title + " ❯ " : "") + subjectName
     const subjectUrl = `${window.location}#${subject_uuid}`

components/frontend/src/subject/SubjectType.js

@@ -1,26 +1,39 @@
-import { func, objectOf, string } from "prop-types"
+import { func, number, objectOf, string } from "prop-types"
 import { useContext } from "react"
+import { HeaderContent, HeaderSubheader } from "semantic-ui-react"
 
 import { DataModel } from "../context/DataModel"
 import { EDIT_REPORT_PERMISSION } from "../context/Permissions"
 import { SingleChoiceInput } from "../fields/SingleChoiceInput"
-import { Header } from "../semantic_ui_react_wrappers"
+import { Header, Icon } from "../semantic_ui_react_wrappers"
 import { subjectPropType } from "../sharedPropTypes"
 
-export function subjectTypes(subjectTypesMapping) {
+export function subjectTypes(subjectTypesMapping, level = 0) {
     const options = []
+    const headingLevel = `h${Math.min(level, 2) + 4}`
+    const bullet = level === 0 ? null : <Icon name="circle" size="tiny" style={{ paddingLeft: `${level}em` }} />
     Object.entries(subjectTypesMapping).forEach(([key, subjectType]) => {
         options.push({
             key: key,
             text: subjectType.name,
             value: key,
-            content: <Header as="h4" content={subjectType.name} subheader={subjectType.description} />,
+            content: (
+                <Header as={headingLevel}>
+                    {bullet}
+                    <HeaderContent>
+                        {subjectType.name}
+                        <HeaderSubheader>{subjectType.description}</HeaderSubheader>
+                    </HeaderContent>
+                </Header>
+            ),
         })
+        options.push(...subjectTypes(subjectType?.subjects ?? [], level + 1))
     })
     return options
 }
 subjectTypes.propTypes = {
     subjectTypesMapping: objectOf(subjectPropType),
+    level: number,
 }
 
 export function SubjectType({ subjectType, setValue }) {

components/frontend/src/utils.js

@@ -10,6 +10,7 @@ import {
     reportsPropType,
     scalePropType,
     stringsPropType,
+    subjectTypePropType,
 } from "./sharedPropTypes"
 import { HyperLink } from "./widgets/HyperLink"
 
@@ -75,8 +76,44 @@ export function getSourceName(source, dataModel) {
     return source.name || dataModel.sources[source.type].name
 }
 
+export function getSubjectTypeMetrics(subjectTypeKey, subjects) {
+    // Return the metric types supported by the specified subject type, and all parents of the subject type, recursively
+    if (Object.keys(subjects).includes(subjectTypeKey)) {
+        return subjects[subjectTypeKey].metrics
+    }
+    const childSubjects = Object.values(subjects).filter((subject) => !!subject.subjects)
+    for (const childSubject of childSubjects) {
+        const metrics = getSubjectTypeMetrics(subjectTypeKey, childSubject.subjects)
+        if (metrics) {
+            return [...childSubject.metrics, ...metrics]
+        }
+    }
+}
+getSubjectTypeMetrics.propTypes = {
+    subjectTypeKey: string,
+    subjects: objectOf(subjectTypePropType),
+}
+
+export function getSubjectType(subjectTypeKey, subjects) {
+    // Return the subject type object
+    if (Object.keys(subjects).includes(subjectTypeKey)) {
+        return subjects[subjectTypeKey]
+    }
+    const childSubjects = Object.values(subjects).filter((subject) => !!subject.subjects)
+    for (const childSubject of childSubjects) {
+        const result = getSubjectType(subjectTypeKey, childSubject.subjects)
+        if (result) {
+            return result
+        }
+    }
+}
+getSubjectType.propTypes = {
+    subjectTypeKey: string,
+    subjects: objectOf(subjectTypePropType),
+}
+
 export function getSubjectName(subject, dataModel) {
-    return subject.name || dataModel.subjects[subject.type].name
+    return subject.name || getSubjectType(subject.type, dataModel.subjects).name
 }
 
 export function getMetricTarget(metric) {

components/frontend/src/utils.test.js

@@ -8,6 +8,8 @@ import {
     getSourceName,
     getStatusName,
     getSubjectName,
+    getSubjectType,
+    getSubjectTypeMetrics,
     getUserPermissions,
     niceNumber,
     nrMetricsInReport,
@@ -139,6 +141,47 @@ it("gets the source name from the data model if the source has no name", () => {
     )
 })
 
+it("gets the subject type", () => {
+    const subject = { name: "Subject" }
+    expect(getSubjectType("subject", { subject: subject })).toStrictEqual({ name: "Subject" })
+})
+
+it("gets the subject type recursively", () => {
+    const subject = { name: "Subject" }
+    expect(getSubjectType("subject", { parent: { subjects: { subject: subject } } })).toStrictEqual({
+        name: "Subject",
+    })
+})
+
+it("gets the subject type recursively from the second subject type", () => {
+    const subject = { name: "Subject" }
+    expect(
+        getSubjectType("subject", {
+            first: { subjects: { foo: { name: "Foo" } } },
+            second: { subjects: { subject: subject } },
+        }),
+    ).toStrictEqual(subject)
+})
+
+it("gets the subject type metrics", () => {
+    expect(getSubjectTypeMetrics("subject", { subject: { metrics: ["metric"] } })).toStrictEqual(["metric"])
+})
+
+it("gets the subject type metrics recursively", () => {
+    const metrics = getSubjectTypeMetrics("child", {
+        parent: { metrics: ["parent metric"], subjects: { child: { metrics: ["child metric"] } } },
+    })
+    expect(metrics).toStrictEqual(["parent metric", "child metric"])
+})
+
+it("gets the subject type metrics recursively from the second subject type", () => {
+    const metrics = getSubjectTypeMetrics("child", {
+        first: { subjects: { foo: { metrics: ["foo metric"] } } },
+        second: { metrics: ["second metric"], subjects: { child: { metrics: ["child metric"] } } },
+    })
+    expect(metrics).toStrictEqual(["second metric", "child metric"])
+})
+
 it("gets the subject name", () => {
     expect(getSubjectName({ name: "subject" }, {})).toStrictEqual("subject")
 })

components/frontend/src/widgets/menu_options.js

@@ -1,8 +1,8 @@
-import { getMetricName, getSourceName, getSubjectName } from "../utils"
+import { getMetricName, getSourceName, getSubjectName, getSubjectTypeMetrics } from "../utils"
 import { ItemBreadcrumb } from "./ItemBreadcrumb"
 
 export function metric_options(reports, dataModel, current_subject_type, current_subject_uuid) {
-    const subject_metrics = dataModel.subjects[current_subject_type].metrics
+    const subject_metrics = getSubjectTypeMetrics(current_subject_type, dataModel.subjects)
     let options = []
     reports.forEach((report) => {
         Object.entries(report.subjects).forEach(([subject_uuid, subject]) => {

components/shared_code/src/shared_data_model/meta/data_model.py

@@ -3,21 +3,20 @@
 import pathlib
 from typing import Self
 
-from pydantic import BaseModel, model_validator
+from pydantic import model_validator
 
 from .metric import Metric
 from .scale import Scale
 from .source import Source
-from .subject import Subject
+from .subject import SubjectContainer
 
 
-class DataModel(BaseModel):
+class DataModel(SubjectContainer):
     """Data model model."""
 
     scales: dict[str, Scale]
     metrics: dict[str, Metric]
     sources: dict[str, Source]
-    subjects: dict[str, Subject]
 
     @model_validator(mode="after")
     def check_scales(self) -> Self:
@@ -137,7 +136,7 @@ def check_quality_time_source_types(self) -> None:
     def check_subjects(self) -> Self:
         """Check that each metric belongs to at least one subject."""
         for metric_key in self.metrics:
-            for subject in self.subjects.values():
+            for subject in self.all_subjects.values():
                 if metric_key in subject.metrics:
                     break
             else:

components/shared_code/src/shared_data_model/meta/subject.py

@@ -1,11 +1,30 @@
 """Data model subject."""
 
-from pydantic import Field
+from __future__ import annotations
+
+from pydantic import BaseModel, Field
 
 from .base import DescribedModel
 
 
-class Subject(DescribedModel):
+class SubjectContainer(BaseModel):
+    """Base model for subject containers."""
+
+    subjects: dict[str, Subject] = Field(default_factory=dict)
+
+    @property
+    def all_subjects(self) -> dict[str, Subject]:
+        """Return all subjects, recursively."""
+        all_subjects = {**self.subjects}
+        for subject in self.subjects.values():
+            all_subjects.update(**subject.all_subjects)
+        return all_subjects
+
+
+class Subject(SubjectContainer, DescribedModel):
     """Base model for subjects."""
 
     metrics: list[str] = Field(..., min_length=1)
+
+
+SubjectContainer.model_rebuild()