diff --git a/api/src/main/java/org/openmrs/module/drcreports/reports/DRCTxNewReportManager.java b/api/src/main/java/org/openmrs/module/drcreports/reports/DRCTxNewReportManager.java new file mode 100644 index 0000000..d64966d --- /dev/null +++ b/api/src/main/java/org/openmrs/module/drcreports/reports/DRCTxNewReportManager.java @@ -0,0 +1,466 @@ +package org.openmrs.module.drcreports.reports; + +import static org.openmrs.module.drcreports.common.Helper.getStringFromResource; + +import java.util.*; + +import org.openmrs.Concept; +import org.openmrs.Program; +import org.openmrs.api.context.Context; +import org.openmrs.module.reporting.cohort.definition.CodedObsCohortDefinition; +import org.openmrs.module.reporting.cohort.definition.BaseObsCohortDefinition.TimeModifier; +import org.openmrs.module.reporting.common.SetComparator; +import org.openmrs.api.ConceptService; +import org.openmrs.module.reporting.cohort.definition.ProgramEnrollmentCohortDefinition; +import org.openmrs.api.ProgramWorkflowService; + +import org.openmrs.module.drcreports.ActivatedReportManager; +import org.openmrs.module.initializer.api.InitializerService; +import org.openmrs.module.reporting.cohort.definition.CompositionCohortDefinition; +import org.openmrs.module.reporting.cohort.definition.GenderCohortDefinition; +import org.openmrs.module.reporting.cohort.definition.BirthAndDeathCohortDefinition; +import org.openmrs.module.reporting.cohort.definition.NumericObsCohortDefinition; +import org.openmrs.module.reporting.common.RangeComparator; + +import org.openmrs.module.reporting.cohort.definition.SqlCohortDefinition; +import org.openmrs.module.reporting.common.MessageUtil; +import org.openmrs.module.reporting.common.DurationUnit; + +import org.openmrs.module.reporting.dataset.definition.CohortCrossTabDataSetDefinition; +import org.openmrs.module.reporting.evaluation.parameter.Mapped; +import org.openmrs.module.reporting.evaluation.parameter.Parameter; +import org.openmrs.module.reporting.report.ReportDesign; +import org.openmrs.module.reporting.report.definition.ReportDefinition; +import org.openmrs.module.reporting.report.manager.ReportManagerUtil; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Qualifier; +import org.springframework.stereotype.Component; +import org.openmrs.module.reporting.cohort.definition.AgeCohortDefinition; +import org.openmrs.module.reporting.cohort.definition.PresenceOrAbsenceCohortDefinition; +import org.openmrs.module.reporting.common.BooleanOperator; + +@Component +public class DRCTxNewReportManager extends ActivatedReportManager { + + @Autowired + @Qualifier("initializer.InitializerService") + private InitializerService inizService; + + @Autowired + @Qualifier("programWorkflowService") + private ProgramWorkflowService ps; + + @Override + public boolean isActivated() { + return inizService.getBooleanFromKey("report.drc.txNew.active", true); + } + + @Override + public String getVersion() { + return "1.0.0-SNAPSHOT"; + } + + @Override + public String getUuid() { + return "eed1b81b-15de-41dd-90ec-157c2f9df33a"; + } + + @Override + public String getName() { + return MessageUtil.translate("drcreports.report.drc.txNew.reportName"); + } + + @Override + public String getDescription() { + return MessageUtil.translate("drcreports.report.drc.txNew.reportDescription"); + } + + private Parameter getStartDateParameter() { + return new Parameter("startDate", MessageUtil.translate("drcreports.report.util.reportingStartDate"), Date.class); + } + + private Parameter getEndDateParameter() { + return new Parameter("endDate", MessageUtil.translate("drcreports.report.util.reportingEndDate"), Date.class); + } + + public static String col0 = ""; + + public static String col1 = ""; + + public static String col2 = ""; + + public static String col3 = ""; + + public static String col4 = ""; + + public static String col5 = ""; + + public static String col6 = ""; + + public static String col7 = ""; + + public static String col8 = ""; + + public static String col9 = ""; + + public static String col10 = ""; + + public static String col11 = ""; + + public static String col12 = ""; + + public static String col13 = ""; + + public static String col14 = ""; + + public static String col15 = ""; + + public static String col16 = ""; + + public static String col17 = ""; + + public static String col18 = ""; + + public static String col19 = ""; + + public static String col20 = ""; + + public static String col21 = ""; + + public static String col22 = ""; + + public static String col23 = ""; + + public static String col24 = ""; + + public static String col25 = ""; + + public static String col26 = ""; + + public static String col27 = ""; + + public static String col28 = ""; + + public static String col29 = ""; + + public static String col30 = ""; + + @Override + public List getParameters() { + List params = new ArrayList(); + params.add(getStartDateParameter()); + params.add(getEndDateParameter()); + return params; + } + + @Override + public ReportDefinition constructReportDefinition() { + ReportDefinition rd = new ReportDefinition(); + rd.setUuid(getUuid()); + rd.setName(getName()); + rd.setDescription(getDescription()); + rd.setParameters(getParameters()); + + // txNew Grouping + CohortCrossTabDataSetDefinition txNew = new CohortCrossTabDataSetDefinition(); + txNew.addParameters(getParameters()); + rd.addDataSetDefinition(getName(), Mapped.mapStraightThrough(txNew)); + + Map parameterMappings = new HashMap(); + parameterMappings.put("onOrAfter", "${startDate}"); + parameterMappings.put("onOrBefore", "${endDate}"); + + Map ageParameterMappings = new HashMap(); + ageParameterMappings.put("effectiveDate", "${endDate}"); + + // HIV Care Program cohort + ProgramEnrollmentCohortDefinition pecd = new ProgramEnrollmentCohortDefinition(); + Program program = ps.getProgramByUuid("64f950e6-1b07-4ac0-8e7e-f3e148f3463f"); //HIV Care program + pecd.setPrograms(Arrays.asList(program)); + + // ART Initiated in date range + SqlCohortDefinition artInitiationSqlCD = new SqlCohortDefinition(); + String artInitiationSql = getStringFromResource("org/openmrs/module/drcreports/sql/DRCTxCurrInitiation.sql"); + artInitiationSqlCD.setQuery(artInitiationSql); + artInitiationSqlCD.addParameter(new Parameter("onOrAfter", "On Or After", Date.class)); + artInitiationSqlCD.addParameter(new Parameter("onOrBefore", "On Or Before", Date.class)); + + CompositionCohortDefinition ccd = new CompositionCohortDefinition(); + ccd.initializeFromElements(artInitiationSqlCD, pecd); + + ConceptService cs = Context.getConceptService(); + // CD4 count less than 200 + NumericObsCohortDefinition cd4CountLessThan200 = new NumericObsCohortDefinition(); + cd4CountLessThan200.setQuestion(cs.getConceptByUuid("5497AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA")); + cd4CountLessThan200.setValue1(200.0); + cd4CountLessThan200.setOperator1(RangeComparator.LESS_THAN); + cd4CountLessThan200.addParameter(new Parameter("onOrAfter", "On Or After", Date.class)); + cd4CountLessThan200.addParameter(new Parameter("onOrBefore", "On Or Before", Date.class)); + cd4CountLessThan200.setTimeModifier(TimeModifier.LAST); + + CompositionCohortDefinition cd4Below200Ccd = new CompositionCohortDefinition(); + cd4Below200Ccd.initializeFromElements(artInitiationSqlCD, pecd, cd4CountLessThan200); + + // CD4 count greater than 200 + NumericObsCohortDefinition cd4CountGreaterEqual200 = new NumericObsCohortDefinition(); + cd4CountGreaterEqual200.setQuestion(cs.getConceptByUuid("5497AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA")); + cd4CountGreaterEqual200.setValue1(200.0); + cd4CountGreaterEqual200.setOperator1(RangeComparator.GREATER_EQUAL); + cd4CountGreaterEqual200.addParameter(new Parameter("onOrAfter", "On Or After", Date.class)); + cd4CountGreaterEqual200.addParameter(new Parameter("onOrBefore", "On Or Before", Date.class)); + cd4CountGreaterEqual200.setTimeModifier(TimeModifier.LAST); + + CompositionCohortDefinition cd4GreaterEqual200Ccd = new CompositionCohortDefinition(); + cd4GreaterEqual200Ccd.initializeFromElements(artInitiationSqlCD, pecd, cd4CountGreaterEqual200); + + CompositionCohortDefinition ccdWithCD4Count = new CompositionCohortDefinition(); + ccdWithCD4Count.initializeFromQueries(BooleanOperator.OR, cd4CountLessThan200, cd4CountGreaterEqual200); + + // Remove patients with cd4 count + CompositionCohortDefinition unknownCD4ArtInitiation = new CompositionCohortDefinition(); + + unknownCD4ArtInitiation.initializeFromQueries(BooleanOperator.NOT, ccd, ccdWithCD4Count); + + // Breastfeeding mothers + List breastfeedingOption = new ArrayList(); + breastfeedingOption.add(cs.getConceptByUuid("1065AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA")); // Yes + CodedObsCohortDefinition breastfeedingObs = new CodedObsCohortDefinition(); + breastfeedingObs.addParameter(new Parameter("onOrAfter", "On Or After", Date.class)); + breastfeedingObs.addParameter(new Parameter("onOrBefore", "On Or Before", Date.class)); + breastfeedingObs.setOperator(SetComparator.IN); + breastfeedingObs.setQuestion(cs.getConceptByUuid("5632AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA")); // Breastfeeding? + breastfeedingObs.setValueList(breastfeedingOption); + breastfeedingObs.setTimeModifier(TimeModifier.LAST); + + CompositionCohortDefinition breastfeedingCcd = new CompositionCohortDefinition(); + breastfeedingCcd.initializeFromElements(artInitiationSqlCD, pecd, breastfeedingObs); + + txNew.addRow(getName(), ccd, parameterMappings); + txNew.addRow(MessageUtil.translate("drcreports.report.drc.cd4Below200.label"), cd4Below200Ccd, parameterMappings); + txNew.addRow(MessageUtil.translate("drcreports.report.drc.cd4GreaterEqual200.label"), cd4GreaterEqual200Ccd, + parameterMappings); + txNew.addRow(MessageUtil.translate("drcreports.report.drc.cd4Unknown.label"), unknownCD4ArtInitiation, + parameterMappings); + txNew.addRow(MessageUtil.translate("drcreports.report.drc.breastfeeding.label"), breastfeedingCcd, + parameterMappings); + + setColumnNames(); + + GenderCohortDefinition males = new GenderCohortDefinition(); + males.setMaleIncluded(true); + + GenderCohortDefinition females = new GenderCohortDefinition(); + females.setFemaleIncluded(true); + + GenderCohortDefinition allGenders = new GenderCohortDefinition(); + allGenders.setFemaleIncluded(true); + allGenders.setMaleIncluded(true); + + txNew.addColumn(col0, createCohortComposition(allGenders), null); + + // < 1 year + AgeCohortDefinition under1y = new AgeCohortDefinition(); + under1y.setMinAge(0); + under1y.setMinAgeUnit(DurationUnit.DAYS); + under1y.setMaxAge(11); + under1y.setMaxAgeUnit(DurationUnit.MONTHS); + under1y.addParameter(new Parameter("effectiveDate", "Effective Date", Date.class)); + txNew.addColumn(col1, createCohortComposition(under1y, males), ageParameterMappings); + txNew.addColumn(col2, createCohortComposition(under1y, females), ageParameterMappings); + + // 1-4 years + AgeCohortDefinition _1To4y = new AgeCohortDefinition(); + _1To4y.setMinAge(1); + _1To4y.setMinAgeUnit(DurationUnit.YEARS); + _1To4y.setMaxAge(4); + _1To4y.setMaxAgeUnit(DurationUnit.YEARS); + _1To4y.addParameter(new Parameter("effectiveDate", "Effective Date", Date.class)); + txNew.addColumn(col3, createCohortComposition(_1To4y, males), ageParameterMappings); + txNew.addColumn(col4, createCohortComposition(_1To4y, females), ageParameterMappings); + + // 5-9 years + AgeCohortDefinition _5To9y = new AgeCohortDefinition(); + _5To9y.setMinAge(5); + _5To9y.setMinAgeUnit(DurationUnit.YEARS); + _5To9y.setMaxAge(9); + _5To9y.setMaxAgeUnit(DurationUnit.YEARS); + _5To9y.addParameter(new Parameter("effectiveDate", "Effective Date", Date.class)); + txNew.addColumn(col5, createCohortComposition(_5To9y, males), ageParameterMappings); + txNew.addColumn(col6, createCohortComposition(_5To9y, females), ageParameterMappings); + + // 10-14 years + AgeCohortDefinition _10To14y = new AgeCohortDefinition(); + _10To14y.setMinAge(10); + _10To14y.setMinAgeUnit(DurationUnit.YEARS); + _10To14y.setMaxAge(14); + _10To14y.setMaxAgeUnit(DurationUnit.YEARS); + _10To14y.addParameter(new Parameter("effectiveDate", "Effective Date", Date.class)); + txNew.addColumn(col7, createCohortComposition(_10To14y, males), ageParameterMappings); + txNew.addColumn(col8, createCohortComposition(_10To14y, females), ageParameterMappings); + + // 15-19 years + AgeCohortDefinition _15To19y = new AgeCohortDefinition(); + _15To19y.setMinAge(15); + _15To19y.setMinAgeUnit(DurationUnit.YEARS); + _15To19y.setMaxAge(19); + _15To19y.setMaxAgeUnit(DurationUnit.YEARS); + _15To19y.addParameter(new Parameter("effectiveDate", "Effective Date", Date.class)); + txNew.addColumn(col9, createCohortComposition(_15To19y, males), ageParameterMappings); + txNew.addColumn(col10, createCohortComposition(_15To19y, females), ageParameterMappings); + + // 20-24 years + AgeCohortDefinition _20To24y = new AgeCohortDefinition(); + _20To24y.setMinAge(20); + _20To24y.setMinAgeUnit(DurationUnit.YEARS); + _20To24y.setMaxAge(24); + _20To24y.setMaxAgeUnit(DurationUnit.YEARS); + _20To24y.addParameter(new Parameter("effectiveDate", "Effective Date", Date.class)); + txNew.addColumn(col11, createCohortComposition(_20To24y, males), ageParameterMappings); + txNew.addColumn(col12, createCohortComposition(_20To24y, females), ageParameterMappings); + + // 25-49 years + AgeCohortDefinition _25To29y = new AgeCohortDefinition(); + _25To29y.setMinAge(25); + _25To29y.setMinAgeUnit(DurationUnit.YEARS); + _25To29y.setMaxAge(29); + _25To29y.setMaxAgeUnit(DurationUnit.YEARS); + _25To29y.addParameter(new Parameter("effectiveDate", "Effective Date", Date.class)); + txNew.addColumn(col13, createCohortComposition(_25To29y, males), ageParameterMappings); + txNew.addColumn(col14, createCohortComposition(_25To29y, females), ageParameterMappings); + + // 30-34 years + AgeCohortDefinition _30To34y = new AgeCohortDefinition(); + _30To34y.setMinAge(30); + _30To34y.setMinAgeUnit(DurationUnit.YEARS); + _30To34y.setMaxAge(34); + _30To34y.setMaxAgeUnit(DurationUnit.YEARS); + _30To34y.addParameter(new Parameter("effectiveDate", "Effective Date", Date.class)); + txNew.addColumn(col15, createCohortComposition(_30To34y, males), ageParameterMappings); + txNew.addColumn(col16, createCohortComposition(_30To34y, females), ageParameterMappings); + + // 35-39 years + AgeCohortDefinition _35To39y = new AgeCohortDefinition(); + _35To39y.setMinAge(35); + _35To39y.setMinAgeUnit(DurationUnit.YEARS); + _35To39y.setMaxAge(39); + _35To39y.setMaxAgeUnit(DurationUnit.YEARS); + _35To39y.addParameter(new Parameter("effectiveDate", "Effective Date", Date.class)); + txNew.addColumn(col17, createCohortComposition(_35To39y, males), ageParameterMappings); + txNew.addColumn(col18, createCohortComposition(_35To39y, females), ageParameterMappings); + + // 40-44 years + AgeCohortDefinition _40To44y = new AgeCohortDefinition(); + _40To44y.setMinAge(40); + _40To44y.setMinAgeUnit(DurationUnit.YEARS); + _40To44y.setMaxAge(44); + _40To44y.setMaxAgeUnit(DurationUnit.YEARS); + _40To44y.addParameter(new Parameter("effectiveDate", "Effective Date", Date.class)); + txNew.addColumn(col19, createCohortComposition(_40To44y, males), ageParameterMappings); + txNew.addColumn(col20, createCohortComposition(_40To44y, females), ageParameterMappings); + + // 45-49 years + AgeCohortDefinition _45To49y = new AgeCohortDefinition(); + _45To49y.setMinAge(45); + _45To49y.setMinAgeUnit(DurationUnit.YEARS); + _45To49y.setMaxAge(49); + _45To49y.setMaxAgeUnit(DurationUnit.YEARS); + _45To49y.addParameter(new Parameter("effectiveDate", "Effective Date", Date.class)); + txNew.addColumn(col21, createCohortComposition(_45To49y, males), ageParameterMappings); + txNew.addColumn(col22, createCohortComposition(_45To49y, females), ageParameterMappings); + + // 50-54 years + AgeCohortDefinition _50To54y = new AgeCohortDefinition(); + _50To54y.setMinAge(50); + _50To54y.setMinAgeUnit(DurationUnit.YEARS); + _50To54y.setMaxAge(54); + _50To54y.setMaxAgeUnit(DurationUnit.YEARS); + _50To54y.addParameter(new Parameter("effectiveDate", "Effective Date", Date.class)); + txNew.addColumn(col23, createCohortComposition(_50To54y, males), ageParameterMappings); + txNew.addColumn(col24, createCohortComposition(_50To54y, females), ageParameterMappings); + + // 55-59 years + AgeCohortDefinition _55To59y = new AgeCohortDefinition(); + _55To59y.setMinAge(55); + _55To59y.setMinAgeUnit(DurationUnit.YEARS); + _55To59y.setMaxAge(59); + _55To59y.setMaxAgeUnit(DurationUnit.YEARS); + _55To59y.addParameter(new Parameter("effectiveDate", "Effective Date", Date.class)); + txNew.addColumn(col25, createCohortComposition(_55To59y, males), ageParameterMappings); + txNew.addColumn(col26, createCohortComposition(_55To59y, females), ageParameterMappings); + + // 60-64 years + AgeCohortDefinition _60To64y = new AgeCohortDefinition(); + _60To64y.setMinAge(60); + _60To64y.setMinAgeUnit(DurationUnit.YEARS); + _60To64y.setMaxAge(64); + _60To64y.setMaxAgeUnit(DurationUnit.YEARS); + _60To64y.addParameter(new Parameter("effectiveDate", "Effective Date", Date.class)); + txNew.addColumn(col27, createCohortComposition(_60To64y, males), ageParameterMappings); + txNew.addColumn(col28, createCohortComposition(_60To64y, females), ageParameterMappings); + + // 65+ years + AgeCohortDefinition _66To69y = new AgeCohortDefinition(); + _66To69y.setMinAge(65); + _66To69y.setMinAgeUnit(DurationUnit.YEARS); + _66To69y.setMaxAge(200); + _66To69y.setMaxAgeUnit(DurationUnit.YEARS); + _66To69y.addParameter(new Parameter("effectiveDate", "Effective Date", Date.class)); + txNew.addColumn(col29, createCohortComposition(_66To69y, males), ageParameterMappings); + txNew.addColumn(col30, createCohortComposition(_66To69y, females), ageParameterMappings); + + return rd; + } + + private void setColumnNames() { + col0 = MessageUtil.translate("drcreports.report.drc.total.label"); + + col1 = MessageUtil.translate("drcreports.report.drc.belowOneYrMales.label"); + col2 = MessageUtil.translate("drcreports.report.drc.belowOneYrFemales.label"); + + col3 = MessageUtil.translate("drcreports.report.drc.oneToFourYrsMales.label"); + col4 = MessageUtil.translate("drcreports.report.drc.oneToFourYrsFemales.label"); + col5 = MessageUtil.translate("drcreports.report.drc.fiveToNineYrsMales.label"); + col6 = MessageUtil.translate("drcreports.report.drc.fiveToNineYrsFemales.label"); + col7 = MessageUtil.translate("drcreports.report.drc.tenToFourteenYrsMales.label"); + col8 = MessageUtil.translate("drcreports.report.drc.tenToFourteenYrsFemales.label"); + col9 = MessageUtil.translate("drcreports.report.drc.fifteenToNineteenYrsMales.label"); + col10 = MessageUtil.translate("drcreports.report.drc.fifteenToNineteenYrsFemales.label"); + + col11 = MessageUtil.translate("drcreports.report.drc.twentyToTwentyFourYrsMales.label"); + col12 = MessageUtil.translate("drcreports.report.drc.twentyToTwentyFourYrsFemales.label"); + col13 = MessageUtil.translate("drcreports.report.drc.twentyFiveToTwentyNineYrsMales.label"); + col14 = MessageUtil.translate("drcreports.report.drc.twentyFiveToTwentyNineYrsFemales.label"); + + col15 = MessageUtil.translate("drcreports.report.drc.thirtyToThirtyFourYrsMales.label"); + col16 = MessageUtil.translate("drcreports.report.drc.thirtyToThirtyFourYrsFemales.label"); + col17 = MessageUtil.translate("drcreports.report.drc.thirtyFiveToThirtyNineYrsMales.label"); + col18 = MessageUtil.translate("drcreports.report.drc.thirtyFiveToThirtyNineYrsFemales.label"); + col19 = MessageUtil.translate("drcreports.report.drc.fortyToFortyFourYrsMales.label"); + col20 = MessageUtil.translate("drcreports.report.drc.fortyToFortyFourYrsFemales.label"); + col21 = MessageUtil.translate("drcreports.report.drc.fortyFiveToFortyNineYrsMales.label"); + col22 = MessageUtil.translate("drcreports.report.drc.fortyFiveToFortyNineYrsFemales.label"); + + col23 = MessageUtil.translate("drcreports.report.drc.fiftyToFiftyFourYrsMales.label"); + col24 = MessageUtil.translate("drcreports.report.drc.fiftyToFiftyFourYrsFemales.label"); + col25 = MessageUtil.translate("drcreports.report.drc.fiftyFiveToFiftyNineYrsMales.label"); + col26 = MessageUtil.translate("drcreports.report.drc.fiftyFiveToFiftyNineYrsFemales.label"); + col27 = MessageUtil.translate("drcreports.report.drc.sixtyToSixtyFourYrsMales.label"); + col28 = MessageUtil.translate("drcreports.report.drc.sixtyToSixtyFourYrsFemales.label"); + col29 = MessageUtil.translate("drcreports.report.drc.sixtyFiveAndAboveMales.label"); + col30 = MessageUtil.translate("drcreports.report.drc.sixtyFiveAndAboveFemales.label"); + + } + + private CompositionCohortDefinition createCohortComposition(Object... elements) { + CompositionCohortDefinition compCD = new CompositionCohortDefinition(); + compCD.initializeFromElements(elements); + return compCD; + } + + @Override + public List constructReportDesigns(ReportDefinition reportDefinition) { + return Arrays + .asList(ReportManagerUtil.createCsvReportDesign("20b98eb6-b42b-4a58-a240-9e81d8383814", reportDefinition)); + + } +} diff --git a/api/src/main/resources/messages.properties b/api/src/main/resources/messages.properties index 448d7b2..d788099 100644 --- a/api/src/main/resources/messages.properties +++ b/api/src/main/resources/messages.properties @@ -363,6 +363,13 @@ ${project.parent.artifactId}.report.drc.ptStartedOnArtWithVLGT12MonthsGreatertha ${project.parent.artifactId}.report.drc.txCurr.reportName=DRC TX_CURR Report ${project.parent.artifactId}.report.drc.txCurr.reportDescription=DRC TX_CURR Report +${project.parent.artifactId}.report.drc.txNew.reportName=DRC TX_NEW Report +${project.parent.artifactId}.report.drc.txNew.reportDescription=DRC TX_NEW Report +${project.parent.artifactId}.report.drc.cd4Below200.label=CD4 < 200 cell/mm3 +${project.parent.artifactId}.report.drc.cd4GreaterEqual200.label=CD4 >= 200 cell/mm3 +${project.parent.artifactId}.report.drc.cd4Unknown.label=Unknown CD4 count +${project.parent.artifactId}.report.drc.breastfeeding.label=Breastfeeding at ART Initiation + ${project.parent.artifactId}.report.drc.total.label=Total ${project.parent.artifactId}.report.drc.belowOneYrMales.label=Below 1 year (Males) diff --git a/api/src/main/resources/messages_fr.properties b/api/src/main/resources/messages_fr.properties index b46c491..21a3882 100644 --- a/api/src/main/resources/messages_fr.properties +++ b/api/src/main/resources/messages_fr.properties @@ -353,6 +353,13 @@ ${project.parent.artifactId}.report.drc.artAbandonment.datasetName=Patients de l ${project.parent.artifactId}.report.drc.txCurr.reportName=Rapport TX_CURR RDC ${project.parent.artifactId}.report.drc.txCurr.reportDescription=Rapport TX_CURR RDC +${project.parent.artifactId}.report.drc.txNew.reportName=Rapport TX_NEW RDC +${project.parent.artifactId}.report.drc.txNew.reportDescription=Rapport TX_NEW RDC +${project.parent.artifactId}.report.drc.cd4Below200.label=CD4 < 200 cellules/mm3 +${project.parent.artifactId}.report.drc.cd4GreaterEqual200.label=CD4 >= 200 cellules/mm3 +${project.parent.artifactId}.report.drc.cd4Unknown.label=Numération CD4 inconnue +${project.parent.artifactId}.report.drc.breastfeeding.label=Allaitement au début du TAR + ${project.parent.artifactId}.report.drc.total.label=Total ${project.parent.artifactId}.report.drc.belowOneYrMales.label=Moins d’1 an (Hommes) diff --git a/api/src/test/java/org/openmrs/module/drcreports/reports/DRCTxNewReportManagerTest.java b/api/src/test/java/org/openmrs/module/drcreports/reports/DRCTxNewReportManagerTest.java new file mode 100644 index 0000000..f8340ec --- /dev/null +++ b/api/src/test/java/org/openmrs/module/drcreports/reports/DRCTxNewReportManagerTest.java @@ -0,0 +1,469 @@ +package org.openmrs.module.drcreports.reports; + +import java.io.File; +import java.sql.Connection; +import java.sql.SQLException; +import java.util.HashMap; +import java.util.Iterator; +import java.util.Map; +import org.dbunit.DatabaseUnitException; +import org.dbunit.DatabaseUnitRuntimeException; +import org.dbunit.database.DatabaseConfig; +import org.dbunit.database.DatabaseConnection; +import org.dbunit.database.IDatabaseConnection; +import org.dbunit.dataset.IDataSet; +import org.dbunit.ext.mysql.MySqlDataTypeFactory; +import org.dbunit.operation.DatabaseOperation; +import org.junit.Before; +import org.junit.Test; +import org.openmrs.Cohort; +import org.openmrs.api.ConceptService; +import org.openmrs.module.initializer.Domain; +import org.openmrs.module.initializer.api.InitializerService; +import org.openmrs.module.initializer.api.loaders.Loader; +import org.openmrs.module.reporting.common.DateUtil; +import org.openmrs.module.reporting.dataset.DataSetRow; +import org.openmrs.module.reporting.evaluation.EvaluationContext; +import org.openmrs.module.reporting.report.ReportData; +import org.openmrs.module.reporting.report.definition.ReportDefinition; +import org.openmrs.module.reporting.report.definition.service.ReportDefinitionService; +import org.openmrs.module.reporting.report.manager.ReportManagerUtil; +import org.openmrs.module.reporting.report.service.ReportService; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Qualifier; +import liquibase.Liquibase; +import liquibase.database.Database; +import liquibase.database.DatabaseFactory; +import liquibase.database.jvm.JdbcConnection; +import liquibase.resource.ClassLoaderResourceAccessor; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.is; +import static org.hamcrest.Matchers.notNullValue; + +public class DRCTxNewReportManagerTest extends BaseModuleContextSensitiveMysqlBackedTest { + + public DRCTxNewReportManagerTest() throws SQLException { + super(); + } + + @Autowired + private InitializerService iniz; + + @Autowired + private ReportService rs; + + @Autowired + private ReportDefinitionService rds; + + @Autowired + @Qualifier("conceptService") + private ConceptService cs; + + @Autowired + private DRCTxNewReportManager manager; + + @Override + public void executeDataSet(IDataSet dataset) { + try { + Connection connection = getConnection(); + IDatabaseConnection dbUnitConn = setupDatabaseConnection(connection); + DatabaseOperation.REFRESH.execute(dbUnitConn, dataset); + } + catch (Exception e) { + throw new DatabaseUnitRuntimeException(e); + } + } + + private IDatabaseConnection setupDatabaseConnection(Connection connection) throws DatabaseUnitException { + IDatabaseConnection dbUnitConn = new DatabaseConnection(connection); + + DatabaseConfig config = dbUnitConn.getConfig(); + config.setProperty(DatabaseConfig.PROPERTY_DATATYPE_FACTORY, new MySqlDataTypeFactory()); + + return dbUnitConn; + } + + @Before + public void setUp() throws Exception { + updateDatabase("org/openmrs/module/drcreports/liquibase/test-liquibase.xml"); + executeDataSet("org/openmrs/module/reporting/include/ReportTestDataset-openmrs-2.0.xml"); + executeDataSet("org/openmrs/module/drcreports/include/DRCTxNewReportTestDataset.xml"); + + String path = getClass().getClassLoader().getResource("testAppDataDir").getPath() + File.separator; + System.setProperty("OPENMRS_APPLICATION_DATA_DIRECTORY", path); + + for (Loader loader : iniz.getLoaders()) { + if (loader.getDomainName().equals(Domain.JSON_KEY_VALUES.getName())) { + loader.load(); + } + } + } + + @Test + public void setupReport_shouldCreateCsvDesign() throws Exception { + // setup + + // replay + ReportManagerUtil.setupReport(manager); + + // verify + assertThat(rs.getReportDesignByUuid("20b98eb6-b42b-4a58-a240-9e81d8383814"), is(notNullValue())); + + } + + @Test + public void testReport() throws Exception { + // setup + EvaluationContext context = new EvaluationContext(); + context.addParameterValue("startDate", DateUtil.parseDate("2024-01-01", "yyyy-MM-dd")); + context.addParameterValue("endDate", DateUtil.parseDate("2024-12-31", "yyyy-MM-dd")); + + // replay + ReportDefinition rd = manager.constructReportDefinition(); + ReportData data = rds.evaluate(rd, context); + + // verify + for (Iterator itr = data.getDataSets().get(rd.getName()).iterator(); itr.hasNext();) { + DataSetRow row = itr.next(); + Map columnValuePairs = getColumnValues(); + for (String column : columnValuePairs.keySet()) { + assertThat(column, ((Cohort) row.getColumnValue(column)).getSize(), is(columnValuePairs.get(column))); + } + } + + } + + private Map getColumnValues() { + Map map = new HashMap(); + + map.put("DRC TX_NEW Report.Total", 7); + + // Below 1 year + map.put("DRC TX_NEW Report.Below 1 year (Males)", 0); + map.put("DRC TX_NEW Report.Below 1 year (Females)", 0); + + // 1–4 years + map.put("DRC TX_NEW Report.1-4 years (Males)", 0); + map.put("DRC TX_NEW Report.1-4 years (Females)", 0); + + // 5–9 years + map.put("DRC TX_NEW Report.5-9 years (Males)", 0); + map.put("DRC TX_NEW Report.5-9 years (Females)", 0); + + // 10–14 years + map.put("DRC TX_NEW Report.10-14 years (Males)", 0); + map.put("DRC TX_NEW Report.10-14 years (Females)", 0); + + // 15–19 years + map.put("DRC TX_NEW Report.15-19 years (Males)", 0); + map.put("DRC TX_NEW Report.15-19 years (Females)", 0); + + // 20–24 years + map.put("DRC TX_NEW Report.20-24 years (Males)", 0); + map.put("DRC TX_NEW Report.20-24 years (Females)", 0); + + // 25–29 years + map.put("DRC TX_NEW Report.25-29 years (Males)", 0); + map.put("DRC TX_NEW Report.25-29 years (Females)", 0); + + // 30–34 years + map.put("DRC TX_NEW Report.30-34 years (Males)", 2); + map.put("DRC TX_NEW Report.30-34 years (Females)", 1); + + // 35–39 years + map.put("DRC TX_NEW Report.35-39 years (Males)", 1); + map.put("DRC TX_NEW Report.35-39 years (Females)", 2); + + // 40–44 years + map.put("DRC TX_NEW Report.40-44 years (Males)", 0); + map.put("DRC TX_NEW Report.40-44 years (Females)", 1); + + // 45–49 years + map.put("DRC TX_NEW Report.45-49 years (Males)", 0); + map.put("DRC TX_NEW Report.45-49 years (Females)", 0); + + // 50-54 years + map.put("DRC TX_NEW Report.50-54 years (Males)", 0); + map.put("DRC TX_NEW Report.50-54 years (Females)", 0); + + // 55–59 years + map.put("DRC TX_NEW Report.55-59 years (Males)", 0); + map.put("DRC TX_NEW Report.55-59 years (Females)", 0); + + // 60–64 years + map.put("DRC TX_NEW Report.60-64 years (Males)", 0); + map.put("DRC TX_NEW Report.60-64 years (Females)", 0); + + // 65+ years + map.put("DRC TX_NEW Report.65+ years (Males)", 0); + map.put("DRC TX_NEW Report.65+ years (Females)", 0); + + map.put("CD4 < 200 cell/mm3.Total", 3); + + // Below 1 year + map.put("CD4 < 200 cell/mm3.Below 1 year (Males)", 0); + map.put("CD4 < 200 cell/mm3.Below 1 year (Females)", 0); + + // 1–4 years + map.put("CD4 < 200 cell/mm3.1-4 years (Males)", 0); + map.put("CD4 < 200 cell/mm3.1-4 years (Females)", 0); + + // 5–9 years + map.put("CD4 < 200 cell/mm3.5-9 years (Males)", 0); + map.put("CD4 < 200 cell/mm3.5-9 years (Females)", 0); + + // 10–14 years + map.put("CD4 < 200 cell/mm3.10-14 years (Males)", 0); + map.put("CD4 < 200 cell/mm3.10-14 years (Females)", 0); + + // 15–19 years + map.put("CD4 < 200 cell/mm3.15-19 years (Males)", 0); + map.put("CD4 < 200 cell/mm3.15-19 years (Females)", 0); + + // 20–24 years + map.put("CD4 < 200 cell/mm3.20-24 years (Males)", 0); + map.put("CD4 < 200 cell/mm3.20-24 years (Females)", 0); + + // 25–29 years + map.put("CD4 < 200 cell/mm3.25-29 years (Males)", 0); + map.put("CD4 < 200 cell/mm3.25-29 years (Females)", 0); + + // 30–34 years + map.put("CD4 < 200 cell/mm3.30-34 years (Males)", 1); + map.put("CD4 < 200 cell/mm3.30-34 years (Females)", 0); + + // 35–39 years + map.put("CD4 < 200 cell/mm3.35-39 years (Males)", 1); + map.put("CD4 < 200 cell/mm3.35-39 years (Females)", 1); + + // 40–44 years + map.put("CD4 < 200 cell/mm3.40-44 years (Males)", 0); + map.put("CD4 < 200 cell/mm3.40-44 years (Females)", 0); + + // 45–49 years + map.put("CD4 < 200 cell/mm3.45-49 years (Males)", 0); + map.put("CD4 < 200 cell/mm3.45-49 years (Females)", 0); + + // 50–54 years + map.put("CD4 < 200 cell/mm3.50-54 years (Males)", 0); + map.put("CD4 < 200 cell/mm3.50-54 years (Females)", 0); + + // 55–59 years + map.put("CD4 < 200 cell/mm3.55-59 years (Males)", 0); + map.put("CD4 < 200 cell/mm3.55-59 years (Females)", 0); + + // 60–64 years + map.put("CD4 < 200 cell/mm3.60-64 years (Males)", 0); + map.put("CD4 < 200 cell/mm3.60-64 years (Females)", 0); + + // 65+ years + map.put("CD4 < 200 cell/mm3.65+ years (Males)", 0); + map.put("CD4 < 200 cell/mm3.65+ years (Females)", 0); + + map.put("CD4 >= 200 cell/mm3.Total", 2); + + // Below 1 year + map.put("CD4 >= 200 cell/mm3.Below 1 year (Males)", 0); + map.put("CD4 >= 200 cell/mm3.Below 1 year (Females)", 0); + + // 1–4 years + map.put("CD4 >= 200 cell/mm3.1-4 years (Males)", 0); + map.put("CD4 >= 200 cell/mm3.1-4 years (Females)", 0); + + // 5–9 years + map.put("CD4 >= 200 cell/mm3.5-9 years (Males)", 0); + map.put("CD4 >= 200 cell/mm3.5-9 years (Females)", 0); + + // 10–14 years + map.put("CD4 >= 200 cell/mm3.10-14 years (Males)", 0); + map.put("CD4 >= 200 cell/mm3.10-14 years (Females)", 0); + + // 15–19 years + map.put("CD4 >= 200 cell/mm3.15-19 years (Males)", 0); + map.put("CD4 >= 200 cell/mm3.15-19 years (Females)", 0); + + // 20–24 years + map.put("CD4 >= 200 cell/mm3.20-24 years (Males)", 0); + map.put("CD4 >= 200 cell/mm3.20-24 years (Females)", 0); + + // 25–29 years + map.put("CD4 >= 200 cell/mm3.25-29 years (Males)", 0); + map.put("CD4 >= 200 cell/mm3.25-29 years (Females)", 0); + + // 30–34 years + map.put("CD4 >= 200 cell/mm3.30-34 years (Males)", 0); + map.put("CD4 >= 200 cell/mm3.30-34 years (Females)", 1); + + // 35–39 years + map.put("CD4 >= 200 cell/mm3.35-39 years (Males)", 0); + map.put("CD4 >= 200 cell/mm3.35-39 years (Females)", 0); + + // 40–44 years + map.put("CD4 >= 200 cell/mm3.40-44 years (Males)", 0); + map.put("CD4 >= 200 cell/mm3.40-44 years (Females)", 1); + + // 45–49 years + map.put("CD4 >= 200 cell/mm3.45-49 years (Males)", 0); + map.put("CD4 >= 200 cell/mm3.45-49 years (Females)", 0); + + // 50–54 years + map.put("CD4 >= 200 cell/mm3.50-54 years (Males)", 0); + map.put("CD4 >= 200 cell/mm3.50-54 years (Females)", 0); + + // 55–59 years + map.put("CD4 >= 200 cell/mm3.55-59 years (Males)", 0); + map.put("CD4 >= 200 cell/mm3.55-59 years (Females)", 0); + + // 60–64 years + map.put("CD4 >= 200 cell/mm3.60-64 years (Males)", 0); + map.put("CD4 >= 200 cell/mm3.60-64 years (Females)", 0); + + // 65+ years + map.put("CD4 >= 200 cell/mm3.65+ years (Males)", 0); + map.put("CD4 >= 200 cell/mm3.65+ years (Females)", 0); + + map.put("Unknown CD4 count.Total", 2); + + // Below 1 year + map.put("Unknown CD4 count.Below 1 year (Males)", 0); + map.put("Unknown CD4 count.Below 1 year (Females)", 0); + + // 1–4 years + map.put("Unknown CD4 count.1-4 years (Males)", 0); + map.put("Unknown CD4 count.1-4 years (Females)", 0); + + // 5–9 years + map.put("Unknown CD4 count.5-9 years (Males)", 0); + map.put("Unknown CD4 count.5-9 years (Females)", 0); + + // 10–14 years + map.put("Unknown CD4 count.10-14 years (Males)", 0); + map.put("Unknown CD4 count.10-14 years (Females)", 0); + + // 15–19 years + map.put("Unknown CD4 count.15-19 years (Males)", 0); + map.put("Unknown CD4 count.15-19 years (Females)", 0); + + // 20–24 years + map.put("Unknown CD4 count.20-24 years (Males)", 0); + map.put("Unknown CD4 count.20-24 years (Females)", 0); + + // 25–29 years + map.put("Unknown CD4 count.25-29 years (Males)", 0); + map.put("Unknown CD4 count.25-29 years (Females)", 0); + + // 30–34 years + map.put("Unknown CD4 count.30-34 years (Males)", 1); + map.put("Unknown CD4 count.30-34 years (Females)", 0); + + // 35–39 years + map.put("Unknown CD4 count.35-39 years (Males)", 0); + map.put("Unknown CD4 count.35-39 years (Females)", 1); + + // 40–44 years + map.put("Unknown CD4 count.40-44 years (Males)", 0); + map.put("Unknown CD4 count.40-44 years (Females)", 0); + + // 45–49 years + map.put("Unknown CD4 count.45-49 years (Males)", 0); + map.put("Unknown CD4 count.45-49 years (Females)", 0); + + // 50–54 years + map.put("Unknown CD4 count.50-54 years (Males)", 0); + map.put("Unknown CD4 count.50-54 years (Females)", 0); + + // 55–59 years + map.put("Unknown CD4 count.55-59 years (Males)", 0); + map.put("Unknown CD4 count.55-59 years (Females)", 0); + + // 60–64 years + map.put("Unknown CD4 count.60-64 years (Males)", 0); + map.put("Unknown CD4 count.60-64 years (Females)", 0); + + // 65+ years + map.put("Unknown CD4 count.65+ years (Males)", 0); + map.put("Unknown CD4 count.65+ years (Females)", 0); + + map.put("Breastfeeding at ART Initiation.Total", 2); + + // Below 1 year + map.put("Breastfeeding at ART Initiation.Below 1 year (Males)", 0); + map.put("Breastfeeding at ART Initiation.Below 1 year (Females)", 0); + + // 1–4 years + map.put("Breastfeeding at ART Initiation.1-4 years (Males)", 0); + map.put("Breastfeeding at ART Initiation.1-4 years (Females)", 0); + + // 5–9 years + map.put("Breastfeeding at ART Initiation.5-9 years (Males)", 0); + map.put("Breastfeeding at ART Initiation.5-9 years (Females)", 0); + + // 10–14 years + map.put("Breastfeeding at ART Initiation.10-14 years (Males)", 0); + map.put("Breastfeeding at ART Initiation.10-14 years (Females)", 0); + + // 15–19 years + map.put("Breastfeeding at ART Initiation.15-19 years (Males)", 0); + map.put("Breastfeeding at ART Initiation.15-19 years (Females)", 0); + + // 20–24 years + map.put("Breastfeeding at ART Initiation.20-24 years (Males)", 0); + map.put("Breastfeeding at ART Initiation.20-24 years (Females)", 0); + + // 25–29 years + map.put("Breastfeeding at ART Initiation.25-29 years (Males)", 0); + map.put("Breastfeeding at ART Initiation.25-29 years (Females)", 0); + + // 30–34 years + map.put("Breastfeeding at ART Initiation.30-34 years (Males)", 0); + map.put("Breastfeeding at ART Initiation.30-34 years (Females)", 0); + + // 35–39 years + map.put("Breastfeeding at ART Initiation.35-39 years (Males)", 0); + map.put("Breastfeeding at ART Initiation.35-39 years (Females)", 2); + + // 40–44 years + map.put("Breastfeeding at ART Initiation.40-44 years (Males)", 0); + map.put("Breastfeeding at ART Initiation.40-44 years (Females)", 0); + + // 45–49 years + map.put("Breastfeeding at ART Initiation.45-49 years (Males)", 0); + map.put("Breastfeeding at ART Initiation.45-49 years (Females)", 0); + + // 50–54 years + map.put("Breastfeeding at ART Initiation.50-54 years (Males)", 0); + map.put("Breastfeeding at ART Initiation.50-54 years (Females)", 0); + + // 55–59 years + map.put("Breastfeeding at ART Initiation.55-59 years (Males)", 0); + map.put("Breastfeeding at ART Initiation.55-59 years (Females)", 0); + + // 60–64 years + map.put("Breastfeeding at ART Initiation.60-64 years (Males)", 0); + map.put("Breastfeeding at ART Initiation.60-64 years (Females)", 0); + + // 65+ years + map.put("Breastfeeding at ART Initiation.65+ years (Males)", 0); + map.put("Breastfeeding at ART Initiation.65+ years (Females)", 0); + + return map; + + } + + private void updateDatabase(String filename) throws Exception { + Liquibase liquibase = getLiquibase(filename); + liquibase.update("Modify column datatype to longblob on reporting_report_design_resource table"); + liquibase.getDatabase().getConnection().commit(); + } + + private Liquibase getLiquibase(String filename) throws Exception { + Database liquibaseConnection = DatabaseFactory.getInstance() + .findCorrectDatabaseImplementation(new JdbcConnection(getConnection())); + + liquibaseConnection.setDatabaseChangeLogTableName("LIQUIBASECHANGELOG"); + liquibaseConnection.setDatabaseChangeLogLockTableName("LIQUIBASECHANGELOGLOCK"); + + return new Liquibase(filename, new ClassLoaderResourceAccessor(getClass().getClassLoader()), liquibaseConnection); + } +} diff --git a/api/src/test/resources/org/openmrs/module/drcreports/include/DRCTxNewReportTestDataset.xml b/api/src/test/resources/org/openmrs/module/drcreports/include/DRCTxNewReportTestDataset.xml new file mode 100644 index 0000000..ead9b6a --- /dev/null +++ b/api/src/test/resources/org/openmrs/module/drcreports/include/DRCTxNewReportTestDataset.xml @@ -0,0 +1,338 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file