官网:http://deepoove.com/poi-tl
package com.guodi.bpm.form.service.impl;
import cn.hutool.core.map.CaseInsensitiveMap;
import cn.hutool.core.map.MapUtil;
import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.converters.date.DateNumberConverter;
import com.alibaba.excel.util.StringUtils;
import com.alibaba.excel.write.style.column.SimpleColumnWidthStyleStrategy;
import com.deepoove.poi.XWPFTemplate;
import com.deepoove.poi.config.Configure;
import com.deepoove.poi.config.ConfigureBuilder;
import com.deepoove.poi.plugin.table.LoopRowTableRenderPolicy;
import com.deepoove.poi.util.RegexUtils;
import com.guodi.bpm.form.service.IPrintService;
import com.guodi.bpm.form.service.factory.PrintFormatFactory;
import com.guodi.bpm.form.util.minio.MinioTemplates;
import com.guodi.bpm.model.constant.BpmConstant;
import com.guodi.bpm.model.enums.BoxFormatEnum;
import com.guodi.bpm.model.enums.FormatEnum;
import com.guodi.bpm.model.enums.PhotoFormatEnum;
import com.guodi.bpm.model.vo.request.*;
import com.guodi.bpm.model.vo.response.CustDelegateInfoResponse;
import com.guodi.bpm.form.model.vo.response.DelegateMyExcelResponse;
import com.guodi.bpm.form.model.vo.response.DelegateToMeExcelResponse;
import com.guodi.bpm.form.util.excel.ExcelUtil;
import com.guodi.bpm.form.util.excel.TimestampNumberConverter;
import com.guodi.bpm.tool.util.formatUtil.FormatUtil;
import org.apache.commons.codec.Charsets;
import org.apache.commons.math3.exception.NullArgumentException;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.apache.poi.xwpf.extractor.XWPFWordExtractor;
import org.apache.poi.xwpf.usermodel.XWPFDocument;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.net.URLEncoder;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;
/**
* @author lwh
* @description: 打印/导出
* @date: 2023/6/28 19:05
*/
@Service
public class PrintServiceImpl implements IPrintService {
@Resource
private MinioTemplates minioTemplates;
@Override
public String formPrint(FormPrintRequest request, Map<String, Object> paramMap, String templatePath) {
try {
Map<String, Object> datasMap = new CaseInsensitiveMap(paramMap);
//由于路径带了存储桶名称,因为需要去除存储桶
String bucketName = minioTemplates.getBucketName();
String objectName = templatePath;
if (objectName.indexOf(bucketName) != -1) {
objectName = objectName.substring(objectName.indexOf(bucketName) + bucketName.length());
}
InputStream inputStream = minioTemplates.getObject(objectName);
XWPFDocument document = new XWPFDocument(inputStream);
//获取表格内容
XWPFWordExtractor xwpfWordExtractor = new XWPFWordExtractor(document);
String text = xwpfWordExtractor.getText();
//格式化处理特殊格式(时间、二维码、图片)
this.customFormat(datasMap, text);
//动态行表格渲染
LoopRowTableRenderPolicy policy = new LoopRowTableRenderPolicy();
ConfigureBuilder builder = Configure.builder();
//修改默认标签
builder.buildGramer("${", "}");
//标签正则,去除除了标签前后缀外的任意字符
builder.buildGrammerRegex(RegexUtils.createGeneral("${", "}"));
Configure config = builder.build();
//动态表格日期格式化
String[] split = text.split("\\$\\{|\\}|\\[|\\]");
for (String s : split) {
Object tbDate = datasMap.get(s);
//获取子表的数据,格式化数据
if (tbDate instanceof List) {
config = builder.bind(s, policy).build();
List<Map<String, Object>> tbData = (List<Map<String, Object>>) datasMap.get(s);
for (Map<String, Object> tableDatum : tbData) {
this.subTableFormat(tableDatum, text);
}
}
}
XWPFTemplate template = XWPFTemplate.compile(document, config);
template.render(datasMap);
//把XWPFTemplate对象转为输入流
InputStream toInputStream = this.convertToInputStream(template);
//获取instId、当前时间作为minio上传的路径
String instId = request.getInstId();
Calendar calendar = Calendar.getInstance();
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMddhhmmss");
String nowTime = dateFormat.format(calendar.getTime());
//关闭资源
document.close();
//存储对象文件到minio服务器
String docxUrl = minioTemplates.putObject(BpmConstant.FORM_PRINT_URL + instId + "/" + request.getFileName() + nowTime + ".docx", toInputStream);
System.out.println("文件地址================== " + docxUrl);
return docxUrl;
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException("打印错误"+e.getMessage());
}
}
public InputStream convertToInputStream(XWPFTemplate template) throws Exception {
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
template.write(outputStream);
return new ByteArrayInputStream(outputStream.toByteArray());
}
public void customFormat(Map<String, Object> entry, String text) {
//截取每个值,正则表达式分割${}
String[] split = text.split("\\$\\{|\\}");
getSplitValue(entry, split);
}
public void subTableFormat(Map<String, Object> entry, String text) {
//截取每个值,正则表达式分割[]的值
String[] split = text.split("\\[|\\]");
getSplitValue(entry, split);
}
private void getSplitValue(Map<String, Object> entry, String[] split) {
for (String s : split) {
String[] strings = s.split("\\|");
//处理特殊类型打印
for (String string : strings) {
//获取字段
String oneValue = strings[0];
//获取字段对应的值
Object value = entry.get(oneValue);
if (BoxFormatEnum.CHK.name().equals(string)) {
//处理复选框CHK
String format = strings[1];
//调用打印数据格式化工厂
handleBoxValue(entry, s, strings, format, value);
} else if (BoxFormatEnum.CHKG.name().equals(string)) {
//处理复选框CHK json
String format = strings[1];
if (BoxFormatEnum.CHKG.name().equals(format)) {
Object formatValue = PrintFormatFactory.formatValue(value, format, null);
entry.put(s, formatValue == null ? "" : formatValue);
}
} else if (BoxFormatEnum.RDO.name().equals(string)) {
//处理单选框RDO
String format = strings[1];
if (BoxFormatEnum.RDO.name().equals(format)) {
handleBoxValue(entry, s, strings, format, value);
}
} else if (BoxFormatEnum.RDOG.name().equals(string)) {
//处理单选框RDO json
String format = strings[1];
if (BoxFormatEnum.RDOG.name().equals(format)) {
//调用打印数据格式化工厂
Object formatValue = PrintFormatFactory.formatValue(value, format, null);
entry.put(s, formatValue == null ? "" : formatValue);
}
} else if (PhotoFormatEnum.IMG.name().equals(string)) {
//处理单张图片IMG
//调用打印数据格式化工厂
imageFormat(entry, s);
} else if (PhotoFormatEnum.IMGLIST.name().equals(string)) {
//处理多张图片IMGLIST
imageFormat(entry, s);
} else if (PhotoFormatEnum.IMG_STR.name().equals(string)) {
//处理二维码、条形码IMG_STR
String imageSubstring = s.substring(1);
String[] splits = imageSubstring.split("\\|");
String vKey = splits[0];
String values = (String) entry.get(vKey);
//打印数据格式化工厂
Object formatValue = PrintFormatFactory.formatValue(values, string, null);
entry.put(imageSubstring, formatValue == null ? "" : formatValue);
}
}
//判断是否有这个格式转换类型
FormatUtil timeFormat = this.getTimeFormat(s);
if (timeFormat != null) {
//时间打印格式化数据
String oneValue = strings[0];
String format = strings[1];
Object value = entry.get(oneValue);
if (value != null) {
//打印数据格式化工厂
Object formatValue = PrintFormatFactory.formatValue(value, format, null);
entry.put(s, StringUtils.isEmpty(formatValue.toString()) ? "" : formatValue);
}
}
}
}
//处理单选框,复选框,value值(默认值)
private void handleBoxValue(Map<String, Object> entry, String s, String[] strings, String format, Object value) {
if (BoxFormatEnum.CHK.name().equals(format) || BoxFormatEnum.RDO.name().equals(format)) {
if (strings.length > 2) {
Object formatValue = PrintFormatFactory.formatValue(value, format, strings[2]);
entry.put(s, formatValue == null ? "" : formatValue);
} else {
Object formatValue = PrintFormatFactory.formatValue(value, format, null);
entry.put(s, formatValue == null ? "" : formatValue);
}
}
}
//处理单张图片,多张图片,value值(size)
private void imageFormat(Map<String, Object> entry, String s) {
String imageSubstring = s.substring(1);
String[] splits = imageSubstring.split("\\|");
String vKey = splits[0];
String format = splits[1];
if (format.equals(PhotoFormatEnum.IMG.name()) || format.equals(PhotoFormatEnum.IMGLIST.name())) {
String value = (String) entry.get(vKey);
if (splits.length > 2 ) {
Object formatValue = PrintFormatFactory.formatValue(value, format, splits[2]);
entry.put(imageSubstring, formatValue == null ? "" : formatValue);
} else {
//打印数据格式化工厂
Object formatValue = PrintFormatFactory.formatValue(value, format, null);
entry.put(imageSubstring,formatValue == null? "": formatValue);
}
}
}
/**
* 判断是否存在对应时间数字类型枚举
*
* @param stringTime 字符串
* @return
*/
public FormatUtil getTimeFormat(String stringTime) {
FormatEnum[] cnEnums = FormatEnum.values();
for (FormatEnum value : cnEnums) {
if (stringTime.indexOf(String.valueOf(value)) != -1) {
return new FormatUtil();
}
}
return null;
}
/**
* @param customField 表头数据
* @param outputStream 输出流
* @param templatePath 模板路径
* @param extension 模板类型
* @param dataList 数据
* @description: 箱列表导出
* @author lwh
* @date: 2023/8/7 9:36
*/
@Override
public void export(LinkedHashMap<String, String> customField, OutputStream outputStream, List<Map<String, Object>> dataList, String templatePath, String extension,Map<String,String> vars) {
try {
//无模板
if (Objects.isNull(templatePath)) {
if (MapUtil.isEmpty(customField)) {
throw new RuntimeException("无模板打印情況下,自定义字段[customField]不能为空");
}
Set<String> fieldKeys = customField.keySet();
//构建表头
List<List<String>> heads = new ArrayList<>();
for (String fieldKey : fieldKeys) {
String fieldName = customField.get(fieldKey);
//是否为子表导出,格式(姓名|xm)
if (vars.containsValue("subtleExport") && dataList.size() == 0){
StringBuffer sb = new StringBuffer();
sb.append(fieldName + ("|")+fieldKey );
heads.add(Collections.singletonList(sb.toString()));
}else {
heads.add(Collections.singletonList(fieldName));
}
if (Objects.isNull(fieldKey) || Objects.isNull(fieldName)) {
throw new RuntimeException("自定义字段信息不能为空");
}
}
List<List<Object>> datas = null;
//时间转类型
if (Objects.nonNull(dataList)) {
dataList.forEach(d -> {
d.forEach((key, value) -> {
if (d.get(key) instanceof Date) {
String time = FormatUtil.toUpper(d.get(key).toString(), null);
d.put(key, time);
}
});
});
//构建表数据
datas = dataList
.stream()
.map(dataMap -> fieldKeys.stream().map(k -> dataMap.get(k)).collect(Collectors.toList()))
.collect(Collectors.toList());
}
EasyExcel.write(outputStream)
.head(heads)
.registerWriteHandler(new SimpleColumnWidthStyleStrategy(25))
.registerConverter(new TimestampNumberConverter())
.registerConverter(new DateNumberConverter())
.autoCloseStream(false)
.sheet("数据")
.doWrite(datas);
} else {
//有模板
if (templatePath == null) {
throw new RuntimeException("打印模板不存在");
}
if (!"xlsx".equals(extension)) {
throw new RuntimeException("只支持xlsx模板导出");
}
String bucketName = minioTemplates.getBucketName();
String objectName = templatePath.substring(bucketName.length() + 2);
InputStream inputStream = minioTemplates.getObject(objectName);
EasyExcel.write(outputStream)
.withTemplate(inputStream)
.registerConverter(new TimestampNumberConverter())
.registerConverter(new DateNumberConverter())
.autoCloseStream(false)
.sheet()
.doFill(dataList);
}
} catch (RuntimeException e) {
e.printStackTrace();
throw new RuntimeException("箱列表导出失败!" + e.getMessage());
}
}
/**
* @description: 委托列表导出
* @author lwh
* @date: 2023/8/7 14:27
*/
@Override
public void delegateExport(DelegatetExportRequest request, HttpServletResponse response, List<CustDelegateInfoResponse> datas) {
try {
response.setContentType("application/vnd.ms-excel");
response.setCharacterEncoding(Charsets.UTF_8.name());
String fileName = URLEncoder.encode("导出数据", Charsets.UTF_8.name());
response.setHeader("Content-disposition", "attachment;filename=" + fileName + ".xlsx");
if ("my".equals(request.getCategory())) {
ExcelUtil.export(response.getOutputStream(), "我的委托列表", "数据表",
datas.stream().map(info -> {
DelegateMyExcelResponse excelResponse = new DelegateMyExcelResponse();
BeanUtils.copyProperties(info, excelResponse);
//状态(0-未生效,1-已生效,2-已失效)
if ("0".equals(info.getStatus())) {
excelResponse.setStatusName("未生效");
} else if ("1".equals(info.getStatus())) {
excelResponse.setStatusName("已生效");
} else {
excelResponse.setStatusName("已失效");
}
return excelResponse;
})
.collect(Collectors.toList()),
DelegateMyExcelResponse.class);
} else {
ExcelUtil.export(response.getOutputStream(), "委托给我列表", "数据表",
datas.stream().map(info -> {
DelegateToMeExcelResponse excelToMeResponse = new DelegateToMeExcelResponse();
BeanUtils.copyProperties(info, excelToMeResponse);
//状态(0-未生效,1-已生效,2-已失效)
if ("0".equals(info.getStatus())) {
excelToMeResponse.setStatusName("未生效");
} else if ("1".equals(info.getStatus())) {
excelToMeResponse.setStatusName("已生效");
} else {
excelToMeResponse.setStatusName("已失效");
}
return excelToMeResponse;
})
.collect(Collectors.toList()),
DelegateToMeExcelResponse.class);
}
} catch (IOException e) {
e.printStackTrace();
throw new RuntimeException("委托导出失败!" + e.getMessage());
}
}
@Override
public List<Map<String, String>> subtleImport(MultipartFile file) {
InputStream inputStream = null;
try {
String filename = file.getOriginalFilename();
if (filename == null) {
throw new NullArgumentException();
}
inputStream = file.getInputStream();
XSSFWorkbook xssfWorkbook = new XSSFWorkbook(inputStream);
List<Map<String, String>> maps = new ArrayList<>();
Map<String, String> headMap = new HashMap<>();
int i = 0;
for (Sheet xssfSheet : xssfWorkbook) {
if (xssfSheet == null) {
continue;
}
//处理当前页,循环读取每一行
for (int rowNum = 0; rowNum <= xssfSheet.getLastRowNum(); rowNum++) {
Map<String, String> dataMap = new HashMap<>();
Row xssfRow = xssfSheet.getRow(rowNum);
int minColIx = xssfRow.getFirstCellNum();
int maxColIx = xssfRow.getLastCellNum();
List<String> rowList = new ArrayList<>();
//遍历行,获取cell元素
for (int colIx = minColIx; colIx < maxColIx; colIx++) {
XSSFCell cell = (XSSFCell) xssfRow.getCell(colIx);
if (cell == null) {
continue;
}
if (rowNum == 0) {
headMap.put(String.valueOf(i), cell.toString());
i++;
}
rowList.add(cell.toString());
if (rowNum > 0) {
String key = headMap.get(String.valueOf(colIx));
String[] split = key.split("\\|");
dataMap.put(split[1], cell.toString());
}
}
if (rowNum > 0) {
maps.add(dataMap);
}
}
}
return maps;
} catch (IOException e) {
throw new RuntimeException("导入数据失败");
}finally {
if (inputStream != null) {
try {
inputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
package com.guodi.bpm.form.service.impl;
import cn.hutool.json.JSONArray;
import cn.hutool.json.JSONObject;
import com.deepoove.poi.data.PictureRenderData;
import com.deepoove.poi.data.PictureType;
import com.deepoove.poi.data.Pictures;
import com.guodi.bpm.form.model.dto.PrintPhotoFormatDTO;
import com.guodi.bpm.form.service.IPrintFormatValue;
import com.guodi.bpm.form.util.minio.MinioTemplates;
import com.guodi.bpm.model.enums.PhotoFormatEnum;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
/**
* Description: 打印图片格式转换
*
* @Author: 洪家洪
* @Date: 2023/8/9 11:19
**/
@Service("ImageFormatImpl")
public class ImageFormatImpl implements IPrintFormatValue {
@Resource
private MinioTemplates minioTemplates;
@Override
public boolean containsFormat(String format) {
try {
return PhotoFormatEnum.valueOf(format) != null;
} catch (Exception e) {
return false;
}
}
@Override
public Object formatValue(Object value, String format, String setting) {
String valueString = value != null ? value.toString() : null;
if (format.equals(PhotoFormatEnum.IMG.name())) {
return this.photoFormat(valueString, setting);
} else if (format.equals(PhotoFormatEnum.IMG_STR.name())) {
return this.qrCodeFormat(valueString);
} else if (format.equals(PhotoFormatEnum.IMGLIST.name())) {
return this.photoFormatList(valueString, setting);
}
return null;
}
//打印处理多张图片
public List<PrintPhotoFormatDTO> photoFormatList(String value, String setting) {
//截取模版图片宽高
int width = 0;
int height = 0;
if (Objects.nonNull(setting)) {
//获取宽高
String[] size = setting.split("x");
//宽
width = Integer.parseInt(size[0]);
//高
height = Integer.parseInt(size[1]);
}
//获取minio图片地址
List<String> objectUrls = getPhotoUrls(value);
List<PrintPhotoFormatDTO> nameList = new ArrayList<>();
if (objectUrls.size() > 0) {
for (String objectUrl : objectUrls) {
PrintPhotoFormatDTO photoFormatDTO = new PrintPhotoFormatDTO();
if (width == 0) {
photoFormatDTO.setNAME(Pictures.of(objectUrl).create());
} else {
photoFormatDTO.setNAME(Pictures.of(objectUrl).size(width, height).create());
}
nameList.add(photoFormatDTO);
}
return nameList;
}
return null;
}
//打印处理单张图片
public PictureRenderData photoFormat(String value, String setting) {
//截取模版图片宽高
int width = 0;
int height = 0;
if (Objects.nonNull(setting)) {
//获取宽高
String[] size = setting.split("x");
//宽
width = Integer.parseInt(size[0]);
//高
height = Integer.parseInt(size[1]);
}
//获取minio图片地址
List<String> objectUrls = getPhotoUrls(value);
if (objectUrls.size() > 0) {
//判断是否有设置图片大小,没设置默认图片大小
if (width == 0) {
return Pictures.of(objectUrls.get(0)).create();
} else {
return Pictures.of(objectUrls.get(0)).size(width, height).create();
}
}
return null;
}
//打印处理二维码
public PictureRenderData qrCodeFormat(String value) {
if (Objects.nonNull(value)) {
return Pictures.ofBase64(value, PictureType.PNG).create();
}
return null;
}
//获取minio图片地址
private List<String> getPhotoUrls(String value) {
//获取到图片路径存到list
List<String> photoUrls = new ArrayList<>();
if (Objects.nonNull(value)) {
JSONArray jsonArray = new JSONArray(value);
for (int i = 0; i < jsonArray.size(); i++) {
JSONObject jsonObject = jsonArray.getJSONObject(i);
//获取图片路径
String filePath = jsonObject.getStr("filePath");
photoUrls.add(filePath);
}
}
//由于路径带了存储桶名称,因为需要去除存储桶
List<String> photoUrlList = new ArrayList<>();
for (String photoUrl : photoUrls) {
String url = photoUrl.substring(photoUrl.indexOf("from-file"));
photoUrlList.add(url);
}
//获取minio图片文件绝对路径
List<String> objectUrls = new ArrayList<>();
for (String objectName : photoUrlList) {
String objectUrl = minioTemplates.getObjectUrl(objectName);
objectUrls.add(objectUrl);
}
return objectUrls;
}
}
package com.guodi.bpm.form.service.impl;
import cn.hutool.core.util.EnumUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONArray;
import cn.hutool.json.JSONObject;
import com.deepoove.poi.data.TextRenderData;
import com.deepoove.poi.data.style.Style;
import com.guodi.bpm.form.service.IPrintFormatValue;
import com.guodi.bpm.model.enums.BoxFormatEnum;
import com.guodi.bpm.model.enums.FormatEnum;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
/**
* Description: 打印复选框 、单选框格式转换
*
* @Author: 洪家洪
* @Date: 2023/8/9 11:18
**/
@Service("BoxFormatImpl")
public class BoxFormatImpl implements IPrintFormatValue {
@Override
public boolean containsFormat(String format) {
try {
return BoxFormatEnum.valueOf(format) != null;
} catch (Exception e) {
return false;
}
}
@Override
public Object formatValue(Object value, String format, String setting) {
String valueString = value != null ? value.toString() : null;
if (BoxFormatEnum.CHK.name().equals(format)) {
return this.handleCheckBox(valueString, setting);
} else if (BoxFormatEnum.CHKG.name().equals(format)) {
return this.handleCheckBoxJson(valueString);
} else if (BoxFormatEnum.RDO.name().equals(format)) {
return this.handleRadio(valueString, setting);
} else if (BoxFormatEnum.RDOG.name().equals(format)) {
return this.handleRadioJson(valueString);
}
return null;
}
//处理复选框
public TextRenderData handleCheckBox(String value, String setting) {
//勾选 F0FE 25A1 25A0
TextRenderData selSymbol = new TextRenderData("■", new Style("Wingdings 2", 10.5));
//不勾选 ■ □
TextRenderData unselSymbol = new TextRenderData("□", new Style("Wingdings 2", 10.5));
//复选简单值模式
if (StrUtil.isNotBlank(value) && !"[]".equals(value) || (StrUtil.isNotBlank(value) && StrUtil.isNotBlank(setting) && value.indexOf(setting) != -1)) {
return selSymbol;
} else {
return unselSymbol;
}
}
//复选框JSON组模式
public StringBuffer handleCheckBoxJson(String value) {
Map<String, Boolean> checkColorMap = new LinkedHashMap<>();
JSONArray jsonArray = new JSONArray(value);
for (int i = 0; i < jsonArray.size(); i++) {
JSONObject jsonObject = jsonArray.getJSONObject(i);
//获取checkbox的值与是否勾选标识
String checkBoxValue = jsonObject.getStr("value");//对应模板字典编号
String checkBoxLabel = jsonObject.getStr("label");//对应模板字典名称
String ifCheckBox = jsonObject.getStr("checked");
boolean aBoolean = Boolean.parseBoolean(ifCheckBox);
checkColorMap.put(checkBoxLabel, aBoolean);
}
StringBuffer sb = new StringBuffer();
Set<Map.Entry<String, Boolean>> entries = checkColorMap.entrySet();
for (Map.Entry<String, Boolean> map : entries) {
String checkBox;
// 勾选(一个大写的R加上Wingdings 2字体就是一个勾选的方框)
if (map.getValue()) {
checkBox = "■";
} else {
// 不勾选的unicode编码
checkBox = "□";
}
sb.append(checkBox).append(map.getKey() + " ");
}
return sb;
}
//处理单选框
public TextRenderData handleRadio(String value, String setting) {
//勾选 009E
TextRenderData selSymbol = new TextRenderData("●", new Style("Wingdings 2", 10.5));
//不勾选 0099
TextRenderData unselSymbol = new TextRenderData("○", new Style("Wingdings 2", 10.5));
//简单值模式
if (StrUtil.isNotBlank(value) || (StrUtil.isNotBlank(setting) && value.equals(setting))) {
return selSymbol;
} else {
return unselSymbol;
}
}
//处理单选框json
public StringBuffer handleRadioJson(String value) {
//复选框JSON组模式
Map<String, Boolean> checkColorMap = new LinkedHashMap<>();
JSONArray jsonArray = new JSONArray(value);
for (int i = 0; i < jsonArray.size(); i++) {
JSONObject jsonObject = jsonArray.getJSONObject(i);
//获取checkbox的值与是否勾选标识
String checkBoxLabel = jsonObject.getStr("label");//对应模板字典名称
String checkBoxValue = jsonObject.getStr("value");//对应模板字典编号
String ifCheckBox = jsonObject.getStr("checked");
boolean aBoolean = Boolean.parseBoolean(ifCheckBox);
checkColorMap.put(checkBoxLabel, aBoolean);
}
StringBuffer sb = new StringBuffer();
Set<Map.Entry<String, Boolean>> entries = checkColorMap.entrySet();
for (Map.Entry<String, Boolean> map : entries) {
String checkBox;
// 勾选 \uF0A4
if (map.getValue()) {
checkBox = "●";
} else {
// 不勾选 \uF0A1
checkBox = "○";
}
sb.append(checkBox).append(map.getKey() + " ");
}
return sb;
}
}
package com.guodi.bpm.tool.util.formatUtil;
import org.apache.commons.lang3.StringUtils;
import java.math.BigDecimal;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
/**
* @author lwh
* @description: 数字时间格式化工具类
* @date: 2023/6/29 15:01
*/
public class FormatUtil {
public static void main(String[] args) {
}
/***
* @author lwh
* function: 将数字转化为yyyy年MM月dd日格式和yyyy-MM-dd
* @createDate 2023-6-29 下午15:18:12
* @param time 日期
* @return 转换后的yyyy年MM月dd日格式
*/
public static String toUpper(String time,String type) {
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
SimpleDateFormat dTime = new SimpleDateFormat("yyyy年MM月dd日");
SimpleDateFormat dTimes = new SimpleDateFormat("yyyy-MM-dd");
String format = null;
if (time != null && StringUtils.isNotBlank(time)) {
Date parse = null;
try {
parse = df.parse(time);
} catch (ParseException e) {
e.printStackTrace();
}
if (type == FormatEnum.DATETYPE1.name()){
format = dTimes.format(parse);
}else {
format = dTime.format(parse);
}
}
return format;
}
/***
* @author lwh
* function: 将数字转化为中文大写日期格式和年份中文格式返回
* @createDate 2023-6-29 下午15:33:12
* @param time 日期
* @return 转换后的中文大写日期格式
*/
public static String toCnUpper(String time) {
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
String timeFormat = null;
if (time != null && StringUtils.isNotBlank(time)) {
Date format = null;
try {
format = df.parse(time);
} catch (ParseException e) {
e.printStackTrace();
}
//时间转大写
timeFormat = dataToUpper(format);
}
return timeFormat;
}
/***
* @author lwh
* function: 将日期按类型返回 年 月 日 (数字与中文)
* @createDate 2023-7-3 上午9:44
* @param time 日期
* @return 将日期按类型返回【int】
*/
public static Object toFormatSpecificDate(String time,String type){
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
if (time != null && StringUtils.isNotBlank(time)) {
try {
Date format = df.parse(time);
Calendar calendar = Calendar.getInstance();
calendar.setTime(format);
// 获取年份、月份和日期
if (type.equals(FormatEnum.DATEYEAR.name())){
return calendar.get(Calendar.YEAR);
}else if (type.equals(FormatEnum.DATEMONTH.name())){
return calendar.get(Calendar.MONTH)+1;
}else if (type.equals(FormatEnum.DATEDAY.name())){
return calendar.get(Calendar.DAY_OF_MONTH);
}else if (type.equals(FormatEnum.DATEYEAR_CN.name())){
return numToUpper(calendar.get(Calendar.YEAR));
} else if (type.equals(FormatEnum.DATEMONTH_CN.name())){
return monthToUppder(calendar.get(Calendar.MONTH)+1);
}else if (type.equals(FormatEnum.DATEDAY_CN.name())){
return dayToUppder(calendar.get(Calendar.DAY_OF_MONTH));
}
} catch (ParseException e) {
e.printStackTrace();
}
}
return null;
}
/***
* @author lwh
* function: 将数字按类型返回中文 中文数字,格式:贰零零染
* @createDate 2023-7-3 上午10:44
* @param num 数字
* @return 将日期按类型返回【string】
*/
public static String toCnUpperNum(int num,String type){
if (type.equals(FormatEnum.NUMBERCN2.getValue())){
String toUpperNum = numCnToUpper(num);
return toUpperNum;
}else if (type.equals(FormatEnum.NUMBERCN.getValue())){
String convert = getNumberStr(num);
return convert;
}
return null;
}
/***
* @author lwh
* function: 将数字按类型返回中文 中文数字,格式:贰仟零柒圆整
* @createDate 2023-7-4 下午16:52
* @param num 数字
* @return 将日期按类型返回【string】
*/
public static String toCnUpperNum(String num){
BigDecimal bigDecimal = new BigDecimal(num);
String convert = convert(bigDecimal);
return convert;
}
//转中文金额 begin ====================================================================================================
private static final String[] CN_NUMERIC = {"零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"};
private static final String[] CN_UNIT = {"圆", "拾", "佰", "仟", "万", "拾", "佰", "仟", "亿"};
public static String convert(BigDecimal amount) {
if (amount.compareTo(BigDecimal.ZERO) == 0) {
return "零元整";
}
StringBuilder result = new StringBuilder();
// 转换为字符串,并去除小数点后多余的0
String strAmount = amount.stripTrailingZeros().toPlainString();
int dotIndex = strAmount.indexOf(".");
// 整数部分
String integerPart = "";
if (dotIndex > -1) {
integerPart = strAmount.substring(0, dotIndex);
} else {
integerPart = strAmount;
}
int length = integerPart.length();
// 是否遇到连续的0
boolean isZero = false;
for (int i = 0; i < length; i++) {
// 获取当前数字的值
int digit = Integer.parseInt(integerPart.substring(i, i + 1));
int unitIndex = length - i - 1; // 数字所在的单位位置
boolean isLastUnit = unitIndex == 0; // 是否为最后一个单位
// 处理连续的0
if (digit == 0) {
isZero = true;
// 若当前数字是最后一个单位对应的数字,并且前面还有非0数字,则追加单位
if (isLastUnit && !result.toString().endsWith("零")) {
result.append(CN_UNIT[unitIndex]);
}
} else {
// 处理非0数字
if (isZero) {
result.append("零");
isZero = false;
}
result.append(CN_NUMERIC[digit]).append(CN_UNIT[unitIndex]);
}
}
// 处理小数部分
if (dotIndex > -1) {
String decimalPart = strAmount.substring(dotIndex + 1);
int decLength = decimalPart.length();
if (decLength == 1) {
int digit = Integer.parseInt(decimalPart);
if (digit != 0) {
result.append(CN_NUMERIC[digit]).append("角");
}
} else if (decLength == 2) {
int digit1 = Integer.parseInt(decimalPart.substring(0, 1));
int digit2 = Integer.parseInt(decimalPart.substring(1, 2));
if (digit1 != 0) {
result.append(CN_NUMERIC[digit1]).append("角");
}
if (digit2 != 0) {
result.append(CN_NUMERIC[digit2]).append("分");
}
}
}
return result.append("整").toString();
}
//转中文金额 end ====================================================================================================
//日期转化为大小写 begin ====================================================================================================
public static String dataToUpper(Date date) {
Calendar ca = Calendar.getInstance();
ca.setTime(date);
int year = ca.get(Calendar.YEAR);
int month = ca.get(Calendar.MONTH) + 1;
int day = ca.get(Calendar.DAY_OF_MONTH);
return numToUpper(year) + "年" + monthToUppder(month) + "月" + dayToUppder(day) + "日";
}
/***
* function: 月转化为大写
* @createDate 2010-5-27 上午10:41:42
* @param month 月份
* @return 返回转换后大写月份
*/
public static String monthToUppder(int month) {
if (month < 10) {
return numToUpper(month);
} else if (month == 10) {
return "十";
} else {
return "十" + numToUpper(month - 10);
}
}
/***
* function: 日转化为大写
* @createDate 2010-5-27 上午10:43:32
* @param day 日期
* @return 转换大写的日期格式
*/
public static String dayToUppder(int day) {
if (day < 20) {
return monthToUppder(day);
} else {
char[] str = String.valueOf(day).toCharArray();
if (str[1] == '0') {
return numToUpper(Integer.parseInt(str[0] + "")) + "十";
} else {
return numToUpper(Integer.parseInt(str[0] + "")) + "十" + numToUpper(Integer.parseInt(str[1] + ""));
}
}
}
//日期转化为大小写 end ====================================================================================================
//转中文数字 begin ====================================================================================================
/***
* function: 将数字转化为大写
* @createDate 2010-5-27 上午10:28:12
* @param num 数字
* @return 转换后的大写数字
*/
public static String numToUpper(int num) {
// String u[] = {"零","壹","贰","叁","肆","伍","陆","柒","捌","玖"};
// String u[] = {"零", "一", "二", "三", "四", "五", "六", "七", "八", "九"};
String u[] = {"○", "一", "二", "三", "四", "五", "六", "七", "八", "九"};
char[] str = String.valueOf(num).toCharArray();
String rstr = "";
for (int i = 0; i < str.length; i++) {
rstr = rstr + u[Integer.parseInt(str[i] + "")];
}
return rstr;
}
/***
* function: 将数字转化为大写
* @createDate 2010-5-27 上午10:28:12
* @param num 数字
* @return 转换后的大写数字
*/
public static String numCnToUpper(int num) {
String u[] = {"零","壹","贰","叁","肆","伍","陆","柒","捌","玖"};
char[] str = String.valueOf(num).toCharArray();
String rstr = "";
for (int i = 0; i < str.length; i++) {
rstr = rstr + u[Integer.parseInt(str[i] + "")];
}
return rstr;
}
private static String[] NUMBER1 = {"零", "一", "两", "三", "四", "五", "六", "七", "八", "九"};
private static String[] NUMBER2 = {"零", "十", "百", "千", "万", "亿"};
/**
* @param num
* @return
* @Author:lwh
* @Description:将数字转化为大写
*/
public static String getNumberStr(int num) {
if (num < 0) {
return "";
}
if (num == 0) {
return NUMBER1[0];
}
int split = 10000;
int y = num / (split * split);
int w = (num / split) % split;
int g = num % split;
StringBuffer sb = new StringBuffer();
//亿
if (y > 0) {
sb.append(getNumberStr1000(y));
sb.append(NUMBER2[5]);
}
//万
if (w > 999) {
sb.append(getNumberStr1000(w));
sb.append(NUMBER2[4]);
} else {
if (w > 0) {
if (y != 0) {
sb.append(NUMBER2[0]);
}
sb.append(getNumberStr1000(w));
sb.append(NUMBER2[4]);
}
}
//万以下
if (g > 0) {
if (w != 0) {
if (g > 999) {
sb.append(getNumberStr1000(g));
} else {
sb.append(NUMBER2[0]);
sb.append(getNumberStr1000(g));
}
} else {
if (y != 0) {
sb.append(NUMBER2[0]);
}
sb.append(getNumberStr1000(g));
}
}
return sb.toString();
}
/**
* @param num
* @return
* @Description:对万以下的数字进行大小写转化
*/
private static String getNumberStr1000 (int num) {
if (num > 9999 || num < 0) {
return "";
}
int q = num / 1000;
int b = (num / 100) % 10;
int s = (num / 10) % 10;
int g = num % 10;
StringBuffer sb = new StringBuffer();
//千
if (q > 0) {
sb.append(NUMBER1[q]);
sb.append(NUMBER2[3]);
}
//百
if (b > 0) {
sb.append(NUMBER1[b]);
sb.append(NUMBER2[2]);
} else {
if (q != 0) {
sb.append(NUMBER2[0]);
}
}
//十
if (s > 0) {
sb.append(NUMBER1[s]);
sb.append(NUMBER2[1]);
} else {
if (b != 0) {
sb.append(NUMBER2[0]);
}
}
//个
if (g > 0) {
sb.append(NUMBER1[g]);
}
return sb.toString();
}
//转中文数字 end ====================================================================================================
}