refactor: embed entity logic within class

src/data/repositories/testRepositories/SurveyFormTestRepository.ts

@@ -31,7 +31,7 @@ export class SurveyTestRepository implements SurveyRepository {
         throw new Error("Method not implemented.");
     }
     getForm(programId: string): FutureData<Questionnaire> {
-        const questionnaire: Questionnaire = {
+        const questionnaire: Questionnaire = Questionnaire.create({
             id: programId,
             name: "Test Questionnaire",
             description: "Test Questionnaire",
@@ -58,7 +58,7 @@ export class SurveyTestRepository implements SurveyRepository {
             isMandatory: false,
             year: "2023",
             rules: [],
-        };
+        });
         return Future.success(questionnaire);
     }
 

src/data/utils/surveyFormMappers.ts

@@ -173,7 +173,7 @@ export const mapProgramToQuestionnaire = (
         programRuleActions
     );
 
-    const form: Questionnaire = {
+    const form = {
         id: program.id,
         name: program.name,
         description: program.name,
@@ -202,9 +202,10 @@ export const mapProgramToQuestionnaire = (
             isVisible: true,
             stageId: "PROFILE",
         };
-        form.entity = profileSection;
+
+        return Questionnaire.create({ ...form, entity: profileSection });
     }
-    return form;
+    return Questionnaire.create(form);
 };
 
 export const mapQuestionnaireToEvent = (

src/domain/entities/Questionnaire/Questionnaire.ts

@@ -14,7 +14,7 @@ export interface QuestionnaireBase {
     isMandatory: boolean;
 }
 
-export interface Questionnaire extends QuestionnaireBase {
+interface QuestionnaireData extends QuestionnaireBase {
     stages: QuestionnaireStage[];
     entity?: QuestionnaireEntity; //Equivalant to tracked entity instance of tracker program
     subLevelDetails?: {
@@ -40,9 +40,72 @@ export interface QuestionnaireStage {
     instanceId?: Id; //Corresponds to DHIS eventId
 }
 
-export class QuestionnaireM {
+export class Questionnaire {
+    private readonly data: QuestionnaireData;
+
+    private constructor(data: QuestionnaireData) {
+        this.data = data;
+    }
+    public get stages(): QuestionnaireStage[] {
+        return this.data.stages;
+    }
+
+    public get rules(): QuestionnaireRule[] {
+        return this.data.rules;
+    }
+    public get entity(): QuestionnaireEntity | undefined {
+        return this.data.entity;
+    }
+    public get orgUnit(): Ref {
+        return this.data.orgUnit;
+    }
+
+    public get subLevelDetails(): { enrollmentId: Id } | undefined {
+        return this.data.subLevelDetails;
+    }
+
+    public static create(data: QuestionnaireData): Questionnaire {
+        //TO DO : Add validations if any
+        return new Questionnaire({
+            id: data.id,
+            name: data.name,
+            description: data.description,
+            orgUnit: data.orgUnit,
+            year: data.year,
+            isCompleted: data.isCompleted,
+            isMandatory: data.isMandatory,
+            stages: data.stages,
+            entity: data.entity,
+            subLevelDetails: data.subLevelDetails,
+            rules: data.rules,
+        });
+    }
+
+    static updateQuestionnaireEntity(
+        questionnaire: Questionnaire,
+        entity: QuestionnaireEntity
+    ): Questionnaire {
+        return Questionnaire.create({
+            ...questionnaire.data,
+            entity: entity,
+        });
+    }
+
+    static updateQuestionnaireStages(
+        questionnaire: Questionnaire,
+        stages: QuestionnaireStage[]
+    ): Questionnaire {
+        return Questionnaire.create({
+            ...questionnaire.data,
+            stages: stages,
+        });
+    }
+
     static setAsComplete(questionnarie: Questionnaire, value: boolean): Questionnaire {
-        return { ...questionnarie, isCompleted: value };
+        return Questionnaire.create({
+            ...questionnarie.data,
+            isCompleted: value,
+        });
     }
 
     static applyAllRulesOnQuestionnaireInitialLoad(questionnaire: Questionnaire): Questionnaire {
@@ -87,8 +150,8 @@ export class QuestionnaireM {
             allQsInQuestionnaire
         );
 
-        return {
-            ...questionnaire,
+        return Questionnaire.create({
+            ...questionnaire.data,
             stages: questionnaire.stages.map(stage => {
                 return {
                     ...stage,
@@ -100,7 +163,7 @@ export class QuestionnaireM {
                     ),
                 };
             }),
-        };
+        });
     }
 
     static doesQuestionnaireHaveErrors(questionnaire: Questionnaire): boolean {

src/domain/usecases/ApplyInitialRulesToSurveyUseCase.ts

@@ -1,7 +1,7 @@
-import { Questionnaire, QuestionnaireM } from "../entities/Questionnaire/Questionnaire";
+import { Questionnaire } from "../entities/Questionnaire/Questionnaire";
 
 export class ApplyInitialRulesToSurveyUseCase {
     public execute(questionnaire: Questionnaire): Questionnaire {
-        return QuestionnaireM.applyAllRulesOnQuestionnaireInitialLoad(questionnaire);
+        return Questionnaire.applyAllRulesOnQuestionnaireInitialLoad(questionnaire);
     }
 }

src/domain/usecases/GetSurveyUseCase.ts

@@ -103,7 +103,9 @@ export class GetSurveyUseCase {
                             sections: updatedSections,
                         };
 
-                        return Future.success({ ...questionnaire, stages: [updatedStage] });
+                        return Future.success(
+                            Questionnaire.updateQuestionnaireStages(questionnaire, [updatedStage])
+                        );
                     } else {
                         return Future.success(questionnaire);
                     }
@@ -143,10 +145,9 @@ export class GetSurveyUseCase {
                         questions: updatedEntityQuestions,
                     };
 
-                    return Future.success({
-                        ...questionnaire,
-                        entity: updatedEntity,
-                    });
+                    return Future.success(
+                        Questionnaire.updateQuestionnaireEntity(questionnaire, updatedEntity)
+                    );
                 });
         } else return this.surveyReporsitory.getForm(programId, undefined, undefined);
     }

src/webapp/components/survey/SurveyForm.tsx

@@ -14,7 +14,7 @@ import { SurveyFormOUSelector } from "./SurveyFormOUSelector";
 import { SurveySection } from "./SurveySection";
 import { useHistory } from "react-router-dom";
 import { Question } from "../../../domain/entities/Questionnaire/QuestionnaireQuestion";
-import { QuestionnaireM } from "../../../domain/entities/Questionnaire/Questionnaire";
+import { Questionnaire } from "../../../domain/entities/Questionnaire/Questionnaire";
 
 export interface SurveyFormProps {
     hideForm: () => void;
@@ -45,7 +45,6 @@ export const SurveyForm: React.FC<SurveyFormProps> = props => {
         currentOrgUnit,
         setCurrentOrgUnit,
         error,
-        addNew,
         shouldDisableSave,
     } = useSurveyForm(props.formType, props.currentSurveyId);
 
@@ -82,10 +81,7 @@ export const SurveyForm: React.FC<SurveyFormProps> = props => {
 
     const updateQuestion = (question: Question) => {
         if (questionnaire) {
-            const updatedQuestionnaire = QuestionnaireM.updateQuestionnaire(
-                questionnaire,
-                question
-            );
+            const updatedQuestionnaire = Questionnaire.updateQuestionnaire(questionnaire, question);
             setQuestionnaire(updatedQuestionnaire);
         }
     };
@@ -128,7 +124,6 @@ export const SurveyForm: React.FC<SurveyFormProps> = props => {
                                         updateQuestion={updateQuestion}
                                         questions={section.questions}
                                         showAddnew={section.showAddnew}
-                                        addNewClick={() => addNew(section)}
                                     />
                                 );
                             })}

src/webapp/components/survey/hook/useSurveyForm.ts

@@ -1,14 +1,10 @@
 import { useEffect, useState } from "react";
 import { useAppContext } from "../../../contexts/app-context";
-import {
-    Questionnaire,
-    QuestionnaireM,
-} from "../../../../domain/entities/Questionnaire/Questionnaire";
+import { Questionnaire } from "../../../../domain/entities/Questionnaire/Questionnaire";
 import { SURVEY_FORM_TYPES } from "../../../../domain/entities/Survey";
 import { OrgUnitAccess } from "../../../../domain/entities/User";
 import { useCurrentSurveys } from "../../../contexts/current-surveys-context";
 import { useHospitalContext } from "../../../contexts/hospital-context";
-import { QuestionnaireSection } from "../../../../domain/entities/Questionnaire/QuestionnaireSection";
 
 export function useSurveyForm(formType: SURVEY_FORM_TYPES, eventId: string | undefined) {
     const { compositionRoot, currentUser } = useAppContext();
@@ -26,51 +22,10 @@ export function useSurveyForm(formType: SURVEY_FORM_TYPES, eventId: string | und
     } = useCurrentSurveys();
     const [error, setError] = useState<string>();
 
-    const addNew = (prevSection: QuestionnaireSection) => {
-        setQuestionnaire(prevQuestionnaire => {
-            if (prevQuestionnaire) {
-                const stageToUpdate = prevQuestionnaire?.stages.find(
-                    stage => stage.code === prevSection.stageId
-                );
-
-                const sectionToUpdate = stageToUpdate?.sections.find(
-                    section => section.sortOrder === prevSection.sortOrder + 1
-                );
-
-                return {
-                    ...prevQuestionnaire,
-                    stages: prevQuestionnaire.stages.map(stage => {
-                        if (stage.code !== stageToUpdate?.code) return stage;
-                        else {
-                            return {
-                                ...stage,
-                                sections: stage.sections.map(section => {
-                                    if (section.code !== sectionToUpdate?.code) return section;
-                                    else {
-                                        return {
-                                            ...section,
-                                            isVisible: true,
-                                            questions: section.questions.map(q => {
-                                                if (q.id === section.showAddQuestion) {
-                                                    q.value = true;
-                                                    return q;
-                                                } else return q;
-                                            }),
-                                        };
-                                    }
-                                }),
-                            };
-                        }
-                    }),
-                };
-            }
-        });
-    };
-
     useEffect(() => {
         if (!questionnaire) setShouldDisableSave(true);
         else {
-            const shouldDisable = QuestionnaireM.doesQuestionnaireHaveErrors(questionnaire);
+            const shouldDisable = Questionnaire.doesQuestionnaireHaveErrors(questionnaire);
             setShouldDisableSave(shouldDisable);
         }
     }, [questionnaire]);
@@ -185,7 +140,6 @@ export function useSurveyForm(formType: SURVEY_FORM_TYPES, eventId: string | und
         setCurrentOrgUnit,
         setLoading,
         error,
-        addNew,
         shouldDisableSave,
     };
 }