Example usage for org.apache.poi.ss.usermodel Workbook getCreationHelper

List of usage examples for org.apache.poi.ss.usermodel Workbook getCreationHelper

Introduction

In this page you can find the example usage for org.apache.poi.ss.usermodel Workbook getCreationHelper.

Prototype

CreationHelper getCreationHelper();

Source Link

Document

Returns an object that handles instantiating concrete classes of the various instances one needs for HSSF and XSSF.

Usage

From source file:org.joeffice.spreadsheet.SpreadsheetComponent.java

License:Apache License

public void load(Workbook workbook) {
    this.workbook = workbook;
    int numberOfSheets = workbook.getNumberOfSheets();
    for (int i = 0; i < numberOfSheets; i++) {
        Sheet sheet = workbook.getSheetAt(i);
        String sheetName = workbook.getSheetName(i);
        JPanel sheetPanel = new SheetComponent(sheet, this);
        addTab(sheetName, sheetPanel);/*  w  ww.j  av  a 2s.c  om*/
    }
    setSelectedIndex(workbook.getActiveSheetIndex());
    formulaEvaluator = workbook.getCreationHelper().createFormulaEvaluator();
}

From source file:org.nuclos.server.report.export.ExcelExport.java

License:Open Source License

private NuclosFile export(Workbook wb, String sheetname, ResultVO result, List<ReportFieldDefinition> fields,
        String name) throws NuclosReportException {
    sheetname = sheetname != null ? sheetname
            : SpringLocaleDelegate.getInstance().getMessage("XLSExport.2", "Daten aus Nucleus");
    Sheet s = wb.getSheet(sheetname);//from  ww  w.  j a  v a  2  s  .c  o m
    if (s == null) {
        s = wb.createSheet(sheetname);
    }

    int iRowNum = 0;
    int iColumnNum = 0;
    CreationHelper createHelper = wb.getCreationHelper();

    Row row = getRow(s, 0);

    Map<Integer, CellStyle> styles = new HashMap<Integer, CellStyle>();

    for (Iterator<ResultColumnVO> i = result.getColumns().iterator(); i.hasNext(); iColumnNum++) {
        i.next();
        Cell cell = getCell(row, iColumnNum);
        cell.setCellValue(fields.get(iColumnNum).getLabel());

        CellStyle style = wb.createCellStyle();
        String f = getFormat(fields.get(iColumnNum));
        if (f != null) {
            style.setDataFormat(createHelper.createDataFormat().getFormat(f));
        }
        styles.put(iColumnNum, style);
    }
    iRowNum++;

    // export data
    for (int i = 0; i < result.getRows().size(); i++, iRowNum++) {
        iColumnNum = 0;
        Object[] dataRow = result.getRows().get(i);
        row = getRow(s, iRowNum);
        for (int j = 0; j < result.getColumns().size(); j++, iColumnNum++) {
            Object value = dataRow[j];
            Cell c = getCell(row, iColumnNum);
            ReportFieldDefinition def = fields.get(j);

            if (value != null) {
                if (value instanceof List) {
                    final StringBuilder sb = new StringBuilder();
                    for (Iterator<?> it = ((List<?>) value).iterator(); it.hasNext();) {
                        final Object v = it.next();
                        sb.append(CollectableFieldFormat.getInstance(def.getJavaClass())
                                .format(def.getOutputformat(), v));
                        if (it.hasNext()) {
                            sb.append(", ");
                        }
                    }
                    c.setCellValue(sb.toString());
                } else {
                    if (Date.class.isAssignableFrom(def.getJavaClass())) {
                        c.setCellStyle(styles.get(iColumnNum));
                        c.setCellValue((Date) value);
                    } else if (Integer.class.isAssignableFrom(def.getJavaClass())) {
                        c.setCellStyle(styles.get(iColumnNum));
                        c.setCellValue((Integer) value);
                    } else if (Double.class.isAssignableFrom(def.getJavaClass())) {
                        c.setCellStyle(styles.get(iColumnNum));
                        c.setCellValue((Double) value);
                    } else {
                        c.setCellValue(String.valueOf(value));
                    }
                }
            } else {
                c.setCellValue("");
            }
        }
    }

    try {
        FormulaEvaluator evaluator = wb.getCreationHelper().createFormulaEvaluator();
        for (int sheetNum = 0; sheetNum < wb.getNumberOfSheets(); sheetNum++) {
            Sheet sheet = wb.getSheetAt(sheetNum);
            for (Row r : sheet) {
                for (Cell c : r) {
                    if (c.getCellType() == Cell.CELL_TYPE_FORMULA) {
                        evaluator.evaluateFormulaCell(c);
                    }
                }
            }
        }
    } catch (Exception e) {
    } // ignore any Exception

    ByteArrayOutputStream baos = new ByteArrayOutputStream(1024);
    try {
        wb.write(baos);
        return new NuclosFile(name + format.getExtension(), baos.toByteArray());
    } catch (IOException e) {
        throw new NuclosReportException(e);
    } finally {
        try {
            baos.close();
        } catch (IOException e) {
        }
    }
}

From source file:org.omnaest.i18nbinder.internal.XLSFile.java

License:Apache License

/**
 * Stores the data from the object onto disk.
 *///  w ww. java 2 s. co  m
public void store() {
    Workbook wb = this.newWorkbookToWrite();
    CreationHelper createHelper = wb.getCreationHelper();
    Sheet sheet = wb.createSheet("all");

    int lineNumber = 0;
    for (TableRow iLine : this.tableRowList) {
        //
        Row row = sheet.createRow(lineNumber++);

        //
        int cellIndex = 0;
        for (String iCellText : iLine) {
            Cell cell = row.createCell(cellIndex++);
            cell.setCellValue(createHelper.createRichTextString(iCellText));
        }
    }

    try {
        final FileOutputStream fileOutputStream = new FileOutputStream(this.file);
        final OutputStream outputStream = new BufferedOutputStream(fileOutputStream);
        wb.write(outputStream);
        outputStream.close();
        fileOutputStream.close();
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }

}

From source file:org.onexus.website.api.widgets.download.formats.ExcelFormat.java

License:Apache License

@Override
public void write(IEntityTable result, OutputStream out) throws IOException {

    Workbook wb = new HSSFWorkbook();
    CreationHelper createHelper = wb.getCreationHelper();
    Sheet sheet = wb.createSheet("new sheet");

    // Header row
    int rowIndex = 0;
    Row row = sheet.createRow(rowIndex);
    writeHeader(row, createHelper, result);

    while (result.next()) {
        rowIndex++;/*from www.  j  a  v  a 2  s .  c  om*/
        row = sheet.createRow(rowIndex);
        writeRow(row, result);
    }

    // Write the output to a file
    wb.write(out);

}

From source file:org.openepics.discs.ccdb.core.util.ExcelCell.java

License:Open Source License

/**
 * Creating a String from Excel file cell. If cell contains numeric value, this value is cast to String.
 * If there is no value for this cell, null is returned.
 *
 * @param cell the Excel {@link Cell}/*from  w w  w.j  ava2  s.c  om*/
 * @param workbook the Excel {@link Workbook}
 *
 * @return the {@link String} result
 */
public static String asStringOrNull(@Nullable Cell cell, Workbook workbook) {
    final String stringValue;
    if (cell != null) {
        if (cell.getCellType() == Cell.CELL_TYPE_NUMERIC) {
            final double numericCellValue = cell.getNumericCellValue();
            if (numericCellValue == (int) numericCellValue) {
                stringValue = String.valueOf((int) numericCellValue);
            } else {
                stringValue = String.valueOf(numericCellValue);
            }
        } else if (cell.getCellType() == Cell.CELL_TYPE_STRING) {
            stringValue = cell.getStringCellValue() != null ? cell.getStringCellValue() : null;
        } else if (cell.getCellType() == Cell.CELL_TYPE_BLANK) {
            stringValue = null;
        } else if (cell.getCellType() == Cell.CELL_TYPE_BOOLEAN) {
            stringValue = String.valueOf(cell.getBooleanCellValue());
        } else if (cell.getCellType() == Cell.CELL_TYPE_FORMULA) {
            final FormulaEvaluator evaluator = workbook.getCreationHelper().createFormulaEvaluator();
            final CellValue cellValue = evaluator.evaluate(cell);
            if (cellValue != null) {
                final String columnValue = cellValue.getStringValue();
                if (columnValue == null) {
                    stringValue = Double.toString(cellValue.getNumberValue());
                } else {
                    stringValue = columnValue;
                }
            } else {
                stringValue = null;
            }
        } else {
            throw new UnhandledCaseException();
        }
    } else {
        stringValue = null;
    }
    return stringValue;
}

From source file:org.patientview.radar.service.impl.ExcelDocumentDataBuilder.java

License:Open Source License

public byte[] build(DocumentData documentData) {

    Workbook workbook = new HSSFWorkbook();
    CreationHelper createHelper = workbook.getCreationHelper();
    Sheet sheet = workbook.createSheet("data");

    // add the headers/columns
    Row headerRow = sheet.createRow((short) 0);
    sheet.autoSizeColumn(0);//w  w  w  . j  a  va2 s .c o  m

    CellStyle headerStyle = workbook.createCellStyle();

    headerStyle.setFillForegroundColor(IndexedColors.GREY_25_PERCENT.getIndex());
    headerStyle.setFillPattern(CellStyle.SOLID_FOREGROUND);
    headerStyle.setLeftBorderColor(IndexedColors.BLACK.getIndex());
    headerStyle.setRightBorderColor(IndexedColors.BLACK.getIndex());
    headerStyle.setTopBorderColor(IndexedColors.BLACK.getIndex());
    headerStyle.setBottomBorderColor(IndexedColors.BLACK.getIndex());

    headerStyle.setLeftBorderColor(CellStyle.BORDER_THIN);
    headerStyle.setRightBorderColor(CellStyle.BORDER_THIN);
    headerStyle.setTopBorderColor(CellStyle.BORDER_THIN);
    headerStyle.setBottomBorderColor(CellStyle.BORDER_THIN);

    Font headerFont = workbook.createFont();
    headerFont.setBoldweight(Font.BOLDWEIGHT_BOLD);
    headerStyle.setFont(headerFont);

    List<String> headers = documentData.getHeaders();
    int headerColumnIndex = 0;
    for (String header : headers) {
        sheet.autoSizeColumn(headerColumnIndex);
        Cell cell = headerRow.createCell(headerColumnIndex);
        cell.setCellStyle(headerStyle);
        cell.setCellValue(header);
        headerColumnIndex++;
    }

    // add the row data
    int columnIndex = 0;
    int rowIndex = 1;
    for (List<String> row : documentData.getRows()) {
        Row spreadSheetRow = sheet.createRow((short) rowIndex++);
        for (String data : row) {
            spreadSheetRow.createCell(columnIndex++).setCellValue(data);
        }
        columnIndex = 0;
    }

    // set the column width to fit the contents - this must be done after the data is added
    headerColumnIndex = 0;
    for (String header : headers) {
        sheet.autoSizeColumn(headerColumnIndex);
        headerColumnIndex++;
    }
    ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
    try {
        workbook.write(outputStream);
        outputStream.close();
        outputStream.flush();
    } catch (IOException e) {
        LOGGER.error("Unable to write workbook to output stream " + e.getMessage(), e);
    }

    return outputStream.toByteArray();
}

From source file:org.sakaiproject.evaluation.tool.reporting.XLSReportExporter.java

License:Educational Community License

/**
 * Build the .xls report in the new (section based) format.
 * //w ww  .j  a  v  a 2 s.com
 * @param evaluation
 * @param groupIDs
 * @param outputStream
 */
private void buildReportSectionAware(EvalEvaluation evaluation, String[] groupIDs, OutputStream outputStream) {
    // Get permission to view, current user and eval owner
    Boolean instructorViewAllResults = evaluation.getInstructorViewAllResults();
    String currentUserId = commonLogic.getCurrentUserId();
    String evalOwner = evaluation.getOwner();

    TemplateItemDataList tidl = getEvalTIDL(evaluation, groupIDs);
    List<DataTemplateItem> dtiList = tidl.getFlatListOfDataTemplateItems(true);
    Workbook wb = new XSSFWorkbook();
    creationHelper = wb.getCreationHelper();

    // Title style
    Sheet courseSheet = wb.createSheet(messageLocator.getMessage("viewreport.xls.courseSheet.name"));
    Sheet instructorSheet = wb.createSheet(messageLocator.getMessage("viewreport.xls.instructorSheet.name"));
    Font font = wb.createFont();
    font.setFontHeightInPoints((short) 12);
    font.setBold(true);
    CellStyle mainTitleStyle = wb.createCellStyle();
    mainTitleStyle.setFont(font);

    // Bold header style
    font = wb.createFont();
    font.setFontHeightInPoints((short) 10);
    font.setBold(true);
    CellStyle boldHeaderStyle = wb.createCellStyle();
    boldHeaderStyle.setFont(font);

    // Italic meta header style
    font = wb.createFont();
    font.setFontHeightInPoints((short) 10);
    font.setItalic(true);
    CellStyle italicMiniHeaderStyle = wb.createCellStyle();
    italicMiniHeaderStyle.setFont(font);

    // Date meta Style
    dateCellStyle = wb.createCellStyle();
    dateCellStyle.setDataFormat((short) 0x16);

    // Evaluation Title
    int rowCounter = 0;
    Row courseSheetRow1 = courseSheet.createRow(rowCounter);
    Row instructorSheetRow1 = instructorSheet.createRow(rowCounter);
    Cell courseSheetCellA1 = courseSheetRow1.createCell((short) 0);
    Cell instructorSheetCellA1 = instructorSheetRow1.createCell((short) 0);
    setPlainStringCell(courseSheetCellA1,
            evaluation.getTitle() + " - " + messageLocator.getMessage("viewreport.xls.courseSheet.name"));
    setPlainStringCell(instructorSheetCellA1,
            evaluation.getTitle() + " - " + messageLocator.getMessage("viewreport.xls.instructorSheet.name"));
    courseSheetCellA1.setCellStyle(mainTitleStyle);
    instructorSheetCellA1.setCellStyle(mainTitleStyle);

    // Calculate the response rate
    rowCounter++;
    int responsesCount = evaluationService.countResponses(null, new Long[] { evaluation.getId() }, groupIDs,
            null);
    int enrollmentsCount = evaluationService.countParticipantsForEval(evaluation.getId(), groupIDs);
    Row courseSheetRow2 = courseSheet.createRow(rowCounter);
    Row instructorSheetRow2 = instructorSheet.createRow(rowCounter);
    Cell courseSheetCellA2 = courseSheetRow2.createCell((short) 0);
    Cell instructorSheetCellA2 = instructorSheetRow2.createCell((short) 0);
    courseSheetCellA2.setCellStyle(boldHeaderStyle);
    instructorSheetCellA2.setCellStyle(boldHeaderStyle);
    setPlainStringCell(courseSheetCellA2,
            EvalUtils.makeResponseRateStringFromCounts(responsesCount, enrollmentsCount));
    setPlainStringCell(instructorSheetCellA2,
            EvalUtils.makeResponseRateStringFromCounts(responsesCount, enrollmentsCount));

    // Dates
    setPlainStringCell(courseSheetRow1.createCell((short) 2),
            messageLocator.getMessage("evalsettings.start.date.header"));
    setPlainStringCell(instructorSheetRow1.createCell((short) 2),
            messageLocator.getMessage("evalsettings.start.date.header"));
    setDateCell(courseSheetRow2.createCell((short) 2), evaluation.getStartDate());
    setDateCell(instructorSheetRow2.createCell((short) 2), evaluation.getStartDate());
    if (evaluation.getDueDate() != null) {
        setPlainStringCell(courseSheetRow1.createCell((short) 3),
                messageLocator.getMessage("evalsettings.due.date.header"));
        setPlainStringCell(instructorSheetRow1.createCell((short) 3),
                messageLocator.getMessage("evalsettings.due.date.header"));
        setDateCell(courseSheetRow2.createCell((short) 3), evaluation.getDueDate());
        setDateCell(instructorSheetRow2.createCell((short) 3), evaluation.getDueDate());
    }

    // List of groups
    if (groupIDs.length > 0) {
        rowCounter++;
        Row courseSheetRow3 = courseSheet.createRow(rowCounter);
        Row instructorSheetRow3 = instructorSheet.createRow(rowCounter);
        Cell courseSheetCellA3 = courseSheetRow3.createCell((short) 0);
        Cell instructorSheetCellA3 = instructorSheetRow3.createCell((short) 0);

        // Get the section/site titles
        setPlainStringCell(courseSheetCellA3, messageLocator.getMessage("reporting.xls.participants",
                new Object[] { responseAggregator.getCommaSeparatedGroupNames(groupIDs) }));
        setPlainStringCell(instructorSheetCellA3, messageLocator.getMessage("reporting.xls.participants",
                new Object[] { responseAggregator.getCommaSeparatedGroupNames(groupIDs) }));
    }

    // Column headers (static)
    rowCounter += 2;
    short courseSheetHeaderCount = 1;
    short instructorSheetHeaderCount = 1;
    Row courseSheetHeaderRow = courseSheet.createRow(rowCounter);
    Row instructorSheetHeaderRow = instructorSheet.createRow(rowCounter);
    Cell courseSheetSectionHeaderCell = courseSheetHeaderRow.createCell(courseSheetHeaderCount++);
    Cell instructorSheetSectionHeaderCell = instructorSheetHeaderRow.createCell(instructorSheetHeaderCount++);
    if (evaluation.getSectionAwareness()) {
        courseSheetSectionHeaderCell.setCellValue(messageLocator.getMessage("viewreport.section.header"));
        instructorSheetSectionHeaderCell.setCellValue(messageLocator.getMessage("viewreport.section.header"));
    } else {
        courseSheetSectionHeaderCell.setCellValue(messageLocator.getMessage("viewreport.site.header"));
        instructorSheetSectionHeaderCell.setCellValue(messageLocator.getMessage("viewreport.site.header"));
    }
    courseSheetSectionHeaderCell.setCellStyle(boldHeaderStyle);
    instructorSheetSectionHeaderCell.setCellStyle(boldHeaderStyle);
    Cell courseSheetResponseIdHeaderCell = courseSheetHeaderRow.createCell(courseSheetHeaderCount++);
    Cell instructorSheetResponseIdHeaderCell = instructorSheetHeaderRow
            .createCell(instructorSheetHeaderCount++);
    courseSheetResponseIdHeaderCell.setCellValue(messageLocator.getMessage("viewreport.responseID.header"));
    instructorSheetResponseIdHeaderCell.setCellValue(messageLocator.getMessage("viewreport.responseID.header"));
    courseSheetResponseIdHeaderCell.setCellStyle(boldHeaderStyle);
    instructorSheetResponseIdHeaderCell.setCellStyle(boldHeaderStyle);
    Cell instructorSheetInstructorIdHeaderCell = instructorSheetHeaderRow
            .createCell(instructorSheetHeaderCount++);
    instructorSheetInstructorIdHeaderCell
            .setCellValue(messageLocator.getMessage("viewreport.instructorID.header"));
    instructorSheetInstructorIdHeaderCell.setCellStyle(boldHeaderStyle);
    Cell instructorSheetFirstNameHeaderCell = instructorSheetHeaderRow.createCell(instructorSheetHeaderCount++);
    instructorSheetFirstNameHeaderCell.setCellValue(messageLocator.getMessage("viewreport.firstName.header"));
    instructorSheetFirstNameHeaderCell.setCellStyle(boldHeaderStyle);
    Cell instructorSheetLastNameHeaderCell = instructorSheetHeaderRow.createCell(instructorSheetHeaderCount++);
    instructorSheetLastNameHeaderCell.setCellValue(messageLocator.getMessage("viewreport.lastName.header"));
    instructorSheetLastNameHeaderCell.setCellStyle(boldHeaderStyle);

    // Generate dynamic question headers
    List<String> instructorRelatedQuestions = new ArrayList<>();
    for (DataTemplateItem dti : dtiList) {
        // Skip items that aren't for the current user
        if (isItemNotForCurrentUser(instructorViewAllResults, currentUserId, evalOwner, dti)) {
            continue;
        }

        // If there's already a header for a specific instructor question, don't list it twice
        String questionText = commonLogic.makePlainTextFromHTML(dti.templateItem.getItem().getItemText());
        if (instructorRelatedQuestions.contains(questionText)) {
            continue;
        }

        // Add the header to the appropriate worksheet
        Cell questionTextHeaderCell;
        if (EvalConstants.ITEM_CATEGORY_ASSISTANT.equals(dti.associateType)
                || EvalConstants.ITEM_CATEGORY_INSTRUCTOR.equals(dti.associateType)) {
            instructorRelatedQuestions.add(questionText);
            questionTextHeaderCell = instructorSheetHeaderRow.createCell(instructorSheetHeaderCount++);
            questionTextHeaderCell.setCellStyle(boldHeaderStyle);
            if (dti.usesComments()) {
                setPlainStringCell(instructorSheetHeaderRow.createCell(instructorSheetHeaderCount++),
                        messageLocator.getMessage("viewreport.comments.header"))
                                .setCellStyle(italicMiniHeaderStyle);
            }
        } else {
            questionTextHeaderCell = courseSheetHeaderRow.createCell(courseSheetHeaderCount++);
            questionTextHeaderCell.setCellStyle(boldHeaderStyle);
            if (dti.usesComments()) {
                setPlainStringCell(courseSheetHeaderRow.createCell(courseSheetHeaderCount++),
                        messageLocator.getMessage("viewreport.comments.header"))
                                .setCellStyle(italicMiniHeaderStyle);
            }
        }
        setPlainStringCell(questionTextHeaderCell, questionText);
    }

    // Parse out the instructor and course related responeses into separate structures
    List<Long> responseIDs = tidl.getResponseIdsForAnswers();
    List<List<String>> courseRelatedResponses = new ArrayList<>();
    Map<Long, Map<User, List<EvalAnswer>>> answerMap = new HashMap<>();
    for (Long responseID : responseIDs) {
        // Dump the (course related) data into a list of strings representing a spreadsheet row (so it can be sorted)
        List<String> row = new ArrayList<>();
        String groupID = "";
        List<EvalAnswer> answers = tidl.getAnswersByResponseId(responseID);
        if (answers != null && !answers.isEmpty()) {
            groupID = answers.get(0).getResponse().getEvalGroupId();
        }
        row.add(SECTION_OR_SITE_COLUMN_NUM,
                responseAggregator.getCommaSeparatedGroupNames(new String[] { groupID }));
        row.add(RESPONSE_ID_COLUMN_NUM, responseID.toString());

        // Add the response ID to the answer map
        answerMap.put(responseID, new HashMap<>());

        // Loop through the data template items...
        int questionCounter = 0;
        for (DataTemplateItem dti : dtiList) {
            // Skip items that aren't for the current user
            if (isItemNotForCurrentUser(instructorViewAllResults, currentUserId, evalOwner, dti)) {
                continue;
            }

            // If it's an instructor related item... 
            EvalAnswer answer = dti.getAnswer(responseID);
            if (EvalConstants.ITEM_CATEGORY_ASSISTANT.equals(dti.associateType)
                    || EvalConstants.ITEM_CATEGORY_INSTRUCTOR.equals(dti.associateType)) {
                // If the answer is NOT null (it would be null for an instructor from a different section than the evaluator)
                if (answer != null) {
                    // Get the instructor
                    User instructor;
                    try {
                        instructor = userDirectoryService.getUser(answer.getAssociatedId());
                    } catch (UserNotDefinedException ex) {
                        continue;
                    }

                    // If the answer map has a list of answers for this response and this instructor, add the answer to the list
                    Map<User, List<EvalAnswer>> responseAnswers = answerMap.get(responseID);
                    List<EvalAnswer> instructorAnswers = responseAnswers.get(instructor);
                    if (instructorAnswers != null) {
                        instructorAnswers.add(answer);
                    }

                    // Otherwise, the answer map doesn't have a list of answers for this response and this instructor,
                    // create the list and add the answer to it
                    else {
                        instructorAnswers = new ArrayList<>();
                        instructorAnswers.add(answer);
                        responseAnswers.put(instructor, instructorAnswers);
                    }
                }
            }

            // If it's a course related item, just add it normally to the course worksheet
            else {
                row.add(QUESTION_COMMENTS_COLUMN_START_INDEX_COURSE_SHEET + questionCounter, "");
                if (answer != null) {
                    row.set(QUESTION_COMMENTS_COLUMN_START_INDEX_COURSE_SHEET + questionCounter,
                            responseAggregator.formatForSpreadSheet(answer.getTemplateItem(), answer));
                }
                if (dti.usesComments()) {
                    row.add(QUESTION_COMMENTS_COLUMN_START_INDEX_COURSE_SHEET + ++questionCounter,
                            StringUtils.trimToEmpty(answer.getComment()));
                }
                questionCounter++;
            }
        }

        // Add the course row data to the list of course data rows
        courseRelatedResponses.add(row);
    }

    // Convert the map structure of instructor responses into a List<List<String>>, representing rows of data
    List<List<String>> instructorRelatedResponses = new ArrayList<>();
    for (Long responseID : answerMap.keySet()) {
        // Loop through the instructors for the current response
        for (User instructor : answerMap.get(responseID).keySet()) {
            // Dump the data into a list of strings representing a spreadsheet row (so it can be sorted)
            List<String> row = new ArrayList<>();
            row.add(SECTION_OR_SITE_COLUMN_NUM, "");
            row.add(RESPONSE_ID_COLUMN_NUM, responseID.toString());
            row.add(INSTRUCTOR_ID_COLUMN_NUM, "");
            row.add(INSTRUCTOR_FIRST_NAME_COLUMN_NUM, "");
            row.add(INSTRUCTOR_LAST_NAME_COLUMN_NUM, "");
            if (instructor != null) {
                row.set(INSTRUCTOR_ID_COLUMN_NUM, instructor.getDisplayId());
                row.set(INSTRUCTOR_FIRST_NAME_COLUMN_NUM, instructor.getFirstName());
                row.set(INSTRUCTOR_LAST_NAME_COLUMN_NUM, instructor.getLastName());
            }

            int questionCounter = 0;
            for (EvalAnswer answer : answerMap.get(responseID).get(instructor)) {
                row.set(SECTION_OR_SITE_COLUMN_NUM, responseAggregator
                        .getCommaSeparatedGroupNames(new String[] { answer.getResponse().getEvalGroupId() }));
                row.add(QUESTION_COMMENTS_COLUMN_START_INDEX_INSTRUCTOR_SHEET + questionCounter, "");
                row.set(QUESTION_COMMENTS_COLUMN_START_INDEX_INSTRUCTOR_SHEET + questionCounter,
                        responseAggregator.formatForSpreadSheet(answer.getTemplateItem(), answer));
                String comment = StringUtils.trimToEmpty(answer.getComment());
                if (!comment.isEmpty()) {
                    row.add(QUESTION_COMMENTS_COLUMN_START_INDEX_INSTRUCTOR_SHEET + ++questionCounter,
                            (StringUtils.trimToEmpty(answer.getComment())));
                }
                questionCounter++;
            }

            // Add the row to the list of rows
            instructorRelatedResponses.add(row);
        }
    }

    // Sort the row data lists
    SortBySectionOrSiteComparator sorter = new SortBySectionOrSiteComparator();
    Collections.sort(instructorRelatedResponses, sorter);
    Collections.sort(courseRelatedResponses, sorter);

    // Output the sorted course related data into the course spreadsheet
    rowCounter = 0;
    for (List<String> row : courseRelatedResponses) {
        // Course sheet answer row, index cell
        short columnCounter = SECTION_OR_SITE_COLUMN_NUM;
        Row courseSheetAnswerRow = courseSheet.createRow(FIRST_ANSWER_ROW + rowCounter);
        Cell courseAnswerIndexCell = courseSheetAnswerRow.createCell(columnCounter++);
        courseAnswerIndexCell.setCellValue(rowCounter + 1);
        courseAnswerIndexCell.setCellStyle(boldHeaderStyle);

        // Course sheet section cell, response ID cell
        Cell courseSheetSectionCell = courseSheetAnswerRow.createCell(columnCounter++);
        Cell courseSheetResponseIdCell = courseSheetAnswerRow.createCell(columnCounter++);
        courseSheetSectionCell.setCellValue(row.get(SECTION_OR_SITE_COLUMN_NUM));
        courseSheetResponseIdCell.setCellValue(Integer.parseInt(row.get(RESPONSE_ID_COLUMN_NUM)));

        // Responses and comments
        for (int i = QUESTION_COMMENTS_COLUMN_START_INDEX_COURSE_SHEET; i < row.size(); i++) {
            setPlainStringCell(courseSheetAnswerRow.createCell(columnCounter++), row.get(i));
        }

        // Increment the row counter
        rowCounter++;
    }

    // Output the sorted instructor related data into the instructor spreadsheet
    rowCounter = 0;
    for (List<String> row : instructorRelatedResponses) {
        // Answer row, index cell
        short columnCounter = SECTION_OR_SITE_COLUMN_NUM;
        Row instructorSheetAnswerRow = instructorSheet.createRow(FIRST_ANSWER_ROW + rowCounter);
        Cell instructorAnswerIndexCell = instructorSheetAnswerRow.createCell(columnCounter++);
        instructorAnswerIndexCell.setCellValue(rowCounter + 1);
        instructorAnswerIndexCell.setCellStyle(boldHeaderStyle);

        // Section cell, response ID cell
        Cell instructorSheetSectionCell = instructorSheetAnswerRow.createCell(columnCounter++);
        Cell instructorSheetResponseIdCell = instructorSheetAnswerRow.createCell(columnCounter++);
        instructorSheetSectionCell.setCellValue(row.get(SECTION_OR_SITE_COLUMN_NUM));
        instructorSheetResponseIdCell.setCellValue(Integer.parseInt(row.get(RESPONSE_ID_COLUMN_NUM)));

        // Instructor ID, first name, last name cells
        Cell instructorIdCell = instructorSheetAnswerRow.createCell(columnCounter++);
        Cell instructorFirstNameCell = instructorSheetAnswerRow.createCell(columnCounter++);
        Cell instructorLastNameCell = instructorSheetAnswerRow.createCell(columnCounter++);
        instructorIdCell.setCellValue(row.get(INSTRUCTOR_ID_COLUMN_NUM));
        instructorFirstNameCell.setCellValue(row.get(INSTRUCTOR_FIRST_NAME_COLUMN_NUM));
        instructorLastNameCell.setCellValue(row.get(INSTRUCTOR_LAST_NAME_COLUMN_NUM));

        // Responses and comments
        for (int i = QUESTION_COMMENTS_COLUMN_START_INDEX_INSTRUCTOR_SHEET; i < row.size(); i++) {
            setPlainStringCell(instructorSheetAnswerRow.createCell(columnCounter++), row.get(i));
        }

        // Increment the row counter
        rowCounter++;
    }

    // Dump the output to the response stream
    try {
        wb.write(outputStream);
    } catch (IOException e) {
        throw UniversalRuntimeException.accumulate(e, "Could not get Writer to dump output to xls");
    }

}

From source file:org.sakaiproject.evaluation.tool.reporting.XLSReportExporter.java

License:Educational Community License

public void buildReport(EvalEvaluation evaluation, String[] groupIds, String evaluateeId,
        OutputStream outputStream, boolean newReportStyle) {

    /*//w w  w.  j  a v a 2s. c o  m
     * Logic for creating this view 1) make tidl 2) get DTIs for this eval from tidl 3) use DTIs
     * to make the headers 4) get responseIds from tidl 5) loop over response ids 6) loop over
     * DTIs 7) check answersmap for an answer, if there put in cell, if missing, insert blank 8)
     * done
     */

    //Make sure responseAggregator is using this messageLocator
    responseAggregator.setMessageLocator(messageLocator);

    // Determine which report style to use; normal or section based
    if (newReportStyle) {
        buildReportSectionAware(evaluation, groupIds, outputStream);
    } else {
        Boolean instructorViewAllResults = (boolean) evaluation.getInstructorViewAllResults();
        String currentUserId = commonLogic.getCurrentUserId();
        String evalOwner = evaluation.getOwner();

        boolean isCurrentUserAdmin = commonLogic.isUserAdmin(currentUserId);

        // 1 Make TIDL
        TemplateItemDataList tidl = getEvalTIDL(evaluation, groupIds);
        // 2: get DTIs for this eval from tidl
        List<DataTemplateItem> dtiList = tidl.getFlatListOfDataTemplateItems(true);

        Workbook wb = new XSSFWorkbook();
        creationHelper = wb.getCreationHelper();

        Sheet sheet = wb.createSheet(messageLocator.getMessage("reporting.xls.sheetname"));

        // Title Style
        Font font = wb.createFont();
        font.setFontHeightInPoints((short) 12);
        font.setBold(true);
        CellStyle mainTitleStyle = wb.createCellStyle();
        mainTitleStyle.setFont(font);

        // Bold header style
        font = wb.createFont();
        font.setFontHeightInPoints((short) 10);
        font.setBold(true);
        CellStyle boldHeaderStyle = wb.createCellStyle();
        boldHeaderStyle.setFont(font);

        // Italic meta header style
        font = wb.createFont();
        font.setFontHeightInPoints((short) 10);
        font.setItalic(true);
        CellStyle italicMiniHeaderStyle = wb.createCellStyle();
        italicMiniHeaderStyle.setFont(font);

        // Date meta Style
        dateCellStyle = wb.createCellStyle();
        // TODO FIXME HELPME To properly
        // String dateCellFormat = ((SimpleDateFormat)DateFormat.getDateInstance(DateFormat.MEDIUM,
        // localeGetter.get())).toLocalizedPattern();
        // http://poi.apache.org/apidocs/org/apache/poi/hssf/usermodel/HSSFDataFormat.html
        dateCellStyle.setDataFormat((short) 0x16);

        // Evaluation Title
        Row row1 = sheet.createRow(0);
        Cell cellA1 = row1.createCell((short) 0);
        setPlainStringCell(cellA1, evaluation.getTitle());
        cellA1.setCellStyle(mainTitleStyle);

        // calculate the response rate
        // int responsesCount = deliveryService.countResponses(evaluation.getId(), null, true);
        int responsesCount = evaluationService.countResponses(null, new Long[] { evaluation.getId() }, groupIds,
                null);
        int enrollmentsCount = evaluationService.countParticipantsForEval(evaluation.getId(), groupIds);

        Row row2 = sheet.createRow(1);
        Cell cellA2 = row2.createCell((short) 0);
        cellA2.setCellStyle(boldHeaderStyle);
        setPlainStringCell(cellA2,
                EvalUtils.makeResponseRateStringFromCounts(responsesCount, enrollmentsCount));

        // dates
        setPlainStringCell(row1.createCell((short) 2),
                messageLocator.getMessage("evalsettings.start.date.header"));
        setDateCell(row2.createCell((short) 2), evaluation.getStartDate());
        if (evaluation.getDueDate() != null) {
            setPlainStringCell(row1.createCell((short) 3),
                    messageLocator.getMessage("evalsettings.due.date.header"));
            setDateCell(row2.createCell((short) 3), evaluation.getDueDate());
        }

        // add in list of groups
        if (groupIds.length > 0) {
            Row row3 = sheet.createRow(2);
            Cell cellA3 = row3.createCell((short) 0);
            setPlainStringCell(cellA3, messageLocator.getMessage("reporting.xls.participants",
                    new Object[] { responseAggregator.getCommaSeparatedGroupNames(groupIds) }));
        }

        // 3 use DTIs to make the headers
        Row questionCatRow = sheet.createRow(QUESTION_CAT_ROW);
        Row questionTypeRow = sheet.createRow(QUESTION_TYPE_ROW);
        Row questionTextRow = sheet.createRow(QUESTION_TEXT_ROW);
        short headerCount = 1;
        for (DataTemplateItem dti : dtiList) {

            if (!instructorViewAllResults // If the eval is so configured,
                    && !isCurrentUserAdmin // and currentUser is not an admin
                    && !currentUserId.equals(evalOwner) // and currentUser is not the eval creator
                    && !EvalConstants.ITEM_CATEGORY_COURSE.equals(dti.associateType)
                    && !currentUserId.equals(commonLogic.getEvalUserById(dti.associateId).userId)) {
                // skip items that aren't for the current user
                continue;
            }

            Cell cell = questionTypeRow.createCell(headerCount);

            setPlainStringCell(cell, responseAggregator.getHeaderLabelForItemType(dti.getTemplateItemType()));
            cell.setCellStyle(italicMiniHeaderStyle);

            Cell questionText = questionTextRow.createCell(headerCount);
            setPlainStringCell(questionText,
                    commonLogic.makePlainTextFromHTML(dti.templateItem.getItem().getItemText()));

            Cell questionCat = questionCatRow.createCell(headerCount);
            if (EvalConstants.ITEM_CATEGORY_INSTRUCTOR.equals(dti.associateType)) {
                EvalUser user = commonLogic.getEvalUserById(dti.associateId);
                String instructorMsg = messageLocator.getMessage("reporting.spreadsheet.instructor",
                        new Object[] { user.displayName });
                setPlainStringCell(questionCat, instructorMsg);
            } else if (EvalConstants.ITEM_CATEGORY_ASSISTANT.equals(dti.associateType)) {
                EvalUser user = commonLogic.getEvalUserById(dti.associateId);
                String assistantMsg = messageLocator.getMessage("reporting.spreadsheet.ta",
                        new Object[] { user.displayName });
                setPlainStringCell(questionCat, assistantMsg);
            } else if (EvalConstants.ITEM_CATEGORY_COURSE.equals(dti.associateType)) {
                setPlainStringCell(questionCat, messageLocator.getMessage("reporting.spreadsheet.course"));
            } else {
                setPlainStringCell(questionCat, messageLocator.getMessage("unknown.caps"));
            }

            headerCount++;

            if (dti.usesComments()) {
                // add an extra column for comments
                setPlainStringCell(questionTypeRow.createCell(headerCount),
                        messageLocator.getMessage("viewreport.comments.header"))
                                .setCellStyle(italicMiniHeaderStyle);
                headerCount++;
            }

        }

        // 4) get responseIds from tidl
        List<Long> responseIds = tidl.getResponseIdsForAnswers();

        // 5) loop over response ids
        short responseIdCounter = 0;
        for (Long responseId : responseIds) {
            Row row = sheet.createRow(responseIdCounter + FIRST_ANSWER_ROW);
            Cell indexCell = row.createCell((short) 0);
            indexCell.setCellValue(responseIdCounter + 1);
            indexCell.setCellStyle(boldHeaderStyle);
            // 6) loop over DTIs
            short dtiCounter = 1;
            for (DataTemplateItem dti : dtiList) {

                if (!instructorViewAllResults // If the eval is so configured,
                        && !isCurrentUserAdmin // and currentUser is not an admin
                        && !currentUserId.equals(evalOwner) // and currentUser is not the eval creator
                        && !EvalConstants.ITEM_CATEGORY_COURSE.equals(dti.associateType)
                        && !currentUserId.equals(commonLogic.getEvalUserById(dti.associateId).userId)) {
                    //skip instructor items that aren't for the current user
                    continue;
                }

                // 7) check answersmap for an answer, if there put in cell, if missing, insert blank
                EvalAnswer answer = dti.getAnswer(responseId);
                Cell responseCell = row.createCell(dtiCounter);
                // In Eval, users can leave questions blank, in which case this will be null
                if (answer != null) {
                    setPlainStringCell(responseCell,
                            responseAggregator.formatForSpreadSheet(answer.getTemplateItem(), answer));
                }
                if (dti.usesComments()) {
                    // put comment in the extra column
                    dtiCounter++;
                    setPlainStringCell(row.createCell(dtiCounter),
                            (answer == null || EvalUtils.isBlank(answer.getComment())) ? ""
                                    : answer.getComment());
                }
                dtiCounter++;
            }
            responseIdCounter++;
        }

        // dump the output to the response stream
        try {
            wb.write(outputStream);
        } catch (IOException e) {
            throw UniversalRuntimeException.accumulate(e, "Could not get Writer to dump output to xls");
        }
    }
}

From source file:org.seedstack.io.jasper.fixtures.CustomXlsRenderer.java

License:Mozilla Public License

@Override
public void render(OutputStream outputStream, Object model, String mimeType, Map<String, Object> parameters) {
    Validate.isTrue(StringUtils.equals(mimeType, "application/xls"));
    try {// ww  w .j ava  2s  .  c om
        Workbook wb = new HSSFWorkbook();
        Sheet sheet = wb.createSheet("new sheet");

        CreationHelper createHelper = wb.getCreationHelper();
        // Create a row and put some cells in it. Rows are 0 based.
        Row row = sheet.createRow((short) 0);

        // Or do it on one line.
        CustomerBean bean = (CustomerBean) model;
        row.createCell(1).setCellValue(bean.getCustomerNo());
        row.createCell(2).setCellValue(createHelper.createRichTextString(bean.getFirstName()));
        row.createCell(3).setCellValue(createHelper.createRichTextString(bean.getLastName()));
        CellStyle cellStyle = wb.createCellStyle();
        cellStyle.setDataFormat(createHelper.createDataFormat().getFormat("m/d/yy h:mm"));
        Cell cell = row.createCell(4);
        cell.setCellValue(bean.getBirthDate());
        cell.setCellStyle(cellStyle);
        row.createCell(5).setCellValue(bean.getMailingAddress());
        row.createCell(6).setCellValue(bean.getMarried());
        row.createCell(7).setCellValue(bean.getNumberOfKids());
        row.createCell(8).setCellValue(bean.getFavouriteQuote());
        row.createCell(9).setCellValue(bean.getEmail());
        row.createCell(10).setCellValue(bean.getLoyaltyPoints());

        wb.write(outputStream);
        outputStream.close();
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

From source file:org.sigmah.server.report.renderer.excel.BaseExcelRenderer.java

License:Open Source License

public BaseExcelRenderer(Workbook book, ElementT element) {

    this.element = element;
    this.book = book;
    this.factory = book.getCreationHelper();
    this.sheet = book.createSheet(composeSheetName());

    /* Create title line */

    Row titleRow = sheet.createRow(0);//  ww w .ja v a2 s  .co  m
    Cell titleCell = titleRow.createCell(0);
    titleCell.setCellValue(factory.createRichTextString(element.getTitle()));

    /* Create filter descriptors */

    List<FilterDescription> descs = generateFilterDescriptions();

    rowIndex = 2;

    for (FilterDescription desc : descs) {

        Row filterRow = sheet.createRow(rowIndex++);
        Cell filterCell = filterRow.createCell(0);

        filterCell.setCellValue(factory.createRichTextString(desc.joinLabels(", ")));
    }

    rowIndex++;

    generate();
}