Skip to content

Commit

Permalink
process the calculated values
Browse files Browse the repository at this point in the history
  • Loading branch information
@mozzy11
mozzy11 committed Jul 23, 2023
1 parent b1fe7b9 commit ea2bacc
Show file tree
Hide file tree
Showing 8 changed files with 316 additions and 40 deletions.
3 changes: 3 additions & 0 deletions src/main/java/org/openelisglobal/result/service/LogbookPersistServiceImpl.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -28,6 +28,7 @@
import org.openelisglobal.sample.valueholder.Sample;
import org.openelisglobal.sampleitem.valueholder.SampleItem;
import org.openelisglobal.spring.util.SpringContext;
import org.openelisglobal.testcalculated.action.util.TestCalculatedUtil;
import org.openelisglobal.testreflex.action.util.TestReflexBean;
import org.openelisglobal.testreflex.action.util.TestReflexUtil;
import org.springframework.beans.factory.annotation.Autowired;
Expand Down Expand Up @@ -167,12 +168,14 @@ private void saveReferralsWithRequiredObjects(ReferralSet referralSet, String sy

protected List<Analysis> setTestReflexes(ResultsUpdateDataSet actionDataSet, String sysUserId) {
TestReflexUtil testReflexUtil = new TestReflexUtil();
TestCalculatedUtil testCalulatedUtil = new TestCalculatedUtil();
List allResults = actionDataSet.getNewResults();
allResults.addAll(actionDataSet.getModifiedResults());
List<Analysis> reflexAnalysises = testReflexUtil
.addNewTestsToDBForReflexTests(convertToTestReflexBeanList(allResults), sysUserId);
testReflexUtil.updateModifiedReflexes(convertToTestReflexBeanList(actionDataSet.getModifiedResults()),
sysUserId);
testCalulatedUtil.addNewTestsToDBForCalculatedTests(allResults, sysUserId) ;
return reflexAnalysises;
}

Expand Down
182 changes: 182 additions & 0 deletions src/main/java/org/openelisglobal/testcalculated/action/util/TestCalculatedUtil.java
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,182 @@
package org.openelisglobal.testcalculated.action.util;

import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.openelisglobal.analysis.valueholder.Analysis;
import org.openelisglobal.common.util.DateUtil;
import org.openelisglobal.result.action.util.ResultSet;
import org.openelisglobal.result.service.ResultService;
import org.openelisglobal.result.valueholder.Result;
import org.openelisglobal.spring.util.SpringContext;
import org.openelisglobal.test.service.TestService;
import org.openelisglobal.test.valueholder.Test;
import org.openelisglobal.testcalculated.service.ResultCalculationService;
import org.openelisglobal.testcalculated.service.TestCalculationService;
import org.openelisglobal.testcalculated.valueholder.Calculation;
import org.openelisglobal.testcalculated.valueholder.Operation;
import org.openelisglobal.testcalculated.valueholder.ResultCalculation;
import org.openelisglobal.testresult.service.TestResultService;
import org.springframework.context.annotation.DependsOn;
import org.springframework.stereotype.Service;

@Service
@DependsOn({ "springContext" })
public class TestCalculatedUtil {

private TestResultService testResultService = SpringContext.getBean(TestResultService.class);

private ResultCalculationService resultcalculationService = SpringContext.getBean(ResultCalculationService.class);

private TestCalculationService calculationService = SpringContext.getBean(TestCalculationService.class);

private TestService testService = SpringContext.getBean(TestService.class);

private ResultService resultService = SpringContext.getBean(ResultService.class);

public List<Analysis> addNewTestsToDBForCalculatedTests(List<ResultSet> resultSetList, String sysUserId)
throws IllegalStateException {

for (ResultSet resultSet : resultSetList) {
List<Calculation> calculations = calculationService.getAll();
for (Calculation calculation : calculations) {
if (!calculation.getActive()) {
break;
}
List<ResultCalculation> resultCalculations = resultcalculationService
.getResultCalculationByPatientAndCalculation(resultSet.patient, calculation);
if (resultCalculations.isEmpty()) {
Boolean createResultCalculation = false;
for (Operation oper : calculation.getOperations()) {
if (oper.getType().equals(Operation.OperationType.TEST_RESULT)) {
if (Integer.valueOf(oper.getValue())
.equals(Integer.valueOf(resultSet.result.getTestResult().getTest().getId()))) {
createResultCalculation = true;
break;
}
}
}
if (createResultCalculation) {
ResultCalculation calc = new ResultCalculation();
calc.setCalculation(calculation);
calc.setPatient(resultSet.patient);
Set<Test> tests = new HashSet<>();
calculation.getOperations().forEach(oper -> {
if (oper.getType().equals(Operation.OperationType.TEST_RESULT)) {
Test test = testService.getActiveTestById(Integer.valueOf(oper.getValue()));
tests.add(test);
}
});
calc.setTest(tests);
Map<Integer, Integer> map = new HashMap<>();
tests.forEach(test -> {
map.put(Integer.valueOf(test.getId()), null);
});
// insert innitail result value
map.put(Integer.valueOf(resultSet.result.getTestResult().getTest().getId()),
Integer.valueOf(resultSet.result.getId()));
calc.setTestResultMap(map);
System.out.println(calc.getTestResultMap());
resultcalculationService.insert(calc);
}

} else {
for (ResultCalculation resultCalculation : resultCalculations) {
resultCalculation.getTestResultMap().put(
Integer.valueOf(resultSet.result.getTestResult().getTest().getId()),
Integer.valueOf(resultSet.result.getId()));
resultcalculationService.update(resultCalculation);
}
}
}
List<ResultCalculation> resultCalculations = resultcalculationService
.getResultCalculationByPatientAndTest(resultSet.patient, resultSet.result.getTestResult().getTest());

if (!resultCalculations.isEmpty()) {
for (ResultCalculation resultCalculation : resultCalculations) {
Boolean missingParams = false;
for (Map.Entry<Integer, Integer> entry : resultCalculation.getTestResultMap().entrySet()) {
Integer key = entry.getKey();
Integer value = entry.getValue();
if (entry.getValue() == null) {
missingParams = true;
}
}
if (!missingParams) {
Calculation calculation = resultCalculation.getCalculation();

StringBuffer function = new StringBuffer();
calculation.getOperations().forEach(operation -> {
switch (operation.getType()) {
case TEST_RESULT:
addNumericOperation(operation ,resultCalculation ,function ,Operation.OperationType.TEST_RESULT.toString());
break;
case INTEGER:
function.append(Integer.valueOf(operation.getValue())).append(" ");
break;
case MATH_FUNCTION:
if (operation.getValue().equals(Operation.IN_NORMAL_RANGE.toLowerCase())) {
int order = operation.getOrder();
Operation prevOperation = calculation.getOperations().get(order - 1);
addNumericOperation(prevOperation ,resultCalculation ,function ,"IN_NORMAL_RANGE");

} else if (operation.getValue().equals(Operation.OUTSIDE_NORMAL_RANGE.toString())) {
int order = operation.getOrder();
Operation prevOperation = calculation.getOperations().get(order - 1);
addNumericOperation(prevOperation ,resultCalculation ,function , "OUTSIDE_NORMAL_RANGE");
} else {
function.append(operation.getValue()).append(" ");
}
break;
case PATIENT_ATTRIBUTE:
if (operation.getValue().equals(Operation.PatientAttribute.AGE.toString())) {
int age = DateUtil.getAgeInYears(
new Date(resultSet.patient.getBirthDate().getTime()), new Date());
function.append(age);
}
break;

}
});
System.out.println(function);
} else {
}
}
}
}

return null;
}

private void addNumericOperation(Operation operation, ResultCalculation resultCalculation, StringBuffer function,
String inputType) {
Test test = testService.getActiveTestById(Integer.valueOf(operation.getValue()));
if (test != null) {
Integer resultId = resultCalculation.getTestResultMap().get(Integer.valueOf(test.getId()));
Result result = resultService.get(resultId.toString());
if (result != null) {
if (result.getResultType().equals("N")) {
switch (inputType) {
case "TEST_RESULT":
function.append(result.getValue()).append(" ");
break;
case "IN_NORMAL_RANGE":
function.append(" >= ").append(result.getMinNormal()).append(" && ").append(result.getValue())
.append(" <= ").append(result.getMaxNormal()).append(" ");
break;
case "OUTSIDE_NORMAL_RANGE":
function.append(" <= ").append(result.getMinNormal()).append(" || ").append(result.getValue())
.append(" >= ").append(result.getMaxNormal()).append(" ");
break;
}
}
}
}

}

}
18 changes: 0 additions & 18 deletions ...java/org/openelisglobal/testcalculated/controller/rest/CalculatedValueRestController.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -80,24 +80,6 @@ public void saveReflexRule(HttpServletRequest request, @RequestBody Calculation
} else {
testCalculationService.save(calculation);
}
// Patient pat = patientService.getAll().get(0);
// Result result = resultService.getAll().get(0);

// ResultCalculation calc = new ResultCalculation();
// calc.setCalculation(calculation);
// calc.setPatient(pat);
// List<Test> tests = new ArrayList<>();
// calculation.getOperations().forEach(oper -> {
// if (oper.getType().equals(Operation.OperationType.TEST_RESULT)) {
// Test test = testService.getActiveTestById(Integer.valueOf(oper.getValue()));
// tests.add(test);
// }
// });
// calc.setTest(tests);
// Map<Integer , Integer> map = new HashMap<>();
// map.put(Integer.valueOf(result.getAnalysis().getTest().getId()), Integer.valueOf(result.getId()));
// calc.setTestRsultMap(map);
// resultCalculationService.insert(calc);

}

Expand Down
13 changes: 12 additions & 1 deletion src/main/java/org/openelisglobal/testcalculated/dao/ResultCalculationDAO.java
View file
Original file line number Diff line number Diff line change
@@ -1,8 +1,19 @@
package org.openelisglobal.testcalculated.dao;

import java.util.List;

import org.openelisglobal.common.dao.BaseDAO;
import org.openelisglobal.common.exception.LIMSRuntimeException;
import org.openelisglobal.patient.valueholder.Patient;
import org.openelisglobal.test.valueholder.Test;
import org.openelisglobal.testcalculated.valueholder.Calculation;
import org.openelisglobal.testcalculated.valueholder.ResultCalculation;

public interface ResultCalculationDAO extends BaseDAO<ResultCalculation, Integer>{


List<ResultCalculation> getResultCalculationByPatientAndTest(Patient patient , Test test) throws LIMSRuntimeException;

List<ResultCalculation> getResultCalculationByTest(Test test) throws LIMSRuntimeException;

List<ResultCalculation> getResultCalculationByPatientAndCalculation(Patient patient , Calculation calculation) throws LIMSRuntimeException;
}
73 changes: 70 additions & 3 deletions src/main/java/org/openelisglobal/testcalculated/daoimpl/ResultCalculationDAOImpl.java
View file
Original file line number Diff line number Diff line change
@@ -1,18 +1,85 @@
package org.openelisglobal.testcalculated.daoimpl;

import java.util.Collections;
import java.util.List;

import javax.transaction.Transactional;

import org.hibernate.Session;
import org.hibernate.query.Query;
import org.openelisglobal.common.daoimpl.BaseDAOImpl;
import org.openelisglobal.patient.valueholder.Patient;
import org.openelisglobal.test.valueholder.Test;
import org.openelisglobal.testcalculated.dao.ResultCalculationDAO;
import org.openelisglobal.testcalculated.valueholder.Calculation;
import org.openelisglobal.testcalculated.valueholder.ResultCalculation;
import org.springframework.stereotype.Component;

@Component
@Transactional
public class ResultCalculationDAOImpl extends BaseDAOImpl<ResultCalculation, Integer> implements ResultCalculationDAO{

public class ResultCalculationDAOImpl extends BaseDAOImpl<ResultCalculation, Integer> implements ResultCalculationDAO {
public ResultCalculationDAOImpl() {
super(ResultCalculation.class);
super(ResultCalculation.class);
}

@Override
public List<ResultCalculation> getResultCalculationByPatientAndTest(Patient patient, Test test) {
try {

String sql = "from ResultCalculation r WHERE r.patient.id = :patientId AND :test IN ELEMENTS(r.test)";
Query<ResultCalculation> query = entityManager.unwrap(Session.class).createQuery(sql, ResultCalculation.class);
query.setParameter("patientId", Integer.parseInt(patient.getId()));
query.setParameter("test", test);

List<ResultCalculation> results = query.list();
if (results.size() > 0) {
return results;
}
}
catch (RuntimeException e) {
handleException(e, "getResultCalculationByPatientAndTest");
}
return Collections.emptyList();
}

@Override
public List<ResultCalculation> getResultCalculationByTest(Test test) {
try {

String sql = "from ResultCalculation r JOIN r.test t WHERE t.id = :testId";
Query<ResultCalculation> query = entityManager.unwrap(Session.class).createQuery(sql, ResultCalculation.class);
query.setParameter("testId", Integer.parseInt(test.getId()));

List<ResultCalculation> results = query.list();
if (results.size() > 0) {
return results;
}
}
catch (RuntimeException e) {
handleException(e, "getResultCalculationByPatientAndTest");
}
return Collections.emptyList();
}

@Override
public List<ResultCalculation> getResultCalculationByPatientAndCalculation(Patient patient, Calculation calculation) {
try {

String sql = "from ResultCalculation r WHERE r.patient.id = :patientId AND r.calculation.id = :calculationId";
Query<ResultCalculation> query = entityManager.unwrap(Session.class).createQuery(sql, ResultCalculation.class);
query.setParameter("patientId", Integer.parseInt(patient.getId()));
query.setParameter("calculationId", calculation.getId());

List<ResultCalculation> results = query.list();
if (results.size() > 0) {
return results;
}
}
catch (RuntimeException e) {
handleException(e, "getResultCalculationByPatientAndCalculation");
}
return Collections.emptyList();
}

}
11 changes: 11 additions & 0 deletions src/main/java/org/openelisglobal/testcalculated/service/ResultCalculationService.java
View file
Original file line number Diff line number Diff line change
@@ -1,8 +1,19 @@
package org.openelisglobal.testcalculated.service;

import java.util.List;

import org.openelisglobal.common.service.BaseObjectService;
import org.openelisglobal.patient.valueholder.Patient;
import org.openelisglobal.test.valueholder.Test;
import org.openelisglobal.testcalculated.valueholder.Calculation;
import org.openelisglobal.testcalculated.valueholder.ResultCalculation;

public interface ResultCalculationService extends BaseObjectService<ResultCalculation , Integer>{

List<ResultCalculation> getResultCalculationByPatientAndTest(Patient patient , Test test);

List<ResultCalculation> getResultCalculationByTest(Test test);

List<ResultCalculation> getResultCalculationByPatientAndCalculation(Patient patient , Calculation calculation);

}
Loading

0 comments on commit ea2bacc

Please sign in to comment.