Release 3.6.0

pom.xml

@@ -6,7 +6,7 @@
 
 	<groupId>com.iemr.common-API</groupId>
 	<artifactId>common-api</artifactId>
-	<version>3.4.0</version>
+	<version>3.6.0</version>
 	<packaging>war</packaging>
 
 	<name>Common-API</name>
@@ -111,6 +111,12 @@
 
 			</exclusions>
 		</dependency>
+
+		<dependency>
+			<groupId>com.google.firebase</groupId>
+			<artifactId>firebase-admin</artifactId>
+			<version>9.4.3</version>
+		</dependency>
 		<dependency>
 			<groupId>org.springframework.boot</groupId>
 			<artifactId>spring-boot-starter-data-jpa</artifactId>

src/main/environment/common_ci.properties

@@ -32,6 +32,7 @@ identity-1097-api-url = @env.IDENTITY_1097_API_URL@
 send-sms=@env.SEND_SMS@
 sendSMSUrl = @env.SEND_SMS_URL@
 source-address=@env.SMS_SOURCE_ADDRESS@
+sms-consent-source-address = @env.SMS_CONSENT_SOURCE_ADDRESS@
 sms-username=@env.SMS_USERNAME@
 sms-password=@env.SMS_PASSWORD@
 send-message-url=@env.SMS_MESSAGE_URL@
@@ -40,6 +41,11 @@ send-message-url=@env.SMS_MESSAGE_URL@
 start-sms-scheduler=true
 cron-scheduler-sms=0 0/1 * * * ? *
 
+# Firebase Configuration
+firebase.enabled=@env.FIREBASE_ENABLE@
+# if using file
+firebase.credential-file=@env.FIREBASE_CREDENTIAL@
+
 #### Email Configuration
 send-email=@env.SEND_EMAIL@
 spring.mail.host=@env.MAIL_HOST@
@@ -185,4 +191,5 @@ cors.allowed-origins=@env.CORS_ALLOWED_ORIGINS@
 
 video-call-url=@env.VIDEO_CALL_URL@
 jibri.output.path=@env.JIBRI_OUTPUT_PATH@
-video.recording.path=@env.VIDEO_RECORDING_PATH@
+video.recording.path=@env.VIDEO_RECORDING_PATH@
+generateBeneficiaryIDs-api-url=@env.GEN_BENEFICIARY_IDS_API_URL@

src/main/environment/common_docker.properties

@@ -32,6 +32,7 @@ identity-1097-api-url = ${IDENTITY_1097_API_URL}
 send-sms=${SEND_SMS}
 sendSMSUrl = ${SEND_SMS_URL}
 source-address=${SMS_SOURCE_ADDRESS}
+sms-consent-source-address=${SMS_CONSENT_SOURCE_ADDRESS}
 sms-username=${SMS_USERNAME}
 sms-password=${SMS_PASSWORD}
 send-message-url=${SMS_MESSAGE_URL}
@@ -185,6 +186,13 @@ captcha.enable-captcha=${ENABLE_CAPTCHA}
 
 cors.allowed-origins=${CORS_ALLOWED_ORIGINS}
 
+# # Firebase Configuration
+firebase.enabled=${FIREBASE_ENABLE}
+# # if using file
+firebase.credential-file=${FIREBASE_CREDENTIAL}
+
+
 video-call-url=${VIDEO_CALL_URL}
 jibri.output.path={JIBRI_OUTPUT_PATH}
-video.recording.path={VIDEO_RECORDING_PATH}
+video.recording.path={VIDEO_RECORDING_PATH}
+generateBeneficiaryIDs-api-url={GEN_BENEFICIARY_IDS_API_URL}

src/main/environment/common_example.properties

@@ -208,3 +208,5 @@ captcha.enable-captcha=true
 
 cors.allowed-origins=http://localhost:*
 
+### generate Beneficiary IDs URL
+generateBeneficiaryIDs-api-url=/generateBeneficiaryController/generateBeneficiaryIDs

src/main/java/com/iemr/common/CommonApplication.java

@@ -29,7 +29,6 @@
 import org.springframework.data.redis.connection.RedisConnectionFactory;
 import org.springframework.data.redis.core.RedisTemplate;
 import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
-import org.springframework.data.redis.serializer.StringRedisSerializer;
 import org.springframework.scheduling.annotation.EnableScheduling;
 import org.springframework.web.client.RestTemplate;
 

src/main/java/com/iemr/common/config/firebase/FirebaseMessagingConfig.java

@@ -0,0 +1,65 @@
+package com.iemr.common.config.firebase;
+
+import com.google.auth.oauth2.GoogleCredentials;
+import com.google.firebase.FirebaseApp;
+import com.google.firebase.FirebaseOptions;
+import com.google.firebase.messaging.FirebaseMessaging;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.core.io.ClassPathResource;
+
+import java.io.ByteArrayInputStream;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.util.Base64;
+
+@Configuration
+public class FirebaseMessagingConfig {
+    private Logger logger = LoggerFactory.getLogger(this.getClass().getSimpleName());
+
+    @Value("${firebase.enabled:false}")
+    private boolean firebaseEnabled;
+
+    @Value("${firebase.credential-file:}")
+    private String firebaseCredentialFile;
+
+
+    @Bean
+    @ConditionalOnProperty(name = "firebase.enabled", havingValue = "true")
+    public FirebaseMessaging firebaseMessaging() throws IOException {
+        if (!firebaseEnabled) {
+            logger.error("⚠️ Firebase disabled by config");
+            return null;
+        }
+
+        try {
+            if (firebaseCredentialFile == null || firebaseCredentialFile.isBlank()) {
+                logger.error("⚠️ No Firebase credentials path provided");
+                return null; // don't throw, app will still start
+            }
+
+            GoogleCredentials credentials = GoogleCredentials.fromStream(
+                    new ClassPathResource(firebaseCredentialFile).getInputStream()
+            );
+            FirebaseOptions options = FirebaseOptions.builder()
+                    .setCredentials(credentials)
+                    .build();
+
+            FirebaseApp firebaseApp = FirebaseApp.getApps().isEmpty()
+                    ? FirebaseApp.initializeApp(options)
+                    : FirebaseApp.getInstance();
+
+            return FirebaseMessaging.getInstance(firebaseApp);
+
+        } catch (Exception e) {
+            logger.error("⚠️ Firebase init failed: " + e.getMessage());
+            return null; // keep app running
+        }
+
+    }
+
+}

src/main/java/com/iemr/common/config/quartz/ScheduleForGrievanceDataSync.java

@@ -37,3 +37,4 @@ public void execute() {
 	}
 
 }
+

src/main/java/com/iemr/common/controller/beneficiaryConsent/BeneficiaryConsentController.java

@@ -0,0 +1,118 @@
+/*
+ * 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.common.controller.beneficiaryConsent;
+
+import com.iemr.common.data.beneficiaryConsent.BeneficiaryConsentRequest;
+import com.iemr.common.service.beneficiaryOTPHandler.BeneficiaryOTPHandler;
+import com.iemr.common.utils.mapper.InputMapper;
+import com.iemr.common.utils.response.OutputResponse;
+import io.lettuce.core.dynamic.annotation.Param;
+import io.swagger.v3.oas.annotations.Operation;
+import jakarta.ws.rs.core.MediaType;
+import org.json.JSONObject;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.RestController;
+
+@RequestMapping(value = { "/beneficiaryConsent" })
+@RestController
+public class BeneficiaryConsentController {
+    final Logger logger = LoggerFactory.getLogger(this.getClass().getName());
+
+    @Autowired
+    private BeneficiaryOTPHandler beneficiaryOTPHandler;
+
+    @Operation(summary = "Send Consent")
+    @RequestMapping(value = "/sendConsent", method = RequestMethod.POST, consumes = MediaType.APPLICATION_JSON, produces = MediaType.APPLICATION_JSON)
+    public String sendConsent(@Param(value = "{\"mobNo\":\"String\"}") @RequestBody String requestOBJ) {
+
+        OutputResponse response = new OutputResponse();
+
+        try {
+            BeneficiaryConsentRequest obj = InputMapper.gson().fromJson(requestOBJ, BeneficiaryConsentRequest.class);
+
+            String success = beneficiaryOTPHandler.sendOTP(obj); // method name unchanged if internal logic still uses 'OTP'
+            logger.info(success.toString());
+            response.setResponse(success);
+
+
+        } catch (Exception e) {
+            response.setError(500, "error : " + e);
+        }
+        return response.toString();
+    }
+
+    @Operation(summary = "Validate Consent")
+    @RequestMapping(value = "/validateConsent", method = RequestMethod.POST, consumes = MediaType.APPLICATION_JSON, produces = MediaType.APPLICATION_JSON)
+    public String validateConsent(@Param(value = "{\"mobNo\":\"String\",\"otp\":\"Integer\"}") @RequestBody String requestOBJ) {
+
+        OutputResponse response = new OutputResponse();
+
+        try {
+            BeneficiaryConsentRequest obj = InputMapper.gson().fromJson(requestOBJ, BeneficiaryConsentRequest.class);
+
+            JSONObject responseOBJ = beneficiaryOTPHandler.validateOTP(obj);
+            if (responseOBJ != null)
+                response.setResponse(responseOBJ.toString());
+            else
+                response.setError(500, "failure");
+
+        } catch (Exception e) {
+            logger.error("error in validating Consent : " + e);
+            response.setError(500, "error : " + e);
+        }
+        return response.toString();
+    }
+
+    @Operation(summary = "Resend Consent")
+    @RequestMapping(value = "/resendConsent", method = RequestMethod.POST, consumes = MediaType.APPLICATION_JSON, produces = MediaType.APPLICATION_JSON)
+    public String resendConsent(@Param(value = "{\"mobNo\":\"String\"}") @RequestBody String requestOBJ) {
+        logger.info(requestOBJ.toString());
+
+        OutputResponse response = new OutputResponse();
+
+        try {
+            BeneficiaryConsentRequest obj = InputMapper.gson().fromJson(requestOBJ, BeneficiaryConsentRequest.class);
+
+            String success = beneficiaryOTPHandler.resendOTP(obj);
+            logger.info(success.toString());
+
+            if (success.contains("otp"))
+                response.setResponse(success);
+            else
+                response.setError(500, "failure");
+
+        } catch (Exception e) {
+            logger.error("error in re-sending Consent : " + e);
+            response.setError(500, "error : " + e);
+        }
+        return response.toString();
+    }
+
+
+}
+
+

src/main/java/com/iemr/common/controller/dynamicForm/DynamicFormController.java

@@ -0,0 +1,98 @@
+package com.iemr.common.controller.dynamicForm;
+
+import com.iemr.common.dto.dynamicForm.FieldDTO;
+import com.iemr.common.dto.dynamicForm.FormDTO;
+import com.iemr.common.dto.dynamicForm.ModuleDTO;
+import com.iemr.common.service.dynamicForm.FormMasterService;
+import com.iemr.common.utils.response.ApiResponse;
+import jakarta.validation.Valid;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+@RequestMapping(value = "dynamicForm")
+@RestController
+public class DynamicFormController {
+    @Autowired
+    private FormMasterService formMasterService;
+
+    @PostMapping(value = "createModule",headers = "Authorization")
+    public ResponseEntity<ApiResponse<?>> createModule(@Valid @RequestBody ModuleDTO moduleDTO) {
+        try {
+            Object result = formMasterService.createModule(moduleDTO);
+            return ResponseEntity.status(HttpStatus.OK)
+                    .body(ApiResponse.success("Module created successfully", HttpStatus.OK.value(), result));
+        } catch (IllegalArgumentException e) {
+            return ResponseEntity.status(HttpStatus.BAD_REQUEST)
+                    .body(ApiResponse.error("Invalid module data: " + e.getMessage(), HttpStatus.BAD_REQUEST.value(), null));
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
+                    .body(ApiResponse.error("Failed to create module", HttpStatus.INTERNAL_SERVER_ERROR.value(), null));
+        }
+    }
+
+    @PostMapping(value = "createForm",headers = "Authorization")
+    public ResponseEntity<ApiResponse<?>> createForm(@Valid @RequestBody FormDTO dto) {
+        try {
+            Object result = formMasterService.createForm(dto);
+            return ResponseEntity.status(HttpStatus.OK)
+                    .body(ApiResponse.success("Form created successfully", HttpStatus.OK.value(), result));
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
+                    .body(ApiResponse.error("Failed to create form", HttpStatus.INTERNAL_SERVER_ERROR.value(), null));
+        }
+    }
+
+    @PostMapping(value = "createFields",headers = "Authorization")
+    public ResponseEntity<ApiResponse<?>> createField(@Valid @RequestBody List<FieldDTO> dto) {
+        try {
+            Object result = formMasterService.createField(dto);
+            return ResponseEntity.status(HttpStatus.OK)
+                    .body(ApiResponse.success("Fields created successfully", HttpStatus.OK.value(), result));
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
+                    .body(ApiResponse.error("Failed to create fields", HttpStatus.INTERNAL_SERVER_ERROR.value(), null));
+        }
+    }
+
+    @PostMapping(value = "field/update",headers = "Authorization")
+    public ResponseEntity<ApiResponse<?>> updateField(@Valid @RequestBody FieldDTO dto) {
+        try {
+            Object result = formMasterService.updateField(dto);
+            return ResponseEntity.status(HttpStatus.OK)
+                    .body(ApiResponse.success("Field updated successfully", HttpStatus.OK.value(), result));
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
+                    .body(ApiResponse.error("Failed to update field", HttpStatus.INTERNAL_SERVER_ERROR.value(), null));
+        }
+    }
+
+    @DeleteMapping(value = "delete/{fieldId}/field",headers = "Authorization")
+    public ResponseEntity<ApiResponse<?>> deleteField(@PathVariable Long fieldId) {
+        try {
+            formMasterService.deleteField(fieldId);
+            return ResponseEntity.status(HttpStatus.OK)
+                    .body(ApiResponse.success("Field deleted successfully", HttpStatus.OK.value(), null));
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
+                    .body(ApiResponse.error("Failed to delete field", HttpStatus.INTERNAL_SERVER_ERROR.value(), null));
+        }
+    }
+
+    @GetMapping(value = "form/{formId}/fields")
+    public ResponseEntity<ApiResponse<?>> getStructuredForm(@PathVariable String formId) {
+        try {
+            Object result = formMasterService.getStructuredFormByFormId(formId);
+            return ResponseEntity.status(HttpStatus.OK)
+                    .body(ApiResponse.success("Form structure fetched successfully", HttpStatus.OK.value(), result));
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
+                    .body(ApiResponse.error("Failed to fetch form structure", HttpStatus.INTERNAL_SERVER_ERROR.value(), null));
+        }
+    }
+
+
+}