初始化提交

jiazx0107@163.com

2023-05-17 620eab6cca2bc9ef9ea6d3067a0a5ba1deadbd1c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
package com.bstek.bdf2.export.excel;
 
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
 
import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.xssf.streaming.SXSSFWorkbook;
import org.apache.commons.lang.StringUtils;
 
import com.bstek.bdf2.export.model.ReportGridHeader;
import com.bstek.bdf2.export.model.ReportGrid;
 
/**
 * @author matt.yao@bstek.com
 * @since 2.0
 */
public abstract class AbstractExcelReportBuilder {
    public static final String DefaultSheetName = "Sheet1";
 
    public Workbook createWorkBook2003() {
        return new HSSFWorkbook();
    }
 
    public Workbook createWorkBook2007(int rowAccessWindowSize) {
        return new SXSSFWorkbook(rowAccessWindowSize);
    }
 
    public void writeFile(Workbook workbook, String fileLocation) throws FileNotFoundException, IOException {
        FileOutputStream out = new FileOutputStream(new File(fileLocation));
        try {
            workbook.write(out);
        } finally {
            if (out != null) {
                out.close();
            }
        }
    }
 
    public void writeOutputStream(Workbook workbook, OutputStream out) throws IOException {
        workbook.write(out);
    }
 
    public Sheet createSheet(Workbook workbook, String sheetName) {
        if (StringUtils.isNotEmpty(sheetName)) {
            return workbook.createSheet(sheetName);
        } else {
            return workbook.createSheet(DefaultSheetName);
        }
    }
 
    public void fillCellValue(Cell cell, Object value, SimpleDateFormat sdf) {
        if (value != null) {
            if (value instanceof Date) {
                String result = sdf.format(value);
                if (result.endsWith("00:00:00")) {
                    result = result.substring(0, 11);
                }
                cell.setCellValue(result);
            } else if (value instanceof Double) {
                cell.setCellValue((Double) value);
            } else if (value instanceof Integer) {
                cell.setCellValue((Integer) value);
            } else if (value instanceof Byte) {
                cell.setCellValue((Byte) value);
            } else if (value instanceof Short) {
                cell.setCellValue((Short) value);
            } else if (value instanceof Boolean) {
                cell.setCellValue((Boolean) value);
            } else if (value instanceof Long) {
                cell.setCellValue((Long) value);
            } else if (value instanceof Float) {
                cell.setCellValue((Float) value);
            } else if (value instanceof BigDecimal) {
                double doubleVal = ((BigDecimal) value).doubleValue();  
                cell.setCellValue(doubleVal);
            } else {
                cell.setCellType(HSSFCell.CELL_TYPE_STRING);
                cell.setCellValue(value.toString());
            }
        } else {
            cell.setCellValue("");
        }
    }
 
    public void calculateMaxHeaderLevel(ReportGrid gridModel, List<ReportGridHeader> gridHeaders) {
        int maxLevel = gridModel.getMaxHeaderLevel();
        for (ReportGridHeader header : gridHeaders) {
            if (header.getLevel() > maxLevel) {
                maxLevel = header.getLevel();
                gridModel.setMaxHeaderLevel(maxLevel);
            }
            if (header.getHeaders().size() > 0) {
                this.calculateMaxHeaderLevel(gridModel, header.getHeaders());
            }
        }
    }
 
    public void calculateGridHeadersByLevel(List<ReportGridHeader> columnHeaderModels, int level, List<ReportGridHeader> result) {
        for (ReportGridHeader reportGridHeaderModel : columnHeaderModels) {
            if (reportGridHeaderModel.getLevel() == level) {
                result.add(reportGridHeaderModel);
            } else if (reportGridHeaderModel.getHeaders().size() > 0) {
                calculateGridHeadersByLevel(reportGridHeaderModel.getHeaders(), level, result);
            }
        }
    }
 
    public void calculateBottomColumnHeader(List<ReportGridHeader> gridHeader, List<ReportGridHeader> result) {
        for (ReportGridHeader header : gridHeader) {
            if (header.getHeaders().size() == 0) {
                result.add(header);
            } else {
                this.calculateBottomColumnHeader(header.getHeaders(), result);
            }
        }
    }
 
    public int calculateGridHeaderColspan(ReportGridHeader headerModel) {
        if (headerModel.getHeaders().size() == 0) {
            return 1;
        } else {
            List<ReportGridHeader> result = new ArrayList<ReportGridHeader>();
            calculateBottomColumnHeader(headerModel.getHeaders(), result);
            return result.size();
        }
    }
 
}