Examples with AnalysisCell com.alibaba.excel.write.metadata.fill.AnalysisCell used on opensource projects

Example 1 with AnalysisCell

use of com.alibaba.excel.write.metadata.fill.AnalysisCell in project easyexcel by alibaba.

the class ExcelWriteFillExecutor method doFill.

private void doFill(List<AnalysisCell> analysisCellList, Object oneRowData, FillConfig fillConfig, Integer relativeRowIndex) {
    if (CollectionUtils.isEmpty(analysisCellList) || oneRowData == null) {
        return;
    }
    Map dataMap;
    if (oneRowData instanceof Map) {
        dataMap = (Map) oneRowData;
    } else {
        dataMap = BeanMapUtils.create(oneRowData);
    }
    Set<String> dataKeySet = new HashSet<>(dataMap.keySet());
    RowWriteHandlerContext rowWriteHandlerContext = WriteHandlerUtils.createRowWriteHandlerContext(writeContext, null, relativeRowIndex, Boolean.FALSE);
    for (AnalysisCell analysisCell : analysisCellList) {
        CellWriteHandlerContext cellWriteHandlerContext = WriteHandlerUtils.createCellWriteHandlerContext(writeContext, null, analysisCell.getRowIndex(), null, analysisCell.getColumnIndex(), relativeRowIndex, Boolean.FALSE, ExcelContentProperty.EMPTY);
        if (analysisCell.getOnlyOneVariable()) {
            String variable = analysisCell.getVariableList().get(0);
            if (!dataKeySet.contains(variable)) {
                continue;
            }
            Object value = dataMap.get(variable);
            ExcelContentProperty excelContentProperty = ClassUtils.declaredExcelContentProperty(dataMap, writeContext.currentWriteHolder().excelWriteHeadProperty().getHeadClazz(), variable);
            cellWriteHandlerContext.setExcelContentProperty(excelContentProperty);
            createCell(analysisCell, fillConfig, cellWriteHandlerContext, rowWriteHandlerContext);
            cellWriteHandlerContext.setOriginalValue(value);
            cellWriteHandlerContext.setOriginalFieldClass(FieldUtils.getFieldClass(dataMap, variable, value));
            converterAndSet(cellWriteHandlerContext);
            WriteCellData<?> cellData = cellWriteHandlerContext.getFirstCellData();
            // Restyle
            if (fillConfig.getAutoStyle()) {
                Optional.ofNullable(collectionFieldStyleCache.get(currentUniqueDataFlag)).map(collectionFieldStyleMap -> collectionFieldStyleMap.get(analysisCell)).ifPresent(cellData::setOriginCellStyle);
            }
        } else {
            StringBuilder cellValueBuild = new StringBuilder();
            int index = 0;
            List<WriteCellData<?>> cellDataList = new ArrayList<>();
            cellWriteHandlerContext.setExcelContentProperty(ExcelContentProperty.EMPTY);
            cellWriteHandlerContext.setIgnoreFillStyle(Boolean.TRUE);
            createCell(analysisCell, fillConfig, cellWriteHandlerContext, rowWriteHandlerContext);
            Cell cell = cellWriteHandlerContext.getCell();
            for (String variable : analysisCell.getVariableList()) {
                cellValueBuild.append(analysisCell.getPrepareDataList().get(index++));
                if (!dataKeySet.contains(variable)) {
                    continue;
                }
                Object value = dataMap.get(variable);
                ExcelContentProperty excelContentProperty = ClassUtils.declaredExcelContentProperty(dataMap, writeContext.currentWriteHolder().excelWriteHeadProperty().getHeadClazz(), variable);
                cellWriteHandlerContext.setOriginalValue(value);
                cellWriteHandlerContext.setOriginalFieldClass(FieldUtils.getFieldClass(dataMap, variable, value));
                cellWriteHandlerContext.setExcelContentProperty(excelContentProperty);
                cellWriteHandlerContext.setTargetCellDataType(CellDataTypeEnum.STRING);
                WriteCellData<?> cellData = convert(cellWriteHandlerContext);
                cellDataList.add(cellData);
                CellDataTypeEnum type = cellData.getType();
                if (type != null) {
                    switch(type) {
                        case STRING:
                            cellValueBuild.append(cellData.getStringValue());
                            break;
                        case BOOLEAN:
                            cellValueBuild.append(cellData.getBooleanValue());
                            break;
                        case NUMBER:
                            cellValueBuild.append(cellData.getNumberValue());
                            break;
                        default:
                            break;
                    }
                }
            }
            cellValueBuild.append(analysisCell.getPrepareDataList().get(index));
            cell.setCellValue(cellValueBuild.toString());
            cellWriteHandlerContext.setCellDataList(cellDataList);
            if (CollectionUtils.isNotEmpty(cellDataList)) {
                cellWriteHandlerContext.setFirstCellData(cellDataList.get(0));
            }
            // Restyle
            if (fillConfig.getAutoStyle()) {
                Optional.ofNullable(collectionFieldStyleCache.get(currentUniqueDataFlag)).map(collectionFieldStyleMap -> collectionFieldStyleMap.get(analysisCell)).ifPresent(cell::setCellStyle);
            }
        }
        WriteHandlerUtils.afterCellDispose(cellWriteHandlerContext);
    }
    // In the case of the fill line may be called many times
    if (rowWriteHandlerContext.getRow() != null) {
        WriteHandlerUtils.afterRowDispose(rowWriteHandlerContext);
    }
}

Example 2 with AnalysisCell

use of com.alibaba.excel.write.metadata.fill.AnalysisCell in project easyexcel by alibaba.

the class ExcelWriteFillExecutor method createCell.

private void createCell(AnalysisCell analysisCell, FillConfig fillConfig, CellWriteHandlerContext cellWriteHandlerContext, RowWriteHandlerContext rowWriteHandlerContext) {
    Sheet cachedSheet = writeContext.writeSheetHolder().getCachedSheet();
    if (WriteTemplateAnalysisCellTypeEnum.COMMON.equals(analysisCell.getCellType())) {
        Row row = cachedSheet.getRow(analysisCell.getRowIndex());
        cellWriteHandlerContext.setRow(row);
        Cell cell = row.getCell(analysisCell.getColumnIndex());
        cellWriteHandlerContext.setCell(cell);
        rowWriteHandlerContext.setRow(row);
        rowWriteHandlerContext.setRowIndex(analysisCell.getRowIndex());
        return;
    }
    Sheet sheet = writeContext.writeSheetHolder().getSheet();
    Map<AnalysisCell, Integer> collectionLastIndexMap = collectionLastIndexCache.computeIfAbsent(currentUniqueDataFlag, key -> MapUtils.newHashMap());
    boolean isOriginalCell = false;
    Integer lastRowIndex;
    Integer lastColumnIndex;
    switch(fillConfig.getDirection()) {
        case VERTICAL:
            lastRowIndex = collectionLastIndexMap.get(analysisCell);
            if (lastRowIndex == null) {
                lastRowIndex = analysisCell.getRowIndex();
                collectionLastIndexMap.put(analysisCell, lastRowIndex);
                isOriginalCell = true;
            } else {
                collectionLastIndexMap.put(analysisCell, ++lastRowIndex);
            }
            lastColumnIndex = analysisCell.getColumnIndex();
            break;
        case HORIZONTAL:
            lastRowIndex = analysisCell.getRowIndex();
            lastColumnIndex = collectionLastIndexMap.get(analysisCell);
            if (lastColumnIndex == null) {
                lastColumnIndex = analysisCell.getColumnIndex();
                collectionLastIndexMap.put(analysisCell, lastColumnIndex);
                isOriginalCell = true;
            } else {
                collectionLastIndexMap.put(analysisCell, ++lastColumnIndex);
            }
            break;
        default:
            throw new ExcelGenerateException("The wrong direction.");
    }
    Row row = createRowIfNecessary(sheet, cachedSheet, lastRowIndex, fillConfig, analysisCell, isOriginalCell, rowWriteHandlerContext);
    cellWriteHandlerContext.setRow(row);
    cellWriteHandlerContext.setRowIndex(lastRowIndex);
    cellWriteHandlerContext.setColumnIndex(lastColumnIndex);
    Cell cell = createCellIfNecessary(row, lastColumnIndex, cellWriteHandlerContext);
    cellWriteHandlerContext.setCell(cell);
    if (isOriginalCell) {
        Map<AnalysisCell, CellStyle> collectionFieldStyleMap = collectionFieldStyleCache.computeIfAbsent(currentUniqueDataFlag, key -> MapUtils.newHashMap());
        collectionFieldStyleMap.put(analysisCell, cell.getCellStyle());
    }
}

Example 3 with AnalysisCell

use of com.alibaba.excel.write.metadata.fill.AnalysisCell in project easyexcel by alibaba.

the class ExcelWriteFillExecutor method prepareData.

/**
 * To prepare data
 *
 * @param cell          cell
 * @param rowIndex      row index
 * @param columnIndex   column index
 * @param firstRowCache first row cache
 * @return Returns the data that the cell needs to replace
 */
private String prepareData(Cell cell, int rowIndex, int columnIndex, Map<UniqueDataFlagKey, Set<Integer>> firstRowCache) {
    if (!CellType.STRING.equals(cell.getCellType())) {
        return null;
    }
    String value = cell.getStringCellValue();
    if (StringUtils.isEmpty(value)) {
        return null;
    }
    StringBuilder preparedData = new StringBuilder();
    AnalysisCell analysisCell = null;
    int startIndex = 0;
    int length = value.length();
    int lastPrepareDataIndex = 0;
    out: while (startIndex < length) {
        int prefixIndex = value.indexOf(FILL_PREFIX, startIndex);
        if (prefixIndex < 0) {
            break;
        }
        if (prefixIndex != 0) {
            char prefixPrefixChar = value.charAt(prefixIndex - 1);
            if (prefixPrefixChar == IGNORE_CHAR) {
                startIndex = prefixIndex + 1;
                continue;
            }
        }
        int suffixIndex = -1;
        while (suffixIndex == -1 && startIndex < length) {
            suffixIndex = value.indexOf(FILL_SUFFIX, startIndex + 1);
            if (suffixIndex < 0) {
                break out;
            }
            startIndex = suffixIndex + 1;
            char prefixSuffixChar = value.charAt(suffixIndex - 1);
            if (prefixSuffixChar == IGNORE_CHAR) {
                suffixIndex = -1;
            }
        }
        if (analysisCell == null) {
            analysisCell = initAnalysisCell(rowIndex, columnIndex);
        }
        String variable = value.substring(prefixIndex + 1, suffixIndex);
        if (StringUtils.isEmpty(variable)) {
            continue;
        }
        int collectPrefixIndex = variable.indexOf(COLLECTION_PREFIX);
        if (collectPrefixIndex > -1) {
            if (collectPrefixIndex != 0) {
                analysisCell.setPrefix(variable.substring(0, collectPrefixIndex));
            }
            variable = variable.substring(collectPrefixIndex + 1);
            if (StringUtils.isEmpty(variable)) {
                continue;
            }
            analysisCell.setCellType(WriteTemplateAnalysisCellTypeEnum.COLLECTION);
        }
        analysisCell.getVariableList().add(variable);
        if (lastPrepareDataIndex == prefixIndex) {
            analysisCell.getPrepareDataList().add(StringUtils.EMPTY);
            // fix https://github.com/alibaba/easyexcel/issues/2035
            if (lastPrepareDataIndex != 0) {
                analysisCell.setOnlyOneVariable(Boolean.FALSE);
            }
        } else {
            String data = convertPrepareData(value.substring(lastPrepareDataIndex, prefixIndex));
            preparedData.append(data);
            analysisCell.getPrepareDataList().add(data);
            analysisCell.setOnlyOneVariable(Boolean.FALSE);
        }
        lastPrepareDataIndex = suffixIndex + 1;
    }
    // up successfully, so all data format to empty first.
    if (analysisCell != null && CollectionUtils.isNotEmpty(analysisCell.getVariableList())) {
        cell.setBlank();
    }
    return dealAnalysisCell(analysisCell, value, rowIndex, lastPrepareDataIndex, length, firstRowCache, preparedData);
}

Example 4 with AnalysisCell

use of com.alibaba.excel.write.metadata.fill.AnalysisCell in project easyexcel by alibaba.

the class ExcelWriteFillExecutor method fill.

public void fill(Object data, FillConfig fillConfig) {
    if (data == null) {
        data = new HashMap<String, Object>(16);
    }
    if (fillConfig == null) {
        fillConfig = FillConfig.builder().build();
    }
    fillConfig.init();
    Object realData;
    // The data prefix that is populated this time
    String currentDataPrefix;
    if (data instanceof FillWrapper) {
        FillWrapper fillWrapper = (FillWrapper) data;
        currentDataPrefix = fillWrapper.getName();
        realData = fillWrapper.getCollectionData();
    } else {
        realData = data;
        currentDataPrefix = null;
    }
    currentUniqueDataFlag = uniqueDataFlag(writeContext.writeSheetHolder(), currentDataPrefix);
    // processing data
    if (realData instanceof Collection) {
        List<AnalysisCell> analysisCellList = readTemplateData(templateCollectionAnalysisCache);
        Collection<?> collectionData = (Collection<?>) realData;
        if (CollectionUtils.isEmpty(collectionData)) {
            return;
        }
        Iterator<?> iterator = collectionData.iterator();
        if (WriteDirectionEnum.VERTICAL.equals(fillConfig.getDirection()) && fillConfig.getForceNewRow()) {
            shiftRows(collectionData.size(), analysisCellList);
        }
        while (iterator.hasNext()) {
            doFill(analysisCellList, iterator.next(), fillConfig, getRelativeRowIndex());
        }
    } else {
        doFill(readTemplateData(templateAnalysisCache), realData, fillConfig, null);
    }
}

Example 5 with AnalysisCell

use of com.alibaba.excel.write.metadata.fill.AnalysisCell in project easyexcel by alibaba.

the class ExcelWriteFillExecutor method shiftRows.

private void shiftRows(int size, List<AnalysisCell> analysisCellList) {
    if (CollectionUtils.isEmpty(analysisCellList)) {
        return;
    }
    int maxRowIndex = 0;
    Map<AnalysisCell, Integer> collectionLastIndexMap = collectionLastIndexCache.get(currentUniqueDataFlag);
    for (AnalysisCell analysisCell : analysisCellList) {
        if (collectionLastIndexMap != null) {
            Integer lastRowIndex = collectionLastIndexMap.get(analysisCell);
            if (lastRowIndex != null) {
                if (lastRowIndex > maxRowIndex) {
                    maxRowIndex = lastRowIndex;
                }
                continue;
            }
        }
        if (analysisCell.getRowIndex() > maxRowIndex) {
            maxRowIndex = analysisCell.getRowIndex();
        }
    }
    Sheet cachedSheet = writeContext.writeSheetHolder().getCachedSheet();
    int lastRowIndex = cachedSheet.getLastRowNum();
    if (maxRowIndex >= lastRowIndex) {
        return;
    }
    Sheet sheet = writeContext.writeSheetHolder().getCachedSheet();
    int number = size;
    if (collectionLastIndexMap == null) {
        number--;
    }
    if (number <= 0) {
        return;
    }
    sheet.shiftRows(maxRowIndex + 1, lastRowIndex, number, true, false);
    // The current data is greater than unity rowindex increase
    increaseRowIndex(templateAnalysisCache, number, maxRowIndex);
    increaseRowIndex(templateCollectionAnalysisCache, number, maxRowIndex);
}