package com.vincent.rsf.server.common.service;
|
|
import com.vincent.rsf.framework.exception.CoolException;
|
import com.vincent.rsf.server.common.domain.BaseParam;
|
import com.vincent.rsf.server.common.utils.ExcelUtil;
|
import org.springframework.stereotype.Service;
|
|
import jakarta.servlet.http.HttpServletResponse;
|
import java.util.ArrayList;
|
import java.util.Collections;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Objects;
|
import java.util.Set;
|
import java.util.function.Function;
|
|
@Service
|
public class ListExportService {
|
private static final Set<String> EXPORT_ONLY_KEYS = Set.of(
|
"columns",
|
"reportTitle",
|
"reportDate",
|
"printedAt",
|
"operator",
|
"count",
|
"report_title",
|
"report_date",
|
"printed_at"
|
);
|
|
public <T, P extends BaseParam> void export(
|
Map<String, Object> map,
|
Function<Map<String, Object>, P> paramBuilder,
|
ListExportHandler<T, P> exportHandler,
|
HttpServletResponse response
|
) throws Exception {
|
Map<String, Object> sanitizedMap = sanitizeExportMap(map);
|
P baseParam = paramBuilder.apply(sanitizedMap);
|
List<ExcelUtil.ExportColumn> columns = buildExportColumns(map);
|
if (columns.isEmpty()) {
|
throw new CoolException("导出列不能为空");
|
}
|
|
List<T> records = getExportRecords(sanitizedMap, baseParam, exportHandler);
|
exportHandler.fillExportFields(records);
|
|
List<Map<String, Object>> rows = records.stream()
|
.map(record -> exportHandler.toExportRow(record, columns))
|
.toList();
|
|
ExcelUtil.ExportMeta exportMeta = buildExportMeta(map, rows.size(), exportHandler.defaultReportTitle());
|
ExcelUtil.build(ExcelUtil.create(rows, columns, exportMeta), response);
|
}
|
|
private Map<String, Object> sanitizeExportMap(Map<String, Object> map) {
|
Map<String, Object> exportMap = new HashMap<>(map);
|
EXPORT_ONLY_KEYS.forEach(exportMap::remove);
|
exportMap.remove("meta");
|
|
sanitizeNestedMap(exportMap, "filter");
|
sanitizeNestedMap(exportMap, "filterValues");
|
return exportMap;
|
}
|
|
private void sanitizeNestedMap(Map<String, Object> exportMap, String key) {
|
Object nestedObject = exportMap.get(key);
|
if (nestedObject instanceof Map<?, ?> nestedMap) {
|
Map<String, Object> sanitizedMap = new HashMap<>();
|
for (Map.Entry<?, ?> entry : nestedMap.entrySet()) {
|
String nestedKey = String.valueOf(entry.getKey());
|
if (!EXPORT_ONLY_KEYS.contains(nestedKey)) {
|
sanitizedMap.put(nestedKey, entry.getValue());
|
}
|
}
|
exportMap.put(key, sanitizedMap);
|
}
|
}
|
|
private List<ExcelUtil.ExportColumn> buildExportColumns(Map<String, Object> map) {
|
Object columnsObject = map.get("columns");
|
if (Objects.isNull(columnsObject)) {
|
Object metaObject = map.get("meta");
|
if (metaObject instanceof Map<?, ?> metaMap) {
|
columnsObject = metaMap.get("columns");
|
}
|
}
|
|
if (!(columnsObject instanceof List<?> rawColumns)) {
|
return Collections.emptyList();
|
}
|
|
List<ExcelUtil.ExportColumn> columns = new ArrayList<>();
|
for (Object rawColumn : rawColumns) {
|
if (!(rawColumn instanceof Map<?, ?> columnMap)) {
|
continue;
|
}
|
Object source = columnMap.get("source");
|
Object label = columnMap.get("label");
|
if (Objects.isNull(source) || Objects.isNull(label)) {
|
continue;
|
}
|
columns.add(new ExcelUtil.ExportColumn(String.valueOf(source), String.valueOf(label)));
|
}
|
return columns;
|
}
|
|
private <T, P extends BaseParam> List<T> getExportRecords(
|
Map<String, Object> sanitizedMap,
|
P baseParam,
|
ListExportHandler<T, P> exportHandler
|
) {
|
List<Long> ids = parseExportIds(sanitizedMap.get("ids"));
|
if (!ids.isEmpty()) {
|
return exportHandler.listByIds(ids);
|
}
|
return exportHandler.listByFilter(sanitizedMap, baseParam);
|
}
|
|
private List<Long> parseExportIds(Object idsObject) {
|
if (idsObject instanceof List<?> ids && !ids.isEmpty()) {
|
return ids.stream()
|
.map(String::valueOf)
|
.map(Long::valueOf)
|
.toList();
|
}
|
if (idsObject instanceof Object[] ids && ids.length > 0) {
|
List<Long> exportIds = new ArrayList<>();
|
for (Object id : ids) {
|
exportIds.add(Long.valueOf(String.valueOf(id)));
|
}
|
return exportIds;
|
}
|
return Collections.emptyList();
|
}
|
|
private ExcelUtil.ExportMeta buildExportMeta(Map<String, Object> map, int count, String defaultReportTitle) {
|
Object metaObject = map.get("meta");
|
if (!(metaObject instanceof Map<?, ?> metaMap)) {
|
return new ExcelUtil.ExportMeta(defaultReportTitle, "", "", "", count);
|
}
|
|
String reportTitle = getMetaValue(metaMap, "reportTitle", defaultReportTitle);
|
String reportDate = getMetaValue(metaMap, "reportDate", "");
|
String printedAt = getMetaValue(metaMap, "printedAt", "");
|
String operator = getMetaValue(metaMap, "operator", "");
|
return new ExcelUtil.ExportMeta(
|
reportTitle,
|
reportDate,
|
printedAt,
|
operator,
|
count,
|
getReportStyle(metaMap)
|
);
|
}
|
|
private String getMetaValue(Map<?, ?> metaMap, String key, String defaultValue) {
|
Object value = metaMap.get(key);
|
return Objects.isNull(value) ? defaultValue : String.valueOf(value);
|
}
|
|
private Map<String, Object> getReportStyle(Map<?, ?> metaMap) {
|
Object reportStyleObject = metaMap.get("reportStyle");
|
if (!(reportStyleObject instanceof Map<?, ?> reportStyleMap)) {
|
return Collections.emptyMap();
|
}
|
|
Map<String, Object> reportStyle = new HashMap<>();
|
for (Map.Entry<?, ?> entry : reportStyleMap.entrySet()) {
|
reportStyle.put(String.valueOf(entry.getKey()), entry.getValue());
|
}
|
return reportStyle;
|
}
|
}
|
