feat: use scores or raw scores for report server processing (M2-7933)

src/apps/activities/domain/custom_validation.py

@@ -1,7 +1,7 @@
 from apps.activities.domain.conditions import MultiSelectConditionType, SingleSelectConditionType
 from apps.activities.domain.response_type_config import PerformanceTaskType, ResponseType
 from apps.activities.domain.response_values import PhrasalTemplateFieldType
-from apps.activities.domain.scores_reports import ReportType, SubscaleItemType
+from apps.activities.domain.scores_reports import ReportType, Score, SubscaleItemType, SubscaleSetting
 from apps.activities.errors import (
     IncorrectConditionItemError,
     IncorrectConditionItemIndexError,
@@ -20,9 +20,14 @@
     IncorrectSectionPrintItemTypeError,
     IncorrectSubscaleInsideSubscaleError,
     IncorrectSubscaleItemError,
+    SubscaleDoesNotExist,
     SubscaleInsideSubscaleError,
+    SubscaleItemDoesNotExist,
     SubscaleItemScoreError,
     SubscaleItemTypeError,
+    SubscaleItemTypeItemDoesNotExist,
+    SubscaleNameDoesNotExist,
+    SubscaleSettingDoesNotExist,
 )
 
 
@@ -63,6 +68,25 @@ def validate_item_flow(values: dict):
     return values
 
 
+def validate_subscale_setting_match_reports(report: Score, subscale_setting: SubscaleSetting):
+    if not subscale_setting:  # report of type score exist then we need a subscale setting
+        raise SubscaleSettingDoesNotExist()
+    report_subscale_linked = report.subscale_name
+    subscales = subscale_setting.subscales
+    if not subscales:
+        raise SubscaleDoesNotExist()
+
+    linked_subscale = next((subscale for subscale in subscales if subscale.name == report_subscale_linked), None)
+    if not linked_subscale:
+        raise SubscaleNameDoesNotExist()
+    elif not linked_subscale.items:
+        raise SubscaleItemDoesNotExist()
+    else:
+        has_non_subscale_items = any(item.type == SubscaleItemType.ITEM for item in linked_subscale.items)
+        if not has_non_subscale_items:
+            raise SubscaleItemTypeItemDoesNotExist()
+
+
 def validate_score_and_sections(values: dict):  # noqa: C901
     items = values.get("items", [])
     item_names = [item.name for item in items]
@@ -78,6 +102,10 @@ def validate_score_and_sections(values: dict):  # noqa: C901
 
         for report in list(scores):
             score_item_ids.append(report.id)
+            if report.scoring_type == "score":
+                subscale_setting = values.get("subscale_setting")
+                validate_subscale_setting_match_reports(report, subscale_setting)
+
             # check if all item names are same as values.name
             for item in report.items_score:
                 if item not in item_names:

src/apps/activities/domain/scores_reports.py

@@ -30,6 +30,11 @@ class CalculationType(str, Enum):
     PERCENTAGE = "percentage"
 
 
+class ScoringType(str, Enum):
+    SCORE = "score"
+    RAW_SCORE = "raw_score"
+
+
 class ScoreConditionalLogic(PublicModel):
     name: str
     id: str
@@ -60,6 +65,8 @@ class Score(PublicModel):
     message: str | None = None
     items_print: list[str] | None = Field(default_factory=list)
     conditional_logic: list[ScoreConditionalLogic] | None = None
+    scoring_type: ScoringType | None = None
+    subscale_name: str | None = None
 
     @validator("conditional_logic")
     def validate_conditional_logic(cls, value, values):

src/apps/activities/errors.py

@@ -270,3 +270,38 @@ class IncorrectPhrasalTemplateItemTypeError(ValidationError):
 
 class IncorrectPhrasalTemplateItemIndexError(ValidationError):
     message = _("Invalid item index for activity item inside phrasal template")
+
+
+class SubscaleIsNotLinked(ValidationError):
+    message = _("The scoring_type is score but no suscale_name string pased")
+    code = _("no_subscale_items_exist")
+
+
+class SubscaleDoesNotExist(ValidationError):
+    message = _("The scoring_type is score but there are no subscales")
+    code = _("no_subscale_linked")
+
+
+class SubscaleNameDoesNotExist(ValidationError):
+    message = _("The lookup table with the passed name does not exist in subscale settings")
+    code = _("no_subscale_name_exist")
+
+
+class SubscaleDataDoesNotExist(ValidationError):
+    message = _("The scoring_type is score but the subscale data does not exist")
+    code = _("no_subscaledata_exist")
+
+
+class SubscaleSettingDoesNotExist(ValidationError):
+    message = _("The scoring_type is score but there are no subscale settings associated with activity")
+    code = _("no_subscale_setting_exist")
+
+
+class SubscaleItemDoesNotExist(ValidationError):
+    message = _("The linked subscale should contain at least one item")
+    code = _("no_items_exist")
+
+
+class SubscaleItemTypeItemDoesNotExist(ValidationError):
+    message = _("The linked subscale should contain at least one non-subscale type item")
+    code = _("no_subscale_type_items_exist")

src/apps/activities/tests/fixtures/scores_reports.py

@@ -48,6 +48,30 @@ def score() -> Score:
     )
 
 
+@pytest.fixture
+def score_with_subscale() -> Score:
+    return Score(
+        type=ReportType.score,
+        name="testscore type score",
+        id=SCORE_ID,
+        calculation_type=CalculationType.SUM,
+        scoring_type="score",
+        subscale_name="subscale type score",
+    )
+
+
+@pytest.fixture
+def score_with_subscale_raw() -> Score:
+    return Score(
+        type=ReportType.score,
+        name="testscore type score",
+        id=SCORE_ID,
+        calculation_type=CalculationType.SUM,
+        scoring_type="raw_score",
+        subscale_name=None,
+    )
+
+
 @pytest.fixture
 def section_conditional_logic() -> SectionConditionalLogic:
     return SectionConditionalLogic(
@@ -76,6 +100,15 @@ def scores_and_reports(score: Score, section: Section) -> ScoresAndReports:
     )
 
 
+@pytest.fixture
+def scores_and_reports_raw_score(score_with_subscale_raw: Score, section: Section) -> ScoresAndReports:
+    return ScoresAndReports(
+        generate_report=True,
+        show_score_summary=True,
+        reports=[score_with_subscale_raw, section],
+    )
+
+
 @pytest.fixture
 def subscale_item() -> SubscaleItem:
     return SubscaleItem(name="activity_item_1", type=SubscaleItemType.ITEM)
@@ -90,6 +123,26 @@ def subscale(subscale_item: SubscaleItem) -> Subscale:
     )
 
 
+@pytest.fixture
+def subscale_score_type() -> Subscale:
+    return Subscale(
+        name="subscale type score",
+        scoring=SubscaleCalculationType.AVERAGE,
+        items=[SubscaleItem(name="subscale_item", type=SubscaleItemType.ITEM)],
+    )
+
+
+@pytest.fixture
+def scores_and_reports_lookup_scores(
+    score_with_subscale: Score, section: Section, subscale: Subscale
+) -> ScoresAndReports:
+    return ScoresAndReports(
+        generate_report=True,
+        show_score_summary=True,
+        reports=[score_with_subscale],
+    )
+
+
 @pytest.fixture
 def subscale_item_type_subscale(subscale: Subscale) -> SubscaleItem:
     # Depends on subscalke because name should contain subscale item
@@ -99,7 +152,9 @@ def subscale_item_type_subscale(subscale: Subscale) -> SubscaleItem:
 @pytest.fixture
 def subscale_with_item_type_subscale(subscale_item_type_subscale: SubscaleItem) -> Subscale:
     return Subscale(
-        name="subscale type subscale", items=[subscale_item_type_subscale], scoring=SubscaleCalculationType.AVERAGE
+        name="subscale type subscale",
+        scoring=SubscaleCalculationType.AVERAGE,
+        items=[subscale_item_type_subscale],
     )
 
 
@@ -111,6 +166,14 @@ def subscale_setting(subscale: Subscale) -> SubscaleSetting:
     )
 
 
+@pytest.fixture
+def subscale_setting_score_type(subscale_score_type: Subscale) -> SubscaleSetting:
+    return SubscaleSetting(
+        calculate_total_score=SubscaleCalculationType.AVERAGE,
+        subscales=[subscale_score_type],
+    )
+
+
 @pytest.fixture
 def subscale_total_score_table() -> list[TotalScoreTable]:
     return [

src/apps/answers/service.py

@@ -1922,7 +1922,9 @@ async def is_flow_finished(self, submit_id: uuid.UUID, answer_id: uuid.UUID) ->
         return self._is_activity_last_in_flow(applet_full, activity_id, flow_id)
 
     async def create_report(
-        self, submit_id: uuid.UUID, answer_id: uuid.UUID | None = None
+        self,
+        submit_id: uuid.UUID,
+        answer_id: uuid.UUID | None = None,
     ) -> ReportServerResponse | None:
         answers = await AnswersCRUD(self.answers_session).get_by_submit_id(submit_id, answer_id)
         if not answers:

src/apps/applets/tests/test_applet_activity_items.py

@@ -16,6 +16,7 @@
 from apps.activities.domain.scores_reports import (
     ScoreConditionalLogic,
     ScoresAndReports,
+    ScoringType,
     SectionConditionalLogic,
     Subscale,
     SubScaleLookupTable,
@@ -522,6 +523,38 @@ async def test_create_applet__activity_with_subscale_settings_with_subscale_look
         result = resp.json()["result"]
         assert result["activities"][0]["subscaleSetting"] == sub_setting.dict(by_alias=True)
 
+    async def test_create_applet__activity_with_subscale_settings_and_lookup_table_and_score_report_lookup_scoring(
+        self,
+        client: TestClient,
+        applet_minimal_data: AppletCreate,
+        single_select_item_create_with_score: ActivityItemCreate,
+        tom: User,
+        subscale_setting_score_type: SubscaleSetting,
+        subscale_lookup_table: list[SubScaleLookupTable],
+        scores_and_reports_lookup_scores: ScoresAndReports,
+    ):
+        client.login(tom)
+        data = applet_minimal_data.copy(deep=True)
+        sub_setting = subscale_setting_score_type.copy(deep=True)
+
+        # Update subscale setting with item name and lookup table
+        sub_setting.subscales[0].items[0].name = single_select_item_create_with_score.name  # type: ignore[index]
+        sub_setting.subscales[0].subscale_table_data = subscale_lookup_table  # type: ignore[index]
+
+        data.activities[0].items = [single_select_item_create_with_score]
+        data.activities[0].subscale_setting = sub_setting
+        data.activities[0].scores_and_reports = scores_and_reports_lookup_scores
+
+        # Make the POST request
+        resp = await client.post(self.applet_create_url.format(owner_id=tom.id), data=data)
+
+        # Assertions
+        assert resp.status_code == http.HTTPStatus.CREATED
+        result = resp.json()["result"]
+        assert result["activities"][0]["subscaleSetting"] == sub_setting.dict(by_alias=True)
+        assert result["activities"][0]["scoresAndReports"]["reports"][0]["scoringType"] == ScoringType.SCORE.value
+        assert result["activities"][0]["scoresAndReports"]["reports"][0]["subscaleName"] == "subscale type score"
+
     async def test_create_applet__activity_with_subscale_settings_with_invalid_subscale_lookup_table_age(
         self,
         client: TestClient,