_ShortDescription}, e.g. {@code V001_AddSideEffectsQuestion},
+ * zero-padded so lexicographic sort matches numeric order. Give each class a javadoc stating the
+ * business reason for the change — that, plus the class itself, is the permanent changelog.
+ *
+ * Example:
+ * {@code
+ * @Component
+ * public class V001_AddSideEffectsQuestionToTbCounselling implements FormStructureMigration {
+ *
+ * @Override
+ * public String migrationId() {
+ * return "V001";
+ * }
+ *
+ * @Override
+ * public void apply(DynamicFormReconciliationService svc) {
+ * FormVersion version = svc.latestVersion("TB_COUNSELLING")
+ * .orElseThrow(() -> new IllegalStateException(
+ * "TB_COUNSELLING not found — must run after TbCounsellingFormSeeder"));
+ * FormSection section = svc.section(version, "TB_SEC_B")
+ * .orElseThrow(() -> new IllegalStateException("Section TB_SEC_B not found"));
+ *
+ * SectionQuestionDTO question = new SectionQuestionDTO();
+ * question.setQuestionUuid("TB_B_Q7");
+ * question.setQuestionText("Side effects reported?");
+ * question.setQuestionType(QuestionType.RADIO);
+ * question.setOptions(List.of(yesOption, noOption));
+ * svc.ensureQuestion(section, question);
+ * }
+ * }
+ * }
+ */
+public interface FormStructureMigration {
+
+ /** Stable id, e.g. "V001" — the migration-log primary key and the sort key for apply order. Never change it once shipped. */
+ String migrationId();
+
+ /**
+ * Applies this migration's change(s) via the reconciliation service's ensureX methods.
+ * Should remain safe to re-run (ensureX no-ops on rows that already exist) even though the
+ * runner normally calls this only once per migrationId, per the tracking log.
+ */
+ void apply(DynamicFormReconciliationService reconciliationService);
+}
diff --git a/src/main/java/com/iemr/flw/seeder/migration/V001_1_CreateContactTracingVersion2.java b/src/main/java/com/iemr/flw/seeder/migration/V001_1_CreateContactTracingVersion2.java
new file mode 100644
index 000000000..78c7cd645
--- /dev/null
+++ b/src/main/java/com/iemr/flw/seeder/migration/V001_1_CreateContactTracingVersion2.java
@@ -0,0 +1,108 @@
+/*
+ * AMRIT – Accessible Medical Records via Integrated Technology
+ * Integrated EHR (Electronic Health Records) Solution
+ *
+ * Copyright (C) "Piramal Swasthya Management and Research Institute"
+ *
+ * This file is part of AMRIT.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see https://www.gnu.org/licenses/.
+ */
+package com.iemr.flw.seeder.migration;
+
+import com.iemr.flw.domain.iemr.FormVersion;
+import com.iemr.flw.dto.iemr.DynamicFormDTO;
+import com.iemr.flw.dto.iemr.FormSectionDTO;
+import com.iemr.flw.dto.iemr.OptionConditionDTO;
+import com.iemr.flw.dto.iemr.QuestionOptionDTO;
+import com.iemr.flw.dto.iemr.QuestionValidationDTO;
+import com.iemr.flw.dto.iemr.SectionQuestionDTO;
+import com.iemr.flw.service.DynamicFormDefinitionService;
+import com.iemr.flw.service.DynamicFormReconciliationService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+
+/**
+ * Clones the seeded version 1 of both contact tracing forms — Community Contact Tracing and
+ * Occupational Contact Tracing — into a new version 2, so the later structural changes to them are
+ * applied to version 2 only and version 1 stays exactly as the seeders created it:
+ * COMMUNITY_CONTACT_TRACING (V002, V003, V006, V007, V008) and OCCUPATION_CONTACT_TRACING (V002, V004,
+ * V005). Responses keep the versionId they were submitted against; new responses and the app use the
+ * latest version.
+ *
+ * Id "V001_1" sorts between V001 and V002, so this runs before the first migration that touches
+ * either form — every migration resolves a form via {@code latestVersion}, which is version 2 from
+ * here on.
+ *
+ * Uses {@link DynamicFormDefinitionService#updateForm}, which copies every section, question, option,
+ * validation and condition into a new version and marks the current one isLatest=false. All ids are
+ * cleared from the version-1 DTO first: the mapper copies them onto the new entities, and saving an
+ * entity with an existing id would move that version-1 row into version 2 instead of copying it.
+ * Conditions are re-wired by targetQuestionUuid/targetSectionUuid, which are kept.
+ */
+@Component
+@RequiredArgsConstructor
+public class V001_1_CreateContactTracingVersion2 implements FormStructureMigration {
+
+ private static final List FORM_UUIDS = List.of(
+ "COMMUNITY_CONTACT_TRACING",
+ "OCCUPATION_CONTACT_TRACING");
+
+ private final DynamicFormDefinitionService definitionService;
+
+ @Override
+ public String migrationId() {
+ return "V001_1";
+ }
+
+ @Override
+ public void apply(DynamicFormReconciliationService svc) {
+ FORM_UUIDS.forEach(formUuid -> createVersion2(svc, formUuid));
+ }
+
+ private void createVersion2(DynamicFormReconciliationService svc, String formUuid) {
+ FormVersion latest = svc.latestVersion(formUuid)
+ .orElseThrow(() -> new IllegalStateException(formUuid + " not found — must run after its seeder"));
+ if (latest.getVersionNumber() > 1) {
+ return;
+ }
+
+ Long formId = latest.getDynamicForm().getFormId();
+ DynamicFormDTO version1 = definitionService.getFormDefinition(formId);
+ clearIds(version1);
+ definitionService.updateForm(formId, version1);
+ }
+
+ private void clearIds(DynamicFormDTO form) {
+ for (FormSectionDTO section : form.getSections()) {
+ section.setSectionId(null);
+ for (SectionQuestionDTO question : section.getQuestions()) {
+ question.setQuestionId(null);
+ for (QuestionValidationDTO validation : question.getValidations()) {
+ validation.setValidationId(null);
+ }
+ for (QuestionOptionDTO option : question.getOptions()) {
+ option.setOptionId(null);
+ for (OptionConditionDTO condition : option.getConditions()) {
+ condition.setConditionId(null);
+ condition.setTargetQuestionId(null);
+ condition.setTargetSectionId(null);
+ }
+ }
+ }
+ }
+ }
+}
diff --git a/src/main/java/com/iemr/flw/seeder/migration/V001_ReplaceTfuAdrOptions.java b/src/main/java/com/iemr/flw/seeder/migration/V001_ReplaceTfuAdrOptions.java
new file mode 100644
index 000000000..6fc90ff6e
--- /dev/null
+++ b/src/main/java/com/iemr/flw/seeder/migration/V001_ReplaceTfuAdrOptions.java
@@ -0,0 +1,104 @@
+/*
+ * AMRIT – Accessible Medical Records via Integrated Technology
+ * Integrated EHR (Electronic Health Records) Solution
+ *
+ * Copyright (C) "Piramal Swasthya Management and Research Institute"
+ *
+ * This file is part of AMRIT.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see https://www.gnu.org/licenses/.
+ */
+package com.iemr.flw.seeder.migration;
+
+import com.iemr.flw.domain.iemr.FormSection;
+import com.iemr.flw.domain.iemr.FormVersion;
+import com.iemr.flw.domain.iemr.SectionQuestion;
+import com.iemr.flw.dto.iemr.QuestionOptionDTO;
+import com.iemr.flw.service.DynamicFormReconciliationService;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+
+/**
+ * Replaces the TPT Follow Up form's "Adverse Drug Reactions" (TFU_ADR) option list with the
+ * clinically revised set of symptoms, per the updated ADR checklist supplied for this form.
+ *
+ * 7 of the 24 existing options already match the new list exactly (same wording) and are left
+ * untouched by {@code ensureOption}'s natural-key match: NAUSEA, VOMITING, ABDOMINAL_PAIN,
+ * DARK_COLOUR_URINE, ITCHING, TINGLING_BURNING_NUMBNESS_HANDS_FEET, FLU_LIKE_SYNDROME. The other
+ * 17 old options are no longer part of the revised list and are soft-removed (never hard-deleted —
+ * historical responses may reference them); the 13 new options are added.
+ */
+@Component
+public class V001_ReplaceTfuAdrOptions implements FormStructureMigration {
+
+ private static final List REMOVED_OPTION_VALUES = List.of(
+ "UNKNOWN",
+ "FLU_LIKE_SYNDROME_WITH_DIZZINESS_HEADACHE",
+ "YELLOWISH_DISCOLORATION_SKIN_EYES",
+ "DISCOLORATION_BODY_FLUIDS",
+ "PALE_STOOL",
+ "SKIN_RASH",
+ "SLEEPINESS_LETHARGY",
+ "PERSISTENT_UNFORMED_WATERY_STOOLS",
+ "MENTAL_CHANGES_SIGNS_BLEEDING",
+ "CONVULSIONS",
+ "ANAEMIA",
+ "ARTHRALGIA",
+ "DECREASED_APPETITE",
+ "HYPOTENSION_SYNCOPE",
+ "CONJUCTIVITIES",
+ "SHOCK",
+ "NONE_REPORTED");
+
+ @Override
+ public String migrationId() {
+ return "V001";
+ }
+
+ @Override
+ public void apply(DynamicFormReconciliationService svc) {
+ FormVersion version = svc.latestVersion("TPT_FOLLOW_UP")
+ .orElseThrow(() -> new IllegalStateException(
+ "TPT_FOLLOW_UP not found — must run after TptFollowUpFormSeeder"));
+ FormSection section = svc.section(version, "TFU_SEC_2")
+ .orElseThrow(() -> new IllegalStateException("Section TFU_SEC_2 not found"));
+ SectionQuestion question = svc.question(section, "TFU_ADR")
+ .orElseThrow(() -> new IllegalStateException("Question TFU_ADR not found"));
+
+ REMOVED_OPTION_VALUES.forEach(value -> svc.option(question, value)
+ .ifPresent(opt -> svc.removeOption(opt.getOptionId())));
+
+ addOption(svc, question, "Yellowness of Skin", "YELLOWNESS_OF_SKIN");
+ addOption(svc, question, "Loose motions >4 times in a day", "LOOSE_MOTIONS_GT4_PER_DAY");
+ addOption(svc, question, "Rashes", "RASHES");
+ addOption(svc, question, "Pain in Joints", "PAIN_IN_JOINTS");
+ addOption(svc, question, "Impaired vision: Pain, Blurring of vision, Disturbance in colour vision", "IMPAIRED_VISION");
+ addOption(svc, question, "Swelling of face or legs, Less or no urine", "SWELLING_FACE_LEGS_LESS_NO_URINE");
+ addOption(svc, question, "Seeing abnormal things, changes of thoughts, suicidal thoughts", "ABNORMAL_THOUGHTS_SUICIDAL");
+ addOption(svc, question, "Tiredness, lethargy, headache, giddiness, pale look, palpitations", "TIREDNESS_LETHARGY_GIDDINESS_PALPITATIONS");
+ addOption(svc, question, "Ringing in ears, Loss of hearing, dizziness and loss of balance leading to recurrent fall", "TINNITUS_HEARING_LOSS_DIZZINESS_FALL");
+ addOption(svc, question, "Slowness of activities, Swelling of face or neck, dis-appropriate weight gain", "SLOWNESS_FACIAL_NECK_SWELLING_WEIGHT_GAIN");
+ addOption(svc, question, "Pain and swelling in muscles and Tendons, difficulty in movement", "MUSCLE_TENDON_PAIN_SWELLING");
+ addOption(svc, question, "Convulsion", "CONVULSION");
+ addOption(svc, question, "Orange and red color of urine, sweat, sputum, saliva or tears", "ORANGE_RED_DISCOLORATION_BODY_FLUIDS");
+ }
+
+ private void addOption(DynamicFormReconciliationService svc, SectionQuestion question, String label, String value) {
+ QuestionOptionDTO dto = new QuestionOptionDTO();
+ dto.setOptionLabel(label);
+ dto.setOptionValue(value);
+ svc.ensureOption(question, dto);
+ }
+}
diff --git a/src/main/java/com/iemr/flw/seeder/migration/V002_RenameNoOfContactsQuestion.java b/src/main/java/com/iemr/flw/seeder/migration/V002_RenameNoOfContactsQuestion.java
new file mode 100644
index 000000000..836c1b1e3
--- /dev/null
+++ b/src/main/java/com/iemr/flw/seeder/migration/V002_RenameNoOfContactsQuestion.java
@@ -0,0 +1,83 @@
+/*
+ * AMRIT – Accessible Medical Records via Integrated Technology
+ * Integrated EHR (Electronic Health Records) Solution
+ *
+ * Copyright (C) "Piramal Swasthya Management and Research Institute"
+ *
+ * This file is part of AMRIT.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see https://www.gnu.org/licenses/.
+ */
+package com.iemr.flw.seeder.migration;
+
+import com.iemr.flw.domain.iemr.FormSection;
+import com.iemr.flw.domain.iemr.FormVersion;
+import com.iemr.flw.domain.iemr.SectionQuestion;
+import com.iemr.flw.dto.iemr.SectionQuestionDTO;
+import com.iemr.flw.service.DynamicFormReconciliationService;
+import org.springframework.stereotype.Component;
+
+/**
+ * Renames the "No. of contacts" question to "Total No. of contacts" (and its Hindi translation)
+ * in both the Community Contact Tracing (CCT_NO_OF_CONTACTS) and Occupational Contact Tracing
+ * (OCT_NO_OF_CONTACTS) forms, per the revised field-label wording supplied for these forms.
+ *
+ * Only the label text changes — type, mandatoriness and position are read off the existing row
+ * and passed back unchanged, since {@code updateQuestion} overwrites all of its scalar fields
+ * unconditionally.
+ */
+@Component
+public class V002_RenameNoOfContactsQuestion implements FormStructureMigration {
+
+ private static final String NEW_TEXT = "Total No. of contacts";
+ private static final String NEW_TEXT_HINDI = "कुल संपर्कों की संख्या";
+
+ @Override
+ public String migrationId() {
+ return "V002";
+ }
+
+ @Override
+ public void apply(DynamicFormReconciliationService svc) {
+ renameQuestion(svc, "COMMUNITY_CONTACT_TRACING", "CCT_SEC_1", "CCT_NO_OF_CONTACTS");
+ renameQuestion(svc, "OCCUPATION_CONTACT_TRACING", "OCT_SEC_1", "OCT_NO_OF_CONTACTS");
+ }
+
+ private void renameQuestion(DynamicFormReconciliationService svc, String formUuid, String sectionUuid,
+ String questionUuid) {
+ FormVersion version = svc.latestVersion(formUuid)
+ .orElseThrow(() -> new IllegalStateException(
+ formUuid + " not found — must run after its seeder"));
+ FormSection section = svc.section(version, sectionUuid)
+ .orElseThrow(() -> new IllegalStateException("Section " + sectionUuid + " not found"));
+ SectionQuestion question = svc.question(section, questionUuid)
+ .orElseThrow(() -> new IllegalStateException("Question " + questionUuid + " not found"));
+
+ if (NEW_TEXT.equals(question.getQuestionText()) && NEW_TEXT_HINDI.equals(question.getQuestionTextHindi())) {
+ return;
+ }
+
+ SectionQuestionDTO dto = new SectionQuestionDTO();
+ dto.setQuestionText(NEW_TEXT);
+ dto.setQuestionTextHindi(NEW_TEXT_HINDI);
+ dto.setQuestionType(question.getQuestionType());
+ dto.setIsMandatory(question.getIsMandatory());
+ dto.setMaxLength(question.getMaxLength());
+ dto.setDefaultValue(question.getDefaultValue());
+ dto.setContainsPii(question.getContainsPii());
+ dto.setDisplayOrder(question.getDisplayOrder());
+
+ svc.updateQuestion(question.getQuestionId(), dto);
+ }
+}
diff --git a/src/main/java/com/iemr/flw/seeder/migration/V003_ChangeExposureSettingToDropdownMulti.java b/src/main/java/com/iemr/flw/seeder/migration/V003_ChangeExposureSettingToDropdownMulti.java
new file mode 100644
index 000000000..ba69d37b4
--- /dev/null
+++ b/src/main/java/com/iemr/flw/seeder/migration/V003_ChangeExposureSettingToDropdownMulti.java
@@ -0,0 +1,76 @@
+/*
+ * AMRIT – Accessible Medical Records via Integrated Technology
+ * Integrated EHR (Electronic Health Records) Solution
+ *
+ * Copyright (C) "Piramal Swasthya Management and Research Institute"
+ *
+ * This file is part of AMRIT.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see https://www.gnu.org/licenses/.
+ */
+package com.iemr.flw.seeder.migration;
+
+import com.iemr.flw.domain.iemr.FormSection;
+import com.iemr.flw.domain.iemr.FormVersion;
+import com.iemr.flw.domain.iemr.SectionQuestion;
+import com.iemr.flw.dto.iemr.SectionQuestionDTO;
+import com.iemr.flw.masterEnum.QuestionType;
+import com.iemr.flw.service.DynamicFormReconciliationService;
+import org.springframework.stereotype.Component;
+
+/**
+ * Changes the Community Contact Tracing form's "Place of exposure" question (CCT_EXPOSURE_SETTING)
+ * from CHECKBOX_MULTI to DROPDOWN_MULTI, so the 12 place options render as a multi-select dropdown
+ * instead of a long checkbox list.
+ *
+ * Both types submit {@code optionValues} and store one response row per selected option, so
+ * existing responses remain valid. Options and the OTHER_PLACE → CCT_EXPOSURE_SETTING_OTHER
+ * conditional rule are untouched. All other scalar fields are read off the existing row and passed
+ * back unchanged, since {@code updateQuestion} overwrites all of them unconditionally.
+ */
+@Component
+public class V003_ChangeExposureSettingToDropdownMulti implements FormStructureMigration {
+
+ @Override
+ public String migrationId() {
+ return "V003";
+ }
+
+ @Override
+ public void apply(DynamicFormReconciliationService svc) {
+ FormVersion version = svc.latestVersion("COMMUNITY_CONTACT_TRACING")
+ .orElseThrow(() -> new IllegalStateException(
+ "COMMUNITY_CONTACT_TRACING not found — must run after CommunityContactTracingFormSeeder"));
+ FormSection section = svc.section(version, "CCT_SEC_1")
+ .orElseThrow(() -> new IllegalStateException("Section CCT_SEC_1 not found"));
+ SectionQuestion question = svc.question(section, "CCT_EXPOSURE_SETTING")
+ .orElseThrow(() -> new IllegalStateException("Question CCT_EXPOSURE_SETTING not found"));
+
+ if (question.getQuestionType() == QuestionType.DROPDOWN_MULTI) {
+ return;
+ }
+
+ SectionQuestionDTO dto = new SectionQuestionDTO();
+ dto.setQuestionText(question.getQuestionText());
+ dto.setQuestionTextHindi(question.getQuestionTextHindi());
+ dto.setQuestionType(QuestionType.DROPDOWN_MULTI);
+ dto.setIsMandatory(question.getIsMandatory());
+ dto.setMaxLength(question.getMaxLength());
+ dto.setDefaultValue(question.getDefaultValue());
+ dto.setContainsPii(question.getContainsPii());
+ dto.setDisplayOrder(question.getDisplayOrder());
+
+ svc.updateQuestion(question.getQuestionId(), dto);
+ }
+}
diff --git a/src/main/java/com/iemr/flw/seeder/migration/V004_ChangeOccupationToDropdown.java b/src/main/java/com/iemr/flw/seeder/migration/V004_ChangeOccupationToDropdown.java
new file mode 100644
index 000000000..24db1f454
--- /dev/null
+++ b/src/main/java/com/iemr/flw/seeder/migration/V004_ChangeOccupationToDropdown.java
@@ -0,0 +1,76 @@
+/*
+ * AMRIT – Accessible Medical Records via Integrated Technology
+ * Integrated EHR (Electronic Health Records) Solution
+ *
+ * Copyright (C) "Piramal Swasthya Management and Research Institute"
+ *
+ * This file is part of AMRIT.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see https://www.gnu.org/licenses/.
+ */
+package com.iemr.flw.seeder.migration;
+
+import com.iemr.flw.domain.iemr.FormSection;
+import com.iemr.flw.domain.iemr.FormVersion;
+import com.iemr.flw.domain.iemr.SectionQuestion;
+import com.iemr.flw.dto.iemr.SectionQuestionDTO;
+import com.iemr.flw.masterEnum.QuestionType;
+import com.iemr.flw.service.DynamicFormReconciliationService;
+import org.springframework.stereotype.Component;
+
+/**
+ * Changes the Occupational Contact Tracing form's "Occupation" question (OCT_OCCUPATION) from RADIO
+ * to DROPDOWN, so the 11 occupation options render as a single-select dropdown instead of a long
+ * radio list.
+ *
+ * Both types submit a single {@code optionValue} and store one response row, so existing responses
+ * remain valid. Options and their conditional rules (address questions, OTHER_OCCUPATION →
+ * OCT_OCCUPATION_OTHER) are untouched. All other scalar fields are read off the existing row and
+ * passed back unchanged, since {@code updateQuestion} overwrites all of them unconditionally.
+ */
+@Component
+public class V004_ChangeOccupationToDropdown implements FormStructureMigration {
+
+ @Override
+ public String migrationId() {
+ return "V004";
+ }
+
+ @Override
+ public void apply(DynamicFormReconciliationService svc) {
+ FormVersion version = svc.latestVersion("OCCUPATION_CONTACT_TRACING")
+ .orElseThrow(() -> new IllegalStateException(
+ "OCCUPATION_CONTACT_TRACING not found — must run after OccupationalContactTracingFormSeeder"));
+ FormSection section = svc.section(version, "OCT_SEC_1")
+ .orElseThrow(() -> new IllegalStateException("Section OCT_SEC_1 not found"));
+ SectionQuestion question = svc.question(section, "OCT_OCCUPATION")
+ .orElseThrow(() -> new IllegalStateException("Question OCT_OCCUPATION not found"));
+
+ if (question.getQuestionType() == QuestionType.DROPDOWN) {
+ return;
+ }
+
+ SectionQuestionDTO dto = new SectionQuestionDTO();
+ dto.setQuestionText(question.getQuestionText());
+ dto.setQuestionTextHindi(question.getQuestionTextHindi());
+ dto.setQuestionType(QuestionType.DROPDOWN);
+ dto.setIsMandatory(question.getIsMandatory());
+ dto.setMaxLength(question.getMaxLength());
+ dto.setDefaultValue(question.getDefaultValue());
+ dto.setContainsPii(question.getContainsPii());
+ dto.setDisplayOrder(question.getDisplayOrder());
+
+ svc.updateQuestion(question.getQuestionId(), dto);
+ }
+}
diff --git a/src/main/java/com/iemr/flw/seeder/migration/V005_AddAreaOfSharedSpaceQuestion.java b/src/main/java/com/iemr/flw/seeder/migration/V005_AddAreaOfSharedSpaceQuestion.java
new file mode 100644
index 000000000..11a6a3d0c
--- /dev/null
+++ b/src/main/java/com/iemr/flw/seeder/migration/V005_AddAreaOfSharedSpaceQuestion.java
@@ -0,0 +1,115 @@
+/*
+ * AMRIT – Accessible Medical Records via Integrated Technology
+ * Integrated EHR (Electronic Health Records) Solution
+ *
+ * Copyright (C) "Piramal Swasthya Management and Research Institute"
+ *
+ * This file is part of AMRIT.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see https://www.gnu.org/licenses/.
+ */
+package com.iemr.flw.seeder.migration;
+
+import com.iemr.flw.domain.iemr.FormSection;
+import com.iemr.flw.domain.iemr.FormVersion;
+import com.iemr.flw.domain.iemr.QuestionOption;
+import com.iemr.flw.domain.iemr.SectionQuestion;
+import com.iemr.flw.dto.iemr.OptionConditionDTO;
+import com.iemr.flw.dto.iemr.QuestionValidationDTO;
+import com.iemr.flw.dto.iemr.SectionQuestionDTO;
+import com.iemr.flw.masterEnum.QuestionType;
+import com.iemr.flw.masterEnum.ValidationType;
+import com.iemr.flw.service.DynamicFormReconciliationService;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+
+/**
+ * Adds an "Approximate Area of Shared Space" question to the Occupational Contact Tracing form,
+ * directly after "Type of Space" (OCT_TYPE_OF_SPACE), per the revised criteria for this form:
+ * enabled once a Type of Space is selected, whole square metres only, accepted range 50–5000.
+ *
+ * Mapped to Type of Space as a condition: hidden by default, and each of the 3 OCT_TYPE_OF_SPACE
+ * options reveals it (SHOW_QUESTION) and makes it mandatory (MANDATORY_IF) — conditions attach to
+ * options, so "any Type of Space selected" is one condition per option, all targeting this single
+ * question. Conventions used, since questions carry no dedicated fields for these:
+ * the helper text is stored in {@code defaultValue}, and the unit as a {@link ValidationType#UNIT}
+ * validation whose {@code validationParam} is the unit label.
+ *
+ * Inserted at display order 7 — {@code ensureQuestion} shifts "Daily duration of contact" to 8 and
+ * "Remarks" to 9.
+ */
+@Component
+public class V005_AddAreaOfSharedSpaceQuestion implements FormStructureMigration {
+
+ private static final String QUESTION_UUID = "OCT_AREA_OF_SHARED_SPACE";
+
+ private static final List TYPE_OF_SPACE_VALUES = List.of(
+ "OPEN_SPACE",
+ "CLOSED_SPACE_VENTILATED",
+ "CLOSED_SPACE_NOT_VENTILATED");
+
+ @Override
+ public String migrationId() {
+ return "V005";
+ }
+
+ @Override
+ public void apply(DynamicFormReconciliationService svc) {
+ FormVersion version = svc.latestVersion("OCCUPATION_CONTACT_TRACING")
+ .orElseThrow(() -> new IllegalStateException(
+ "OCCUPATION_CONTACT_TRACING not found — must run after OccupationalContactTracingFormSeeder"));
+ FormSection section = svc.section(version, "OCT_SEC_1")
+ .orElseThrow(() -> new IllegalStateException("Section OCT_SEC_1 not found"));
+ SectionQuestion typeOfSpace = svc.question(section, "OCT_TYPE_OF_SPACE")
+ .orElseThrow(() -> new IllegalStateException("Question OCT_TYPE_OF_SPACE not found"));
+
+ SectionQuestionDTO dto = new SectionQuestionDTO();
+ dto.setQuestionUuid(QUESTION_UUID);
+ dto.setQuestionText("Approximate Area of Shared Space");
+ dto.setQuestionTextHindi("साझा स्थान का अनुमानित क्षेत्रफल");
+ dto.setQuestionType(QuestionType.NUMBER_PICKER);
+ dto.setDefaultValue("Give estimated measurement of area");
+ dto.setIsMandatory(true);
+ dto.setDisplayOrder(7);
+ dto.setVisibleByDefault(false);
+ dto.setOptions(List.of());
+ dto.setValidations(List.of());
+ SectionQuestion area = svc.ensureQuestion(section, dto);
+
+ svc.ensureValidation(area, validation(ValidationType.REGEX,
+ "^([5-9][0-9]|[1-9][0-9]{2}|[1-4][0-9]{3}|5000)$", "Enter a value between 50 and 5000."));
+ svc.ensureValidation(area, validation(ValidationType.UNIT, "sq. m.", "Value is in sq. m."));
+
+ for (String value : TYPE_OF_SPACE_VALUES) {
+ svc.ensureValidation(area, validation(ValidationType.MANDATORY_IF,
+ "OCT_TYPE_OF_SPACE=" + value, "This field is mandatory"));
+
+ QuestionOption option = svc.option(typeOfSpace, value)
+ .orElseThrow(() -> new IllegalStateException("Option OCT_TYPE_OF_SPACE=" + value + " not found"));
+ OptionConditionDTO show = new OptionConditionDTO();
+ show.setActionType("SHOW_QUESTION");
+ show.setTargetQuestionUuid(QUESTION_UUID);
+ svc.ensureCondition(option, show, version);
+ }
+ }
+
+ private QuestionValidationDTO validation(ValidationType type, String param, String errorMessage) {
+ QuestionValidationDTO v = new QuestionValidationDTO();
+ v.setValidationType(type);
+ v.setValidationParam(param);
+ v.setErrorMessage(errorMessage);
+ return v;
+ }
+}
diff --git a/src/main/java/com/iemr/flw/seeder/migration/V006_PerRelationshipTypeOfSpace.java b/src/main/java/com/iemr/flw/seeder/migration/V006_PerRelationshipTypeOfSpace.java
new file mode 100644
index 000000000..822ea0867
--- /dev/null
+++ b/src/main/java/com/iemr/flw/seeder/migration/V006_PerRelationshipTypeOfSpace.java
@@ -0,0 +1,172 @@
+/*
+ * AMRIT – Accessible Medical Records via Integrated Technology
+ * Integrated EHR (Electronic Health Records) Solution
+ *
+ * Copyright (C) "Piramal Swasthya Management and Research Institute"
+ *
+ * This file is part of AMRIT.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see https://www.gnu.org/licenses/.
+ */
+package com.iemr.flw.seeder.migration;
+
+import com.iemr.flw.domain.iemr.FormSection;
+import com.iemr.flw.domain.iemr.FormVersion;
+import com.iemr.flw.domain.iemr.QuestionOption;
+import com.iemr.flw.domain.iemr.SectionQuestion;
+import com.iemr.flw.dto.iemr.OptionConditionDTO;
+import com.iemr.flw.dto.iemr.QuestionOptionDTO;
+import com.iemr.flw.dto.iemr.QuestionValidationDTO;
+import com.iemr.flw.dto.iemr.SectionQuestionDTO;
+import com.iemr.flw.masterEnum.QuestionType;
+import com.iemr.flw.masterEnum.ValidationType;
+import com.iemr.flw.service.DynamicFormReconciliationService;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+
+/**
+ * Replaces the Community Contact Tracing form's single, standalone "Type of Space" question
+ * (CCT_TYPE_OF_SPACE) with one per "Relationship with community contacts" (CCT_RELATIONSHIP)
+ * option, each followed by its own "Approximate Area of Shared Space", so the exposure setting is
+ * captured per relationship type:
+ *
+ *
+ * CCT_RELATIONSHIP=<R> ─ SHOW_QUESTION ─► CCT_TYPE_OF_SPACE_<R>
+ * └─ each option ─ SHOW_QUESTION ─► CCT_AREA_OF_SHARED_SPACE_<R>
+ *
+ *
+ * The old CCT_TYPE_OF_SPACE is soft-removed (never hard-deleted — historical responses may
+ * reference it). The 14 new questions (a Type of Space / Area pair per relationship) are inserted
+ * into its slot, all hidden by default and mandatory only when revealed (MANDATORY_IF). Area
+ * questions follow V006's conventions: helper text in {@code defaultValue}, unit as a
+ * {@link ValidationType#UNIT} validation, whole square metres 50–5000.
+ */
+@Component
+public class V006_PerRelationshipTypeOfSpace implements FormStructureMigration {
+
+ private static final List RELATIONSHIP_VALUES = List.of(
+ "NEIGHBOUR",
+ "FRIEND",
+ "FELLOW_WORSHIPPER",
+ "FELLOW_COMMUTER",
+ "COMMUNITY_GROUP_MEMBER",
+ "FELLOW_PATIENT",
+ "OTHER");
+
+ /** {label, labelHindi, value} — same options as the retired CCT_TYPE_OF_SPACE. */
+ private static final List TYPE_OF_SPACE_OPTIONS = List.of(
+ new String[] {"Open space", "खुला स्थान", "OPEN_SPACE"},
+ new String[] {"Closed space with ventilation", "वेंटिलेशन के साथ बंद स्थान", "CLOSED_SPACE_VENTILATED"},
+ new String[] {"Closed space with no ventilation", "बिना वेंटिलेशन के बंद स्थान", "CLOSED_SPACE_NOT_VENTILATED"});
+
+ private static final String AREA_REGEX = "^([5-9][0-9]|[1-9][0-9]{2}|[1-4][0-9]{3}|5000)$";
+ private static final String MANDATORY_ERROR = "This field is mandatory";
+
+ @Override
+ public String migrationId() {
+ return "V006";
+ }
+
+ @Override
+ public void apply(DynamicFormReconciliationService svc) {
+ FormVersion version = svc.latestVersion("COMMUNITY_CONTACT_TRACING")
+ .orElseThrow(() -> new IllegalStateException(
+ "COMMUNITY_CONTACT_TRACING not found — must run after CommunityContactTracingFormSeeder"));
+ FormSection section = svc.section(version, "CCT_SEC_1")
+ .orElseThrow(() -> new IllegalStateException("Section CCT_SEC_1 not found"));
+ SectionQuestion relationship = svc.question(section, "CCT_RELATIONSHIP")
+ .orElseThrow(() -> new IllegalStateException("Question CCT_RELATIONSHIP not found"));
+ SectionQuestion oldTypeOfSpace = svc.question(section, "CCT_TYPE_OF_SPACE")
+ .orElseThrow(() -> new IllegalStateException("Question CCT_TYPE_OF_SPACE not found"));
+
+ int base = oldTypeOfSpace.getDisplayOrder();
+ if (Boolean.TRUE.equals(oldTypeOfSpace.getIsActive())) {
+ svc.unlinkQuestion(oldTypeOfSpace.getQuestionId());
+ }
+
+ for (int i = 0; i < RELATIONSHIP_VALUES.size(); i++) {
+ String r = RELATIONSHIP_VALUES.get(i);
+ String typeOfSpaceUuid = "CCT_TYPE_OF_SPACE_" + r;
+ String areaUuid = "CCT_AREA_OF_SHARED_SPACE_" + r;
+
+ // Type of Space for this relationship — revealed by CCT_RELATIONSHIP=
+ SectionQuestion typeOfSpace = svc.ensureQuestion(section, question(typeOfSpaceUuid,
+ "Type of Space", "स्थान का प्रकार", QuestionType.RADIO, null, base + 1 + 2 * i));
+ svc.ensureValidation(typeOfSpace, validation(ValidationType.MANDATORY_IF,
+ "CCT_RELATIONSHIP=" + r, MANDATORY_ERROR));
+ QuestionOption relationshipOption = svc.option(relationship, r)
+ .orElseThrow(() -> new IllegalStateException("Option CCT_RELATIONSHIP=" + r + " not found"));
+ svc.ensureCondition(relationshipOption, showQuestion(typeOfSpaceUuid), version);
+
+ // Approximate Area of Shared Space for this relationship — revealed by any of its Type of Space options
+ SectionQuestion area = svc.ensureQuestion(section, question(areaUuid,
+ "Approximate Area of Shared Space", "साझा स्थान का अनुमानित क्षेत्रफल", QuestionType.NUMBER_PICKER,
+ "Give estimated measurement of area", base + 2 + 2 * i));
+ svc.ensureValidation(area, validation(ValidationType.REGEX, AREA_REGEX, "Enter a value between 50 and 5000."));
+ svc.ensureValidation(area, validation(ValidationType.UNIT, "sq. m.", "Value is in sq. m."));
+
+ for (int j = 0; j < TYPE_OF_SPACE_OPTIONS.size(); j++) {
+ String[] o = TYPE_OF_SPACE_OPTIONS.get(j);
+ QuestionOption spaceOption = svc.ensureOption(typeOfSpace, option(o[0], o[1], o[2], j + 1));
+ svc.ensureValidation(area, validation(ValidationType.MANDATORY_IF,
+ typeOfSpaceUuid + "=" + o[2], MANDATORY_ERROR));
+ svc.ensureCondition(spaceOption, showQuestion(areaUuid), version);
+ }
+ }
+
+ }
+
+ private SectionQuestionDTO question(String uuid, String text, String textHindi, QuestionType type,
+ String defaultValue, int order) {
+ SectionQuestionDTO q = new SectionQuestionDTO();
+ q.setQuestionUuid(uuid);
+ q.setQuestionText(text);
+ q.setQuestionTextHindi(textHindi);
+ q.setQuestionType(type);
+ q.setDefaultValue(defaultValue);
+ q.setIsMandatory(true);
+ q.setDisplayOrder(order);
+ q.setVisibleByDefault(false);
+ q.setOptions(List.of());
+ q.setValidations(List.of());
+ return q;
+ }
+
+ private QuestionOptionDTO option(String label, String labelHindi, String value, int order) {
+ QuestionOptionDTO o = new QuestionOptionDTO();
+ o.setOptionLabel(label);
+ o.setOptionLabelHindi(labelHindi);
+ o.setOptionValue(value);
+ o.setOptionValueHindi(labelHindi);
+ o.setDisplayOrder(order);
+ o.setConditions(List.of());
+ return o;
+ }
+
+ private QuestionValidationDTO validation(ValidationType type, String param, String errorMessage) {
+ QuestionValidationDTO v = new QuestionValidationDTO();
+ v.setValidationType(type);
+ v.setValidationParam(param);
+ v.setErrorMessage(errorMessage);
+ return v;
+ }
+
+ private OptionConditionDTO showQuestion(String targetQuestionUuid) {
+ OptionConditionDTO c = new OptionConditionDTO();
+ c.setActionType("SHOW_QUESTION");
+ c.setTargetQuestionUuid(targetQuestionUuid);
+ return c;
+ }
+}
diff --git a/src/main/java/com/iemr/flw/seeder/migration/V007_AddRelationshipHoursQuestions.java b/src/main/java/com/iemr/flw/seeder/migration/V007_AddRelationshipHoursQuestions.java
new file mode 100644
index 000000000..3486eea07
--- /dev/null
+++ b/src/main/java/com/iemr/flw/seeder/migration/V007_AddRelationshipHoursQuestions.java
@@ -0,0 +1,129 @@
+/*
+ * AMRIT – Accessible Medical Records via Integrated Technology
+ * Integrated EHR (Electronic Health Records) Solution
+ *
+ * Copyright (C) "Piramal Swasthya Management and Research Institute"
+ *
+ * This file is part of AMRIT.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see https://www.gnu.org/licenses/.
+ */
+package com.iemr.flw.seeder.migration;
+
+import com.iemr.flw.domain.iemr.FormSection;
+import com.iemr.flw.domain.iemr.FormVersion;
+import com.iemr.flw.domain.iemr.QuestionOption;
+import com.iemr.flw.domain.iemr.SectionQuestion;
+import com.iemr.flw.dto.iemr.OptionConditionDTO;
+import com.iemr.flw.dto.iemr.QuestionValidationDTO;
+import com.iemr.flw.dto.iemr.SectionQuestionDTO;
+import com.iemr.flw.masterEnum.QuestionType;
+import com.iemr.flw.masterEnum.ValidationType;
+import com.iemr.flw.service.DynamicFormReconciliationService;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+
+/**
+ * Adds a mandatory "Time spent with contact in hours" number picker to the Community Contact
+ * Tracing form for each "Relationship with community contacts" (CCT_RELATIONSHIP) option, so the
+ * exposure duration is captured per relationship type alongside its existing contact count.
+ *
+ * One question per option (CCT_RELATIONSHIP_HOURS_<OPTION_VALUE>) rather than a shared one,
+ * since CCT_RELATIONSHIP is multi-select and a shared field couldn't disambiguate which duration
+ * belongs to which relationship. Each is hidden by default, revealed by a SHOW_QUESTION condition
+ * on its option, and mandatory only when that option is selected (MANDATORY_IF).
+ *
+ * Each question is inserted directly after its relationship's "Approximate Area of Shared Space"
+ * (CCT_AREA_OF_SHARED_SPACE_<OPTION_VALUE>), so every relationship's revealed questions read
+ * Type of Space, Area, Time spent; {@code ensureQuestion} shifts everything after it down by one.
+ * Must run after V006_PerRelationshipTypeOfSpace, which creates those Area questions — and since it
+ * runs later, each option's SHOW_QUESTION conditions are also created in that same order.
+ */
+@Component
+public class V007_AddRelationshipHoursQuestions implements FormStructureMigration {
+
+ private static final List RELATIONSHIP_VALUES = List.of(
+ "NEIGHBOUR",
+ "FRIEND",
+ "FELLOW_WORSHIPPER",
+ "FELLOW_COMMUTER",
+ "COMMUNITY_GROUP_MEMBER",
+ "FELLOW_PATIENT",
+ "OTHER");
+
+ private static final String QUESTION_TEXT = "Time spent with contact in hours";
+ private static final String QUESTION_TEXT_HINDI = "संपर्क के साथ बिताया गया समय (घंटों में)";
+ private static final String HOURS_REGEX = "^([0-9]|1[0-9]|2[0-4])$";
+ private static final String HOURS_ERROR = "Enter whole hours between 0 and 24";
+
+ @Override
+ public String migrationId() {
+ return "V007";
+ }
+
+ @Override
+ public void apply(DynamicFormReconciliationService svc) {
+ FormVersion version = svc.latestVersion("COMMUNITY_CONTACT_TRACING")
+ .orElseThrow(() -> new IllegalStateException(
+ "COMMUNITY_CONTACT_TRACING not found — must run after CommunityContactTracingFormSeeder"));
+ FormSection section = svc.section(version, "CCT_SEC_1")
+ .orElseThrow(() -> new IllegalStateException("Section CCT_SEC_1 not found"));
+ SectionQuestion relationship = svc.question(section, "CCT_RELATIONSHIP")
+ .orElseThrow(() -> new IllegalStateException("Question CCT_RELATIONSHIP not found"));
+
+ for (String value : RELATIONSHIP_VALUES) {
+ String questionUuid = "CCT_RELATIONSHIP_HOURS_" + value;
+ String areaUuid = "CCT_AREA_OF_SHARED_SPACE_" + value;
+
+ SectionQuestion area = svc.question(section, areaUuid)
+ .orElseThrow(() -> new IllegalStateException(
+ "Question " + areaUuid + " not found — must run after V006_PerRelationshipTypeOfSpace"));
+ SectionQuestion hours = svc.ensureQuestion(section,
+ hoursQuestion(questionUuid, area.getDisplayOrder() + 1));
+ svc.ensureValidation(hours, validation(ValidationType.REGEX, HOURS_REGEX, HOURS_ERROR));
+ svc.ensureValidation(hours, validation(ValidationType.MANDATORY_IF,
+ "CCT_RELATIONSHIP=" + value, "This field is mandatory"));
+
+ QuestionOption option = svc.option(relationship, value)
+ .orElseThrow(() -> new IllegalStateException("Option CCT_RELATIONSHIP=" + value + " not found"));
+ OptionConditionDTO show = new OptionConditionDTO();
+ show.setActionType("SHOW_QUESTION");
+ show.setTargetQuestionUuid(questionUuid);
+ svc.ensureCondition(option, show, version);
+ }
+ }
+
+ private SectionQuestionDTO hoursQuestion(String uuid, int order) {
+ SectionQuestionDTO q = new SectionQuestionDTO();
+ q.setQuestionUuid(uuid);
+ q.setQuestionText(QUESTION_TEXT);
+ q.setQuestionTextHindi(QUESTION_TEXT_HINDI);
+ q.setQuestionType(QuestionType.NUMBER_PICKER);
+ q.setIsMandatory(true);
+ q.setDisplayOrder(order);
+ q.setVisibleByDefault(false);
+ q.setOptions(List.of());
+ q.setValidations(List.of());
+ return q;
+ }
+
+ private QuestionValidationDTO validation(ValidationType type, String param, String errorMessage) {
+ QuestionValidationDTO v = new QuestionValidationDTO();
+ v.setValidationType(type);
+ v.setValidationParam(param);
+ v.setErrorMessage(errorMessage);
+ return v;
+ }
+}
diff --git a/src/main/java/com/iemr/flw/seeder/migration/V008_ChangeRelationshipToDropdownMulti.java b/src/main/java/com/iemr/flw/seeder/migration/V008_ChangeRelationshipToDropdownMulti.java
new file mode 100644
index 000000000..7db08a382
--- /dev/null
+++ b/src/main/java/com/iemr/flw/seeder/migration/V008_ChangeRelationshipToDropdownMulti.java
@@ -0,0 +1,77 @@
+/*
+ * AMRIT – Accessible Medical Records via Integrated Technology
+ * Integrated EHR (Electronic Health Records) Solution
+ *
+ * Copyright (C) "Piramal Swasthya Management and Research Institute"
+ *
+ * This file is part of AMRIT.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see https://www.gnu.org/licenses/.
+ */
+package com.iemr.flw.seeder.migration;
+
+import com.iemr.flw.domain.iemr.FormSection;
+import com.iemr.flw.domain.iemr.FormVersion;
+import com.iemr.flw.domain.iemr.SectionQuestion;
+import com.iemr.flw.dto.iemr.SectionQuestionDTO;
+import com.iemr.flw.masterEnum.QuestionType;
+import com.iemr.flw.service.DynamicFormReconciliationService;
+import org.springframework.stereotype.Component;
+
+/**
+ * Changes the Community Contact Tracing form's "Relationship with community contacts" question
+ * (CCT_RELATIONSHIP) from CHECKBOX_MULTI to DROPDOWN_MULTI, so the 7 relationship options render as
+ * a multi-select dropdown instead of a checkbox list.
+ *
+ * Both types submit {@code optionValues} and store one response row per selected option, so
+ * existing responses remain valid. Options and their conditions (per-relationship count, Type of
+ * Space and hours questions, and "Other" text) are untouched. All other scalar fields are read off
+ * the existing row and passed back unchanged, since {@code updateQuestion} overwrites all of them
+ * unconditionally.
+ */
+@Component
+public class V008_ChangeRelationshipToDropdownMulti implements FormStructureMigration {
+
+ @Override
+ public String migrationId() {
+ return "V008";
+ }
+
+ @Override
+ public void apply(DynamicFormReconciliationService svc) {
+ FormVersion version = svc.latestVersion("COMMUNITY_CONTACT_TRACING")
+ .orElseThrow(() -> new IllegalStateException(
+ "COMMUNITY_CONTACT_TRACING not found — must run after CommunityContactTracingFormSeeder"));
+ FormSection section = svc.section(version, "CCT_SEC_1")
+ .orElseThrow(() -> new IllegalStateException("Section CCT_SEC_1 not found"));
+ SectionQuestion question = svc.question(section, "CCT_RELATIONSHIP")
+ .orElseThrow(() -> new IllegalStateException("Question CCT_RELATIONSHIP not found"));
+
+ if (question.getQuestionType() == QuestionType.DROPDOWN_MULTI) {
+ return;
+ }
+
+ SectionQuestionDTO dto = new SectionQuestionDTO();
+ dto.setQuestionText(question.getQuestionText());
+ dto.setQuestionTextHindi(question.getQuestionTextHindi());
+ dto.setQuestionType(QuestionType.DROPDOWN_MULTI);
+ dto.setIsMandatory(question.getIsMandatory());
+ dto.setMaxLength(question.getMaxLength());
+ dto.setDefaultValue(question.getDefaultValue());
+ dto.setContainsPii(question.getContainsPii());
+ dto.setDisplayOrder(question.getDisplayOrder());
+
+ svc.updateQuestion(question.getQuestionId(), dto);
+ }
+}
diff --git a/src/main/java/com/iemr/flw/seeder/migration/V009_BackfillOptionUuid.java b/src/main/java/com/iemr/flw/seeder/migration/V009_BackfillOptionUuid.java
new file mode 100644
index 000000000..bfcb384d2
--- /dev/null
+++ b/src/main/java/com/iemr/flw/seeder/migration/V009_BackfillOptionUuid.java
@@ -0,0 +1,62 @@
+/*
+ * AMRIT – Accessible Medical Records via Integrated Technology
+ * Integrated EHR (Electronic Health Records) Solution
+ *
+ * Copyright (C) "Piramal Swasthya Management and Research Institute"
+ *
+ * This file is part of AMRIT.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see https://www.gnu.org/licenses/.
+ */
+package com.iemr.flw.seeder.migration;
+
+import com.iemr.flw.domain.iemr.QuestionOption;
+import com.iemr.flw.repo.iemr.QuestionOptionRepo;
+import com.iemr.flw.service.DynamicFormReconciliationService;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+
+/**
+ * Backfills t_question_option.optionUuid for every option of every form version created before
+ * the column existed. The uuid is formType + optionValue, so the same option resolves to the same
+ * optionUuid in v1, v2, … — letting clients map answers across versions, as with sectionUuid/questionUuid.
+ * Only touches rows whose optionUuid is still blank, so re-running is a no-op.
+ */
+@Slf4j
+@Component
+@RequiredArgsConstructor
+public class V009_BackfillOptionUuid implements FormStructureMigration {
+
+ private final QuestionOptionRepo optionRepo;
+
+ @Override
+ public String migrationId() {
+ return "V009";
+ }
+
+ @Override
+ public void apply(DynamicFormReconciliationService svc) {
+ List options = optionRepo.findAllMissingOptionUuid();
+ for (QuestionOption option : options) {
+ option.setOptionUuid(QuestionOption.buildOptionUuid(
+ option.getSectionQuestion().getFormSection().getFormVersion().getDynamicForm().getFormType(),
+ option.getOptionValue()));
+ }
+ optionRepo.saveAll(options);
+ log.info("V009: backfilled optionUuid on {} option(s).", options.size());
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/com/iemr/flw/service/BeneficiaryService.java b/src/main/java/com/iemr/flw/service/BeneficiaryService.java
index e69bc887f..d043e7eea 100644
--- a/src/main/java/com/iemr/flw/service/BeneficiaryService.java
+++ b/src/main/java/com/iemr/flw/service/BeneficiaryService.java
@@ -5,11 +5,14 @@
import com.iemr.flw.dto.iemr.SAMResponseDTO;
import java.util.List;
+import java.util.Map;
public interface BeneficiaryService {
String getBenData(GetBenRequestHandler requestDTO, String authorisation) throws Exception;
+ Map getBeneficiaryRecordsByRegIds(List benRegIds, String authorisation);
+
String saveEyeCheckupVsit(List eyeCheckupRequestDTOS,String token);
List getEyeCheckUpVisit(GetBenRequestHandler request,String token);
diff --git a/src/main/java/com/iemr/flw/service/CampConfigService.java b/src/main/java/com/iemr/flw/service/CampConfigService.java
index 305bf1f05..325b0dabf 100644
--- a/src/main/java/com/iemr/flw/service/CampConfigService.java
+++ b/src/main/java/com/iemr/flw/service/CampConfigService.java
@@ -1,8 +1,14 @@
package com.iemr.flw.service;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.PersistenceContext;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
+import java.util.List;
+
/**
* Camp/van identity for this deployment.
*
@@ -17,12 +23,14 @@
* No inline default — every properties file must set stoptb.van.id explicitly, so a forgotten
* config fails loudly at startup instead of silently running unconfigured.
*
- * Scope: vanID (and the VanSerialNo stamping that depends on it) only. parkingPlaceID is out of
- * scope for this change.
+ * The van's parking place and store (facility) come from m_van, the same source MMU uses
+ * (MasterVanRepo.getFacilityID), and are read once and cached since the van never changes.
*/
@Service
public class CampConfigService {
+ private final Logger logger = LoggerFactory.getLogger(CampConfigService.class);
+
@Value("${stoptb.van.id}")
private int vanID;
@@ -31,6 +39,12 @@ public class CampConfigService {
@Value("${stoptb.enforce.vanid}")
private boolean enforceVanID;
+ @PersistenceContext(unitName = "db_iemr")
+ private EntityManager entityManager;
+
+ private volatile Integer parkingPlaceID;
+ private volatile Integer facilityID;
+
public Integer getVanID() {
if (vanID <= 0) {
if (enforceVanID) {
@@ -42,13 +56,51 @@ public Integer getVanID() {
return vanID;
}
+ /**
+ * The configured van (stoptb.van.id) is always used. A vanID sent by the app is ignored, so data and
+ * stock never land on another camp's van/store; a different value is only logged.
+ */
+ public Integer resolveVanID(Integer requestedVanID) {
+ Integer configured = getVanID();
+ if (requestedVanID != null && requestedVanID > 0 && !requestedVanID.equals(configured)) {
+ logger.warn("Ignoring vanID " + requestedVanID + " from request; using stoptb.van.id " + configured);
+ }
+ return configured;
+ }
+
public boolean isCampConfigured() {
return vanID > 0;
}
- // Not sourced from Redis anymore (out of scope for this change) — kept only because
- // callers across StopTBServiceImpl/DiagnosticOrderServiceImpl/etc. still call it.
+ // Parking place of the configured van (m_van.ParkingPlaceID); 0 when the camp is not configured
+ // or the van is not found, which is what callers received before this lookup existed.
public Integer getParkingPlaceID() {
- return 0;
+ if (parkingPlaceID == null) loadVanDetails();
+ return parkingPlaceID != null ? parkingPlaceID : 0;
+ }
+
+ // Store mapped to the configured van (m_van.FacilityID); null when no store is mapped.
+ public Integer getFacilityID() {
+ if (facilityID == null) loadVanDetails();
+ return facilityID;
+ }
+
+ private synchronized void loadVanDetails() {
+ if (!isCampConfigured() || (parkingPlaceID != null && facilityID != null)) return;
+ try {
+ List rows = entityManager.createNativeQuery(
+ "SELECT ParkingPlaceID, FacilityID FROM db_iemr.m_van WHERE VanID = :vanID AND Deleted = false")
+ .setParameter("vanID", vanID)
+ .getResultList();
+ if (rows.isEmpty()) {
+ logger.warn("stoptb.van.id " + vanID + " not found in m_van");
+ return;
+ }
+ Object[] row = (Object[]) rows.get(0);
+ parkingPlaceID = row[0] != null ? ((Number) row[0]).intValue() : null;
+ facilityID = row[1] != null ? ((Number) row[1]).intValue() : null;
+ } catch (Exception e) {
+ logger.error("Cannot read m_van details for vanID " + vanID, e);
+ }
}
}
diff --git a/src/main/java/com/iemr/flw/service/DiagnosticOrderService.java b/src/main/java/com/iemr/flw/service/DiagnosticOrderService.java
index 0bd5207b8..42fb1c337 100644
--- a/src/main/java/com/iemr/flw/service/DiagnosticOrderService.java
+++ b/src/main/java/com/iemr/flw/service/DiagnosticOrderService.java
@@ -12,18 +12,50 @@
public interface DiagnosticOrderService {
- DiagnosticOrder createAndPushOrder(DiagnosticOrderRequestDto request) throws Exception;
+ DiagnosticOrder createAndPushOrderByUser(DiagnosticOrderRequestDto request, String jwtToken) throws Exception;
+
+ /**
+ * Same create/push logic as createAndPushOrder, attributed to "SYSTEM" instead of a JWT-derived
+ * user. For callers with no authenticated user in context, e.g. the poll scheduler auto-recreating
+ * an order after an invalid result.
+ */
+ DiagnosticOrder createAndPushOrderAsSystem(DiagnosticOrderRequestDto request) throws Exception;
DiagnosticOrderResultDto processResult(DiagnosticOrder order, DiagnosticPollResult result) throws Exception;
+ /**
+ * Polls the vendor once for this order. The order is re-read first and skipped (returns null) if it
+ * is no longer PENDING/IN_PROGRESS, e.g. a manual result landed after the scheduler loaded it.
+ */
DiagnosticPollResult pollOnce(DiagnosticOrder order) throws Exception;
+ /**
+ * Daily cutoff: marks this order CLOSED with the given reason and notifies the vendor, unless it was
+ * resolved (e.g. by a manual result) after the scheduler loaded it.
+ */
+ void expireOrder(DiagnosticOrder order, String reason) throws Exception;
+
DiagnosticOrderResultDto triggerManualPoll(Long beneficiaryId, String orderType, Long visitCode) throws Exception;
DiagnosticOrder retryPoll(Long beneficiaryId, String orderType, Long visitCode) throws Exception;
+ /**
+ * Best-effort: tells the vendor this order is closed out (no result coming), so they stop
+ * tracking it. Never throws — a provider failure is logged and swallowed, since the order's own
+ * CLOSED status is what actually matters locally. No-op if the order was never pushed to a vendor.
+ */
+ void notifyProviderOrderClosed(DiagnosticOrder order, String reason);
+
DiagnosticOrderResultDto getOrderResult(Long beneficiaryId, String orderType, Long visitCode);
+ /**
+ * Orders with their result, keyed by order id (STOP-TB changes feed). Deleted orders are left
+ * out. Each record carries what getBeneficiariesByStatus and getOrderResult give today: the
+ * beneficiary, order type, visit code and status (the app buckets by the latest order per
+ * beneficiary and type), plus the result fields.
+ */
+ java.util.Map> getOrderRecordsByIds(java.util.Collection ids);
+
DiagnosticOrder getOrder(Long beneficiaryId, String orderType, Long visitCode) throws Exception;
List getOrdersByBeneficiaryId(Long beneficiaryId) throws Exception;
@@ -32,5 +64,5 @@ public interface DiagnosticOrderService {
VendorHealthDto checkVendorHealth(String orderType) throws Exception;
- DiagnosticOrderResultDto submitManualResult(ManualDiagnosticResultRequestDto request) throws Exception;
+ DiagnosticOrderResultDto submitManualResult(ManualDiagnosticResultRequestDto request, String jwtToken) throws Exception;
}
diff --git a/src/main/java/com/iemr/flw/service/DynamicFormDefinitionService.java b/src/main/java/com/iemr/flw/service/DynamicFormDefinitionService.java
index c7aae24df..b3e5558c9 100644
--- a/src/main/java/com/iemr/flw/service/DynamicFormDefinitionService.java
+++ b/src/main/java/com/iemr/flw/service/DynamicFormDefinitionService.java
@@ -23,6 +23,7 @@
import com.iemr.flw.dto.iemr.DynamicFormDTO;
import com.iemr.flw.dto.iemr.FormSectionDTO;
+import com.iemr.flw.dto.iemr.LatestFormVersionDTO;
import com.iemr.flw.dto.iemr.OptionConditionDTO;
import com.iemr.flw.dto.iemr.QuestionOptionDTO;
import com.iemr.flw.dto.iemr.QuestionValidationDTO;
@@ -47,7 +48,7 @@ public interface DynamicFormDefinitionService {
/** Returns a specific version's full definition tree (no cache). */
DynamicFormDTO getFormDefinitionByVersion(Long formId, Integer versionNumber);
- /** Returns metadata for all active forms (without full tree). */
+ /** Returns every active form's latest full definition, with each version's full definition in {@code versions}. */
List getAllForms();
/** Sets the form's isActive flag to true. */
@@ -56,4 +57,6 @@ public interface DynamicFormDefinitionService {
/** Sets the form's isActive flag to false and invalidates cache. */
void deactivateForm(Long formId);
+ /** Latest version of every active form: formId, formUuid, formName and current version number. */
+ List getLatestFormVersions();
}
diff --git a/src/main/java/com/iemr/flw/service/DynamicFormReconciliationService.java b/src/main/java/com/iemr/flw/service/DynamicFormReconciliationService.java
new file mode 100644
index 000000000..f558f0078
--- /dev/null
+++ b/src/main/java/com/iemr/flw/service/DynamicFormReconciliationService.java
@@ -0,0 +1,101 @@
+/*
+ * AMRIT – Accessible Medical Records via Integrated Technology
+ * Integrated EHR (Electronic Health Records) Solution
+ *
+ * Copyright (C) "Piramal Swasthya Management and Research Institute"
+ *
+ * This file is part of AMRIT.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see https://www.gnu.org/licenses/.
+ */
+package com.iemr.flw.service;
+
+import com.iemr.flw.domain.iemr.DynamicForm;
+import com.iemr.flw.domain.iemr.FormSection;
+import com.iemr.flw.domain.iemr.FormVersion;
+import com.iemr.flw.domain.iemr.OptionCondition;
+import com.iemr.flw.domain.iemr.QuestionOption;
+import com.iemr.flw.domain.iemr.QuestionValidation;
+import com.iemr.flw.domain.iemr.SectionQuestion;
+import com.iemr.flw.dto.iemr.DynamicFormDTO;
+import com.iemr.flw.dto.iemr.FormSectionDTO;
+import com.iemr.flw.dto.iemr.OptionConditionDTO;
+import com.iemr.flw.dto.iemr.QuestionOptionDTO;
+import com.iemr.flw.dto.iemr.QuestionValidationDTO;
+import com.iemr.flw.dto.iemr.SectionQuestionDTO;
+
+import java.util.Optional;
+
+/**
+ * Idempotent, in-place reconciliation for dynamic form structure — inserts whatever is missing
+ * from the current latest {@link FormVersion} and leaves existing rows untouched. Never creates a
+ * new version (unlike {@link DynamicFormDefinitionService#updateForm}, which always clones one).
+ *
+ * Used both by the startup seeders (walking their full hardcoded DTO tree every run) and by the
+ * granular structure endpoints (a single section/question/option at a time).
+ *
+ * Each {@code ensureX} method operates on exactly one level — callers walk the tree themselves and
+ * call the next level down, since only the caller knows whether it's safe yet to wire cross-sibling
+ * references (see {@link #ensureCondition}).
+ */
+public interface DynamicFormReconciliationService {
+
+ /** Finds the form by formUuid, or creates it. If found inactive, reactivates it (touches no other field). */
+ DynamicForm ensureForm(DynamicFormDTO dto);
+
+ /** Finds the form's isLatest=true version, or creates version 1 if none exists yet. */
+ FormVersion ensureLatestVersion(DynamicForm form);
+
+ /** Finds a section by sectionUuid within the version, or creates it. */
+ FormSection ensureSection(FormVersion version, FormSectionDTO dto);
+
+ /** Finds a question by questionUuid within the section, or creates it (a section's question is "linked" the moment it's created — no separate link step exists). */
+ SectionQuestion ensureQuestion(FormSection section, SectionQuestionDTO dto);
+
+ /** Finds an option by optionValue within the question, or creates it. */
+ QuestionOption ensureOption(SectionQuestion question, QuestionOptionDTO dto);
+
+ /** Finds a validation by (validationType, validationParam) within the question, or creates it — validations carry no natural key of their own. */
+ QuestionValidation ensureValidation(SectionQuestion question, QuestionValidationDTO dto);
+
+ /**
+ * Finds a condition by (actionType, target) within the option, or creates it, resolving
+ * targetQuestionUuid/targetSectionUuid against the given version. Call only once every sibling
+ * section/question this condition might target already exists as a row.
+ */
+ OptionCondition ensureCondition(QuestionOption option, OptionConditionDTO dto, FormVersion version);
+
+ /** Updates a question's scalar fields only (options/validations are managed by their own endpoints). A displayOrder change moves the question among its siblings, shifting them accordingly. */
+ SectionQuestion updateQuestion(Long questionId, SectionQuestionDTO dto);
+
+ /** Soft-deletes (isActive=false) a question — never hard-deleted; historical responses may reference it. */
+ void unlinkQuestion(Long questionId);
+
+ /** Soft-deletes (isActive=false) an option — never hard-deleted; historical responses may reference it. */
+ void removeOption(Long optionId);
+
+ // ── Read-only lookups, for FormStructureMigration classes to locate what they're changing ──
+
+ /** Finds the given form's current latest version, if the form exists at all. */
+ Optional latestVersion(String formUuid);
+
+ /** Finds a section by sectionUuid within the given version. */
+ Optional section(FormVersion version, String sectionUuid);
+
+ /** Finds a question by questionUuid within the given section. */
+ Optional question(FormSection section, String questionUuid);
+
+ /** Finds an option by optionValue within the given question. */
+ Optional option(SectionQuestion question, String optionValue);
+}
diff --git a/src/main/java/com/iemr/flw/service/DynamicFormResponseService.java b/src/main/java/com/iemr/flw/service/DynamicFormResponseService.java
index 1f2255f3e..8265cfafb 100644
--- a/src/main/java/com/iemr/flw/service/DynamicFormResponseService.java
+++ b/src/main/java/com/iemr/flw/service/DynamicFormResponseService.java
@@ -55,6 +55,12 @@ List getResponsesByBeneficiary(Long beneficiaryId, Integer vill
/** Single response with all nested section and question answers. */
FormResponseDTO getResponseById(Long responseId);
+ /**
+ * Responses with all nested answers, keyed by responseId, as getResponsesByBeneficiary returns
+ * them (STOP-TB changes feed). Ids with no response are left out.
+ */
+ java.util.Map getResponsesByIds(java.util.Collection responseIds);
+
/**
* Submit multiple form responses in one bulk transaction.
* All FormResponse rows are batch-inserted via saveAll() so responseIds are available
diff --git a/src/main/java/com/iemr/flw/service/StopTBPrescriptionService.java b/src/main/java/com/iemr/flw/service/StopTBPrescriptionService.java
new file mode 100644
index 000000000..c61b4d4f9
--- /dev/null
+++ b/src/main/java/com/iemr/flw/service/StopTBPrescriptionService.java
@@ -0,0 +1,721 @@
+package com.iemr.flw.service;
+
+import com.iemr.flw.domain.identity.RMNCHMBeneficiarydetail;
+import com.iemr.flw.domain.identity.RMNCHMBeneficiarymapping;
+import com.iemr.flw.domain.iemr.BenVisitDetail;
+import com.iemr.flw.repo.identity.BeneficiaryRepo;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.PersistenceContext;
+import jakarta.persistence.Query;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.math.BigInteger;
+import java.time.LocalDate;
+import java.time.Period;
+import java.util.*;
+
+/**
+ * Stop TB nurse OPD: chief complaints, prescription and dispensing written to the same standard
+ * tables MMU/TM and Inventory-API use, inside the caller's transaction.
+ *
+ * - Chief complaints -> t_benchiefcomplaint (one row per complaint, like TM saveBenChiefComplaints)
+ * - Prescription -> t_prescription + t_prescribeddrug (DrugID + QtyPrescribed, like TM doctor save)
+ * - Dispensing -> t_patientissue + t_itemstockexit (ExitType T_PatientIssue) and
+ * t_itemstockentry.QuantityInHand reduced, like Inventory-API issuePatientDrugs.
+ *
+ * Batches are picked by m_itemcategory.IssueType (FEFO / FIFO / LIFO) from non-expired batches that
+ * last the treatment duration, and are locked (SELECT ... FOR UPDATE) so two nurses can never take the
+ * same stock. If any drug is short, nothing is saved (InsufficientStockException rolls back the caller).
+ *
+ * Native SQL only, no new entity mappings: FLW runs with ddl-auto=create.
+ */
+@Service
+public class StopTBPrescriptionService {
+
+ private static final String REFERENCE_PREFIX = "StopTB:";
+
+ @PersistenceContext(unitName = "db_iemr")
+ private EntityManager em;
+
+ @Autowired
+ private CampConfigService campConfigService;
+
+ @Autowired
+ private BeneficiaryRepo beneficiaryRepo;
+
+ // Off by default: save the prescription only (no store/stock check, no patient issue, stock unchanged).
+ // true = check stock and dispense from the camp store.
+ @Value("${stoptb.dispense.enabled:false}")
+ private boolean dispenseEnabled;
+
+ private final Logger logger = LoggerFactory.getLogger(StopTBPrescriptionService.class);
+
+ public static class InsufficientStockException extends RuntimeException {
+ public InsufficientStockException(String message) {
+ super(message);
+ }
+ }
+
+ /** Previous result for a submissionId already saved, or null. Lets the app retry safely. */
+ @Transactional(propagation = Propagation.MANDATORY)
+ public Map findPreviousSubmission(Long beneficiaryRegID, String submissionId) {
+ if (submissionId == null || submissionId.isBlank()) return null;
+ List rows = em.createNativeQuery("SELECT PatientIssueID, VisitCode, PrescriptionID FROM db_iemr.t_patientissue "
+ + "WHERE BeneficiaryRegID = :ben AND Reference = :ref AND Deleted = false")
+ .setParameter("ben", beneficiaryRegID)
+ .setParameter("ref", REFERENCE_PREFIX + submissionId)
+ .getResultList();
+ if (rows.isEmpty()) return null;
+ Object[] row = (Object[]) rows.get(0);
+ Integer facilityID = campConfigService.getFacilityID();
+
+ List issued = em.createNativeQuery("SELECT e.ItemID, i.ItemName, SUM(x.Quantity) "
+ + "FROM db_iemr.t_itemstockexit x "
+ + "JOIN db_iemr.t_itemstockentry e ON e.VanSerialNo = x.ItemStockEntryID AND e.FacilityID = x.FacilityID "
+ + "JOIN db_iemr.m_item i ON i.ItemID = e.ItemID "
+ + "WHERE x.ExitType = 'T_PatientIssue' AND x.ExitTypeID = :issueID AND x.FacilityID = :facilityID "
+ + "GROUP BY e.ItemID, i.ItemName")
+ .setParameter("issueID", ((Number) row[0]).longValue())
+ .setParameter("facilityID", facilityID)
+ .getResultList();
+ List> dispensed = new ArrayList<>();
+ for (Object o : issued) {
+ Object[] r = (Object[]) o;
+ int drugID = ((Number) r[0]).intValue();
+ Map d = new LinkedHashMap<>();
+ d.put("drugID", drugID);
+ d.put("drugName", r[1]);
+ d.put("qtyIssued", ((Number) r[2]).intValue());
+ d.put("availableQuantity", availableQuantity(facilityID, drugID, 0));
+ dispensed.add(d);
+ }
+ Map result = new LinkedHashMap<>();
+ result.put("beneficiaryRegID", beneficiaryRegID);
+ result.put("visitCode", row[1] != null ? ((Number) row[1]).longValue() : null);
+ result.put("prescriptionID", row[2] != null ? ((Number) row[2]).longValue() : null);
+ result.put("dispensed", dispensed);
+ result.put("duplicate", true);
+ return result;
+ }
+
+ /**
+ * Replaces the visit's chief complaints with the given list (edit = remove old + insert new, as MMU
+ * does on update). Rows without an ID and without a name are skipped.
+ */
+ @Transactional(propagation = Propagation.MANDATORY)
+ public void saveChiefComplaints(List> complaints, Long beneficiaryRegID, BenVisitDetail visit,
+ String createdBy, Integer vanID, Integer parkingPlaceID) {
+ if (complaints == null) return;
+ // Processed='N' so the removal is uploaded to central again (central updates rows it already has).
+ em.createNativeQuery("UPDATE db_iemr.t_benchiefcomplaint SET Deleted = true, Processed = 'N', ModifiedBy = :user "
+ + "WHERE BeneficiaryRegID = :ben AND VisitCode = :visitCode AND Deleted = false")
+ .setParameter("user", createdBy)
+ .setParameter("ben", beneficiaryRegID)
+ .setParameter("visitCode", visit.getVisitCode())
+ .executeUpdate();
+ for (Map c : complaints) {
+ Integer complaintID = toInt(c.get("chiefComplaintID"));
+ String complaint = toStr(c.get("chiefComplaint"));
+ // ID from the chief complaint master is required: getAll and reports identify new records by it.
+ if (complaintID == null) {
+ throw new IllegalArgumentException("chiefComplaintID is required for every chief complaint"
+ + (complaint != null ? " (" + complaint + ")" : ""));
+ }
+ em.createNativeQuery("INSERT INTO db_iemr.t_benchiefcomplaint (BeneficiaryRegID, BenVisitID, ProviderServiceMapID, "
+ + "VisitCode, ChiefComplaintID, ChiefComplaint, Duration, UnitOfDuration, Description, Deleted, "
+ + "Processed, CreatedBy, VanID, ParkingPlaceID) VALUES (:ben, :visitID, :psm, :visitCode, :cid, "
+ + ":name, :duration, :unit, :description, false, 'N', :user, :van, :pp)")
+ .setParameter("ben", beneficiaryRegID)
+ .setParameter("visitID", visit.getBenVisitId())
+ .setParameter("psm", visit.getProviderServiceMapID())
+ .setParameter("visitCode", visit.getVisitCode())
+ .setParameter("cid", complaintID)
+ .setParameter("name", complaint)
+ .setParameter("duration", toInt(c.get("duration")))
+ .setParameter("unit", toStr(c.get("unitOfDuration")))
+ .setParameter("description", toStr(c.get("description")))
+ .setParameter("user", createdBy)
+ .setParameter("van", vanID)
+ .setParameter("pp", parkingPlaceID)
+ .executeUpdate();
+ stampVanSerialNo("t_benchiefcomplaint", "ID", lastInsertId());
+ }
+ }
+
+ /**
+ * Saves the prescription and issues every drug from the camp store. Returns prescriptionID and,
+ * per drug, the quantity issued and what is left in the store.
+ */
+ @Transactional(propagation = Propagation.MANDATORY)
+ public Map prescribeAndDispense(Map prescription, Long beneficiaryRegID,
+ BenVisitDetail visit, String submissionId, String createdBy, Integer vanID, Integer parkingPlaceID) {
+ List> drugs = toList(prescription.get("drugs"));
+ if (!dispenseEnabled) {
+ return prescribeWithoutDispensing(prescription, drugs, beneficiaryRegID, visit, createdBy, vanID,
+ parkingPlaceID);
+ }
+ Map result = new LinkedHashMap<>();
+ if (drugs.isEmpty()) {
+ // Remarks without medicine are still kept, as MMU saves the visit instruction without drugs.
+ String instruction = toStr(prescription.get("instruction"));
+ if (instruction != null && !instruction.isBlank()) {
+ result.put("prescriptionID", insertPrescription(beneficiaryRegID, visit, instruction, createdBy, vanID,
+ parkingPlaceID));
+ }
+ return result;
+ }
+
+ Integer facilityID = campConfigService.getFacilityID();
+ if (facilityID == null) {
+ throw new IllegalStateException("No store is mapped to van " + vanID + " (m_van.FacilityID)");
+ }
+
+ // 1. Validate every line and check total stock per drug before writing anything.
+ Map requested = new LinkedHashMap<>();
+ Map items = new HashMap<>();
+ for (Map d : drugs) {
+ Integer drugID = toInt(d.get("drugID"));
+ if (drugID == null) throw new IllegalArgumentException("drugID is required for every drug");
+ if (!items.containsKey(drugID)) items.put(drugID, getStoreItem(facilityID, drugID));
+ Integer qty = toInt(d.get("qtyPrescribed"));
+ if (qty == null || qty <= 0) {
+ // No quantity from the app: tablets/capsules = doses per day x days, other forms = 1.
+ qty = calculateQuantity(d, toInt(items.get(drugID)[7]));
+ if (qty == null) {
+ throw new IllegalArgumentException("qtyPrescribed is required for drugID " + drugID
+ + " (tablet/capsule quantity needs frequency and duration)");
+ }
+ d.put("qtyPrescribed", qty); // saved in t_prescribeddrug.QtyPrescribed
+ }
+ requested.merge(drugID, qty, Integer::sum);
+ }
+ List shortages = new ArrayList<>();
+ Map> lockedBatches = new HashMap<>();
+ for (Map.Entry r : requested.entrySet()) {
+ Object[] item = items.get(r.getKey());
+ int durationDays = maxDurationDays(drugs, r.getKey());
+ List batches = lockBatches(facilityID, r.getKey(), (String) item[6], durationDays);
+ lockedBatches.put(r.getKey(), batches);
+ int available = batches.stream().mapToInt(b -> ((Number) b[1]).intValue()).sum();
+ if (available < r.getValue()) {
+ shortages.add(item[1] + " (drugID " + r.getKey() + "): asked " + r.getValue() + ", available " + available);
+ }
+ }
+ if (!shortages.isEmpty()) {
+ throw new InsufficientStockException("Insufficient stock - " + String.join("; ", shortages));
+ }
+
+ // 2. Prescription + prescribed drugs (Stop TB service line, same as the visit).
+ Integer storePsm = getStorePsm(facilityID);
+ long prescriptionID = insertPrescription(beneficiaryRegID, visit, toStr(prescription.get("instruction")),
+ createdBy, vanID, parkingPlaceID);
+
+ for (Map d : drugs) {
+ Integer drugID = toInt(d.get("drugID"));
+ Object[] item = items.get(drugID);
+ em.createNativeQuery("INSERT INTO db_iemr.t_prescribeddrug (BeneficiaryRegID, BenVisitID, ProviderServiceMapID, "
+ + "VisitCode, PrescriptionID, DrugForm, DrugID, GenericDrugName, DrugStrength, Dose, Route, Frequency, "
+ + "Duration, DuartionUnit, SpecialInstruction, QtyPrescribed, isEDL, Deleted, Processed, CreatedBy, "
+ + "VanID, ParkingPlaceID) VALUES (:ben, :visitID, :psm, :visitCode, :prescriptionID, :form, :drugID, "
+ + ":name, :strength, :dose, :route, :frequency, :duration, :durationUnit, :instruction, :qty, "
+ + ":isEDL, false, 'N', :user, :van, :pp)")
+ .setParameter("ben", beneficiaryRegID)
+ .setParameter("visitID", visit.getBenVisitId())
+ .setParameter("psm", visit.getProviderServiceMapID())
+ .setParameter("visitCode", visit.getVisitCode())
+ .setParameter("prescriptionID", prescriptionID)
+ .setParameter("form", item[3])
+ .setParameter("drugID", drugID)
+ .setParameter("name", item[1])
+ .setParameter("strength", item[2])
+ .setParameter("dose", toStr(d.get("dose")))
+ .setParameter("route", item[4])
+ .setParameter("frequency", toStr(d.get("frequency")))
+ .setParameter("duration", toStr(d.get("duration")))
+ .setParameter("durationUnit", toStr(d.get("durationUnit")))
+ .setParameter("instruction", toStr(d.get("instructions")))
+ .setParameter("qty", toInt(d.get("qtyPrescribed")))
+ .setParameter("isEDL", item[5])
+ .setParameter("user", createdBy)
+ .setParameter("van", vanID)
+ .setParameter("pp", parkingPlaceID)
+ .executeUpdate();
+ stampVanSerialNo("t_prescribeddrug", "PrescribedDrugID", lastInsertId());
+ }
+
+ // 3. Patient issue header (same shape as Inventory-API issuePatientDrugs, IssueType 'System').
+ Object[] patient = getPatientDetails(beneficiaryRegID);
+ em.createNativeQuery("INSERT INTO db_iemr.t_patientissue (BeneficiaryRegID, BenVisitID, VisitCode, FacilityID, "
+ + "PatientName, Age, Gender, PrescriptionID, Reference, IssueType, IssuedBy, ProviderServiceMapID, "
+ + "Deleted, Processed, CreatedBy, SyncFacilityID, VanID, ParkingPlaceID) VALUES (:ben, :visitID, "
+ + ":visitCode, :facilityID, :name, :age, :gender, :prescriptionID, :ref, 'System', :user, :psm, false, "
+ + "'N', :user, :facilityID, :van, :pp)")
+ .setParameter("ben", beneficiaryRegID)
+ .setParameter("name", patient[0])
+ .setParameter("age", patient[1])
+ .setParameter("gender", patient[2])
+ .setParameter("visitID", visit.getBenVisitId())
+ .setParameter("visitCode", visit.getVisitCode())
+ .setParameter("facilityID", facilityID)
+ .setParameter("prescriptionID", prescriptionID)
+ .setParameter("ref", submissionId != null && !submissionId.isBlank() ? REFERENCE_PREFIX + submissionId : null)
+ .setParameter("user", createdBy)
+ .setParameter("psm", storePsm)
+ .setParameter("van", vanID)
+ .setParameter("pp", parkingPlaceID)
+ .executeUpdate();
+ long patientIssueID = lastInsertId();
+ stampVanSerialNo("t_patientissue", "PatientIssueID", patientIssueID);
+
+ // 4. Take each drug from its locked batches in issue order; one stock exit per batch used.
+ List> dispensed = new ArrayList<>();
+ for (Map.Entry r : requested.entrySet()) {
+ int remaining = r.getValue();
+ for (Object[] batch : lockedBatches.get(r.getKey())) {
+ if (remaining == 0) break;
+ long batchSerialNo = ((Number) batch[0]).longValue();
+ int take = Math.min(remaining, ((Number) batch[1]).intValue());
+ em.createNativeQuery("INSERT INTO db_iemr.t_itemstockexit (ItemStockEntryID, FacilityID, Quantity, "
+ + "ProviderServiceMapID, ExitTypeID, ExitType, Deleted, Processed, CreatedBy, SyncFacilityID, "
+ + "VanID, ParkingPlaceID) VALUES (:batch, :facilityID, :qty, :psm, :issueID, 'T_PatientIssue', "
+ + "false, 'N', :user, :facilityID, :van, :pp)")
+ .setParameter("batch", batchSerialNo)
+ .setParameter("facilityID", facilityID)
+ .setParameter("qty", take)
+ .setParameter("psm", storePsm)
+ .setParameter("issueID", patientIssueID)
+ .setParameter("user", createdBy)
+ .setParameter("van", vanID)
+ .setParameter("pp", parkingPlaceID)
+ .executeUpdate();
+ stampVanSerialNo("t_itemstockexit", "ItemStockExitID", lastInsertId());
+ // Same update as Inventory-API ItemStockEntryRepo.updateStock. Processed='N' sends the batch's
+ // new stock to central on the next upload; central updates its copy by VanSerialNo + store.
+ em.createNativeQuery("UPDATE db_iemr.t_itemstockentry SET QuantityInHand = QuantityInHand - :qty, "
+ + "Processed = 'N' WHERE VanSerialNo = :batch AND FacilityID = :facilityID")
+ .setParameter("qty", take)
+ .setParameter("batch", batchSerialNo)
+ .setParameter("facilityID", facilityID)
+ .executeUpdate();
+ remaining -= take;
+ }
+ Map d = new LinkedHashMap<>();
+ d.put("drugID", r.getKey());
+ d.put("drugName", items.get(r.getKey())[1]);
+ d.put("qtyIssued", r.getValue());
+ d.put("availableQuantity", availableQuantity(facilityID, r.getKey(), 0));
+ dispensed.add(d);
+ }
+
+ result.put("prescriptionID", prescriptionID);
+ result.put("dispensed", dispensed);
+ return result;
+ }
+
+ /**
+ * OPD records for getAll from the standard tables, one per visit that was saved with the new payload
+ * (complaint with ChiefComplaintID or drug with DrugID). Older visits have only the free-text copy in
+ * tb_stoptb_general_opd and are added by the caller. Field names and formats match that table's response:
+ * chiefComplaint = JSON list of names, medication/dosage/frequency/duration = comma separated.
+ */
+ @SuppressWarnings("unchecked")
+ public List> getStandardOpdRecords(Integer providerServiceMapID, Integer villageID) {
+ String villageFilter = villageID != null
+ ? "AND v.BeneficiaryRegID IN (SELECT f.beneficiary_reg_id FROM db_iemr.i_ben_flow_outreach f "
+ + "WHERE f.providerServiceMapID = :psm AND f.villageID = :villageID) "
+ : "";
+ Map params = new HashMap<>();
+ params.put("psm", providerServiceMapID);
+ if (villageID != null) params.put("villageID", villageID);
+ return standardOpdRecords("v.ProviderServiceMapID = :psm " + villageFilter, params);
+ }
+
+ // The same records for specific visits (BenVisitID), for the STOP-TB changes feed. A visit that is
+ // deleted or has no complaint or drug is left out, exactly as getStandardOpdRecords leaves it out.
+ public List> getStandardOpdRecordsByVisitIds(Collection benVisitIds) {
+ if (benVisitIds.isEmpty()) return new ArrayList<>();
+ Map params = new HashMap<>();
+ params.put("ids", benVisitIds);
+ return standardOpdRecords("v.BenVisitID IN (:ids) ", params);
+ }
+
+ // Visit codes among these that getStandardOpdRecords would return (not deleted, with a complaint or drug).
+ public Set visitCodesWithStandardOpd(Collection visitCodes) {
+ Set out = new HashSet<>();
+ if (visitCodes.isEmpty()) return out;
+ Map params = new HashMap<>();
+ params.put("codes", visitCodes);
+ for (Map m : standardOpdRecords("v.VisitCode IN (:codes) ", params)) {
+ out.add((Long) m.get("visitCode"));
+ }
+ return out;
+ }
+
+ private List> standardOpdRecords(String visitFilter, Map params) {
+ Query visitQuery = em.createNativeQuery("SELECT v.BenVisitID, v.BeneficiaryRegID, v.VisitCode, v.CreatedBy, "
+ + "v.CreatedDate, v.LastModDate, v.ProviderServiceMapID FROM db_iemr.t_benvisitdetail v "
+ + "WHERE " + visitFilter + "AND v.Deleted = false "
+ + "AND (EXISTS (SELECT 1 FROM db_iemr.t_benchiefcomplaint c WHERE c.BeneficiaryRegID = v.BeneficiaryRegID "
+ + " AND c.VisitCode = v.VisitCode AND c.ChiefComplaintID IS NOT NULL AND c.Deleted = false) "
+ + " OR EXISTS (SELECT 1 FROM db_iemr.t_prescribeddrug d WHERE d.BeneficiaryRegID = v.BeneficiaryRegID "
+ + " AND d.VisitCode = v.VisitCode AND d.DrugID IS NOT NULL AND d.Deleted = false)) "
+ + "ORDER BY v.CreatedDate DESC");
+ params.forEach(visitQuery::setParameter);
+ List visits = visitQuery.getResultList();
+
+ Map> byVisit = new LinkedHashMap<>();
+ for (Object[] v : visits) {
+ Map m = new LinkedHashMap<>();
+ m.put("id", ((Number) v[0]).longValue());
+ m.put("beneficiaryRegID", ((Number) v[1]).longValue());
+ m.put("visitCode", ((Number) v[2]).longValue());
+ m.put("providerServiceMapID", v[6] != null ? ((Number) v[6]).intValue() : null);
+ m.put("chiefComplaint", new ArrayList());
+ m.put("medication", new StringJoiner(", "));
+ m.put("dosage", new StringJoiner(", "));
+ m.put("frequency", new StringJoiner(", "));
+ m.put("duration", new StringJoiner(", "));
+ m.put("drugs", new ArrayList>());
+ m.put("notes", null);
+ m.put("createdBy", v[3]);
+ m.put("createdDate", v[4]);
+ m.put("updateDate", v[5]);
+ m.put("updatedBy", null);
+ byVisit.put(((Number) v[2]).longValue(), m);
+ }
+ if (byVisit.isEmpty()) return new ArrayList<>();
+
+ List visitCodes = new ArrayList<>(byVisit.keySet());
+ for (int i = 0; i < visitCodes.size(); i += 500) {
+ List chunk = visitCodes.subList(i, Math.min(i + 500, visitCodes.size()));
+
+ for (Object o : em.createNativeQuery("SELECT VisitCode, ChiefComplaint, LastModDate FROM db_iemr.t_benchiefcomplaint "
+ + "WHERE VisitCode IN (:codes) AND ChiefComplaintID IS NOT NULL AND Deleted = false ORDER BY ID")
+ .setParameter("codes", chunk).getResultList()) {
+ Object[] r = (Object[]) o;
+ Map m = byVisit.get(((Number) r[0]).longValue());
+ if (r[1] != null) ((List) m.get("chiefComplaint")).add(r[1].toString());
+ latest(m, r[2]);
+ }
+
+ for (Object o : em.createNativeQuery("SELECT d.VisitCode, d.GenericDrugName, d.Dose, d.Frequency, d.Duration, "
+ + "d.DuartionUnit, d.LastModDate, d.DrugID, i.ItemFormID, d.DrugForm, d.QtyPrescribed, "
+ + "d.SpecialInstruction FROM db_iemr.t_prescribeddrug d "
+ + "LEFT JOIN db_iemr.m_item i ON i.ItemID = d.DrugID "
+ + "WHERE d.VisitCode IN (:codes) AND d.DrugID IS NOT NULL AND d.Deleted = false "
+ + "ORDER BY d.PrescribedDrugID")
+ .setParameter("codes", chunk).getResultList()) {
+ Object[] r = (Object[]) o;
+ Map m = byVisit.get(((Number) r[0]).longValue());
+ ((StringJoiner) m.get("medication")).add(r[1] != null ? r[1].toString() : "");
+ ((StringJoiner) m.get("dosage")).add(r[2] != null ? r[2].toString() : "");
+ ((StringJoiner) m.get("frequency")).add(r[3] != null ? r[3].toString() : "");
+ ((StringJoiner) m.get("duration")).add(r[4] == null ? "" : r[5] == null ? r[4].toString() : r[4] + " " + r[5]);
+ latest(m, r[6]);
+
+ // Full prescription per drug, so a saved record can show form, quantity and instructions.
+ Map drug = new LinkedHashMap<>();
+ drug.put("drugID", ((Number) r[7]).intValue());
+ drug.put("drugName", r[1]);
+ drug.put("itemFormID", r[8] != null ? ((Number) r[8]).intValue() : null);
+ drug.put("drugForm", r[9]);
+ drug.put("dose", r[2]);
+ drug.put("frequency", r[3]);
+ drug.put("duration", r[4] != null ? toInt(r[4]) : null);
+ drug.put("durationUnit", r[5]);
+ drug.put("qtyPrescribed", r[10] != null ? ((Number) r[10]).intValue() : null);
+ drug.put("instructions", r[11]);
+ ((List>) m.get("drugs")).add(drug);
+ }
+
+ // Latest prescription instruction per visit is the visit's note.
+ for (Object o : em.createNativeQuery("SELECT VisitCode, Instruction, LastModDate FROM db_iemr.t_prescription "
+ + "WHERE VisitCode IN (:codes) AND Deleted = false ORDER BY PrescriptionID")
+ .setParameter("codes", chunk).getResultList()) {
+ Object[] r = (Object[]) o;
+ Map m = byVisit.get(((Number) r[0]).longValue());
+ if (r[1] != null && !r[1].toString().isBlank()) m.put("notes", r[1].toString());
+ latest(m, r[2]);
+ }
+ }
+
+ com.google.gson.Gson gson = new com.google.gson.Gson();
+ List> records = new ArrayList<>();
+ for (Map m : byVisit.values()) {
+ List complaints = (List) m.get("chiefComplaint");
+ m.put("chiefComplaint", complaints.isEmpty() ? null : gson.toJson(complaints));
+ for (String key : new String[] { "medication", "dosage", "frequency", "duration" }) {
+ String joined = m.get(key).toString();
+ m.put(key, joined.replace(",", "").isBlank() ? null : joined);
+ }
+ records.add(m);
+ }
+ return records;
+ }
+
+ // updateDate = latest change on the visit, so the app picks up a later save on the same day.
+ private void latest(Map m, Object modDate) {
+ if (modDate instanceof Date && (m.get("updateDate") == null || ((Date) modDate).after((Date) m.get("updateDate")))) {
+ m.put("updateDate", modDate);
+ }
+ }
+
+ // Name, age (years), gender for the issue row shown on the Inventory dispense screen. Missing details
+ // never block dispensing, same as Inventory-API.
+ private Object[] getPatientDetails(Long beneficiaryRegID) {
+ try {
+ RMNCHMBeneficiarymapping mapping = beneficiaryRepo.getById(BigInteger.valueOf(beneficiaryRegID));
+ RMNCHMBeneficiarydetail detail = (mapping != null && mapping.getBenDetailsId() != null)
+ ? beneficiaryRepo.getDetailsById(mapping.getBenDetailsId())
+ : null;
+ if (detail == null) return new Object[3];
+ StringJoiner name = new StringJoiner(" ");
+ for (String part : new String[] { detail.getFirstName(), detail.getMiddleName(), detail.getLastName() }) {
+ if (part != null && !part.isBlank()) name.add(part.trim());
+ }
+ Integer age = detail.getDob() != null
+ ? Period.between(detail.getDob().toLocalDateTime().toLocalDate(), LocalDate.now()).getYears()
+ : null;
+ String fullName = name.length() > 150 ? name.toString().substring(0, 150) : name.toString();
+ return new Object[] { fullName.isEmpty() ? null : fullName, age, detail.getGender() };
+ } catch (Exception e) {
+ logger.warn("Cannot read patient details for benRegID " + beneficiaryRegID + ": " + e.getMessage());
+ return new Object[3];
+ }
+ }
+
+ /**
+ * Dispensing off (stoptb.dispense.enabled=false): the prescription is saved as the app sent it. No store or
+ * stock check and no patient issue, so drugs from the app's own list need not exist in this camp's store;
+ * DrugID, name and form are taken from the request. A new save replaces the visit's earlier prescription
+ * (same as chief complaints), so an edit or retry does not leave a second copy.
+ */
+ private Map prescribeWithoutDispensing(Map prescription,
+ List> drugs, Long beneficiaryRegID, BenVisitDetail visit, String createdBy,
+ Integer vanID, Integer parkingPlaceID) {
+ for (Map d : drugs) {
+ if (toInt(d.get("drugID")) == null) throw new IllegalArgumentException("drugID is required for every drug");
+ }
+ // Processed='N' so the removal is uploaded to central again (central updates rows it already has).
+ for (String table : new String[] { "t_prescribeddrug", "t_prescription" }) {
+ em.createNativeQuery("UPDATE db_iemr." + table + " SET Deleted = true, Processed = 'N', ModifiedBy = :user "
+ + "WHERE BeneficiaryRegID = :ben AND VisitCode = :visitCode AND Deleted = false")
+ .setParameter("user", createdBy)
+ .setParameter("ben", beneficiaryRegID)
+ .setParameter("visitCode", visit.getVisitCode())
+ .executeUpdate();
+ }
+
+ Map result = new LinkedHashMap<>();
+ String instruction = toStr(prescription.get("instruction"));
+ if (!drugs.isEmpty() || (instruction != null && !instruction.isBlank())) {
+ long prescriptionID = insertPrescription(beneficiaryRegID, visit, instruction, createdBy, vanID,
+ parkingPlaceID);
+ for (Map d : drugs) {
+ Integer qty = toInt(d.get("qtyPrescribed"));
+ if (qty == null || qty <= 0) qty = calculateQuantity(d, toInt(d.get("itemFormID"))); // null if unknown
+ em.createNativeQuery("INSERT INTO db_iemr.t_prescribeddrug (BeneficiaryRegID, BenVisitID, "
+ + "ProviderServiceMapID, VisitCode, PrescriptionID, DrugForm, DrugID, GenericDrugName, Dose, "
+ + "Frequency, Duration, DuartionUnit, SpecialInstruction, QtyPrescribed, Deleted, Processed, "
+ + "CreatedBy, VanID, ParkingPlaceID) VALUES (:ben, :visitID, :psm, :visitCode, "
+ + ":prescriptionID, :form, :drugID, :name, :dose, :frequency, :duration, :durationUnit, "
+ + ":instruction, :qty, false, 'N', :user, :van, :pp)")
+ .setParameter("ben", beneficiaryRegID)
+ .setParameter("visitID", visit.getBenVisitId())
+ .setParameter("psm", visit.getProviderServiceMapID())
+ .setParameter("visitCode", visit.getVisitCode())
+ .setParameter("prescriptionID", prescriptionID)
+ .setParameter("form", toStr(d.get("drugForm")))
+ .setParameter("drugID", toInt(d.get("drugID")))
+ .setParameter("name", toStr(d.get("drugName")))
+ .setParameter("dose", toStr(d.get("dose")))
+ .setParameter("frequency", toStr(d.get("frequency")))
+ .setParameter("duration", toStr(d.get("duration")))
+ .setParameter("durationUnit", toStr(d.get("durationUnit")))
+ .setParameter("instruction", toStr(d.get("instructions")))
+ .setParameter("qty", qty)
+ .setParameter("user", createdBy)
+ .setParameter("van", vanID)
+ .setParameter("pp", parkingPlaceID)
+ .executeUpdate();
+ stampVanSerialNo("t_prescribeddrug", "PrescribedDrugID", lastInsertId());
+ }
+ result.put("prescriptionID", prescriptionID);
+ }
+ result.put("dispensed", new ArrayList>());
+ return result;
+ }
+
+ // t_prescription row for the visit (Stop TB service line, same as the visit).
+ private long insertPrescription(Long beneficiaryRegID, BenVisitDetail visit, String instruction, String createdBy,
+ Integer vanID, Integer parkingPlaceID) {
+ em.createNativeQuery("INSERT INTO db_iemr.t_prescription (BeneficiaryRegID, BenVisitID, ProviderServiceMapID, VisitCode, "
+ + "Instruction, Deleted, Processed, CreatedBy, VanID, ParkingPlaceID) "
+ + "VALUES (:ben, :visitID, :psm, :visitCode, :instruction, false, 'N', :user, :van, :pp)")
+ .setParameter("ben", beneficiaryRegID)
+ .setParameter("visitID", visit.getBenVisitId())
+ .setParameter("psm", visit.getProviderServiceMapID())
+ .setParameter("visitCode", visit.getVisitCode())
+ .setParameter("instruction", instruction)
+ .setParameter("user", createdBy)
+ .setParameter("van", vanID)
+ .setParameter("pp", parkingPlaceID)
+ .executeUpdate();
+ long prescriptionID = lastInsertId();
+ stampVanSerialNo("t_prescription", "PrescriptionID", prescriptionID);
+ return prescriptionID;
+ }
+
+ /**
+ * Units to give when the app sends no quantity – MMU's rule (CommonNurseServiceImpl.calculateQtyPrescribed).
+ * Tablets/capsules: tablets per intake x intakes per day x days, rounded up. Tablets per intake come from the
+ * dose (Half Tab 0.5, One Tab 1, One & Half Tab 1.5, Two Tabs 2); no dose sent = one tablet (capsule always 1).
+ * Single/Stat dose = one intake. SOS = up to one intake a day (one intake when no duration). Once in a week =
+ * one intake per 7 days. Other forms (syrup, cream, injection, drops...): 1 bottle/tube/vial. Null when a
+ * tablet/capsule quantity cannot be worked out (unknown frequency or missing duration).
+ */
+ private Integer calculateQuantity(Map drug, Integer formID) {
+ if (formID == null || (formID != 1 && formID != 2)) return 1; // 1 = Tablet, 2 = Capsule
+ double perIntake = formID == 2 ? 1 : tabletsPerIntake(toStr(drug.get("dose")));
+ String frequency = Optional.ofNullable(toStr(drug.get("frequency"))).orElse("").toUpperCase();
+ if (frequency.contains("SINGLE DOSE") || frequency.contains("STAT")) return (int) Math.ceil(perIntake);
+
+ Integer duration = toInt(drug.get("duration"));
+ boolean sos = frequency.contains("SOS");
+ if (duration == null || duration <= 0) return sos ? (int) Math.ceil(perIntake) : null;
+ String unit = Optional.ofNullable(toStr(drug.get("durationUnit"))).orElse("Day").toLowerCase();
+ int days = unit.startsWith("week") ? duration * 7 : unit.startsWith("month") ? duration * 30
+ : unit.startsWith("year") ? duration * 365 : duration;
+
+ if (frequency.contains("WEEK")) return (int) Math.ceil(perIntake * ((days + 6) / 7)); // Once in a Week
+ int perDay;
+ if (frequency.contains("QID") || frequency.contains("FOUR")) perDay = 4;
+ else if (frequency.contains("TID") || frequency.contains("THRICE")) perDay = 3;
+ else if (frequency.contains("BD") || frequency.contains("TWICE")) perDay = 2;
+ else if (frequency.contains("OD") || frequency.contains("ONCE DAILY") || sos) perDay = 1; // SOS: up to 1 a day
+ else return null; // unknown frequency
+ return (int) Math.ceil(perIntake * perDay * days);
+ }
+
+ // MMU dose names (m_drugdose); anything else or no dose = one tablet
+ private static double tabletsPerIntake(String dose) {
+ if (dose == null) return 1;
+ String d = dose.trim().toLowerCase();
+ if (d.startsWith("half")) return 0.5;
+ if (d.startsWith("one & half") || d.startsWith("one and half") || d.startsWith("1.5")) return 1.5;
+ if (d.startsWith("two")) return 2;
+ return 1;
+ }
+
+ // ItemID, ItemName, strength+UOM, form, route, isEDL, IssueType, ItemFormID — only if the drug is mapped to
+ // the store on its own service line (same join as v_drugforprescription, so the save accepts what the list shows).
+ private Object[] getStoreItem(Integer facilityID, Integer drugID) {
+ List rows = em.createNativeQuery("SELECT i.ItemID, i.ItemName, CONCAT_WS(' ', i.Strength, u.UOMName), "
+ + "f.ItemFormName, r.RouteName, i.isEDL, c.IssueType, i.ItemFormID "
+ + "FROM db_iemr.m_item i "
+ + "JOIN db_iemr.m_itemfacilitymapping m ON m.ItemID = i.ItemID AND m.FacilityID = :facilityID "
+ + "AND m.ProviderServiceMapID = i.ProviderServiceMapID AND m.Deleted = false "
+ + "LEFT JOIN db_iemr.m_uom u ON u.UOMID = i.UOMID "
+ + "LEFT JOIN db_iemr.m_itemform f ON f.ItemFormID = i.ItemFormID "
+ + "LEFT JOIN db_iemr.m_routeofadmin r ON r.RouteID = i.RouteID "
+ + "LEFT JOIN db_iemr.m_itemcategory c ON c.ItemCategoryID = i.ItemCategoryID "
+ + "WHERE i.ItemID = :drugID AND i.Deleted = false")
+ .setParameter("facilityID", facilityID)
+ .setParameter("drugID", drugID)
+ .getResultList();
+ if (rows.isEmpty()) {
+ throw new IllegalArgumentException("drugID " + drugID + " is not available in this camp's store");
+ }
+ return (Object[]) rows.get(0);
+ }
+
+ // A batch is usable if it has no expiry date (counted by v_drugforprescription too) or lasts the course.
+ private static final String USABLE_BATCH = "AND (ExpiryDate IS NULL OR ExpiryDate > DATE_ADD(CURDATE(), INTERVAL :days DAY)) ";
+
+ // Usable batches (VanSerialNo, QuantityInHand), locked for this transaction, in the category's issue order.
+ @SuppressWarnings("unchecked")
+ private List lockBatches(Integer facilityID, Integer drugID, String issueType, int durationDays) {
+ String order;
+ if ("Last In First Out".equalsIgnoreCase(issueType)) order = "CreatedDate DESC, ItemStockEntryID DESC";
+ else if ("First In First Out".equalsIgnoreCase(issueType)) order = "CreatedDate ASC, ItemStockEntryID ASC";
+ else order = "ExpiryDate IS NULL, ExpiryDate ASC, ItemStockEntryID ASC"; // First Expiry First Out (default)
+ Query q = em.createNativeQuery("SELECT VanSerialNo, QuantityInHand FROM db_iemr.t_itemstockentry "
+ + "WHERE FacilityID = :facilityID AND ItemID = :drugID AND Deleted = false AND QuantityInHand > 0 "
+ + USABLE_BATCH + "ORDER BY " + order + " FOR UPDATE")
+ .setParameter("facilityID", facilityID)
+ .setParameter("drugID", drugID)
+ .setParameter("days", durationDays);
+ return (List) q.getResultList();
+ }
+
+ private int availableQuantity(Integer facilityID, Integer drugID, int durationDays) {
+ Object v = em.createNativeQuery("SELECT COALESCE(SUM(QuantityInHand), 0) FROM db_iemr.t_itemstockentry "
+ + "WHERE FacilityID = :facilityID AND ItemID = :drugID AND Deleted = false AND QuantityInHand > 0 "
+ + USABLE_BATCH)
+ .setParameter("facilityID", facilityID)
+ .setParameter("drugID", drugID)
+ .setParameter("days", durationDays)
+ .getSingleResult();
+ return ((Number) v).intValue();
+ }
+
+ private Integer getStorePsm(Integer facilityID) {
+ Object v = em.createNativeQuery("SELECT ProviderServiceMapID FROM db_iemr.m_facility WHERE FacilityID = :facilityID")
+ .setParameter("facilityID", facilityID)
+ .getSingleResult();
+ return v != null ? ((Number) v).intValue() : null;
+ }
+
+ // Longest treatment among the lines for this drug, so the batch lasts until the course ends.
+ private int maxDurationDays(List> drugs, Integer drugID) {
+ int max = 0;
+ for (Map d : drugs) {
+ if (!drugID.equals(toInt(d.get("drugID")))) continue;
+ Integer n = toInt(d.get("duration"));
+ if (n == null || n <= 0) continue;
+ String unit = Optional.ofNullable(toStr(d.get("durationUnit"))).orElse("Day").toLowerCase();
+ int days = unit.startsWith("week") ? n * 7 : unit.startsWith("month") ? n * 30 : unit.startsWith("year") ? n * 365 : n;
+ max = Math.max(max, days);
+ }
+ return max;
+ }
+
+ private long lastInsertId() {
+ return ((Number) em.createNativeQuery("SELECT LAST_INSERT_ID()").getSingleResult()).longValue();
+ }
+
+ // VanSerialNo = own ID, as every MMU/Inventory save does, so van-to-server sync can identify the row.
+ private void stampVanSerialNo(String table, String idColumn, long id) {
+ em.createNativeQuery("UPDATE db_iemr." + table + " SET VanSerialNo = " + idColumn + " WHERE " + idColumn + " = :id")
+ .setParameter("id", id)
+ .executeUpdate();
+ }
+
+ @SuppressWarnings("unchecked")
+ private List> toList(Object v) {
+ if (v instanceof List) return (List>) v;
+ return Collections.emptyList();
+ }
+
+ private Integer toInt(Object v) {
+ if (v == null) return null;
+ if (v instanceof Number) return ((Number) v).intValue();
+ String s = v.toString().trim();
+ if (s.isEmpty()) return null;
+ try {
+ return (int) Double.parseDouble(s);
+ } catch (NumberFormatException e) {
+ return null;
+ }
+ }
+
+ private String toStr(Object v) {
+ return v != null ? v.toString() : null;
+ }
+}
diff --git a/src/main/java/com/iemr/flw/service/StopTBService.java b/src/main/java/com/iemr/flw/service/StopTBService.java
index e549daa6f..4011d4315 100644
--- a/src/main/java/com/iemr/flw/service/StopTBService.java
+++ b/src/main/java/com/iemr/flw/service/StopTBService.java
@@ -1,5 +1,6 @@
package com.iemr.flw.service;
+import java.util.Collection;
import java.util.List;
import java.util.Map;
@@ -19,4 +20,15 @@ public interface StopTBService {
// Nurse — Diagnostics
List> saveDiagnostics(List> dataList) throws Exception;
Map getAllDiagnostics(Integer providerServiceMapID, Integer villageID) throws Exception;
+
+ // The same records the getAll endpoints return, for specific rows (STOP-TB changes feed), keyed by
+ // the row id. Deleted rows, and rows getAll would not return, are left out.
+ Map> getNurseTBScreeningsByIds(Collection ids);
+ Map> getGeneralExaminationsByIds(Collection ids);
+ Map> getDiagnosticsByIds(Collection ids);
+ // Standard-table OPD visits, keyed by BenVisitID
+ Map> getGeneralOpdByVisitIds(Collection benVisitIds);
+ // Older free-text OPD rows (tb_stoptb_general_opd), keyed by their id; left out when the same visit
+ // also exists in the standard tables, as getAllGeneralOpd does
+ Map> getLegacyGeneralOpdByIds(Collection ids);
}
diff --git a/src/main/java/com/iemr/flw/service/StopTBSyncService.java b/src/main/java/com/iemr/flw/service/StopTBSyncService.java
new file mode 100644
index 000000000..9e8c94b6a
--- /dev/null
+++ b/src/main/java/com/iemr/flw/service/StopTBSyncService.java
@@ -0,0 +1,19 @@
+package com.iemr.flw.service;
+
+import java.util.List;
+import java.util.Map;
+
+public interface StopTBSyncService {
+
+ /**
+ * One page of the STOP-TB changes feed for the given villages: a first full download when the
+ * token is missing, from another hub or too old; otherwise only what changed after it.
+ * Returns {supported:false} where the change log isn't installed, so the app keeps its full pull.
+ * The service and villages must be mapped to userId (from the JWT); empty villageIds means all of
+ * the user's villages for that service.
+ * types limits the feed to the record types the app applies (StopTBSyncType api names); null or
+ * empty means all. The app must start a new snapshot (no token) whenever it changes this list.
+ */
+ Map getChanges(Integer userId, String token, Integer providerServiceMapID, List villageIds,
+ List types, Integer limit, String authorisation);
+}
diff --git a/src/main/java/com/iemr/flw/service/TBConfirmedCaseService.java b/src/main/java/com/iemr/flw/service/TBConfirmedCaseService.java
index 23871f1b2..b1d4165eb 100644
--- a/src/main/java/com/iemr/flw/service/TBConfirmedCaseService.java
+++ b/src/main/java/com/iemr/flw/service/TBConfirmedCaseService.java
@@ -1,8 +1,6 @@
package com.iemr.flw.service;
import com.iemr.flw.domain.iemr.TBConfirmedCaseDTO;
-import com.iemr.flw.dto.iemr.TbReferralFollowUpDTO;
-import com.iemr.flw.dto.iemr.TbTptFollowUpDTO;
import org.springframework.stereotype.Service;
import java.util.List;
@@ -18,11 +16,6 @@ public interface TBConfirmedCaseService {
String getByProviderServiceMapId(Integer providerServiceMapID, Integer villageID) throws Exception;
- String saveReferralFollowUp(TbReferralFollowUpDTO requestDTO, String token);
-
- String getReferralFollowUp(String token);
-
- String saveTptFollowUp(TbTptFollowUpDTO requestDTO, String token);
-
- String getTptFollowUp(String token);
+ // One record per row, in the same JSON shape getAll returns (STOP-TB changes feed), keyed by id.
+ java.util.Map getRecordsByIds(java.util.Collection ids);
}
diff --git a/src/main/java/com/iemr/flw/service/TBSuspectedService.java b/src/main/java/com/iemr/flw/service/TBSuspectedService.java
index 32d882a80..97d9e0d87 100644
--- a/src/main/java/com/iemr/flw/service/TBSuspectedService.java
+++ b/src/main/java/com/iemr/flw/service/TBSuspectedService.java
@@ -13,4 +13,7 @@ public interface TBSuspectedService {
String save(TBSuspectedRequestDTO tbScreeningList) throws Exception;
String getByUserId(GetBenRequestHandler userId);
+
+ // One record per row, in the same JSON shape getAll returns (STOP-TB changes feed), keyed by id.
+ java.util.Map getRecordsByIds(java.util.Collection ids);
}
diff --git a/src/main/java/com/iemr/flw/service/impl/BeneficiaryServiceImpl.java b/src/main/java/com/iemr/flw/service/impl/BeneficiaryServiceImpl.java
index dda2bb9d1..bc1edc372 100644
--- a/src/main/java/com/iemr/flw/service/impl/BeneficiaryServiceImpl.java
+++ b/src/main/java/com/iemr/flw/service/impl/BeneficiaryServiceImpl.java
@@ -12,6 +12,7 @@
import java.util.ArrayList;
import java.util.Calendar;
import java.util.HashMap;
+import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
@@ -119,6 +120,9 @@ public class BeneficiaryServiceImpl implements BeneficiaryService {
@Autowired
private BenPhysicalVitalRepo benPhysicalVitalRepo;
+ @Autowired
+ private WorklistPagePrefetch worklistPagePrefetch;
+
private static final DateTimeFormatter FORMATTER = DateTimeFormatter.ofPattern("dd-MM-yyyy");
@@ -141,8 +145,10 @@ public String getBenData(GetBenRequestHandler request, String authorisation) thr
// O(village size), on every page including page 0. See BeneficiaryRepo for the
// underlying query.
if (request.getProviderServiceMapID() != null && request.getVillageID() != null) {
+ long tStart = System.currentTimeMillis();
long totalCount = beneficiaryRepo.countVillageWorklist(
request.getProviderServiceMapID(), request.getVillageID());
+ long tCount = System.currentTimeMillis();
if (totalCount == 0) return null;
@@ -152,6 +158,7 @@ public String getBenData(GetBenRequestHandler request, String authorisation) thr
List addressIds = beneficiaryRepo.getVillageWorklistAddressIds(
request.getProviderServiceMapID(), request.getVillageID(), pageSize, offset);
+ long tIds = System.currentTimeMillis();
if (addressIds.isEmpty()) return null;
@@ -159,17 +166,28 @@ public String getBenData(GetBenRequestHandler request, String authorisation) thr
// Hibernate 6.4.1 bug there: "Binding is multi-valued; illegal call to
// #getBindValue" even with a well-formed, non-empty id list (confirmed live
// against 192.168.45.40 - the 10 rows returned have no NULLs/type issues, so
- // this isn't a data problem). Looping getAddressById() per id sidesteps
- // Hibernate's collection-parameter binding entirely - only ever pageSize (10)
- // calls per page, same order-preservation as before.
- List pageAddresses = addressIds.stream()
- .map(beneficiaryRepo::getAddressById)
- .filter(java.util.Objects::nonNull)
- .collect(Collectors.toList());
+ // this isn't a data problem). WorklistPagePrefetch reads them in one native query
+ // with the ids as numeric literals (no collection binding), keeping page order;
+ // the per-id loop stays as the fallback.
+ List pageAddresses;
+ try {
+ pageAddresses = worklistPagePrefetch.addressesInOrder(addressIds);
+ } catch (Exception e) {
+ logger.warn("Worklist address batch failed, reading one by one: " + e.getMessage());
+ pageAddresses = addressIds.stream()
+ .map(beneficiaryRepo::getAddressById)
+ .filter(java.util.Objects::nonNull)
+ .collect(Collectors.toList());
+ }
if (pageAddresses.isEmpty()) return null;
+ long tAddr = System.currentTimeMillis();
- return getMappingsForAddressIDs(pageAddresses, totalPage, authorisation);
+ String timingLabel = "[WORKLIST-TIMING] psm=" + request.getProviderServiceMapID()
+ + " village=" + request.getVillageID() + " page=" + request.getPageNo() + "/" + totalPage
+ + " pageSize=" + pageSize + " villageTotal=" + totalCount
+ + " | countMs=" + (tCount - tStart) + " idsMs=" + (tIds - tCount) + " addressMs=" + (tAddr - tIds);
+ return getMappingsForAddressIDs(pageAddresses, totalPage, authorisation, timingLabel, tStart);
}
// Normal FLW/ASHA path
@@ -213,13 +231,59 @@ public String getBenData(GetBenRequestHandler request, String authorisation) thr
return getMappingsForAddressIDs(
pageResult.getContent(),
pageResult.getTotalPages(),
- authorisation
+ authorisation,
+ null,
+ 0L
);
}
+ // timingLabel != null logs one [WORKLIST-TIMING] line per page (Stop TB village path) so camp-laptop
+ // logs show where each page's time goes.
private String getMappingsForAddressIDs(List addressList, int totalPage,
- String authorisation) {
+ String authorisation, String timingLabel, long tStart) {
+ long tBuildStart = System.currentTimeMillis();
+ List> resultList = buildBeneficiaryRecords(addressList, authorisation);
+ long tBuild = System.currentTimeMillis();
+
+ Map response = new HashMap<>();
+ response.put("data", resultList);
+ response.put("pageSize", Integer.parseInt(door_to_door_page_size));
+ response.put("totalPage", totalPage);
+ Gson gson = new GsonBuilder().setDateFormat("MMM dd, yyyy h:mm:ss a").create();
+ String json = gson.toJson(response);
+
+ if (timingLabel != null) {
+ long tEnd = System.currentTimeMillis();
+ logger.info(timingLabel + " buildMs=" + (tBuild - tBuildStart) + " jsonMs=" + (tEnd - tBuild)
+ + " totalMs=" + (tEnd - tStart) + " rows=" + resultList.size() + "/" + addressList.size()
+ + " bytes=" + json.length());
+ }
+ return json;
+ }
+
+ // One record per beneficiary, in the same JSON shape getBeneficiaryData returns, keyed by BenRegId.
+ // Used by the STOP-TB changes feed; a BenRegId with no mapping or address is left out.
+ @Override
+ public Map getBeneficiaryRecordsByRegIds(List benRegIds, String authorisation) {
+ List addresses = new ArrayList<>();
+ for (Long benRegId : benRegIds) {
+ RMNCHMBeneficiarymapping m = beneficiaryRepo.getById(BigInteger.valueOf(benRegId));
+ if (m == null || m.getBenAddressId() == null) continue;
+ RMNCHMBeneficiaryaddress a = beneficiaryRepo.getAddressById(m.getBenAddressId());
+ if (a != null) addresses.add(a);
+ }
+ Gson gson = new GsonBuilder().setDateFormat("MMM dd, yyyy h:mm:ss a").create();
+ Map records = new LinkedHashMap<>();
+ for (Map record : buildBeneficiaryRecords(addresses, authorisation)) {
+ Object benRegId = record.get("BenRegId");
+ if (benRegId != null) records.put(new BigInteger(benRegId.toString()).longValue(), gson.toJson(record));
+ }
+ return records;
+ }
+
+ private List> buildBeneficiaryRecords(List addressList,
+ String authorisation) {
RMNCHHouseHoldDetails benHouseHoldRMNCH_ROBJ;
RMNCHBeneficiaryDetailsRmnch benDetailsRMNCH_OBJ;
RMNCHBornBirthDetails benBotnBirthRMNCH_ROBJ;
@@ -233,10 +297,20 @@ private String getMappingsForAddressIDs(List addressLi
Map resultMap;
ArrayList> resultList = new ArrayList<>();
+ // One query per table for the whole page; if it fails, every lookup below falls back to its
+ // original per-beneficiary query.
+ WorklistPagePrefetch.Page pf = null;
+ try {
+ pf = worklistPagePrefetch.load(addressList);
+ } catch (Exception e) {
+ logger.warn("Worklist page prefetch failed, using per-beneficiary queries: " + e.getMessage());
+ }
+
for (RMNCHMBeneficiaryaddress a : addressList) {
// exception by-passing
try {
- List mappingsForAddress = beneficiaryRepo.getByAddressID(a.getId());
+ List mappingsForAddress = pf != null ? pf.mappings(a.getId())
+ : beneficiaryRepo.getByAddressID(a.getId());
if(!mappingsForAddress.isEmpty()){
RMNCHMBeneficiarymapping m = mappingsForAddress.get(0);
if (m != null) {
@@ -249,38 +323,53 @@ private String getMappingsForAddressIDs(List addressLi
benImageOBJ = new RMNCHMBeneficiaryImage();
benAddressOBJ = new RMNCHMBeneficiaryaddress();
benContactOBJ = new RMNCHMBeneficiarycontact();
- Map healthDetails = getBenHealthDetails(m.getBenRegId());
+ Long regIdLong = m.getBenRegId() != null ? m.getBenRegId().longValue() : null;
+ // no m_benhealthidmapping row -> the original lookup returns an empty map too
+ Map healthDetails = (pf != null && regIdLong != null && !pf.hasHealthId(regIdLong))
+ ? new HashMap<>() : getBenHealthDetails(m.getBenRegId());
if (m.getBenDetailsId() != null) {
- benDetailsOBJ = beneficiaryRepo.getDetailsById(m.getBenDetailsId());
+ benDetailsOBJ = pf != null ? pf.detail(m.getBenDetailsId())
+ : beneficiaryRepo.getDetailsById(m.getBenDetailsId());
}
if (m.getBenAccountID() != null) {
- benAccountOBJ = beneficiaryRepo.getAccountById(m.getBenAccountID());
+ benAccountOBJ = pf != null ? pf.account(m.getBenAccountID())
+ : beneficiaryRepo.getAccountById(m.getBenAccountID());
}
if (m.getBenImageId() != null) {
- benImageOBJ = beneficiaryRepo.getImageById(m.getBenImageId().longValue());
+ benImageOBJ = pf != null ? pf.image(m.getBenImageId())
+ : beneficiaryRepo.getImageById(m.getBenImageId().longValue());
}
if (m.getBenAddressId() != null) {
- benAddressOBJ = beneficiaryRepo.getAddressById(m.getBenAddressId());
+ benAddressOBJ = pf != null ? pf.address(m.getBenAddressId())
+ : beneficiaryRepo.getAddressById(m.getBenAddressId());
}
if (m.getBenContactsId() != null) {
- benContactOBJ = beneficiaryRepo.getContactById(m.getBenContactsId());
+ benContactOBJ = pf != null ? pf.contact(m.getBenContactsId())
+ : beneficiaryRepo.getContactById(m.getBenContactsId());
}
BigInteger benID = null;
- if (m.getBenRegId() != null)
- benID = beneficiaryRepo.getBenIdFromRegID(m.getBenRegId().longValue());
+ if (regIdLong != null) {
+ // more than one row: let the original single-result query decide, as before
+ benID = (pf != null && pf.benIds(regIdLong).size() <= 1)
+ ? pf.benIds(regIdLong).stream().findFirst().orElse(null)
+ : beneficiaryRepo.getBenIdFromRegID(regIdLong);
+ }
- if (m.getBenRegId() != null) {
- List detailsByRegID = beneficiaryRepo
- .getDetailsByRegID((m.getBenRegId()).longValue());
+ if (regIdLong != null) {
+ List detailsByRegID = pf != null ? pf.rmnch(regIdLong)
+ : beneficiaryRepo.getDetailsByRegID(regIdLong);
if(!detailsByRegID.isEmpty()){
benDetailsRMNCH_OBJ = detailsByRegID.get(0);
}
- benBotnBirthRMNCH_ROBJ = beneficiaryRepo.getBornBirthByRegID((m.getBenRegId()).longValue());
+ benBotnBirthRMNCH_ROBJ = (pf != null && pf.bornBirth(regIdLong).size() <= 1)
+ ? pf.bornBirth(regIdLong).stream().findFirst().orElse(null)
+ : beneficiaryRepo.getBornBirthByRegID(regIdLong);
if (benDetailsRMNCH_OBJ != null && benDetailsRMNCH_OBJ.getHouseoldId() != null) {
- List householdsById = houseHoldRepo
- .getByHouseHoldID(benDetailsRMNCH_OBJ.getHouseoldId());
+ List householdsById = pf != null
+ ? pf.households(benDetailsRMNCH_OBJ.getHouseoldId())
+ : houseHoldRepo.getByHouseHoldID(benDetailsRMNCH_OBJ.getHouseoldId());
if(!householdsById.isEmpty()){
benHouseHoldRMNCH_ROBJ = householdsById.get(0);
}
@@ -363,7 +452,6 @@ private String getMappingsForAddressIDs(List addressLi
if (benAddressOBJ.getPermPinCode() != null)
benDetailsRMNCH_OBJ.setPinCode(benAddressOBJ.getPermPinCode());
-
// -----------------------------------------------------------------------------
// related benids
@@ -393,7 +481,8 @@ private String getMappingsForAddressIDs(List