public void exportSlListForth(@RequestBody DemandExampleListVo vo, HttpServletResponse response) {
try {
String sheetName = "模块需求覆盖系统需求";
String excelName = POIExcelUtil.createExcelName("", sheetName, null);
List<DemandUpLowerVo> rows = demandExampleService.getExportPageFourth(vo);
List<String> columns = Arrays.asList(BasisFormationConstant.IMPORTEXCELDXAMPLE4);
List<String> requiredHeaders = Arrays.asList(BasisFormationConstant.IMPORTEXCEL_REQUIREDHEADER4);
Map<String, List<String>> validationDataMap = new HashMap<String, List<String>>();
ExcelVo excelVo = new ExcelVo();
excelVo.setTitle(sheetName);
excelVo.setColumns(columns);
excelVo.setAttention("");
excelVo.setRequiredHeaders(requiredHeaders);
excelVo.setValidationDataMap(validationDataMap);
excelVo.setDataList(rows);
excelVo.setErrorMsgMap(null);
HSSFWorkbook workbook = POIExcelUtil.getInstance().exportExcel(true, excelVo, "yyyy-MM-dd");;
POIExcelUtil.responseReportWithName(response, workbook, excelName);
} catch (Exception e) {
e.printStackTrace();
}
}
public class BasisFormationConstant {
public static final String[] IMPORTEXCELDXAMPLE4 = new String[] {
"num:下游(模块需求)",
"remark:说明",
"upNum:上游(系统需求)",
"bi:覆盖率"
};
public static final String[] IMPORTEXCEL_REQUIREDHEADER4 = new String[] {
"下游(模块需求)",
"说明",
"上游(系统需求)",
"覆盖率"
};
}
public class POIExcelUtil<T> {
public POIExcelUtil() {
}
public static POIExcelUtil getInstance() {
return new POIExcelUtil();
}
public static void responseReportWithName(HttpServletResponse response, HSSFWorkbook workbook, String excelName) {
try {
excelName = excelName.replace("+", " ");
response.reset();
response.setContentType("application/octet-stream;charset=UTF-8");
response.setHeader("Content-Disposition", "attachment;filename="" + new String(excelName.getBytes("gb2312"), "iso8859-1") + ".xls"");
OutputStream stream = response.getOutputStream();
workbook.write(stream);
stream.close();
} catch (Exception var4) {
}
}
public HSSFWorkbook exportExcel(boolean isExport, List<ExcelVo> excelVoList, String pattern) {
HSSFWorkbook workbook = new HSSFWorkbook();
if (CommonUtil.isEmpty(excelVoList)) {
return null;
} else {
Iterator var5 = excelVoList.iterator();
while(true) {
ExcelVo excelVo;
String title;
ArrayList rowProperties;
ArrayList rowHeaders;
ArrayList properties;
ArrayList headers;
List columns;
do {
do {
if (!var5.hasNext()) {
return workbook;
}
excelVo = (ExcelVo)var5.next();
title = excelVo.getTitle();
} while(CommonUtil.isEmpty(title));
rowProperties = new ArrayList();
rowHeaders = new ArrayList();
List<String> rows = excelVo.getRows();
if (!CommonUtil.isEmpty(rows)) {
Iterator var11 = rows.iterator();
while(var11.hasNext()) {
String row = (String)var11.next();
String[] rowArr = row.split(":");
if (rowArr.length == 2) {
rowProperties.add(rowArr[0]);
rowHeaders.add(rowArr[1]);
}
}
}
properties = new ArrayList();
headers = new ArrayList();
columns = excelVo.getColumns();
} while(CommonUtil.isEmpty(columns));
Iterator var14 = columns.iterator();
while(var14.hasNext()) {
String column = (String)var14.next();
String[] columnArr = column.split(":");
if (columnArr.length == 2) {
properties.add(columnArr[0]);
headers.add(columnArr[1]);
}
}
if (!CommonUtil.isEmpty(headers)) {
Map<String, Integer> splitPropertiesMap = excelVo.getSplitPropertiesMap();
int validHeaderSize = this.getValidHeaderSize(properties, splitPropertiesMap);
HSSFSheet sheet = this.createHSSFSheet(workbook, title, 30, validHeaderSize);
HSSFCellStyle attentionStyle = this.createAttentionStyle(workbook);
HSSFCellStyle titleStyle = this.createTitleStyle(workbook);
HSSFCellStyle headerStyle = this.createHeaderStyle(workbook);
HSSFCellStyle requiredHeaderStyle = this.createRequiredHeaderStyle(workbook);
HSSFCellStyle dataStyle = this.createDataStyle(workbook);
HSSFCellStyle doubleDataStyle = this.createDoubleDataStyle(workbook);
HSSFCellStyle longDataStyle = this.createLongDataStyle(workbook);
HSSFCellStyle errorMsgStyle = this.createErrorMsgStyle(workbook);
String attention = excelVo.getAttention();
this.createAttention(sheet, attention, attentionStyle, isExport, validHeaderSize);
this.createTitle(sheet, title, titleStyle, isExport, validHeaderSize);
List<String> requiredRowHeaders = excelVo.getRequiredRowHeaders();
this.createRowHeaders(sheet, rowHeaders, requiredRowHeaders, headerStyle, requiredHeaderStyle, isExport);
List<T> rowDataList = excelVo.getRowDataList();
if (!CommonUtil.isEmpty(rowDataList)) {
Map<String, HSSFCellStyle> dataStyleList = new HashMap();
dataStyleList.put("dataStyle", dataStyle);
dataStyleList.put("doubleDataStyle", doubleDataStyle);
dataStyleList.put("longDataStyle", longDataStyle);
this.createRowData(sheet, rowProperties, rowDataList, dataStyleList, isExport, pattern);
}
List<String> requiredHeaders = excelVo.getRequiredHeaders();
this.createHeaders(sheet, headers, properties, splitPropertiesMap, requiredHeaders, headerStyle, requiredHeaderStyle, rowHeaders.size(), isExport);
List<T> dataList = excelVo.getDataList();
if (!CommonUtil.isEmpty(dataList)) {
Map<String, HSSFCellStyle> dataStyleList = new HashMap();
dataStyleList.put("dataStyle", dataStyle);
dataStyleList.put("doubleDataStyle", doubleDataStyle);
dataStyleList.put("longDataStyle", longDataStyle);
this.createData(sheet, properties, splitPropertiesMap, dataList, dataStyleList, isExport, rowHeaders.size(), pattern);
}
Map<String, List<String>> validationDataMap = excelVo.getValidationDataMap();
if (!isExport && !CommonUtil.isEmpty(validationDataMap)) {
this.createValidationData(sheet, properties, validationDataMap, splitPropertiesMap, rowHeaders.size(), workbook);
}
Map<String, String> errorMsgMap = excelVo.getErrorMsgMap();
if (!CommonUtil.isEmpty(errorMsgMap)) {
this.createErrorMsg(sheet, errorMsgMap, errorMsgStyle, dataList, validHeaderSize);
}
}
}
}
}
public HSSFWorkbook exportExcel(boolean isExport, ExcelVo excelVo, String pattern) {
if (!CommonUtil.isEmpty(excelVo)) {
List<ExcelVo> excelVoList = new ArrayList();
excelVoList.add(excelVo);
HSSFWorkbook workbook = this.exportExcel(isExport, (List)excelVoList, pattern);
return workbook;
} else {
return null;
}
}
private HSSFSheet createHSSFSheet(HSSFWorkbook workbook, String title, int defaultColumnWidth, int headersLength) {
HSSFSheet sheet = workbook.createSheet(title);
sheet.setDefaultColumnWidth(defaultColumnWidth);
sheet.setColumnWidth(headersLength, 11000);
return sheet;
}
private HSSFCellStyle createAttentionStyle(HSSFWorkbook workbook) {
HSSFFont attentionFont = this.generateHSSFFont(workbook, "宋体", false, 11);
HSSFCellStyle attentionStyle = this.generateHSSFCellStyle(workbook, attentionFont, 1, new int[]{0, 0, 0, 0});
attentionStyle.setWrapText(true);
attentionStyle.setFillPattern(FillPatternType.SOLID_FOREGROUND);
HSSFPalette attPalette = workbook.getCustomPalette();
attPalette.setColorAtIndex((short)10, (byte)-29, (byte)79, (byte)79);
attentionStyle.setFillForegroundColor((short)10);
return attentionStyle;
}
private HSSFCellStyle createTitleStyle(HSSFWorkbook workbook) {
HSSFFont titleFont = this.generateHSSFFont(workbook, "宋体", true, 18);
HSSFCellStyle titleStyle = this.generateHSSFCellStyle(workbook, titleFont, 2, new int[]{1, 1, 1, 1});
return titleStyle;
}
private HSSFCellStyle createHeaderStyle(HSSFWorkbook workbook) {
HSSFFont headerFont = this.generateHSSFFont(workbook, "宋体", false, 12);
HSSFCellStyle headerStyle = this.generateHSSFCellStyle(workbook, headerFont, 2, new int[]{1, 1, 1, 1});
headerStyle.setFillPattern(FillPatternType.SOLID_FOREGROUND);
HSSFPalette palette = workbook.getCustomPalette();
palette.setColorAtIndex((short)9, (byte)-39, (byte)-39, (byte)-39);
headerStyle.setFillForegroundColor((short)9);
return headerStyle;
}
private HSSFCellStyle createRequiredHeaderStyle(HSSFWorkbook workbook) {
HSSFFont headerFont = this.generateHSSFFont(workbook, "宋体", false, 12);
headerFont.setColor((short)10);
HSSFCellStyle headerStyle = this.generateHSSFCellStyle(workbook, headerFont, 2, new int[]{1, 1, 1, 1});
headerStyle.setFillPattern(FillPatternType.SOLID_FOREGROUND);
HSSFPalette palette = workbook.getCustomPalette();
palette.setColorAtIndex((short)9, (byte)-39, (byte)-39, (byte)-39);
headerStyle.setFillForegroundColor((short)9);
return headerStyle;
}
private HSSFCellStyle createDataStyle(HSSFWorkbook workbook) {
HSSFFont dataFont = this.generateHSSFFont(workbook, "宋体", false, 11);
HSSFCellStyle dataStyle = this.generateHSSFCellStyle(workbook, dataFont, 2, new int[]{1, 1, 1, 1});
return dataStyle;
}
private HSSFCellStyle createErrorMsgStyle(HSSFWorkbook workbook) {
HSSFFont errorFont = this.generateHSSFFont(workbook, "宋体", false, 11);
HSSFCellStyle errorStyle = this.generateHSSFCellStyle(workbook, errorFont, 2, new int[]{0, 0, 0, 0});
errorStyle.setWrapText(true);
errorStyle.setFillPattern(FillPatternType.SOLID_FOREGROUND);
HSSFPalette errPalette = workbook.getCustomPalette();
errPalette.setColorAtIndex((short)10, (byte)-29, (byte)79, (byte)79);
errorStyle.setFillForegroundColor((short)10);
return errorStyle;
}
private HSSFCellStyle createDoubleDataStyle(HSSFWorkbook workbook) {
HSSFCellStyle dataStyle = this.createDataStyle(workbook);
dataStyle.setAlignment(HorizontalAlignment.forInt(3));
dataStyle.setDataFormat(this.createDoubleDataFormat(workbook));
return dataStyle;
}
private short createDoubleDataFormat(HSSFWorkbook workbook) {
HSSFDataFormat dataFormat = workbook.createDataFormat();
short format = dataFormat.getFormat("0.00");
return format;
}
private HSSFCellStyle createLongDataStyle(HSSFWorkbook workbook) {
HSSFCellStyle dataStyle = this.createDataStyle(workbook);
dataStyle.setAlignment(HorizontalAlignment.forInt(3));
dataStyle.setDataFormat(this.createLongDataFormat(workbook));
return dataStyle;
}
private short createLongDataFormat(HSSFWorkbook workbook) {
HSSFDataFormat dataFormat = workbook.createDataFormat();
short format = dataFormat.getFormat("0");
return format;
}
private HSSFCellStyle generateHSSFCellStyle(HSSFWorkbook workbook, HSSFFont font, int alignment, int[] border) {
HSSFCellStyle cellStyle = workbook.createCellStyle();
cellStyle.setAlignment(HorizontalAlignment.forInt(alignment));
cellStyle.setBorderTop((BorderStyle.valueOf((short)border[0])));
cellStyle.setBorderRight(BorderStyle.valueOf((short)border[1]));
cellStyle.setBorderBottom(BorderStyle.valueOf((short)border[2]));
cellStyle.setBorderLeft(BorderStyle.valueOf((short)border[3]));
cellStyle.setFont(font);
return cellStyle;
}
private HSSFFont generateHSSFFont(HSSFWorkbook workbook, String fontName, boolean isBold, int fontSize) {
HSSFFont font = workbook.createFont();
font.setFontName(fontName);
font.setBold(isBold);
font.setFontHeightInPoints((short)fontSize);
return font;
}
private void createAttention(HSSFSheet sheet, String attention, HSSFCellStyle attentionStyle, boolean isExport, int headersLength) {
if (!isExport) {
sheet.addMergedRegion(new CellRangeAddress(0, 0, 0, headersLength - 1));
HSSFRow attentionRow = sheet.createRow(0);
int height = attention.split("\r\n").length * 14;
height = height < 30 ? 30 : height;
attentionRow.setHeightInPoints((float)((short)height));
HSSFCell attentionCell = attentionRow.createCell(0);
attentionCell.setCellValue(attention);
attentionCell.setCellStyle(attentionStyle);
}
}
private void createTitle(HSSFSheet sheet, String title, HSSFCellStyle titleStyle, boolean isExport, int headersLength) {
HSSFRow titleRow;
if (!isExport) {
sheet.addMergedRegion(new CellRangeAddress(1, 1, 0, headersLength - 1));
titleRow = sheet.createRow(1);
} else {
sheet.addMergedRegion(new CellRangeAddress(0, 0, 0, headersLength - 1));
titleRow = sheet.createRow(0);
}
titleRow.setHeightInPoints(24.0F);
HSSFCell titleCell = titleRow.createCell(0);
titleCell.setCellValue(title);
titleCell.setCellStyle(titleStyle);
}
private void createRowHeaders(HSSFSheet sheet, List<String> rowHeaders, List<String> requiredRowHeaders, HSSFCellStyle headerStyle, HSSFCellStyle requiredHeaderStyle, boolean isExport) {
int rownum = 2;
if (isExport) {
rownum = 1;
}
for(int i = 0; i < rowHeaders.size(); ++i) {
String rowHeader = (String)rowHeaders.get(i);
HSSFRow headerRow = sheet.createRow(rownum + i);
headerRow.setHeightInPoints(18.0F);
HSSFCell headCell = headerRow.createCell(0);
headCell.setCellValue(rowHeader);
if (!isExport && requiredRowHeaders != null && requiredRowHeaders.contains(rowHeader)) {
headCell.setCellStyle(requiredHeaderStyle);
} else {
headCell.setCellStyle(headerStyle);
}
}
}
private void createHeaders(HSSFSheet sheet, List<String> headers, List<String> properties, Map<String, Integer> splitPropertiesMap, List<String> requiredHeaders, HSSFCellStyle headerStyle, HSSFCellStyle requiredHeaderStyle, int rowHeadersSize, boolean isExport) {
int rownum = 2 + rowHeadersSize;
if (isExport) {
rownum = 1 + rowHeadersSize;
}
HSSFRow headerRow = sheet.createRow(rownum);
headerRow.setHeightInPoints(18.0F);
int j = 0;
for(int i = 0; i < headers.size(); ++i) {
HSSFCell headCell;
if (!CommonUtil.isEmpty(splitPropertiesMap)) {
Integer splitSize = (Integer)splitPropertiesMap.get(properties.get(i));
if (splitSize != null && splitSize >= 2) {
sheet.addMergedRegion(new CellRangeAddress(rownum, rownum, j, j + splitSize - 1));
headCell = headerRow.createCell(j);
j += splitSize;
} else {
headCell = headerRow.createCell(j);
++j;
}
} else {
headCell = headerRow.createCell(j);
++j;
}
String header = (String)headers.get(i);
headCell.setCellValue(header);
if (!isExport && requiredHeaders != null && requiredHeaders.contains(header)) {
headCell.setCellStyle(requiredHeaderStyle);
} else {
headCell.setCellStyle(headerStyle);
}
}
}
private void createRowData(HSSFSheet sheet, List<String> rowProperties, List<T> rowDataList, Map<String, HSSFCellStyle> dataStyleList, boolean isExport, String pattern) {
try {
int rownum = 2;
if (isExport) {
rownum = 1;
}
T t = rowDataList.get(0);
for(int i = 0; i < rowProperties.size(); ++i) {
Object value = PropertyUtils.getProperty(t, (String)rowProperties.get(i));
HSSFRow dataRow = sheet.getRow(rownum + i);
HSSFCell dataCell = dataRow.createCell(1);
this.createData(value, dataCell, dataStyleList, pattern);
}
} catch (Exception var13) {
var13.printStackTrace();
}
}
private void createData(HSSFSheet sheet, List<String> properties, Map<String, Integer> splitPropertiesMap, List<T> dataList, Map<String, HSSFCellStyle> dataStyleList, boolean isExport, int rowHeadersSize, String pattern) {
try {
for(int i = 0; i < dataList.size(); ++i) {
HSSFRow dataRow;
if (!isExport) {
dataRow = sheet.createRow(3 + i + rowHeadersSize);
} else {
dataRow = sheet.createRow(2 + i + rowHeadersSize);
}
T t = dataList.get(i);
int j = 0;
Iterator var13 = properties.iterator();
while(var13.hasNext()) {
String property = (String)var13.next();
Object value = null;
if (t instanceof Map) {
value = ((Map)t).get(property);
} else {
value = PropertyUtils.getProperty(t, property);
}
if (!CommonUtil.isEmpty(splitPropertiesMap)) {
Integer splitSize = (Integer)splitPropertiesMap.get(property);
if (splitSize != null && splitSize >= 2) {
String[] values = value.toString().split("/");
for(int k = 0; k < splitSize; ++k) {
HSSFCell dataCell = dataRow.createCell(j);
if (k < values.length) {
this.createData(values[k], dataCell, dataStyleList, pattern);
} else {
this.createData("", dataCell, dataStyleList, pattern);
}
++j;
}
} else {
HSSFCell dataCell = dataRow.createCell(j);
this.createData(value, dataCell, dataStyleList, pattern);
++j;
}
} else {
HSSFCell dataCell = dataRow.createCell(j);
this.createData(value, dataCell, dataStyleList, pattern);
++j;
}
}
}
} catch (Exception var20) {
var20.printStackTrace();
}
private void createData(Object value, HSSFCell dataCell, Map<String, HSSFCellStyle> dataStyleList, String pattern) throws Exception {
if (value instanceof Double) {
dataCell.setCellValue((Double)value);
dataCell.setCellStyle((HSSFCellStyle)dataStyleList.get("doubleDataStyle"));
} else if (value instanceof Integer) {
dataCell.setCellValue((double)(Integer)value);
dataCell.setCellStyle((HSSFCellStyle)dataStyleList.get("longDataStyle"));
} else if (value instanceof Long) {
dataCell.setCellValue((double)(Long)value);
dataCell.setCellStyle((HSSFCellStyle)dataStyleList.get("longDataStyle"));
} else if (value instanceof BigDecimal) {
BigDecimal val = (BigDecimal)value;
dataCell.setCellValue(val.doubleValue());
dataCell.setCellStyle((HSSFCellStyle)dataStyleList.get("dataStyle"));
dataCell.setCellType(CellType.NUMERIC);
} else {
dataCell.setCellValue(this.getTextValue(value, pattern));
dataCell.setCellStyle((HSSFCellStyle)dataStyleList.get("dataStyle"));
}
}
private String getTextValue(Object value, String pattern) {
String textValue = "";
if (value == null) {
textValue = "";
} else if (value instanceof Boolean) {
boolean bValue = (Boolean)value;
textValue = "是";
if (!bValue) {
textValue = "否";
}
} else if (value instanceof Date) {
Date date = (Date)value;
SimpleDateFormat sdf;
if (CommonUtil.isEmpty(pattern)) {
sdf = new SimpleDateFormat("yyyy-MM-dd");
} else {
sdf = new SimpleDateFormat(pattern);
}
textValue = sdf.format(date);
} else {
textValue = (String)value;
}
return textValue;
}
private void createValidationData(HSSFSheet sheet, List<String> properties, Map<String, List<String>> validationDataMap, Map<String, Integer> splitPropertiesMap, int rowHeadersSize, HSSFWorkbook workbook) {
int j = 0;
Iterator var8 = properties.iterator();
while(true) {
while(true) {
while(true) {
while(var8.hasNext()) {
String property = (String)var8.next();
List<String> validatonDataList = (List)validationDataMap.get(property);
if (CollectionUtils.isNotEmpty(validatonDataList) && validatonDataList.size() > 0) {
HSSFSheet sheetDepart = workbook.createSheet(property);
for(int i = 0; i < validatonDataList.size(); ++i) {
HSSFCell validatonCell = sheetDepart.createRow(i).createCell(0);
validatonCell.setCellValue((String)validatonDataList.get(i));
}
HSSFName nameRange = workbook.createName();
nameRange.setNameName(property);
nameRange.setRefersToFormula(property + "!$A$1:$A$" + validatonDataList.size());
DVConstraint constraint = DVConstraint.createFormulaListConstraint(property);
if (!CommonUtil.isEmpty(splitPropertiesMap)) {
Integer splitSize = (Integer)splitPropertiesMap.get(property);
if (splitSize != null && splitSize >= 2) {
for(int k = 0; k < splitSize; ++k) {
CellRangeAddressList regions = new CellRangeAddressList(3 + rowHeadersSize, 1002 + rowHeadersSize, j, j);
HSSFDataValidation data = new HSSFDataValidation(regions, constraint);
sheet.addValidationData(data);
workbook.setSheetHidden(workbook.getSheetIndex(property), true);
++j;
}
} else {
CellRangeAddressList regions = new CellRangeAddressList(3 + rowHeadersSize, 1002 + rowHeadersSize, j, j);
HSSFDataValidation data = new HSSFDataValidation(regions, constraint);
sheet.addValidationData(data);
workbook.setSheetHidden(workbook.getSheetIndex(property), true);
++j;
}
} else {
CellRangeAddressList regions = new CellRangeAddressList(3 + rowHeadersSize, 1002 + rowHeadersSize, j, j);
HSSFDataValidation data = new HSSFDataValidation(regions, constraint);
sheet.addValidationData(data);
workbook.setSheetHidden(workbook.getSheetIndex(property), true);
++j;
}
} else {
++j;
}
}
return;
}
}
}
}
private void createErrorMsg(HSSFSheet sheet, Map<String, String> errorMsgMap, HSSFCellStyle errorMsgStyle, List<T> dataList, int headersLength) {
try {
Iterator var6 = errorMsgMap.keySet().iterator();
while(var6.hasNext()) {
String key = (String)var6.next();
String errorMsg = (String)errorMsgMap.get(key);
if (!CommonUtil.isEmpty(errorMsg)) {
HSSFRow dataRow = sheet.getRow(Integer.parseInt(key));
if (null == dataRow) {
dataRow = sheet.createRow(Integer.parseInt(key));
}
HSSFCell errorCell = dataRow.createCell(headersLength);
errorCell.setCellValue(errorMsg);
errorCell.setCellStyle(errorMsgStyle);
}
}
} catch (Exception var11) {
var11.printStackTrace();
}
}
private int getValidHeaderSize(List<String> properties, Map<String, Integer> splitPropertiesMap) {
int validHeaderSize = properties.size();
if (CommonUtil.isEmpty(splitPropertiesMap)) {
return validHeaderSize;
} else {
Iterator var4 = properties.iterator();
while(var4.hasNext()) {
String property = (String)var4.next();
Integer splitSize = (Integer)splitPropertiesMap.get(property);
if (splitSize != null && splitSize >= 2) {
validHeaderSize = validHeaderSize + splitSize - 1;
}
}
return validHeaderSize;
}
}
public static String createExcelName(String isExport, String title, Map<String, String> errorMsgMap) {
String excelName = "";
DateFormat df = new SimpleDateFormat("YYYYMMdd");
String formatDate = df.format(new Date());
if ("true".equals(isExport)) {
if (null == errorMsgMap) {
excelName = title + formatDate;
} else {
excelName = title + "_" + I18nUtil.getValue("com.glaway.foundation.container.importErrorReport");
}
} else if ("error".equals(isExport)) {
excelName = title + "_" + I18nUtil.getValue("com.glaway.foundation.container.importErrorReport");
} else {
excelName = title + "_" + I18nUtil.getValue("com.glaway.foundation.container.importTemplate");
}
return excelName;
}
public static String getCellValue(Cell cell) {
String value = "";
if (cell != null) {CellType cellType = cell.getCellType();
switch( cellType.getCode()) {
case 0:
if (HSSFDateUtil.isCellDateFormatted(cell)) {
Date date = cell.getDateCellValue();
if (date != null) {
value = (new SimpleDateFormat("yyyyMMdd")).format(date);
} else {
value = "";
}
} else {
value = (new DecimalFormat("0")).format(cell.getNumericCellValue());
}
break;
case 1:
value = cell.getStringCellValue().trim();
break;
case 2:
value = cell.getStringCellValue().trim();
case 3:
break;
case 4:
value = cell.getBooleanCellValue() ? "Y" : "N";
break;
case 5:
value = "";
break;
default:
value = "";
}
}
return value;
}
public static boolean doJudgeImport(Sheet sheet, List<String> headers) {
return doJudgeImport(sheet, new ArrayList(), headers);
}
public static boolean doJudgeImport(Sheet sheet, List<String> rowHeaders, List<String> headers) {
if (null == sheet) {
return false;
} else {
int i = 0;
while(true) {
Cell cell;
String cellValue;
if (i < rowHeaders.size()) {
Row rowHeader = sheet.getRow(2 + i);
cell = rowHeader.getCell(0);
if (null == cell) {
return false;
}
cellValue = getCellValue(cell);
if (!CommonUtil.isEmpty(cellValue) && ((String)rowHeaders.get(i)).equals(cellValue)) {
++i;
continue;
}
return false;
}
Row titleRow = sheet.getRow(2 + rowHeaders.size());
if (null == titleRow) {
return false;
}
for(int j = 0; j < headers.size(); ++j) {
cell = titleRow.getCell(j);
if (null == cell) {
return false;
}
cellValue = getCellValue(cell);
if (CommonUtil.isEmpty(cellValue) || !((String)headers.get(j)).equals(cellValue)) {
return false;
}
}
return true;
}
}
}
public static void addErrorMsg(int row, String errorInfo, Map<String, String> errorMsgMap) {
String rowStr = String.valueOf(row);
String errorMsg = (String)errorMsgMap.get(rowStr);
if (CommonUtil.isEmpty(errorMsg)) {
errorMsg = errorInfo;
} else {
errorMsg = errorMsg + errorInfo;
}
errorMsgMap.put(rowStr, errorMsg);
}
public static void doJudgeNull(Map<String, String> errorMsgMap, String key, int row, String value) {
if (StringUtils.isEmpty(key) || StringUtils.isBlank(key)) {
String rowStr = String.valueOf(row);
String errorMsg = (String)errorMsgMap.get(rowStr);
if (CommonUtil.isEmpty(errorMsg)) {
errorMsg = value + " " + I18nUtil.getValue("com.glaway.foundation.common.notNull") + "; ";
} else {
errorMsg = errorMsg + value + " " + I18nUtil.getValue("com.glaway.foundation.common.notNull") + "; ";
}
errorMsgMap.put(rowStr, errorMsg);
}
}
public static void doJudgeRepeat(Map<String, String> errorMsgMap, String key, int row, String value) {
String rowStr = String.valueOf(row);
String errorMsg = (String)errorMsgMap.get(rowStr);
if (CommonUtil.isEmpty(errorMsg)) {
errorMsg = value + "重复;";
} else {
errorMsg = errorMsg + value + "重复;";
}
errorMsgMap.put(rowStr, errorMsg);
}
public static void doJudgeRange(JudgeRangeParam judgeRangeParam, Map<String, String> errorMsgMap) {
String key = judgeRangeParam.getKey();
int minLength = judgeRangeParam.getMinLength();
int maxLength = judgeRangeParam.getMaxLength();
int row = judgeRangeParam.getRow();
String value = judgeRangeParam.getValue();
if (StringUtils.isNotEmpty(key) && StringUtils.isNotBlank(key) && StringUtils.isNotEmpty(value) && StringUtils.isNotEmpty(value) && (minLength > key.length() || maxLength < key.length())) {
String errorMsg = (String)errorMsgMap.get(String.valueOf(row));
if (CommonUtil.isEmpty(errorMsg)) {
if (minLength == 0) {
errorMsg = value + MessageFormat.format(I18nUtil.getValue("com.glaway.foundation.common.limitCharacter"), maxLength) + "; ";
} else {
errorMsg = value + MessageFormat.format(I18nUtil.getValue("com.glaway.foundation.common.limitFormat"), minLength, maxLength) + "; ";
}
} else if (minLength == 0) {
errorMsg = errorMsg + value + MessageFormat.format(I18nUtil.getValue("com.glaway.foundation.common.limitCharacter"), maxLength) + "; ";
} else {
errorMsg = errorMsg + value + MessageFormat.format(I18nUtil.getValue("com.glaway.foundation.common.limitFormat"), minLength, maxLength) + "; ";
}
errorMsgMap.put(String.valueOf(row), errorMsg);
}
}
public static void doJudgeReg(Map<String, String> errorMsgMap, String key, String reg, int row, String value) {
if (StringUtils.isNotEmpty(key) && StringUtils.isNotBlank(key) && StringUtils.isNotEmpty(reg) && StringUtils.isNotEmpty(reg) && StringUtils.isNotEmpty(value) && StringUtils.isNotEmpty(value) && !key.matches(reg)) {
String errorMsg = (String)errorMsgMap.get(String.valueOf(row));
if (CommonUtil.isEmpty(errorMsg)) {
errorMsg = value + " " + I18nUtil.getValue("com.glaway.foundation.common.unlegal") + "; ";
} else {
errorMsg = errorMsg + value + " " + I18nUtil.getValue("com.glaway.foundation.common.unlegal") + "; ";
}
errorMsgMap.put(String.valueOf(row), errorMsg);
}
}
public static void doJudgeDate(Map<String, String> errorMsgMap, String key, int row, String columnType, String columnValue) {
if (StringUtils.isNotEmpty(key) && StringUtils.isNotBlank(key) && StringUtils.isNotEmpty(columnValue) && StringUtils.isNotEmpty(columnValue)) {
boolean isMatch = true;
String errorMsg;
try {
errorMsg = "Date".equals(columnType) ? "yyyy-MM-dd" : "yyyy-MM-dd HH:mm:ss";
DateUtil.parseDate(key, errorMsg);
} catch (ParseException var8) {
isMatch = false;
}
if (!isMatch) {
errorMsg = (String)errorMsgMap.get(String.valueOf(row));
if (CommonUtil.isEmpty(errorMsg)) {
errorMsg = columnValue + " " + I18nUtil.getValue("com.glaway.foundation.common.unlegal") + "; ";
} else {
errorMsg = errorMsg + columnValue + " " + I18nUtil.getValue("com.glaway.foundation.common.unlegal") + "; ";
}
errorMsgMap.put(String.valueOf(row), errorMsg);
}
}
}
