public String execute() throws Exception {
if (name == null || name.equals(ALL)) {
Collection<PeriodType> periodTypes = periodService.getAllPeriodTypes();
for (PeriodType type : periodTypes) {
periods.addAll(periodService.getPeriodsByPeriodType(type));
}
} else {
PeriodType periodType = periodService.getPeriodTypeByName(name);
ArrayList<Period> allPeriodsOfSelectedPeriodType =
new ArrayList<Period>(periodService.getPeriodsByPeriodType(periodType));
for (Period p : allPeriodsOfSelectedPeriodType) {
if (!(p.getStartDate().compareTo(new Date()) > 0)) {
periods.add(p);
}
}
}
for (Period period : periods) {
period.setName(format.formatPeriod(period));
}
Collections.sort(periods, new PeriodComparator());
return SUCCESS;
}
/**
* Gets the Set of period types found in a set of rules.
*
* <p>Note that that we have to get periodType from periodService, otherwise the ID will not be
* present.)
*
* @param rules validation rules of interest
* @return period types contained in those rules
*/
private Set<PeriodType> getPeriodTypesFromRules(Collection<ValidationRule> rules) {
Set<PeriodType> rulePeriodTypes = new HashSet<>();
for (ValidationRule rule : rules) {
rulePeriodTypes.add(periodService.getPeriodTypeByName(rule.getPeriodType().getName()));
}
return rulePeriodTypes;
}
@Override
public void setUpTest() {
organisationUnit = createOrganisationUnit('A');
organisationUnitLevel = new OrganisationUnitLevel(1, "Level");
organisationUnitService.addOrganisationUnit(organisationUnit);
organisationUnitService.addOrganisationUnitLevel(organisationUnitLevel);
indicatorGroup = createIndicatorGroup('A');
indicatorService.addIndicatorGroup(indicatorGroup);
indicatorType = createIndicatorType('A');
indicatorService.addIndicatorType(indicatorType);
indicator = createIndicator('A', indicatorType);
indicatorService.addIndicator(indicator);
dataElement = createDataElement('A');
dataElementService.addDataElement(dataElement);
dataElementGroup = createDataElementGroup('A');
dataElementGroup.getMembers().add(dataElement);
dataElementService.addDataElementGroup(dataElementGroup);
periodType = periodService.getPeriodTypeByName(MonthlyPeriodType.NAME);
period = createPeriod(periodType, getDate(2000, 1, 1), getDate(2000, 2, 1));
periodService.addPeriod(period);
mapLegendSet = createLegendSet('A');
legendService.addLegendSet(mapLegendSet);
internalMapLayer = new InternalMapLayer();
internalMapLayer.setRadiusLow(15);
internalMapLayer.setRadiusHigh(35);
internalMapLayer.setColorLow(Color.YELLOW);
internalMapLayer.setColorHigh(Color.RED);
internalMapLayer.setOpacity(0.5f);
}
public String execute() {
Expression leftSide = new Expression();
leftSide.setExpression(leftSideExpression);
leftSide.setDescription(leftSideDescription);
leftSide.setNullIfBlank(leftSideNullIfBlank);
leftSide.setDataElementsInExpression(
expressionService.getDataElementsInExpression(leftSideExpression));
leftSide.setOptionCombosInExpression(
expressionService.getOptionCombosInExpression(leftSideExpression));
Expression rightSide = new Expression();
rightSide.setExpression(rightSideExpression);
rightSide.setDescription(rightSideDescription);
rightSide.setNullIfBlank(rightSideNullIfBlank);
rightSide.setDataElementsInExpression(
expressionService.getDataElementsInExpression(rightSideExpression));
rightSide.setOptionCombosInExpression(
expressionService.getOptionCombosInExpression(rightSideExpression));
ValidationRule validationRule = new ValidationRule();
validationRule.setName(name);
validationRule.setDescription(description);
validationRule.setType(ValidationRule.TYPE_ABSOLUTE);
validationRule.setOperator(Operator.valueOf(operator));
validationRule.setLeftSide(leftSide);
validationRule.setRightSide(rightSide);
PeriodType periodType = periodService.getPeriodTypeByName(periodTypeName);
validationRule.setPeriodType(periodType);
validationRuleService.saveValidationRule(validationRule);
return SUCCESS;
}
// -------------------------------------------------------------------------
// Action implementation
// -------------------------------------------------------------------------
public String execute() throws Exception {
statementManager.initialise();
// Initialization
raFolderName = reportService.getRAFolderName();
String colArray[] = {
"A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S",
"T", "U", "V", "W", "X", "Y", "Z", "AA", "AB", "AC", "AD", "AE", "AF", "AG", "AH", "AI", "AJ",
"AK", "AL", "AM", "AN", "AO", "AP", "AQ", "AR", "AS", "AT", "AU", "AV", "AW", "AX", "AY",
"AZ", "BA", "BB", "BC", "BD", "BE", "BF", "BG", "BH", "BI", "BJ", "BK", "BL", "BM", "BN",
"BO", "BP", "BQ", "BR", "BS", "BT", "BU", "BV", "BW", "BX", "BY", "BZ"
};
Report_in selReportObj = reportService.getReport(Integer.parseInt(reportList));
// OrgUnit Info
OrganisationUnit currentOrgUnit = organisationUnitService.getOrganisationUnit(ouIDTB);
System.out.println(
currentOrgUnit.getName()
+ " : "
+ selReportObj.getName()
+ " : Report Generation Start Time is : "
+ new Date());
List<OrganisationUnit> childOrgUnitTree =
new ArrayList<OrganisationUnit>(
organisationUnitService.getOrganisationUnitWithChildren(ouIDTB));
List<Integer> childOrgUnitTreeIds =
new ArrayList<Integer>(getIdentifiers(OrganisationUnit.class, childOrgUnitTree));
String childOrgUnitsByComma = getCommaDelimitedString(childOrgUnitTreeIds);
// Report Info
String deCodesXMLFileName = selReportObj.getXmlTemplateName();
String reportModelTB = selReportObj.getModel();
String reportFileNameTB = selReportObj.getExcelTemplateName();
String inputTemplatePath =
System.getenv("DHIS2_HOME")
+ File.separator
+ raFolderName
+ File.separator
+ "template"
+ File.separator
+ reportFileNameTB;
// String outputReportPath = System.getenv( "DHIS2_HOME" ) + File.separator + raFolderName +
// File.separator + "output" + File.separator + UUID.randomUUID().toString() + ".xls";
String outputReportPath =
System.getenv("DHIS2_HOME") + File.separator + Configuration_IN.DEFAULT_TEMPFOLDER;
File newdir = new File(outputReportPath);
if (!newdir.exists()) {
newdir.mkdirs();
}
outputReportPath += File.separator + UUID.randomUUID().toString() + ".xls";
Workbook templateWorkbook = Workbook.getWorkbook(new File(inputTemplatePath));
WritableWorkbook outputReportWorkbook =
Workbook.createWorkbook(new File(outputReportPath), templateWorkbook);
WritableCellFormat wCellformat = new WritableCellFormat();
wCellformat.setBorder(Border.ALL, BorderLineStyle.THIN);
wCellformat.setAlignment(Alignment.CENTRE);
wCellformat.setVerticalAlignment(VerticalAlignment.CENTRE);
wCellformat.setWrap(true);
// Period Info
selectedPeriod = periodService.getPeriod(availablePeriods);
selectedEndPeriod = periodService.getPeriod(availablePeriodsto);
sDate = format.parseDate(String.valueOf(selectedPeriod.getStartDate()));
eDate = format.parseDate(String.valueOf(selectedEndPeriod.getEndDate()));
PeriodType periodType = periodService.getPeriodTypeByName(periodTypeId);
List<Period> periodList =
new ArrayList<Period>(periodService.getPeriodsBetweenDates(periodType, sDate, eDate));
// List<Period> periodList = new ArrayList<Period>( periodService.getIntersectingPeriods( sDate,
// eDate ) );
Collections.sort(periodList, new PeriodStartDateComparator());
if (periodTypeId.equalsIgnoreCase("monthly")) {
simpleDateFormat = new SimpleDateFormat("MMM-yyyy");
} else if (periodTypeId.equalsIgnoreCase("yearly")) {
simpleDateFormat = new SimpleDateFormat("yyyy");
} else {
simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
}
// To get Aggregation Data
List<Report_inDesign> reportDesignList = reportService.getReportDesign(deCodesXMLFileName);
// String dataElmentIdsByComma = reportService.getDataelementIds( reportDesignList );
String dataElmentIdsByComma =
reportService.getDataelementIdsByStype(reportDesignList, Report_inDesign.ST_DATAELEMENT);
String nonNumberDataElementIdsByComma =
reportService.getDataelementIdsByStype(
reportDesignList, Report_inDesign.ST_NON_NUMBER_DATAELEMENT);
// Collection<Integer> periodIds1 = new ArrayList<Integer>( getIdentifiers(Period.class,
// periodList ) );
String periodsByComma = "";
// getCommaDelimitedString( periodIds1 );
int colCount = 0;
for (Period period : periodList) {
if (periodTypeId.equalsIgnoreCase("daily")) {
periodsByComma = "" + period.getId();
} else {
Collection<Integer> periodIds =
new ArrayList<Integer>(
getIdentifiers(
Period.class,
periodService.getIntersectingPeriods(
period.getStartDate(), period.getEndDate())));
periodsByComma = getCommaDelimitedString(periodIds);
}
Map<String, String> aggDeMap = new HashMap<String, String>();
if (aggData.equalsIgnoreCase(USEEXISTINGAGGDATA)) {
aggDeMap.putAll(
reportService.getResultDataValueFromAggregateTable(
currentOrgUnit.getId(), dataElmentIdsByComma, periodsByComma));
} else if (aggData.equalsIgnoreCase(GENERATEAGGDATA)) {
aggDeMap.putAll(
reportService.getAggDataFromDataValueTable(
childOrgUnitsByComma, dataElmentIdsByComma, periodsByComma));
aggDeMap.putAll(
reportService.getAggNonNumberDataFromDataValueTable(
childOrgUnitsByComma, nonNumberDataElementIdsByComma, periodsByComma));
System.out.println(
childOrgUnitsByComma + " \n " + dataElmentIdsByComma + " \n " + periodsByComma);
} else if (aggData.equalsIgnoreCase(USECAPTUREDDATA)) {
aggDeMap.putAll(
reportService.getAggDataFromDataValueTable(
"" + currentOrgUnit.getId(), dataElmentIdsByComma, periodsByComma));
aggDeMap.putAll(
reportService.getAggNonNumberDataFromDataValueTable(
"" + currentOrgUnit.getId(), nonNumberDataElementIdsByComma, periodsByComma));
}
System.out.println("aggDeMap size : " + aggDeMap.size());
Iterator<Report_inDesign> reportDesignIterator = reportDesignList.iterator();
while (reportDesignIterator.hasNext()) {
Report_inDesign reportDesign = reportDesignIterator.next();
String deCodeString = reportDesign.getExpression();
String sType = reportDesign.getStype();
String tempStr = "";
tempRowNo = reportDesign.getRowno();
tempColNo = reportDesign.getColno();
sheetNo = reportDesign.getSheetno();
if (deCodeString.equalsIgnoreCase("FACILITY")) {
tempStr = currentOrgUnit.getName();
} else if (deCodeString.equalsIgnoreCase("PERIOD-RANGE")) {
tempStr =
simpleDateFormat.format(selectedPeriod.getStartDate())
+ " To "
+ simpleDateFormat.format(selectedEndPeriod.getEndDate());
} else if (deCodeString.equalsIgnoreCase("PROGRESSIVE-PERIOD")) {
tempStr = simpleDateFormat.format(period.getStartDate());
} else if (deCodeString.equalsIgnoreCase("NA")) {
tempStr = " ";
} else {
if (sType.equalsIgnoreCase("dataelement")) {
if (aggData.equalsIgnoreCase(USECAPTUREDDATA)) {
// tempStr = reportService.getIndividualResultDataValue( deCodeString,
// period.getStartDate(), period.getEndDate(), currentOrgUnit, reportModelTB );
tempStr = getAggVal(deCodeString, aggDeMap);
} else if (aggData.equalsIgnoreCase(GENERATEAGGDATA)) {
// tempStr = reportService.getResultDataValue( deCodeString, period.getStartDate(),
// period.getEndDate(), currentOrgUnit, reportModelTB );
tempStr = getAggVal(deCodeString, aggDeMap);
} else if (aggData.equalsIgnoreCase(USEEXISTINGAGGDATA)) {
tempStr = getAggVal(deCodeString, aggDeMap);
}
} else if (sType.equalsIgnoreCase(Report_inDesign.ST_DATAELEMENT_NO_REPEAT)) {
deCodeString = deCodeString.replaceAll(":", "\\.");
deCodeString = deCodeString.replaceAll("[", "");
deCodeString = deCodeString.replaceAll("]", "");
System.out.println("deCodeString : " + deCodeString);
tempStr = aggDeMap.get(deCodeString);
}
}
if (tempStr == null || tempStr.equals(" ")) {
tempColNo += colCount;
WritableSheet sheet0 = outputReportWorkbook.getSheet(sheetNo);
sheet0.addCell(new Blank(tempColNo, tempRowNo, wCellformat));
} else {
if (reportModelTB.equalsIgnoreCase("PROGRESSIVE-PERIOD")) {
if (deCodeString.equalsIgnoreCase("FACILITY")
|| deCodeString.equalsIgnoreCase("PERIOD-RANGE")) {
} else {
tempColNo += colCount;
}
WritableSheet sheet0 = outputReportWorkbook.getSheet(sheetNo);
try {
try {
sheet0.addCell(
new Number(tempColNo, tempRowNo, Double.parseDouble(tempStr), wCellformat));
} catch (Exception e) {
sheet0.addCell(new Label(tempColNo, tempRowNo, tempStr, wCellformat));
}
} catch (Exception e) {
System.out.println("Cannot write to Excel");
}
}
}
} // inner while loop end
colCount++;
} // outer while loop end
// ---------------------------------------------------------------------
// Writing Total Values
// ---------------------------------------------------------------------
Iterator<Report_inDesign> reportDesignIterator = reportDesignList.iterator();
while (reportDesignIterator.hasNext()) {
Report_inDesign reportDesign = reportDesignIterator.next();
String deCodeString = reportDesign.getExpression();
if (deCodeString.equalsIgnoreCase("FACILITY")
|| deCodeString.equalsIgnoreCase("PERIOD-RANGE")) {
continue;
}
tempRowNo = reportDesign.getRowno();
tempColNo = reportDesign.getColno();
sheetNo = reportDesign.getSheetno();
String colStart = "" + colArray[tempColNo];
String colEnd = "" + colArray[tempColNo + colCount - 1];
String tempFormula =
"SUM(" + colStart + (tempRowNo + 1) + ":" + colEnd + (tempRowNo + 1) + ")";
WritableSheet totalSheet = outputReportWorkbook.getSheet(sheetNo);
WritableFont arialBold = new WritableFont(WritableFont.ARIAL, 10, WritableFont.BOLD);
WritableCellFormat totalCellformat = new WritableCellFormat(arialBold);
totalCellformat.setBorder(Border.ALL, BorderLineStyle.THIN);
totalCellformat.setAlignment(Alignment.CENTRE);
totalCellformat.setVerticalAlignment(VerticalAlignment.CENTRE);
totalCellformat.setWrap(true);
if (deCodeString.equalsIgnoreCase("PROGRESSIVE-PERIOD")) {
totalSheet.addCell(new Label(tempColNo + colCount, tempRowNo, "Total", totalCellformat));
} else if (deCodeString.equalsIgnoreCase("NA")) {
totalSheet.addCell(new Label(tempColNo + colCount, tempRowNo, " ", totalCellformat));
} else {
totalSheet.addCell(
new Formula(tempColNo + colCount, tempRowNo, tempFormula, totalCellformat));
}
}
outputReportWorkbook.write();
outputReportWorkbook.close();
fileName = reportFileNameTB.replace(".xls", "");
fileName += "_" + currentOrgUnit.getShortName();
fileName += "_" + simpleDateFormat.format(selectedPeriod.getStartDate()) + ".xls";
File outputReportFile = new File(outputReportPath);
inputStream = new BufferedInputStream(new FileInputStream(outputReportFile));
System.out.println(
currentOrgUnit.getName()
+ " : "
+ selReportObj.getName()
+ " : Report Generation End Time is : "
+ new Date());
outputReportFile.deleteOnExit();
statementManager.destroy();
return SUCCESS;
}