Yangwl
/
lanju-cloud
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/master'

Browse Source
master
Yangwl 7 months ago
parent 190116c425 b250e7146f
commit 024a293bee
73 changed files with 3072 additions and 107 deletions
Show Stats Download Patch File Download Diff File

3
op-api/op-api-system/src/main/java/com/op/system/api/RemoteFileService.java
Unescape Escape View File

@ -4,6 +4,7 @@ import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestPart;
import org.springframework.web.multipart.MultipartFile;
import com.op.common.core.constant.ServiceNameConstants;
@ -33,4 +34,6 @@ public interface RemoteFileService {
@PostMapping(value = "/getFile/{id}")
public InputStream getFile(@PathVariable("id") String id);
@PostMapping(value = "/downLoadFileByte")
public byte[] downLoadFileByte(@RequestBody SysFile sysFile);
}

9
op-api/op-api-system/src/main/java/com/op/system/api/domain/mes/ProRfidProcessDetail.java
Unescape Escape View File

@ -115,6 +115,15 @@ public class ProRfidProcessDetail extends BaseEntity {
@Excel(name = "班次")
private String shiftId;
private String recordCount;
public String getRecordCount() {
return recordCount;
}
public void setRecordCount(String recordCount) {
this.recordCount = recordCount;
}
public String getShiftId() {
return shiftId;

5
op-api/op-api-system/src/main/java/com/op/system/api/factory/RemoteFileFallbackFactory.java
Unescape Escape View File

@ -33,6 +33,11 @@ public class RemoteFileFallbackFactory implements FallbackFactory<RemoteFileServ
public InputStream getFile(String id) {
return null;
}
@Override
public byte[] downLoadFileByte(SysFile sysFile) {
return new byte[0];
}
};
}
}

596
op-common/op-common-core/src/main/java/com/op/common/core/utils/poi/ExcelCPReportMapUtil.java
Unescape Escape View File

@ -0,0 +1,596 @@
package com.op.common.core.utils.poi;
import com.alibaba.fastjson2.JSONObject;
import com.op.common.core.domain.ExcelCol;
import org.apache.commons.compress.utils.IOUtils;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.ss.util.CellRangeAddress;
import org.apache.poi.xssf.streaming.SXSSFWorkbook;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
/**
* Excel导出报告相关处理
*
* @author OP
*/
public class ExcelCPReportMapUtil {
//下载
public static <T> SXSSFWorkbook initWorkbook(String sheetName , String title, List<ExcelCol> excelCol ,
List<T> data0, List<T> data1,Map<String,String> detailMap) throws IOException {
SXSSFWorkbook workbook = new SXSSFWorkbook();
int colSize = excelCol.size();
//创建Sheet（工作簿）
Sheet sheet = null;
if (!StringUtils.hasText(sheetName)){
sheet = workbook.createSheet();
}else{
sheet = workbook.createSheet(sheetName);
}
// 从resources目录获取图片字节数组
byte[] imageBytes = getImageBytesFromResources("image/logo.png");
/**logo**/
int pictureIdx = workbook.addPicture(imageBytes, Workbook.PICTURE_TYPE_PNG);
CreationHelper helper = workbook.getCreationHelper();
Drawing<?> drawing = sheet.createDrawingPatriarch();
ClientAnchor anchor = helper.createClientAnchor();
anchor.setCol1(0); // B列
anchor.setRow1(0); // 第2行（Excel的行和列都是从0开始计数的）
anchor.setCol2(1); // C列（图片宽度跨越的列数，这里设置为1列宽）
anchor.setRow2(2); // 第6行（图片高度跨越的行数，这里设置为4行高，可以根据图片大小调整）
Picture pict = drawing.createPicture(anchor, pictureIdx);
pict.resize(); // 根据图片的实际大小调整图片在Excel中的显示大小
/**报告标题**/
sheet.addMergedRegion(new CellRangeAddress(0, 1, 2, 11));
// 获取合并后的单元格的第一个单元格（即C1），并设置值
Row row1 = sheet.getRow(0); // 获取第1行（索引为0）
if (row1 == null) {row1 = sheet.createRow(0); // 如果第1行不存在，则创建它
}
Cell cell = row1.getCell(2); // 获取C列（索引为2）的单元格
if (cell == null) {
cell = row1.createCell(2); // 如果C列的单元格不存在，则创建它
}
cell.setCellValue("中山榄菊日化实业有限公司"); // 设置单元格的值
cell.setCellStyle(getTitelStyle(workbook)); // 应用样式到单元格
/**报告二级标题、检验标准**/
// 合并C3到I4的单元格，并设置样式
mergeAndStyleCells(sheet, new CellRangeAddress(2, 3, 2, 8), detailMap.get("title"));
// 合并J3到L4的单元格，并设置样式
mergeAndStyleCells(sheet, new CellRangeAddress(2, 3, 9, 12), "编码"+detailMap.get("standardNo"));
/**左右表格1**/
//画边框
for(int r5=4;r5<12;r5++){
Row row05 = sheet.getRow(r5);
if (row05 == null) {row05 = sheet.createRow(r5);}
for (int col = 0; col < 14; col++) {
Cell cell1 = row05.createCell(col);
cell1.setCellStyle(getRowStyle(sheet));
}
}
for(int d5=12;d5<(14+data0.size()+data1.size());d5++){
Row row05 = sheet.getRow(d5);
if (row05 == null) {row05 = sheet.createRow(d5);}
for (int col = 0; col < 14; col++) {
Cell cell1 = row05.createCell(col);
cell1.setCellStyle(getDataStyle(sheet));
}
}
Row row5 = sheet.getRow(4);
// 合并A5到B6的单元格，并设置样式和内容
mergeAndStyleCells2(sheet,row5, new CellRangeAddress(4, 5, 0, 1), "产品名称", true, true, IndexedColors.GREY_25_PERCENT);
// 合并C5到D6的单元格，并设置样式（无背景色，只有边框和内容居中）
mergeAndStyleCells2(sheet,row5, new CellRangeAddress(4, 5, 2, 3), detailMap.get("materialName"), true, false, null);
// 合并E5到F6的单元格，并设置样式和内容
mergeAndStyleCells2(sheet,row5, new CellRangeAddress(4, 5, 4, 5), "生产数量(单位/箱)", true, true, IndexedColors.GREY_25_PERCENT);
// 合并G5到I6的单元格，并设置样式（无背景色，只有边框和内容居中）
mergeAndStyleCells2(sheet,row5, new CellRangeAddress(4, 5, 6, 8), detailMap.get("quality"), true, false, null);
// 合并J5到K6的单元格，并设置样式和内容
mergeAndStyleCells2(sheet,row5, new CellRangeAddress(4, 5, 9, 10), "检验编码", true, true, IndexedColors.GREY_25_PERCENT);
// 合并L5到N6的单元格，并设置样式（无背景色，只有边框和内容居中）
mergeAndStyleCells2(sheet,row5, new CellRangeAddress(4, 5, 11, 13), detailMap.get("checkNo"), true, false, null);
Row row7 = sheet.getRow(6);
// 合并A7到B8的单元格，并设置样式和内容
mergeAndStyleCells2(sheet,row7, new CellRangeAddress(6, 7, 0, 1), "产品编码", true, true, IndexedColors.GREY_25_PERCENT);
// 合并C5到D6的单元格，并设置样式（无背景色，只有边框和内容居中）
mergeAndStyleCells2(sheet,row7, new CellRangeAddress(6, 7, 2, 3), detailMap.get("materialCode"), true, false, null);
// 合并E5到F6的单元格，并设置样式和内容
mergeAndStyleCells2(sheet,row7, new CellRangeAddress(6, 7, 4, 5), "抽样地点", true, true, IndexedColors.GREY_25_PERCENT);
// 合并G5到I6的单元格，并设置样式（无背景色，只有边框和内容居中）
mergeAndStyleCells2(sheet,row7, new CellRangeAddress(6, 7, 6, 8), detailMap.get("checkLoc"), true, false, null);
// 合并J5到K6的单元格，并设置样式和内容
mergeAndStyleCells2(sheet,row7, new CellRangeAddress(6, 7, 9, 10), "报检日期", true, true, IndexedColors.GREY_25_PERCENT);
// 合并L5到N6的单元格，并设置样式（无背景色，只有边框和内容居中）
mergeAndStyleCells2(sheet,row7, new CellRangeAddress(6, 7, 11, 13), detailMap.get("incomeTime"), true, false, null);
Row row9 = sheet.getRow(8);
// 合并A7到B8的单元格，并设置样式和内容
mergeAndStyleCells2(sheet,row9, new CellRangeAddress(8, 9, 0, 1), "生产批号", true, true, IndexedColors.GREY_25_PERCENT);
// 合并C5到D6的单元格，并设置样式（无背景色，只有边框和内容居中）
mergeAndStyleCells2(sheet,row9, new CellRangeAddress(8, 9, 2, 3), detailMap.get("incomeBatchNo"), true, false, null);
// 合并E5到F6的单元格，并设置样式和内容
mergeAndStyleCells2(sheet,row9, new CellRangeAddress(8, 9, 4, 5), "检验依据", true, true, IndexedColors.GREY_25_PERCENT);
// 合并G5到I6的单元格，并设置样式（无背景色，只有边框和内容居中）
mergeAndStyleCells2(sheet,row9, new CellRangeAddress(8, 9,6, 8), detailMap.get("quality"), true, false, null);
// 合并J5到K6的单元格，并设置样式和内容
mergeAndStyleCells2(sheet,row9, new CellRangeAddress(8, 9, 9, 10), "检验日期 ", true, true, IndexedColors.GREY_25_PERCENT);
// 合并L5到N6的单元格，并设置样式（无背景色，只有边框和内容居中）
mergeAndStyleCells2(sheet,row9, new CellRangeAddress(8, 9, 11, 13), detailMap.get("checkTime"), true, false, null);
Row row10 = sheet.getRow(10);
mergeAndStyleCells2(sheet,row10, new CellRangeAddress(10, 10, 0, 13), "包装检验项目", true, false, null);
/**上下表格2**///-------------------------------------------------
Row row11 = sheet.getRow(11);
if (row11 == null) {row11 = sheet.createRow(11);}
Cell cellA13 = row11.createCell(0);
cellA13.setCellValue("序号");
cellA13.setCellStyle(getRowStyle(sheet));
mergeAndStyleCells(sheet, new CellRangeAddress(11, 11, 1, 4), "检验项目");
mergeAndStyleCells(sheet, new CellRangeAddress(11, 11, 5, 9), "标准要求");
Cell cellK = row11.createCell(10);
cellK.setCellValue("抽检数(PC)");
cellK.setCellStyle(getRowStyle(sheet));
mergeAndStyleCells(sheet, new CellRangeAddress(11, 11, 11, 12), "实测结果");
Cell cellL13 = row11.createCell(13);
cellL13.setCellValue("判定");
cellL13.setCellStyle(getRowStyle(sheet));
//将data中的值填充到excel
int rowNum = 12;
if(!CollectionUtils.isEmpty(data0)){
Iterator<T> iterator = data0.iterator();
//遍历数据
for (;iterator.hasNext();){
T obj = iterator.next();//获取当前行对应的数据
JSONObject jsonObject = JSONObject.parseObject(JSONObject.toJSONString(obj));
Row dataRow = sheet.getRow(rowNum);//创建行
// 假设使用了默认字体和字符宽度来计算行高（这是一个简化的示例）
int cellHeight = (int) (cell.getStringCellValue().length() * 6); // 每个字符大约15个单位高度
dataRow.setHeightInPoints(Math.max(dataRow.getHeightInPoints(), cellHeight));
Cell cellData0 = dataRow.getCell(0);
cellData0.setCellValue(rowNum-11);
cellData0.setCellStyle(getDataStyle(sheet));
Cell cellData1 = dataRow.getCell(1);
cellData1.setCellValue(getValue(jsonObject.get(excelCol.get(0).getField())));
cellData1.setCellStyle(getDataStyle(sheet));
Cell cellData2 = dataRow.getCell(5);
cellData2.setCellValue(getValue(jsonObject.get(excelCol.get(1).getField())));
cellData2.setCellStyle(getDataStyle(sheet));
sheet.addMergedRegion(new CellRangeAddress(rowNum, rowNum, 5, 9));
Cell cellData3 = dataRow.getCell(10);
cellData3.setCellValue(getValue(jsonObject.get(excelCol.get(2).getField())));
cellData3.setCellStyle(getDataStyle(sheet));
Cell cellData4 = dataRow.getCell(11);
cellData4.setCellValue(getValue(jsonObject.get(excelCol.get(3).getField())));
cellData4.setCellStyle(getDataStyle(sheet));
sheet.addMergedRegion(new CellRangeAddress(rowNum, rowNum, 11, 12));
Cell cellData5 = dataRow.getCell(13);
cellData5.setCellValue(getValue(jsonObject.get(excelCol.get(4).getField())));
cellData5.setCellStyle(getDataStyle(sheet));
iterator.remove();
rowNum++;
}
}
// 指定要检查的列索引（例如，B列的索引是1）
int columnIndex = 1;
// 遍历所有行，从第二行开始（索引1），因为第一行可能是标题行
for (int rowIndex = 12; rowIndex <= sheet.getLastRowNum(); ) {
Row currentRow = sheet.getRow(rowIndex);
if (currentRow != null) {
Cell currentCell = currentRow.getCell(columnIndex);
if (currentCell != null && currentCell.getCellType() == CellType.STRING) { // 假设我们处理字符串类型的单元格
String currentValue = currentCell.getStringCellValue();
// 查找连续相同值的行
int lastRowIndex = rowIndex;
while (lastRowIndex + 1 <= sheet.getLastRowNum()) {
Row nextRow = sheet.getRow(lastRowIndex + 1);
if (nextRow != null) {
Cell nextCell = nextRow.getCell(columnIndex);
if (nextCell != null && nextCell.getCellType() == CellType.STRING &&
nextCell.getStringCellValue().equals(currentValue)) {
lastRowIndex++; // 继续向下查找
} else {
break; // 找到不同值，停止查找
}
} else {
break; // 没有更多行，停止查找
}
}
// 合并找到的行
if (rowIndex != lastRowIndex) { // 只有在找到连续相同值的行时才进行合并
sheet.addMergedRegion(new CellRangeAddress(rowIndex, lastRowIndex, 1, 4));
}else{
sheet.addMergedRegion(new CellRangeAddress(rowIndex, rowIndex, 1, 4));
}
// 更新rowIndex以跳过已合并的行
rowIndex = lastRowIndex + 1; // 从下一个未合并的行开始继续遍历
} else {
// 如果当前单元格不是字符串类型，则直接跳到下一行
rowIndex++;
}
} else {
// 如果当前行为空，则直接跳到下一行
rowIndex++;
}
}
//表格2
int startNum2= rowNum;
Row row100 = sheet.getRow(startNum2);
mergeAndStyleCells2(sheet,row100, new CellRangeAddress(startNum2, startNum2, 0, 13), "内容物分析项目", true, false, null);
Row row101 = sheet.getRow(startNum2+1);
if (row101 == null) {row101 = sheet.createRow(startNum2+1);}
Cell cellA103 = row101.createCell(0);
cellA103.setCellValue("序号");
cellA103.setCellStyle(getRowStyle(sheet));
mergeAndStyleCells(sheet, new CellRangeAddress(startNum2+1, startNum2+1, 1, 4), "检验项目");
mergeAndStyleCells(sheet, new CellRangeAddress(startNum2+1, startNum2+1, 5, 9), "标准要求");
Cell cellK0 = row101.createCell(10);
cellK0.setCellValue("抽检数(PC)");
cellK0.setCellStyle(getRowStyle(sheet));
mergeAndStyleCells(sheet, new CellRangeAddress(startNum2+1, startNum2+1, 11, 12), "实测结果");
Cell cellL103 = row101.createCell(13);
cellL103.setCellValue("判定");
cellL103.setCellStyle(getRowStyle(sheet));
//将data中的值填充到excel
int rowNum2 = startNum2+2,m=1;
if(!CollectionUtils.isEmpty(data1)){
Iterator<T> iterator = data1.iterator();
//遍历数据
for (;iterator.hasNext();){
T obj = iterator.next();//获取当前行对应的数据
JSONObject jsonObject = JSONObject.parseObject(JSONObject.toJSONString(obj));
Row dataRow = sheet.getRow(rowNum2);//创建行
// 假设使用了默认字体和字符宽度来计算行高（这是一个简化的示例）
int cellHeight = (int) (cell.getStringCellValue().length() * 6); // 每个字符大约15个单位高度
dataRow.setHeightInPoints(Math.max(dataRow.getHeightInPoints(), cellHeight));
Cell cellData0 = dataRow.getCell(0);
cellData0.setCellValue(m++);
cellData0.setCellStyle(getDataStyle(sheet));
Cell cellData1 = dataRow.getCell(1);
cellData1.setCellValue(getValue(jsonObject.get(excelCol.get(0).getField())));
cellData1.setCellStyle(getDataStyle(sheet));
Cell cellData2 = dataRow.getCell(5);
cellData2.setCellValue(getValue(jsonObject.get(excelCol.get(1).getField())));
cellData2.setCellStyle(getDataStyle(sheet));
sheet.addMergedRegion(new CellRangeAddress(rowNum2, rowNum2, 5, 9));
Cell cellData3 = dataRow.getCell(10);
cellData3.setCellValue(getValue(jsonObject.get(excelCol.get(2).getField())));
cellData3.setCellStyle(getDataStyle(sheet));
Cell cellData4 = dataRow.getCell(11);
cellData4.setCellValue(getValue(jsonObject.get(excelCol.get(3).getField())));
cellData4.setCellStyle(getDataStyle(sheet));
sheet.addMergedRegion(new CellRangeAddress(rowNum2, rowNum2, 11, 12));
Cell cellData5 = dataRow.getCell(13);
cellData5.setCellValue(getValue(jsonObject.get(excelCol.get(4).getField())));
cellData5.setCellStyle(getDataStyle(sheet));
iterator.remove();
rowNum2++;
}
}
// 指定要检查的列索引（例如，B列的索引是1）
int columnIndex2 = 1;
// 遍历所有行，从第二行开始（索引1），因为第一行可能是标题行
for (int rowIndex = startNum2+2; rowIndex <= sheet.getLastRowNum(); ) {
Row currentRow = sheet.getRow(rowIndex);
if (currentRow != null) {
Cell currentCell = currentRow.getCell(columnIndex2);
if (currentCell != null && currentCell.getCellType() == CellType.STRING) { // 假设我们处理字符串类型的单元格
String currentValue = currentCell.getStringCellValue();
// 查找连续相同值的行
int lastRowIndex = rowIndex;
while (lastRowIndex + 1 <= sheet.getLastRowNum()) {
Row nextRow = sheet.getRow(lastRowIndex + 1);
if (nextRow != null) {
Cell nextCell = nextRow.getCell(columnIndex2);
if (nextCell != null && nextCell.getCellType() == CellType.STRING &&
nextCell.getStringCellValue().equals(currentValue)) {
lastRowIndex++; // 继续向下查找
} else {
break; // 找到不同值，停止查找
}
} else {
break; // 没有更多行，停止查找
}
}
// 合并找到的行
if (rowIndex != lastRowIndex) { // 只有在找到连续相同值的行时才进行合并
sheet.addMergedRegion(new CellRangeAddress(rowIndex, lastRowIndex, 1, 4));
}else{
sheet.addMergedRegion(new CellRangeAddress(rowIndex, rowIndex, 1, 4));
}
// 更新rowIndex以跳过已合并的行
rowIndex = lastRowIndex + 1; // 从下一个未合并的行开始继续遍历
} else {
// 如果当前单元格不是字符串类型，则直接跳到下一行
rowIndex++;
}
} else {
// 如果当前行为空，则直接跳到下一行
rowIndex++;
}
}
Row rowEnd1 = sheet.createRow(rowNum2+2);
mergeAndStyleCellsNoBorder(sheet,rowEnd1, new CellRangeAddress(rowNum2+2, rowNum2+3, 0, 1), "综合检验结论", true, true, IndexedColors.GREY_25_PERCENT);
mergeAndStyleCellsNoBorder(sheet,rowEnd1, new CellRangeAddress(rowNum2+2, rowNum2+3, 2, 3), detailMap.get("checkResult"), true, false, null);
mergeAndStyleCellsNoBorder(sheet,rowEnd1, new CellRangeAddress(rowNum2+2, rowNum2+3, 5, 10), "备注:判定合格打“√”，不合格打“×”", true, true, null);
Row rowEnd2 = sheet.createRow(rowNum2+5);
mergeAndStyleCellsNoBorder(sheet,rowEnd2, new CellRangeAddress(rowNum2+5, rowNum2+5, 0, 2), "品质主管", true, true, IndexedColors.GREY_25_PERCENT);
mergeAndStyleCellsNoBorder(sheet,rowEnd2, new CellRangeAddress(rowNum2+5, rowNum2+5, 3, 8), "", true, false, null);
mergeAndStyleCellsNoBorder(sheet,rowEnd2, new CellRangeAddress(rowNum2+5, rowNum2+5, 10, 11), "品管员", true, true, IndexedColors.GREY_25_PERCENT);
mergeAndStyleCellsNoBorder(sheet,rowEnd2, new CellRangeAddress(rowNum2+5, rowNum2+5, 12, 13), detailMap.get("checkManName"), true, false, null);
return workbook;
}
// //标题样式
// public static CellStyle getHeaderFont(Workbook workbook){
// Font font = workbook.createFont();
// font.setFontHeightInPoints((short) 15);//字体大小
// font.setBold(true);//加粗
// CellStyle cellStyle = workbook.createCellStyle();
// cellStyle.setFont(font);
// cellStyle.setAlignment(HorizontalAlignment.CENTER_SELECTION);//设置水平居中
// cellStyle.setVerticalAlignment(VerticalAlignment.CENTER);//设置垂直居中
// // 设置上边框
// cellStyle.setBorderTop(BorderStyle.THIN);
// // 设置下边框
// cellStyle.setBorderBottom(BorderStyle.THIN);
// // 设置左边框
// cellStyle.setBorderLeft(BorderStyle.THIN);
// // 设置右边框
// cellStyle.setBorderRight(BorderStyle.THIN);
// cellStyle.setFillBackgroundColor(IndexedColors.AQUA.getIndex());
//
// return cellStyle;
// }
// //内容样式
// public static CellStyle getDataFont(Workbook workbook){
// Font font = workbook.createFont();
// font.setFontHeightInPoints((short) 12);//字体大小
// font.setBold(false);//不加粗
// CellStyle cellStyle = workbook.createCellStyle();
// cellStyle.setFont(font);
// cellStyle.setAlignment(HorizontalAlignment.CENTER_SELECTION);//设置水平居中
// cellStyle.setVerticalAlignment(VerticalAlignment.CENTER);//设置垂直居中
// cellStyle.setWrapText(true);//设置单元格内容自动换行
// return cellStyle;
// }
//
//处理数据
public static String getValue(Object object){
if (object==null){
return "";
}else {
return object.toString();
}
}
// //处理数据
// public static Integer getValueNum(Object object){
// if (object==null){
// return 0;
// }else {
// return Integer.parseInt(object.toString());
// }
// }
// 从resources目录获取图片的字节数组
private static byte[] getImageBytesFromResources(String resourceName) {
try (InputStream inputStream = ExcelCPReportMapUtil.class.getClassLoader().getResourceAsStream(resourceName);
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream()) {
if (inputStream == null) {
throw new RuntimeException("找不到资源: " + resourceName);
}
IOUtils.copy(inputStream, byteArrayOutputStream);
return byteArrayOutputStream.toByteArray();
} catch (IOException e) {
throw new RuntimeException("读取资源时出错: " + resourceName, e);
}
}
//报告大标题样式-1
public static CellStyle getTitelStyle(Workbook workbook){
Font font = workbook.createFont();
// 设置字体为加粗
font.setBold(true);
// 设置字体大小（例如，设置为16）
font.setFontHeightInPoints((short) 24);
CellStyle cellStyle = workbook.createCellStyle();
cellStyle.setFont(font);
cellStyle.setAlignment(HorizontalAlignment.CENTER_SELECTION);//设置水平居中
cellStyle.setVerticalAlignment(VerticalAlignment.CENTER);//设置垂直居中
cellStyle.setWrapText(true);//设置单元格内容自动换行
return cellStyle;
}
public static CellStyle getRowStyle(Sheet sheet){
CellStyle style = sheet.getWorkbook().createCellStyle();
// 设置边框线
style.setBorderBottom(BorderStyle.THIN);
style.setBorderLeft(BorderStyle.THIN);
style.setBorderRight(BorderStyle.THIN);
style.setBorderTop(BorderStyle.THIN);
// 设置水平居中
style.setAlignment(HorizontalAlignment.CENTER);
style.setWrapText(true);//设置单元格内容自动换行
// 设置垂直居中
style.setVerticalAlignment(VerticalAlignment.CENTER);
Font font = sheet.getWorkbook().createFont();
font.setBold(true);
// 设置字体大小（例如，设置为14）
font.setFontHeightInPoints((short) 14);
style.setFont(font);
return style;
}
public static CellStyle getDataStyle(Sheet sheet){
CellStyle style = sheet.getWorkbook().createCellStyle();
// 设置边框线
style.setBorderBottom(BorderStyle.THIN);
style.setBorderLeft(BorderStyle.THIN);
style.setBorderRight(BorderStyle.THIN);
style.setBorderTop(BorderStyle.THIN);
Font font = sheet.getWorkbook().createFont();
// 设置字体大小（例如，设置为14）
font.setFontHeightInPoints((short) 14);
style.setFont(font);
style.setWrapText(true);//设置单元格内容自动换行
// 设置水平居中
style.setAlignment(HorizontalAlignment.LEFT);
// 设置垂直居中
style.setVerticalAlignment(VerticalAlignment.CENTER);
return style;
}
private static void mergeAndStyleCells(Sheet sheet, CellRangeAddress cellRangeAddress, String cellValue) {
// 合并单元格
sheet.addMergedRegion(cellRangeAddress);
// 创建一个单元格样式
CellStyle style = sheet.getWorkbook().createCellStyle();
// 设置字体为加粗
Font font = sheet.getWorkbook().createFont();
font.setBold(true);
// 设置字体大小（例如，设置为14）
font.setFontHeightInPoints((short) 14);
style.setFont(font);
// 设置水平居中
style.setAlignment(HorizontalAlignment.CENTER);
// 设置垂直居中
style.setVerticalAlignment(VerticalAlignment.CENTER);
style.setWrapText(true);//设置单元格内容自动换行
// 获取合并后的单元格的第一个单元格，并设置值
Row row = sheet.getRow(cellRangeAddress.getFirstRow());
if (row == null) {
row = sheet.createRow(cellRangeAddress.getFirstRow());
}
Cell cell = row.getCell(cellRangeAddress.getFirstColumn());
if (cell == null) {
cell = row.createCell(cellRangeAddress.getFirstColumn());
}
cell.setCellValue(cellValue); // 设置单元格的值
cell.setCellStyle(style); // 应用样式到单元格
}
private static void mergeAndStyleCells2(Sheet sheet,Row row, CellRangeAddress cellRangeAddress, String cellValue, boolean centered, boolean hasBackground, IndexedColors backgroundColor) {
// 合并单元格
sheet.addMergedRegion(cellRangeAddress);
// 创建一个单元格样式
CellStyle style = sheet.getWorkbook().createCellStyle();
// 设置字体居中
if (centered) {
style.setAlignment(HorizontalAlignment.CENTER);
style.setVerticalAlignment(VerticalAlignment.CENTER);
}
// 设置背景颜色（如果有）
if (hasBackground && backgroundColor != null) {
style.setFillForegroundColor(backgroundColor.getIndex());
style.setFillPattern(FillPatternType.SOLID_FOREGROUND);
}
// 设置边框线
style.setBorderBottom(BorderStyle.THIN);
style.setBorderLeft(BorderStyle.THIN);
style.setBorderRight(BorderStyle.THIN);
style.setBorderTop(BorderStyle.THIN);
// 获取合并后的单元格的第一个单元格，并设置值
Cell cell = row.getCell(cellRangeAddress.getFirstColumn());
if (cell == null) {
cell = row.createCell(cellRangeAddress.getFirstColumn());
}
cell.setCellValue(cellValue); // 设置单元格的值
cell.setCellStyle(style); // 应用样式到单元格
}
private static void mergeAndStyleCellsNoBorder(Sheet sheet,Row row, CellRangeAddress cellRangeAddress, String cellValue, boolean centered, boolean hasBackground, IndexedColors backgroundColor) {
// 合并单元格
sheet.addMergedRegion(cellRangeAddress);
// 创建一个单元格样式
CellStyle style = sheet.getWorkbook().createCellStyle();
// 设置字体居中
if (centered) {
style.setAlignment(HorizontalAlignment.CENTER);
style.setVerticalAlignment(VerticalAlignment.CENTER);
}
// 设置背景颜色（如果有）
if (hasBackground && backgroundColor != null) {
style.setFillForegroundColor(backgroundColor.getIndex());
style.setFillPattern(FillPatternType.SOLID_FOREGROUND);
}
// 获取合并后的单元格的第一个单元格，并设置值
Cell cell = row.getCell(cellRangeAddress.getFirstColumn());
if (cell == null) {
cell = row.createCell(cellRangeAddress.getFirstColumn());
}
cell.setCellValue(cellValue); // 设置单元格的值
cell.setCellStyle(style); // 应用样式到单元格
}
// 下载图片的方法
private static byte[] downloadImage(String imageUrl) throws IOException {
URL url = new URL("http://192.168.202.20:9300/downLoadFile?id=6750f005dfe388096d533c66&fileName=1733357574344_IMG_20241112_124257_956.jpg");
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.setRequestMethod("GET");
connection.connect();
int responseCode = connection.getResponseCode();
if (responseCode != HttpURLConnection.HTTP_OK) {
throw new IOException("Failed to download image: HTTP error code : " + responseCode);
}
// 获取图片大小并读取图片数据
int contentLength = connection.getContentLength();
byte[] imageBytes = new byte[contentLength];
try (InputStream inputStream = connection.getInputStream()) {
int bytesRead = -1;
int totalBytesRead = 0;
while ((bytesRead = inputStream.read(imageBytes, totalBytesRead, contentLength - totalBytesRead)) != -1) {
totalBytesRead += bytesRead;
}
}
return imageBytes;
}
}

473
op-common/op-common-core/src/main/java/com/op/common/core/utils/poi/ExcelReportMapUtil.java
Unescape Escape View File

@ -0,0 +1,473 @@
package com.op.common.core.utils.poi;
import com.alibaba.fastjson2.JSONObject;
import com.op.common.core.domain.ExcelCol;
import com.op.common.core.utils.DateUtils;
import org.apache.commons.compress.utils.IOUtils;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.ss.util.CellRangeAddress;
import org.apache.poi.xssf.streaming.SXSSFWorkbook;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
/**
* Excel导出报告相关处理
*
* @author OP
*/
public class ExcelReportMapUtil {
//下载
public static <T> SXSSFWorkbook initWorkbook(String sheetName , String title, List<ExcelCol> excelCol , List<T> data, Map<String,String> detailMap) throws IOException {
SXSSFWorkbook workbook = new SXSSFWorkbook();
int colSize = excelCol.size();
//创建Sheet（工作簿）
Sheet sheet = null;
if (!StringUtils.hasText(sheetName)){
sheet = workbook.createSheet();
}else{
sheet = workbook.createSheet(sheetName);
}
// 从resources目录获取图片字节数组
byte[] imageBytes = getImageBytesFromResources("image/logo.png");
/**logo**/
int pictureIdx = workbook.addPicture(imageBytes, Workbook.PICTURE_TYPE_PNG);
CreationHelper helper = workbook.getCreationHelper();
Drawing<?> drawing = sheet.createDrawingPatriarch();
ClientAnchor anchor = helper.createClientAnchor();
anchor.setCol1(0); // B列
anchor.setRow1(0); // 第2行（Excel的行和列都是从0开始计数的）
anchor.setCol2(1); // C列（图片宽度跨越的列数，这里设置为1列宽）
anchor.setRow2(2); // 第6行（图片高度跨越的行数，这里设置为4行高，可以根据图片大小调整）
Picture pict = drawing.createPicture(anchor, pictureIdx);
pict.resize(); // 根据图片的实际大小调整图片在Excel中的显示大小
/**报告标题**/
sheet.addMergedRegion(new CellRangeAddress(0, 1, 2, 11));
// 获取合并后的单元格的第一个单元格（即C1），并设置值
Row row1 = sheet.getRow(0); // 获取第1行（索引为0）
if (row1 == null) {row1 = sheet.createRow(0); // 如果第1行不存在，则创建它
}
Cell cell = row1.getCell(2); // 获取C列（索引为2）的单元格
if (cell == null) {
cell = row1.createCell(2); // 如果C列的单元格不存在，则创建它
}
cell.setCellValue("中山榄菊日化实业有限公司"); // 设置单元格的值
cell.setCellStyle(getTitelStyle(workbook)); // 应用样式到单元格
/**报告二级标题、检验标准**/
// 合并C3到I4的单元格，并设置样式
mergeAndStyleCells(sheet, new CellRangeAddress(2, 3, 2, 8), detailMap.get("title"));
// 合并J3到L4的单元格，并设置样式
mergeAndStyleCells(sheet, new CellRangeAddress(2, 3, 9, 12), "编码："+detailMap.get("standardNo"));
/**左右表格1**/
//画边框
for(int r5=4;r5<13;r5++){
Row row05 = sheet.getRow(r5);
if (row05 == null) {row05 = sheet.createRow(r5);}
for (int col = 0; col < 14; col++) {
Cell cell1 = row05.createCell(col);
cell1.setCellStyle(getRowStyle(sheet));
}
}
for(int d5=13;d5<(13+data.size());d5++){
Row row05 = sheet.getRow(d5);
if (row05 == null) {row05 = sheet.createRow(d5);}
for (int col = 0; col < 14; col++) {
Cell cell1 = row05.createCell(col);
cell1.setCellStyle(getDataStyle(sheet));
}
}
Row row5 = sheet.getRow(4);
// 合并A5到B6的单元格，并设置样式和内容
mergeAndStyleCells2(sheet,row5, new CellRangeAddress(4, 5, 0, 1), "来料类别", true, true, IndexedColors.GREY_25_PERCENT);
// 合并C5到D6的单元格，并设置样式（无背景色，只有边框和内容居中）
mergeAndStyleCells2(sheet,row5, new CellRangeAddress(4, 5, 2, 3), detailMap.get("productGroupName"), true, false, null);
// 合并E5到F6的单元格，并设置样式和内容
mergeAndStyleCells2(sheet,row5, new CellRangeAddress(4, 5, 4, 5), "生产批号", true, true, IndexedColors.GREY_25_PERCENT);
// 合并G5到I6的单元格，并设置样式（无背景色，只有边框和内容居中）
mergeAndStyleCells2(sheet,row5, new CellRangeAddress(4, 5, 6, 8), detailMap.get("incomeBatchNo"), true, false, null);
// 合并J5到K6的单元格，并设置样式和内容
mergeAndStyleCells2(sheet,row5, new CellRangeAddress(4, 5, 9, 10), "报告编号", true, true, IndexedColors.GREY_25_PERCENT);
// 合并L5到N6的单元格，并设置样式（无背景色，只有边框和内容居中）
mergeAndStyleCells2(sheet,row5, new CellRangeAddress(4, 5, 11, 13), detailMap.get("checkNo"), true, false, null);
Row row7 = sheet.getRow(6);
// 合并A7到B8的单元格，并设置样式和内容
mergeAndStyleCells2(sheet,row7, new CellRangeAddress(6, 7, 0, 1), "物料名称", true, true, IndexedColors.GREY_25_PERCENT);
// 合并C5到D6的单元格，并设置样式（无背景色，只有边框和内容居中）
mergeAndStyleCells2(sheet,row7, new CellRangeAddress(6, 7, 2, 3), detailMap.get("materialName"), true, false, null);
// 合并E5到F6的单元格，并设置样式和内容
mergeAndStyleCells2(sheet,row7, new CellRangeAddress(6, 7, 4, 5), "物料编码", true, true, IndexedColors.GREY_25_PERCENT);
// 合并G5到I6的单元格，并设置样式（无背景色，只有边框和内容居中）
mergeAndStyleCells2(sheet,row7, new CellRangeAddress(6, 7, 6, 8), detailMap.get("materialCode"), true, false, null);
// 合并J5到K6的单元格，并设置样式和内容
mergeAndStyleCells2(sheet,row7, new CellRangeAddress(6, 7, 9, 10), "供应单位", true, true, IndexedColors.GREY_25_PERCENT);
// 合并L5到N6的单元格，并设置样式（无背景色，只有边框和内容居中）
mergeAndStyleCells2(sheet,row7, new CellRangeAddress(6, 7, 11, 13), detailMap.get("supplierName"), true, false, null);
Row row9 = sheet.getRow(8);
// 合并A7到B8的单元格，并设置样式和内容
mergeAndStyleCells2(sheet,row9, new CellRangeAddress(8, 9, 0, 1), "供应编码", true, true, IndexedColors.GREY_25_PERCENT);
// 合并C5到D6的单元格，并设置样式（无背景色，只有边框和内容居中）
mergeAndStyleCells2(sheet,row9, new CellRangeAddress(8, 9, 2, 3), detailMap.get("supplierCode"), true, false, null);
// 合并E5到F6的单元格，并设置样式和内容
mergeAndStyleCells2(sheet,row9, new CellRangeAddress(8, 9, 4, 5), "来料数量", true, true, IndexedColors.GREY_25_PERCENT);
// 合并G5到I6的单元格，并设置样式（无背景色，只有边框和内容居中）
mergeAndStyleCells2(sheet,row9, new CellRangeAddress(8, 9,6, 8), detailMap.get("quality"), true, false, null);
// 合并J5到K6的单元格，并设置样式和内容
mergeAndStyleCells2(sheet,row9, new CellRangeAddress(8, 9, 9, 10), "单位", true, true, IndexedColors.GREY_25_PERCENT);
// 合并L5到N6的单元格，并设置样式（无背景色，只有边框和内容居中）
mergeAndStyleCells2(sheet,row9, new CellRangeAddress(8, 9, 11, 13), detailMap.get("unit"), true, false, null);
Row row10 = sheet.getRow(10);
// 合并A7到B8的单元格，并设置样式和内容
mergeAndStyleCells2(sheet,row10, new CellRangeAddress(10, 11, 0, 1), "物料来源", true, true, IndexedColors.GREY_25_PERCENT);
// 合并C5到D6的单元格，并设置样式（无背景色，只有边框和内容居中）
mergeAndStyleCells2(sheet,row10, new CellRangeAddress(10, 11, 2, 3), detailMap.get("checkType"), true, false, null);
// 合并E5到F6的单元格，并设置样式和内容
mergeAndStyleCells2(sheet,row10, new CellRangeAddress(10, 11, 4, 5), "检验依据", true, true, IndexedColors.GREY_25_PERCENT);
// 合并G5到I6的单元格，并设置样式（无背景色，只有边框和内容居中）
mergeAndStyleCells2(sheet,row10, new CellRangeAddress(10, 11,6, 8), detailMap.get("standardNo"), true, false, null);
// 合并J5到K6的单元格，并设置样式和内容
mergeAndStyleCells2(sheet,row10, new CellRangeAddress(10, 11, 9, 10), "报检日期", true, true, IndexedColors.GREY_25_PERCENT);
// 合并L5到N6的单元格，并设置样式（无背景色，只有边框和内容居中）
mergeAndStyleCells2(sheet,row10, new CellRangeAddress(10, 11, 11, 13), detailMap.get("incomeTime"), true, false, null);
/**上下表格2**/
Row row12 = sheet.getRow(12);
if (row12 == null) {row12 = sheet.createRow(12);}
Cell cellA13 = row12.createCell(0);
cellA13.setCellValue("序号");
cellA13.setCellStyle(getRowStyle(sheet));
mergeAndStyleCells(sheet, new CellRangeAddress(12, 12, 1, 4), "检验项目");
mergeAndStyleCells(sheet, new CellRangeAddress(12, 12, 5, 8), "标准要求");
mergeAndStyleCells(sheet, new CellRangeAddress(12, 12, 9, 10), "实测结果");
Cell cellL13 = row12.createCell(11);
cellL13.setCellValue("判定");
cellL13.setCellStyle(getRowStyle(sheet));
mergeAndStyleCells(sheet, new CellRangeAddress(12, 12, 12, 13), "附件");
//将data中的值填充到excel
int rowNum = 13;
if(!CollectionUtils.isEmpty(data)){
Iterator<T> iterator = data.iterator();
//遍历数据
for (;iterator.hasNext();){
T obj = iterator.next();//获取当前行对应的数据
JSONObject jsonObject = JSONObject.parseObject(JSONObject.toJSONString(obj));
Row dataRow = sheet.getRow(rowNum);//创建行
// 假设使用了默认字体和字符宽度来计算行高（这是一个简化的示例）
int cellHeight = (int) (cell.getStringCellValue().length() * 6); // 每个字符大约15个单位高度
dataRow.setHeightInPoints(Math.max(dataRow.getHeightInPoints(), cellHeight));
Cell cellData0 = dataRow.getCell(0);
cellData0.setCellValue(rowNum-12);
cellData0.setCellStyle(getDataStyle(sheet));
Cell cellData1 = dataRow.getCell(1);
cellData1.setCellValue(getValue(jsonObject.get(excelCol.get(0).getField())));
cellData1.setCellStyle(getDataStyle(sheet));
Cell cellData2 = dataRow.getCell(5);
cellData2.setCellValue(getValue(jsonObject.get(excelCol.get(1).getField())));
cellData2.setCellStyle(getDataStyle(sheet));
sheet.addMergedRegion(new CellRangeAddress(rowNum, rowNum, 5, 8));
Cell cellData3 = dataRow.getCell(9);
cellData3.setCellValue(getValue(jsonObject.get(excelCol.get(2).getField())));
cellData3.setCellStyle(getDataStyle(sheet));
sheet.addMergedRegion(new CellRangeAddress(rowNum, rowNum, 9, 10));
Cell cellData4 = dataRow.getCell(11);
cellData4.setCellValue(getValue(jsonObject.get(excelCol.get(3).getField())));
cellData4.setCellStyle(getDataStyle(sheet));
Cell cellData5 = dataRow.getCell(12);
cellData5.setCellValue(getValue(jsonObject.get(excelCol.get(4).getField())));
cellData5.setCellStyle(getDataStyle(sheet));
sheet.addMergedRegion(new CellRangeAddress(rowNum, rowNum, 12, 13));
iterator.remove();
rowNum++;
}
}
// 指定要检查的列索引（例如，B列的索引是1）
int columnIndex = 1;
// 遍历所有行，从第二行开始（索引1），因为第一行可能是标题行
for (int rowIndex = 13; rowIndex <= sheet.getLastRowNum(); ) {
Row currentRow = sheet.getRow(rowIndex);
if (currentRow != null) {
Cell currentCell = currentRow.getCell(columnIndex);
if (currentCell != null && currentCell.getCellType() == CellType.STRING) { // 假设我们处理字符串类型的单元格
String currentValue = currentCell.getStringCellValue();
// 查找连续相同值的行
int lastRowIndex = rowIndex;
while (lastRowIndex + 1 <= sheet.getLastRowNum()) {
Row nextRow = sheet.getRow(lastRowIndex + 1);
if (nextRow != null) {
Cell nextCell = nextRow.getCell(columnIndex);
if (nextCell != null && nextCell.getCellType() == CellType.STRING &&
nextCell.getStringCellValue().equals(currentValue)) {
lastRowIndex++; // 继续向下查找
} else {
break; // 找到不同值，停止查找
}
} else {
break; // 没有更多行，停止查找
}
}
// 合并找到的行
if (rowIndex != lastRowIndex) { // 只有在找到连续相同值的行时才进行合并
sheet.addMergedRegion(new CellRangeAddress(rowIndex, lastRowIndex, 1, 4));
}else{
sheet.addMergedRegion(new CellRangeAddress(rowIndex, rowIndex, 1, 4));
}
// 更新rowIndex以跳过已合并的行
rowIndex = lastRowIndex + 1; // 从下一个未合并的行开始继续遍历
} else {
// 如果当前单元格不是字符串类型，则直接跳到下一行
rowIndex++;
}
} else {
// 如果当前行为空，则直接跳到下一行
rowIndex++;
}
}
Row rowEnd1 = sheet.createRow(rowNum+2);
mergeAndStyleCellsNoBorder(sheet,rowEnd1, new CellRangeAddress(rowNum+2, rowNum+3, 0, 1), "综合检验结论", true, true, IndexedColors.GREY_25_PERCENT);
mergeAndStyleCellsNoBorder(sheet,rowEnd1, new CellRangeAddress(rowNum+2, rowNum+3, 2, 3), detailMap.get("checkResult"), true, false, null);
mergeAndStyleCellsNoBorder(sheet,rowEnd1, new CellRangeAddress(rowNum+2, rowNum+3, 5, 10), "备注:判定合格打“√”，不合格打“×”", true, true, null);
Row rowEnd2 = sheet.createRow(rowNum+5);
mergeAndStyleCellsNoBorder(sheet,rowEnd2, new CellRangeAddress(rowNum+5, rowNum+5, 0, 1), "品管经理/主任", true, true, IndexedColors.GREY_25_PERCENT);
mergeAndStyleCellsNoBorder(sheet,rowEnd2, new CellRangeAddress(rowNum+5, rowNum+5, 2, 3), "", true, false, null);
mergeAndStyleCellsNoBorder(sheet,rowEnd2, new CellRangeAddress(rowNum+5, rowNum+5, 5, 6), "品质主管", true, true, IndexedColors.GREY_25_PERCENT);
mergeAndStyleCellsNoBorder(sheet,rowEnd2, new CellRangeAddress(rowNum+5, rowNum+5, 7, 8), "", true, false, null);
mergeAndStyleCellsNoBorder(sheet,rowEnd2, new CellRangeAddress(rowNum+5, rowNum+5, 10, 11), "品管员", true, true, IndexedColors.GREY_25_PERCENT);
mergeAndStyleCellsNoBorder(sheet,rowEnd2, new CellRangeAddress(rowNum+5, rowNum+5, 12, 13), detailMap.get("checkManName"), true, false, null);
return workbook;
}
// //标题样式
// public static CellStyle getHeaderFont(Workbook workbook){
// Font font = workbook.createFont();
// font.setFontHeightInPoints((short) 15);//字体大小
// font.setBold(true);//加粗
// CellStyle cellStyle = workbook.createCellStyle();
// cellStyle.setFont(font);
// cellStyle.setAlignment(HorizontalAlignment.CENTER_SELECTION);//设置水平居中
// cellStyle.setVerticalAlignment(VerticalAlignment.CENTER);//设置垂直居中
// // 设置上边框
// cellStyle.setBorderTop(BorderStyle.THIN);
// // 设置下边框
// cellStyle.setBorderBottom(BorderStyle.THIN);
// // 设置左边框
// cellStyle.setBorderLeft(BorderStyle.THIN);
// // 设置右边框
// cellStyle.setBorderRight(BorderStyle.THIN);
// cellStyle.setFillBackgroundColor(IndexedColors.AQUA.getIndex());
//
// return cellStyle;
// }
// //内容样式
// public static CellStyle getDataFont(Workbook workbook){
// Font font = workbook.createFont();
// font.setFontHeightInPoints((short) 12);//字体大小
// font.setBold(false);//不加粗
// CellStyle cellStyle = workbook.createCellStyle();
// cellStyle.setFont(font);
// cellStyle.setAlignment(HorizontalAlignment.CENTER_SELECTION);//设置水平居中
// cellStyle.setVerticalAlignment(VerticalAlignment.CENTER);//设置垂直居中
// cellStyle.setWrapText(true);//设置单元格内容自动换行
// return cellStyle;
// }
//
//处理数据
public static String getValue(Object object){
if (object==null){
return "";
}else {
return object.toString();
}
}
// //处理数据
// public static Integer getValueNum(Object object){
// if (object==null){
// return 0;
// }else {
// return Integer.parseInt(object.toString());
// }
// }
// 从resources目录获取图片的字节数组
private static byte[] getImageBytesFromResources(String resourceName) {
try (InputStream inputStream = ExcelReportMapUtil.class.getClassLoader().getResourceAsStream(resourceName);
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream()) {
if (inputStream == null) {
throw new RuntimeException("找不到资源: " + resourceName);
}
IOUtils.copy(inputStream, byteArrayOutputStream);
return byteArrayOutputStream.toByteArray();
} catch (IOException e) {
throw new RuntimeException("读取资源时出错: " + resourceName, e);
}
}
//报告大标题样式-1
public static CellStyle getTitelStyle(Workbook workbook){
Font font = workbook.createFont();
// 设置字体为加粗
font.setBold(true);
// 设置字体大小（例如，设置为16）
font.setFontHeightInPoints((short) 24);
CellStyle cellStyle = workbook.createCellStyle();
cellStyle.setFont(font);
cellStyle.setAlignment(HorizontalAlignment.CENTER_SELECTION);//设置水平居中
cellStyle.setVerticalAlignment(VerticalAlignment.CENTER);//设置垂直居中
cellStyle.setWrapText(true);//设置单元格内容自动换行
return cellStyle;
}
public static CellStyle getRowStyle(Sheet sheet){
CellStyle style = sheet.getWorkbook().createCellStyle();
// 设置边框线
style.setBorderBottom(BorderStyle.THIN);
style.setBorderLeft(BorderStyle.THIN);
style.setBorderRight(BorderStyle.THIN);
style.setBorderTop(BorderStyle.THIN);
// 设置水平居中
style.setAlignment(HorizontalAlignment.CENTER);
style.setWrapText(true);//设置单元格内容自动换行
// 设置垂直居中
style.setVerticalAlignment(VerticalAlignment.CENTER);
Font font = sheet.getWorkbook().createFont();
font.setBold(true);
// 设置字体大小（例如，设置为14）
font.setFontHeightInPoints((short) 14);
style.setFont(font);
return style;
}
public static CellStyle getDataStyle(Sheet sheet){
CellStyle style = sheet.getWorkbook().createCellStyle();
// 设置边框线
style.setBorderBottom(BorderStyle.THIN);
style.setBorderLeft(BorderStyle.THIN);
style.setBorderRight(BorderStyle.THIN);
style.setBorderTop(BorderStyle.THIN);
Font font = sheet.getWorkbook().createFont();
// 设置字体大小（例如，设置为14）
font.setFontHeightInPoints((short) 14);
style.setFont(font);
style.setWrapText(true);//设置单元格内容自动换行
// 设置水平居中
style.setAlignment(HorizontalAlignment.LEFT);
// 设置垂直居中
style.setVerticalAlignment(VerticalAlignment.CENTER);
return style;
}
private static void mergeAndStyleCells(Sheet sheet, CellRangeAddress cellRangeAddress, String cellValue) {
// 合并单元格
sheet.addMergedRegion(cellRangeAddress);
// 创建一个单元格样式
CellStyle style = sheet.getWorkbook().createCellStyle();
// 设置字体为加粗
Font font = sheet.getWorkbook().createFont();
font.setBold(true);
// 设置字体大小（例如，设置为14）
font.setFontHeightInPoints((short) 14);
style.setFont(font);
// 设置水平居中
style.setAlignment(HorizontalAlignment.CENTER);
// 设置垂直居中
style.setVerticalAlignment(VerticalAlignment.CENTER);
style.setWrapText(true);//设置单元格内容自动换行
// 获取合并后的单元格的第一个单元格，并设置值
Row row = sheet.getRow(cellRangeAddress.getFirstRow());
if (row == null) {
row = sheet.createRow(cellRangeAddress.getFirstRow());
}
Cell cell = row.getCell(cellRangeAddress.getFirstColumn());
if (cell == null) {
cell = row.createCell(cellRangeAddress.getFirstColumn());
}
cell.setCellValue(cellValue); // 设置单元格的值
cell.setCellStyle(style); // 应用样式到单元格
}
private static void mergeAndStyleCells2(Sheet sheet,Row row, CellRangeAddress cellRangeAddress, String cellValue, boolean centered, boolean hasBackground, IndexedColors backgroundColor) {
// 合并单元格
sheet.addMergedRegion(cellRangeAddress);
// 创建一个单元格样式
CellStyle style = sheet.getWorkbook().createCellStyle();
// 设置字体居中
if (centered) {
style.setAlignment(HorizontalAlignment.CENTER);
style.setVerticalAlignment(VerticalAlignment.CENTER);
}
// 设置背景颜色（如果有）
if (hasBackground && backgroundColor != null) {
style.setFillForegroundColor(backgroundColor.getIndex());
style.setFillPattern(FillPatternType.SOLID_FOREGROUND);
}
// 设置边框线
style.setBorderBottom(BorderStyle.THIN);
style.setBorderLeft(BorderStyle.THIN);
style.setBorderRight(BorderStyle.THIN);
style.setBorderTop(BorderStyle.THIN);
// 获取合并后的单元格的第一个单元格，并设置值
Cell cell = row.getCell(cellRangeAddress.getFirstColumn());
if (cell == null) {
cell = row.createCell(cellRangeAddress.getFirstColumn());
}
cell.setCellValue(cellValue); // 设置单元格的值
cell.setCellStyle(style); // 应用样式到单元格
}
private static void mergeAndStyleCellsNoBorder(Sheet sheet,Row row, CellRangeAddress cellRangeAddress, String cellValue, boolean centered, boolean hasBackground, IndexedColors backgroundColor) {
// 合并单元格
sheet.addMergedRegion(cellRangeAddress);
// 创建一个单元格样式
CellStyle style = sheet.getWorkbook().createCellStyle();
// 设置字体居中
if (centered) {
style.setAlignment(HorizontalAlignment.CENTER);
style.setVerticalAlignment(VerticalAlignment.CENTER);
}
// 设置背景颜色（如果有）
if (hasBackground && backgroundColor != null) {
style.setFillForegroundColor(backgroundColor.getIndex());
style.setFillPattern(FillPatternType.SOLID_FOREGROUND);
}
// 获取合并后的单元格的第一个单元格，并设置值
Cell cell = row.getCell(cellRangeAddress.getFirstColumn());
if (cell == null) {
cell = row.createCell(cellRangeAddress.getFirstColumn());
}
cell.setCellValue(cellValue); // 设置单元格的值
cell.setCellStyle(style); // 应用样式到单元格
}
}

515
op-common/op-common-core/src/main/java/com/op/common/core/utils/poi/ExcelSCReportMapUtil.java
Unescape Escape View File

@ -0,0 +1,515 @@
package com.op.common.core.utils.poi;
import com.alibaba.fastjson2.JSONObject;
import com.op.common.core.domain.ExcelCol;
import org.apache.commons.compress.utils.IOUtils;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.ss.util.CellRangeAddress;
import org.apache.poi.xssf.streaming.SXSSFWorkbook;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
/**
* Excel导出报告相关处理
*
* @author OP
*/
public class ExcelSCReportMapUtil {
//下载
public static <T> SXSSFWorkbook initWorkbook(String sheetName , String title, List<ExcelCol> excelCol , List<T> data, Map<String,String> detailMap,List<byte[]> bytes) throws IOException {
SXSSFWorkbook workbook = new SXSSFWorkbook();
int colSize = excelCol.size();
//创建Sheet（工作簿）
Sheet sheet = null;
if (!StringUtils.hasText(sheetName)){
sheet = workbook.createSheet();
}else{
sheet = workbook.createSheet(sheetName);
}
// 从resources目录获取图片字节数组
byte[] imageBytes = getImageBytesFromResources("image/logo.png");
/**logo**/
int pictureIdx = workbook.addPicture(imageBytes, Workbook.PICTURE_TYPE_PNG);
CreationHelper helper = workbook.getCreationHelper();
Drawing<?> drawing = sheet.createDrawingPatriarch();
ClientAnchor anchor = helper.createClientAnchor();
anchor.setCol1(0); // B列
anchor.setRow1(0); // 第2行（Excel的行和列都是从0开始计数的）
anchor.setCol2(1); // C列（图片宽度跨越的列数，这里设置为1列宽）
anchor.setRow2(2); // 第6行（图片高度跨越的行数，这里设置为4行高，可以根据图片大小调整）
Picture pict = drawing.createPicture(anchor, pictureIdx);
pict.resize(); // 根据图片的实际大小调整图片在Excel中的显示大小
/**报告标题**/
sheet.addMergedRegion(new CellRangeAddress(0, 1, 2, 11));
// 获取合并后的单元格的第一个单元格（即C1），并设置值
Row row1 = sheet.getRow(0); // 获取第1行（索引为0）
if (row1 == null) {row1 = sheet.createRow(0); // 如果第1行不存在，则创建它
}
Cell cell = row1.getCell(2); // 获取C列（索引为2）的单元格
if (cell == null) {
cell = row1.createCell(2); // 如果C列的单元格不存在，则创建它
}
cell.setCellValue("中山榄菊日化实业有限公司"); // 设置单元格的值
cell.setCellStyle(getTitelStyle(workbook)); // 应用样式到单元格
/**报告二级标题、检验标准**/
// 合并C3到I4的单元格，并设置样式
mergeAndStyleCells(sheet, new CellRangeAddress(2, 3, 2, 8), detailMap.get("title"));
// 合并J3到L4的单元格，并设置样式
mergeAndStyleCells(sheet, new CellRangeAddress(2, 3, 9, 12), "编码"+detailMap.get("standardNo"));
/**左右表格1**/
//画边框
for(int r5=4;r5<11;r5++){
Row row05 = sheet.getRow(r5);
if (row05 == null) {row05 = sheet.createRow(r5);}
for (int col = 0; col < 14; col++) {
Cell cell1 = row05.createCell(col);
cell1.setCellStyle(getRowStyle(sheet));
}
}
for(int d5=11;d5<(11+data.size());d5++){
Row row05 = sheet.getRow(d5);
if (row05 == null) {row05 = sheet.createRow(d5);}
for (int col = 0; col < 14; col++) {
Cell cell1 = row05.createCell(col);
cell1.setCellStyle(getDataStyle(sheet));
}
}
Row row5 = sheet.getRow(4);
// 合并A5到B6的单元格，并设置样式和内容
mergeAndStyleCells2(sheet,row5, new CellRangeAddress(4, 5, 0, 1), "产品名称/生产组", true, true, IndexedColors.GREY_25_PERCENT);
// 合并C5到D6的单元格，并设置样式（无背景色，只有边框和内容居中）
mergeAndStyleCells2(sheet,row5, new CellRangeAddress(4, 5, 2, 8), detailMap.get("materialName")+"/"+detailMap.get("checkLoc"), true, false, null);
// 合并J5到K6的单元格，并设置样式和内容
mergeAndStyleCells2(sheet,row5, new CellRangeAddress(4, 5, 9, 10), "产品编码", true, true, IndexedColors.GREY_25_PERCENT);
// 合并L5到N6的单元格，并设置样式（无背景色，只有边框和内容居中）
mergeAndStyleCells2(sheet,row5, new CellRangeAddress(4, 5, 11, 13), detailMap.get("materialCode"), true, false, null);
Row row7 = sheet.getRow(6);
// 合并A7到B8的单元格，并设置样式和内容
mergeAndStyleCells2(sheet,row7, new CellRangeAddress(6, 7, 0, 1), "首检时间", true, true, IndexedColors.GREY_25_PERCENT);
// 合并C5到D6的单元格，并设置样式（无背景色，只有边框和内容居中）
mergeAndStyleCells2(sheet,row7, new CellRangeAddress(6, 7, 2, 3), detailMap.get("incomeTime"), true, false, null);
// 合并E5到F6的单元格，并设置样式和内容
mergeAndStyleCells2(sheet,row7, new CellRangeAddress(6, 7, 4, 5), "生产批次", true, true, IndexedColors.GREY_25_PERCENT);
// 合并G5到I6的单元格，并设置样式（无背景色，只有边框和内容居中）
mergeAndStyleCells2(sheet,row7, new CellRangeAddress(6, 7, 6, 13), detailMap.get("incomeBatchNo"), true, false, null);
// 合并J5到K6的单元格，并设置样式和内容
Row row9 = sheet.getRow(8);
// 合并A7到B8的单元格，并设置样式和内容
mergeAndStyleCells2(sheet,row9, new CellRangeAddress(8, 9, 0, 1), "首检原因", true, true, IndexedColors.GREY_25_PERCENT);
// 合并C5到D6的单元格，并设置样式（无背景色，只有边框和内容居中）
mergeAndStyleCells2(sheet,row9, new CellRangeAddress(8, 9, 2, 13), detailMap.get("reason"), true, false, null);
/**上下表格2**///-------------------------------------------------
Row row10 = sheet.getRow(10);
if (row10 == null) {row10 = sheet.createRow(10);}
Cell cellA13 = row10.createCell(0);
cellA13.setCellValue("序号");
cellA13.setCellStyle(getRowStyle(sheet));
mergeAndStyleCells(sheet, new CellRangeAddress(10, 10, 1, 4), "检验项目");
mergeAndStyleCells(sheet, new CellRangeAddress(10, 10, 5, 8), "内容");
mergeAndStyleCells(sheet, new CellRangeAddress(10, 10, 9, 10), "实测结果");
Cell cellL13 = row10.createCell(11);
cellL13.setCellValue("判定");
cellL13.setCellStyle(getRowStyle(sheet));
mergeAndStyleCells(sheet, new CellRangeAddress(10, 10, 12, 13), "附件");
//将data中的值填充到excel
int rowNum = 11;
if(!CollectionUtils.isEmpty(data)){
Iterator<T> iterator = data.iterator();
//遍历数据
for (;iterator.hasNext();){
T obj = iterator.next();//获取当前行对应的数据
JSONObject jsonObject = JSONObject.parseObject(JSONObject.toJSONString(obj));
Row dataRow = sheet.getRow(rowNum);//创建行
// 假设使用了默认字体和字符宽度来计算行高（这是一个简化的示例）
int cellHeight = (int) (cell.getStringCellValue().length() * 6); // 每个字符大约15个单位高度
dataRow.setHeightInPoints(Math.max(dataRow.getHeightInPoints(), cellHeight));
Cell cellData0 = dataRow.getCell(0);
cellData0.setCellValue(rowNum-10);
cellData0.setCellStyle(getDataStyle(sheet));
Cell cellData1 = dataRow.getCell(1);
cellData1.setCellValue(getValue(jsonObject.get(excelCol.get(0).getField())));
cellData1.setCellStyle(getDataStyle(sheet));
Cell cellData2 = dataRow.getCell(5);
cellData2.setCellValue(getValue(jsonObject.get(excelCol.get(1).getField())));
cellData2.setCellStyle(getDataStyle(sheet));
sheet.addMergedRegion(new CellRangeAddress(rowNum, rowNum, 5, 8));
Cell cellData3 = dataRow.getCell(9);
cellData3.setCellValue(getValue(jsonObject.get(excelCol.get(2).getField())));
cellData3.setCellStyle(getDataStyle(sheet));
sheet.addMergedRegion(new CellRangeAddress(rowNum, rowNum, 9, 10));
Cell cellData4 = dataRow.getCell(11);
cellData4.setCellValue(getValue(jsonObject.get(excelCol.get(3).getField())));
cellData4.setCellStyle(getDataStyle(sheet));
//Cell cellData5 = dataRow.getCell(12);
//cellData5.setCellValue(getValue(jsonObject.get(excelCol.get(4).getField())));
//cellData5.setCellStyle(getDataStyle(sheet));
//sheet.addMergedRegion(new CellRangeAddress(rowNum, rowNum, 12, 13));
// 下载图片
byte[] imageFileBytes = bytes.get(rowNum-11);
if (imageFileBytes != null) {
// 将图片添加到工作簿中
int picIdx = workbook.addPicture(imageFileBytes, Workbook.PICTURE_TYPE_JPEG); // 假设图片是JPEG格式，根据实际情况调整
// 创建绘图对象和锚点
CreationHelper fhelper = workbook.getCreationHelper();
Drawing<?> fdrawing = sheet.createDrawingPatriarch();
ClientAnchor fanchor = fhelper.createClientAnchor();
fanchor.setCol1(12); // 列索引从0开始，1表示第二列（B列）
fanchor.setRow1(rowNum); // 行索引从0开始，1表示第二行
fanchor.setCol2(14); // 14-12是列数
fanchor.setRow2(rowNum+1); //
// 插入图片到指定位置
Picture fpict =fdrawing.createPicture(fanchor, picIdx);
//fpict.resize(); // 根据图片的实际大小调整图片在Excel中的显示大小
}
iterator.remove();
rowNum++;
}
}
// 指定要检查的列索引（例如，B列的索引是1）
int columnIndex = 1;
// 遍历所有行，从第二行开始（索引1），因为第一行可能是标题行
for (int rowIndex = 11; rowIndex <= sheet.getLastRowNum(); ) {
Row currentRow = sheet.getRow(rowIndex);
if (currentRow != null) {
Cell currentCell = currentRow.getCell(columnIndex);
if (currentCell != null && currentCell.getCellType() == CellType.STRING) { // 假设我们处理字符串类型的单元格
String currentValue = currentCell.getStringCellValue();
// 查找连续相同值的行
int lastRowIndex = rowIndex;
while (lastRowIndex + 1 <= sheet.getLastRowNum()) {
Row nextRow = sheet.getRow(lastRowIndex + 1);
if (nextRow != null) {
Cell nextCell = nextRow.getCell(columnIndex);
if (nextCell != null && nextCell.getCellType() == CellType.STRING &&
nextCell.getStringCellValue().equals(currentValue)) {
lastRowIndex++; // 继续向下查找
} else {
break; // 找到不同值，停止查找
}
} else {
break; // 没有更多行，停止查找
}
}
// 合并找到的行
if (rowIndex != lastRowIndex) { // 只有在找到连续相同值的行时才进行合并
sheet.addMergedRegion(new CellRangeAddress(rowIndex, lastRowIndex, 1, 4));
}else{
sheet.addMergedRegion(new CellRangeAddress(rowIndex, rowIndex, 1, 4));
}
// 更新rowIndex以跳过已合并的行
rowIndex = lastRowIndex + 1; // 从下一个未合并的行开始继续遍历
} else {
// 如果当前单元格不是字符串类型，则直接跳到下一行
rowIndex++;
}
} else {
// 如果当前行为空，则直接跳到下一行
rowIndex++;
}
}
Row rowEnd0 = sheet.createRow(rowNum);
mergeAndStyleCellsNoBorder(sheet,rowEnd0, new CellRangeAddress(rowNum, rowNum+1, 0, 1), "备注", true, true, IndexedColors.GREY_25_PERCENT);
mergeAndStyleCellsNoBorder(sheet,rowEnd0, new CellRangeAddress(rowNum, rowNum+1, 2, 13), detailMap.get("remark"), true, true,null);
Row rowEnd1 = sheet.createRow(rowNum+2);
mergeAndStyleCellsNoBorder(sheet,rowEnd1, new CellRangeAddress(rowNum+2, rowNum+3, 0, 1), "综合检验结论", true, true, IndexedColors.GREY_25_PERCENT);
mergeAndStyleCellsNoBorder(sheet,rowEnd1, new CellRangeAddress(rowNum+2, rowNum+3, 2, 3), detailMap.get("checkResult"), true, false, null);
mergeAndStyleCellsNoBorder(sheet,rowEnd1, new CellRangeAddress(rowNum+2, rowNum+3, 5, 10), "备注:判定合格打“√”，不合格打“×”", true, true, null);
Row rowEnd2 = sheet.createRow(rowNum+5);
mergeAndStyleCellsNoBorder(sheet,rowEnd2, new CellRangeAddress(rowNum+5, rowNum+5, 0, 1), "车间组长/机管员签名", true, true, IndexedColors.GREY_25_PERCENT);
// 下载图片
int signNum = bytes.size()-3;
byte[] imageFileBytes1 = bytes.get(signNum);
if (imageFileBytes1 != null) {
// 将图片添加到工作簿中
int picIdx = workbook.addPicture(imageFileBytes1, Workbook.PICTURE_TYPE_JPEG); // 假设图片是JPEG格式，根据实际情况调整
// 创建绘图对象和锚点
CreationHelper fhelper = workbook.getCreationHelper();
Drawing<?> fdrawing = sheet.createDrawingPatriarch();
ClientAnchor fanchor = fhelper.createClientAnchor();
fanchor.setCol1(2); // 列索引从0开始，1表示第二列（B列）
fanchor.setRow1(rowNum+5); // 行索引从0开始，1表示第二行
fanchor.setCol2(5); // 14-12是列数
fanchor.setRow2(rowNum+7); //
// 插入图片到指定位置
Picture fpict =fdrawing.createPicture(fanchor, picIdx);
//fpict.resize(); // 根据图片的实际大小调整图片在Excel中的显示大小
}
// 下载图片
byte[] imageFileBytes2 = bytes.get(signNum+1);
if (imageFileBytes2 != null) {
// 将图片添加到工作簿中
int picIdx = workbook.addPicture(imageFileBytes2, Workbook.PICTURE_TYPE_JPEG); // 假设图片是JPEG格式，根据实际情况调整
// 创建绘图对象和锚点
CreationHelper fhelper = workbook.getCreationHelper();
Drawing<?> fdrawing = sheet.createDrawingPatriarch();
ClientAnchor fanchor = fhelper.createClientAnchor();
fanchor.setCol1(6); // 列索引从0开始，1表示第二列（B列）
fanchor.setRow1(rowNum+5); // 行索引从0开始，1表示第二行
fanchor.setCol2(9); // 14-12是列数
fanchor.setRow2(rowNum+7); //
// 插入图片到指定位置
Picture fpict =fdrawing.createPicture(fanchor, picIdx);
//fpict.resize(); // 根据图片的实际大小调整图片在Excel中的显示大小
}
Row rowEnd3 = sheet.createRow(rowNum+8);
mergeAndStyleCellsNoBorder(sheet,rowEnd3, new CellRangeAddress(rowNum+8, rowNum+8, 0, 1), "质量管理部品管员签名", true, true, IndexedColors.GREY_25_PERCENT);
// 下载图片
byte[] imageFileBytes3 = bytes.get(signNum+2);
if (imageFileBytes3 != null) {
// 将图片添加到工作簿中
int picIdx = workbook.addPicture(imageFileBytes3, Workbook.PICTURE_TYPE_JPEG); // 假设图片是JPEG格式，根据实际情况调整
// 创建绘图对象和锚点
CreationHelper fhelper = workbook.getCreationHelper();
Drawing<?> fdrawing = sheet.createDrawingPatriarch();
ClientAnchor fanchor = fhelper.createClientAnchor();
fanchor.setCol1(2); // 列索引从0开始，1表示第二列（B列）
fanchor.setRow1(rowNum+8); // 行索引从0开始，1表示第二行
fanchor.setCol2(5); // 14-12是列数
fanchor.setRow2(rowNum+10); //
// 插入图片到指定位置
Picture fpict =fdrawing.createPicture(fanchor, picIdx);
//fpict.resize(); // 根据图片的实际大小调整图片在Excel中的显示大小
}
return workbook;
}
// //标题样式
// public static CellStyle getHeaderFont(Workbook workbook){
// Font font = workbook.createFont();
// font.setFontHeightInPoints((short) 15);//字体大小
// font.setBold(true);//加粗
// CellStyle cellStyle = workbook.createCellStyle();
// cellStyle.setFont(font);
// cellStyle.setAlignment(HorizontalAlignment.CENTER_SELECTION);//设置水平居中
// cellStyle.setVerticalAlignment(VerticalAlignment.CENTER);//设置垂直居中
// // 设置上边框
// cellStyle.setBorderTop(BorderStyle.THIN);
// // 设置下边框
// cellStyle.setBorderBottom(BorderStyle.THIN);
// // 设置左边框
// cellStyle.setBorderLeft(BorderStyle.THIN);
// // 设置右边框
// cellStyle.setBorderRight(BorderStyle.THIN);
// cellStyle.setFillBackgroundColor(IndexedColors.AQUA.getIndex());
//
// return cellStyle;
// }
// //内容样式
// public static CellStyle getDataFont(Workbook workbook){
// Font font = workbook.createFont();
// font.setFontHeightInPoints((short) 12);//字体大小
// font.setBold(false);//不加粗
// CellStyle cellStyle = workbook.createCellStyle();
// cellStyle.setFont(font);
// cellStyle.setAlignment(HorizontalAlignment.CENTER_SELECTION);//设置水平居中
// cellStyle.setVerticalAlignment(VerticalAlignment.CENTER);//设置垂直居中
// cellStyle.setWrapText(true);//设置单元格内容自动换行
// return cellStyle;
// }
//
//处理数据
public static String getValue(Object object){
if (object==null){
return "";
}else {
return object.toString();
}
}
// //处理数据
// public static Integer getValueNum(Object object){
// if (object==null){
// return 0;
// }else {
// return Integer.parseInt(object.toString());
// }
// }
// 从resources目录获取图片的字节数组
private static byte[] getImageBytesFromResources(String resourceName) {
try (InputStream inputStream = ExcelSCReportMapUtil.class.getClassLoader().getResourceAsStream(resourceName);
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream()) {
if (inputStream == null) {
throw new RuntimeException("找不到资源: " + resourceName);
}
IOUtils.copy(inputStream, byteArrayOutputStream);
return byteArrayOutputStream.toByteArray();
} catch (IOException e) {
throw new RuntimeException("读取资源时出错: " + resourceName, e);
}
}
//报告大标题样式-1
public static CellStyle getTitelStyle(Workbook workbook){
Font font = workbook.createFont();
// 设置字体为加粗
font.setBold(true);
// 设置字体大小（例如，设置为16）
font.setFontHeightInPoints((short) 24);
CellStyle cellStyle = workbook.createCellStyle();
cellStyle.setFont(font);
cellStyle.setAlignment(HorizontalAlignment.CENTER_SELECTION);//设置水平居中
cellStyle.setVerticalAlignment(VerticalAlignment.CENTER);//设置垂直居中
cellStyle.setWrapText(true);//设置单元格内容自动换行
return cellStyle;
}
public static CellStyle getRowStyle(Sheet sheet){
CellStyle style = sheet.getWorkbook().createCellStyle();
// 设置边框线
style.setBorderBottom(BorderStyle.THIN);
style.setBorderLeft(BorderStyle.THIN);
style.setBorderRight(BorderStyle.THIN);
style.setBorderTop(BorderStyle.THIN);
// 设置水平居中
style.setAlignment(HorizontalAlignment.CENTER);
style.setWrapText(true);//设置单元格内容自动换行
// 设置垂直居中
style.setVerticalAlignment(VerticalAlignment.CENTER);
Font font = sheet.getWorkbook().createFont();
font.setBold(true);
// 设置字体大小（例如，设置为14）
font.setFontHeightInPoints((short) 14);
style.setFont(font);
return style;
}
public static CellStyle getDataStyle(Sheet sheet){
CellStyle style = sheet.getWorkbook().createCellStyle();
// 设置边框线
style.setBorderBottom(BorderStyle.THIN);
style.setBorderLeft(BorderStyle.THIN);
style.setBorderRight(BorderStyle.THIN);
style.setBorderTop(BorderStyle.THIN);
Font font = sheet.getWorkbook().createFont();
// 设置字体大小（例如，设置为14）
font.setFontHeightInPoints((short) 14);
style.setFont(font);
style.setWrapText(true);//设置单元格内容自动换行
// 设置水平居中
style.setAlignment(HorizontalAlignment.LEFT);
// 设置垂直居中
style.setVerticalAlignment(VerticalAlignment.CENTER);
return style;
}
private static void mergeAndStyleCells(Sheet sheet, CellRangeAddress cellRangeAddress, String cellValue) {
// 合并单元格
sheet.addMergedRegion(cellRangeAddress);
// 创建一个单元格样式
CellStyle style = sheet.getWorkbook().createCellStyle();
// 设置字体为加粗
Font font = sheet.getWorkbook().createFont();
font.setBold(true);
// 设置字体大小（例如，设置为14）
font.setFontHeightInPoints((short) 14);
style.setFont(font);
// 设置水平居中
style.setAlignment(HorizontalAlignment.CENTER);
// 设置垂直居中
style.setVerticalAlignment(VerticalAlignment.CENTER);
style.setWrapText(true);//设置单元格内容自动换行
// 获取合并后的单元格的第一个单元格，并设置值
Row row = sheet.getRow(cellRangeAddress.getFirstRow());
if (row == null) {
row = sheet.createRow(cellRangeAddress.getFirstRow());
}
Cell cell = row.getCell(cellRangeAddress.getFirstColumn());
if (cell == null) {
cell = row.createCell(cellRangeAddress.getFirstColumn());
}
cell.setCellValue(cellValue); // 设置单元格的值
cell.setCellStyle(style); // 应用样式到单元格
}
private static void mergeAndStyleCells2(Sheet sheet,Row row, CellRangeAddress cellRangeAddress, String cellValue, boolean centered, boolean hasBackground, IndexedColors backgroundColor) {
// 合并单元格
sheet.addMergedRegion(cellRangeAddress);
// 创建一个单元格样式
CellStyle style = sheet.getWorkbook().createCellStyle();
// 设置字体居中
if (centered) {
style.setAlignment(HorizontalAlignment.CENTER);
style.setVerticalAlignment(VerticalAlignment.CENTER);
}
// 设置背景颜色（如果有）
if (hasBackground && backgroundColor != null) {
style.setFillForegroundColor(backgroundColor.getIndex());
style.setFillPattern(FillPatternType.SOLID_FOREGROUND);
}
// 设置边框线
style.setBorderBottom(BorderStyle.THIN);
style.setBorderLeft(BorderStyle.THIN);
style.setBorderRight(BorderStyle.THIN);
style.setBorderTop(BorderStyle.THIN);
// 获取合并后的单元格的第一个单元格，并设置值
Cell cell = row.getCell(cellRangeAddress.getFirstColumn());
if (cell == null) {
cell = row.createCell(cellRangeAddress.getFirstColumn());
}
cell.setCellValue(cellValue); // 设置单元格的值
cell.setCellStyle(style); // 应用样式到单元格
}
private static void mergeAndStyleCellsNoBorder(Sheet sheet,Row row, CellRangeAddress cellRangeAddress, String cellValue, boolean centered, boolean hasBackground, IndexedColors backgroundColor) {
// 合并单元格
sheet.addMergedRegion(cellRangeAddress);
// 创建一个单元格样式
CellStyle style = sheet.getWorkbook().createCellStyle();
// 设置字体居中
if (centered) {
style.setAlignment(HorizontalAlignment.CENTER);
style.setVerticalAlignment(VerticalAlignment.CENTER);
}
// 设置背景颜色（如果有）
if (hasBackground && backgroundColor != null) {
style.setFillForegroundColor(backgroundColor.getIndex());
style.setFillPattern(FillPatternType.SOLID_FOREGROUND);
}
// 获取合并后的单元格的第一个单元格，并设置值
Cell cell = row.getCell(cellRangeAddress.getFirstColumn());
if (cell == null) {
cell = row.createCell(cellRangeAddress.getFirstColumn());
}
cell.setCellValue(cellValue); // 设置单元格的值
cell.setCellStyle(style); // 应用样式到单元格
}
}

BIN
op-common/op-common-core/src/main/resources/image/logo.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 6.5 KiB

7
op-modules/op-file/src/main/java/com/op/file/controller/SysFileController.java
Unescape Escape View File

@ -14,6 +14,7 @@ import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
@ -113,6 +114,12 @@ public class SysFileController {
}
}
@PostMapping("/downLoadFileByte")
public byte[] downLoadFileByte(@RequestBody SysFile sysFile) {
byte[] io = sysFileService.imageOnline(sysFile.getUrl());
return io;
}
// 转byte[]
public static byte[] toByteArray(InputStream input) throws IOException {
ByteArrayOutputStream output = new ByteArrayOutputStream();

8
op-modules/op-mes/src/main/java/com/op/mes/controller/ProRfidProcessDetailController.java
Unescape Escape View File

@ -45,6 +45,14 @@ public class ProRfidProcessDetailController extends BaseController {
List<ProRfidProcessDetail> list = proRfidProcessDetailService.selectProRfidProcessDetailList(proRfidProcessDetail);
return getDataTable(list);
}
@RequiresPermissions("mes:detail:list")
@GetMapping("/listAll")
@Log(title = "rfid流程查看", businessType = BusinessType.QUERY)
public TableDataInfo listAll(ProRfidProcessDetail proRfidProcessDetail) {
startPage();
List<ProRfidProcessDetail> list = proRfidProcessDetailService.selectProRfidProcessDetailListAll(proRfidProcessDetail);
return getDataTable(list);
}
/**
* 导出生产rfid流程列表

2
op-modules/op-mes/src/main/java/com/op/mes/mapper/ProRfidProcessDetailMapper.java
Unescape Escape View File

@ -72,4 +72,6 @@ public interface ProRfidProcessDetailMapper {
String getEquipStatus(String machineCode);
String getEquipMode(String machineCode);
List<ProRfidProcessDetail> selectProRfidProcessDetailListAll(ProRfidProcessDetail proRfidProcessDetail);
}

2
op-modules/op-mes/src/main/java/com/op/mes/service/IProRfidProcessDetailService.java
Unescape Escape View File

@ -58,4 +58,6 @@ public interface IProRfidProcessDetailService {
* @return 结果
*/
public int deleteProRfidProcessDetailByRecordId(String recordId);
List<ProRfidProcessDetail> selectProRfidProcessDetailListAll(ProRfidProcessDetail proRfidProcessDetail);
}

3
op-modules/op-mes/src/main/java/com/op/mes/service/impl/MesReportWorkConsumeServiceImpl.java
Unescape Escape View File

@ -18,6 +18,7 @@ import com.op.system.api.domain.dto.BaseBomDTO;
import com.op.system.api.domain.mes.BaseProductDTO;
import com.op.system.api.domain.mes.BaseTeamTDTO;
import org.apache.commons.lang.StringUtils;
import org.apache.poi.util.StringUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
@ -391,7 +392,7 @@ public class MesReportWorkConsumeServiceImpl implements IMesReportWorkConsumeSer
mesReportWorkConsume.setWorkorderCode(sonWorkOrder.getWorkorderCode());
List<MesReportWorkConsume> liblist = mesReportWorkConsumeMapper.getConsumeList(mesReportWorkConsume);
for(MesReportWorkConsume lib:liblist){
lib.setQuantitySplitBom(actPro.multiply(new BigDecimal(lib.getErfmg()))
lib.setQuantitySplitBom(actPro.multiply(new BigDecimal(StringUtils.isBlank(lib.getErfmg())?"1":lib.getErfmg()))
.divide(planPro,6,BigDecimal.ROUND_HALF_UP));
}
sTabs.setLibList(liblist);

6
op-modules/op-mes/src/main/java/com/op/mes/service/impl/ProRfidProcessDetailServiceImpl.java
Unescape Escape View File

@ -94,4 +94,10 @@ public class ProRfidProcessDetailServiceImpl implements IProRfidProcessDetailSer
public int deleteProRfidProcessDetailByRecordId(String recordId) {
return proRfidProcessDetailMapper.deleteProRfidProcessDetailByRecordId(recordId);
}
@Override
@DS("#header.poolName")
public List<ProRfidProcessDetail> selectProRfidProcessDetailListAll(ProRfidProcessDetail proRfidProcessDetail) {
return proRfidProcessDetailMapper.selectProRfidProcessDetailListAll(proRfidProcessDetail);
}
}

2
op-modules/op-mes/src/main/resources/mapper/mes/MesReportWorkMapper.xml
Unescape Escape View File

@ -552,7 +552,7 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
<if test="orderCode != null and orderCode != ''"> and pow.workorder_code_sap like concat('%', #{orderCode}, '%')</if>
<if test="workorderCode != null and workorderCode != ''"> and pow.workorder_code like concat('%', #{workorderCode}, '%')</if>
</where>
order by pow.product_date desc
order by pow.product_date desc,mrw.machineName
</select>
<select id="getReportList" resultType="com.op.mes.domain.MesReportWork">
select

31
op-modules/op-mes/src/main/resources/mapper/mes/ProRfidProcessDetailMapper.xml
Unescape Escape View File

@ -99,7 +99,38 @@
</where>
order by ppd.in_time desc
</select>
<select id="selectProRfidProcessDetailListAll" parameterType="ProRfidProcessDetail"
resultType="com.op.system.api.domain.mes.ProRfidProcessDetail">
SELECT
ppd.workorder_code AS workorderCode,
ppd.factory_code AS factoryCode,
pow.product_code AS productCode,
pow.product_name AS productName,
pow.product_date AS productDate,
pow.shift_id AS shiftId,
COUNT ( * ) AS recordCount -- 增加记录数量的汇总
FROM
pro_rfid_process_detail ppd
LEFT JOIN pro_process pp ON pp.process_id = ppd.next_process_id
LEFT JOIN pro_process ppp ON ppp.process_id = ppd.now_process_id
LEFT JOIN pro_order_workorder pow ON pow.workorder_code = ppd.workorder_code
<where>
<if test="workorderCode != null and workorderCode != ''">and ppd.workorder_code like concat('%',
#{workorderCode}, '%')
</if>
</where>
GROUP BY
ppd.workorder_code,
ppd.factory_code,
pow.product_code,
pow.product_name,
pow.product_date,
pow.shift_id
ORDER BY
MAX ( pow.product_date ) DESC;-- 根据产品日期排序
</select>
<select id="selectProRfidProcessDetailByRecordId" parameterType="String" resultMap="ProRfidProcessDetailResult">
<include refid="selectProRfidProcessDetailVo"/>
where record_id = #{recordId}

3
op-modules/op-open/src/main/java/com/op/open/controller/OpenController.java
Unescape Escape View File

@ -255,7 +255,7 @@ public class OpenController extends BaseController {
public AjaxResult getDeliveryNoteDetail(@RequestBody Map paramMap) {
return openService.getDeliveryNoteDetail(paramMap);
}
//给oa提供的物料建议标准更新
//给oa提供的物料建议标准更新;物料英文名称编辑
@PostMapping("/sendProductCheckNo")
public AjaxResult sendProductCheckNo(@RequestBody List<BaseProductDTO> dots) {
return openService.sendProductCheckNo(dots);
@ -269,4 +269,5 @@ public class OpenController extends BaseController {
}
return openService.addEquSapInfo(dto);
}
}

5
op-modules/op-open/src/main/resources/mapper/open/OpenMapper.xml
Unescape Escape View File

@ -33,6 +33,7 @@
set
product_code = #{item.productCode},
product_desc_zh = #{item.productDescZh},
product_desc_en = #{item.productDescEn},
product_group = #{item.productGroup},
product_group_name = #{item.productGroupName},
meins = #{item.meins},
@ -408,14 +409,14 @@
</insert>
<insert id="addProductNoBatchs">
insert into base_product(
product_code,product_desc_zh,product_group,product_group_name,
product_code,product_desc_zh,product_desc_en,product_group,product_group_name,
meins,product_model,umrez,umren,mvgr5,
gross_weight,volume
,create_by,create_time
) values
<foreach item="item" index="index" collection="list" separator=",">
(
#{item.productCode},#{item.productDescZh},#{item.productGroup},#{item.productGroupName},
#{item.productCode},#{item.productDescZh},#{item.productDescEn},#{item.productGroup},#{item.productGroupName},
#{item.meins},#{item.productModel},#{item.umrez},#{item.umren},#{item.mvgr5},
#{item.grossWeight},#{item.volume},
'oa',GETDATE()

11
op-modules/op-plan/src/main/java/com/op/plan/controller/ProBPOrderWorkorderController.java
Unescape Escape View File

@ -227,4 +227,15 @@ public class ProBPOrderWorkorderController extends BaseController {
public AjaxResult deleteWetMaterial(@PathVariable String[] workorderIds) {
return toAjax(proOrderWorkorderService.deleteWetMaterial(workorderIds));
}
/**
* 白坯bom列表
*/
@RequiresPermissions("mes:bppro:workorder:list")
@GetMapping("/getBPNBomList")
public TableDataInfo getBPNBomList(ProOrderWorkorder proOrderWorkorder) {
startPage();
List<ProOrderWorkorder> list = proOrderWorkorderService.getBPNBomList(proOrderWorkorder);
return getDataTable(list);
}
}

2
op-modules/op-plan/src/main/java/com/op/plan/mapper/ProOrderWorkorderMapper.java
Unescape Escape View File

@ -264,5 +264,7 @@ public interface ProOrderWorkorderMapper {
String getPreviousLineCode(String workorderId);//查询之前的产线
String getPlanLineCodes(String workorderId);
List<ProOrderWorkorder> getBPNBomList(ProOrderWorkorder proOrderWorkorder);
}

2
op-modules/op-plan/src/main/java/com/op/plan/service/IProOrderWorkorderService.java
Unescape Escape View File

@ -161,4 +161,6 @@ public interface IProOrderWorkorderService {
int updateWorkOrderBom(String workorderCode);
List<HashMap> getPowExportData(ProOrderWorkorder proOrderWorkorder);
List<ProOrderWorkorder> getBPNBomList(ProOrderWorkorder proOrderWorkorder);
}

7
op-modules/op-plan/src/main/java/com/op/plan/service/impl/ProOrderWorkorderServiceImpl.java
Unescape Escape View File

@ -1832,7 +1832,12 @@ public class ProOrderWorkorderServiceImpl implements IProOrderWorkorderService {
logger.info(poolName + "工厂进行切线，没有新产线需要点检。");
}
}
@Override
@DS("#header.poolName")
public List<ProOrderWorkorder> getBPNBomList(ProOrderWorkorder proOrderWorkorder) {
List<ProOrderWorkorder> workorderList = proOrderWorkorderMapper.getBPNBomList(proOrderWorkorder);
return workorderList;
}
public static void main(String args[]) {
String s = "000800003044";
System.out.println(s.substring(3));

16
op-modules/op-plan/src/main/resources/mapper/plan/ProOrderWorkorderMapper.xml
Unescape Escape View File

@ -1106,5 +1106,21 @@
where workorder_id = #{workorderId}
and del_flag = '0'
</select>
<select id="getBPNBomList" resultType="com.op.plan.domain.ProOrderWorkorder">
select bom.product_code productCode,
bp.product_desc_zh productName
from base_bom_component bom
left join base_product bp on bp.product_code = bom.product_code
where
(
concat('0000000',bom.component) in(select product_code from pro_order_workorder where workorder_id = #{workorderId})
or (bom.component in(select product_code from pro_order_workorder where workorder_id = #{workorderId}))
)
and (
concat('0000000',bom.cumc) in(select product_code from pro_order_workorder where workorder_id = #{workorderId})
or (bom.cumc in(select product_code from pro_order_workorder where workorder_id = #{workorderId}))
)
order by bom.product_code
</select>
</mapper>

129
op-modules/op-quality/src/main/java/com/op/quality/controller/QcCheckReportProduceController.java
Unescape Escape View File

@ -1,6 +1,10 @@
package com.op.quality.controller;
import com.op.common.core.domain.ExcelCol;
import com.op.common.core.utils.DateUtils;
import com.op.common.core.utils.StringUtils;
import com.op.common.core.utils.poi.ExcelReportMapUtil;
import com.op.common.core.utils.poi.ExcelSCReportMapUtil;
import com.op.common.core.utils.poi.ExcelUtil;
import com.op.common.core.web.controller.BaseController;
import com.op.common.core.web.domain.AjaxResult;
@ -11,15 +15,24 @@ import com.op.common.security.annotation.RequiresPermissions;
import com.op.common.security.utils.SecurityUtils;
import com.op.quality.domain.*;
import com.op.quality.service.IQcCheckReportProduceService;
import com.op.system.api.RemoteFileService;
import com.op.system.api.domain.SysFile;
import com.op.system.api.domain.SysUser;
import org.apache.commons.lang.StringUtils;
import org.apache.poi.xssf.streaming.SXSSFWorkbook;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
/**
* 来料检验Controller
@ -32,7 +45,8 @@ import java.util.List;
public class QcCheckReportProduceController extends BaseController {
@Autowired
private IQcCheckReportProduceService qcCheckReportProduceService;
@Autowired
private RemoteFileService remoteFileService;
/**
* 查询来料检验列表
*/
@ -49,7 +63,6 @@ public class QcCheckReportProduceController extends BaseController {
// String dateEndStr = dtf.format(dateEnd)+" 00:00:00";
// qcCheckReportIncome.setCheckTimeEnd(dateEndStr);//end
// }
startPage();
List<QcCheckReportIncome> list = qcCheckReportProduceService.selectQcCheckReportIncomeList(qcCheckReportIncome);
return getDataTable(list);
@ -82,7 +95,117 @@ public class QcCheckReportProduceController extends BaseController {
ExcelUtil<QcCheckReportIncome> util = new ExcelUtil<QcCheckReportIncome>(QcCheckReportIncome.class);
util.exportExcel(response, list, "生产过程检验报告明细");
}
@RequiresPermissions("quality:produceReport:export")
@Log(title = "首检报告导出", businessType = BusinessType.EXPORT)
@PostMapping("/SCReportExport")
public void SCReportExport(HttpServletResponse response, QcCheckTaskIncome qcCheckTaskIncome) {
List<Map> list = qcCheckReportProduceService.getCkeckProjectMap(qcCheckTaskIncome.getRecordId());
List<byte[]> bytes = new ArrayList<>();//图片
SysFile sysFile = null;
for(Map mapdto:list){
sysFile = new SysFile();
if(mapdto.get("files")!=null){
sysFile.setUrl(mapdto.get("files").toString());
byte[] byte0 = remoteFileService.downLoadFileByte(sysFile);
bytes.add(byte0);
}else{
bytes.add(null);
}
}
QcCheckReportIncome detailInfo = qcCheckReportProduceService.selectQcCheckReportIncomeByRecordId(qcCheckTaskIncome.getRecordId());
// 定义正则表达式，匹配id=后面的内容直到&fileName之前的部分
String regex = "id=([^&]+)&fileName";
// 创建Pattern对象
Pattern pattern = Pattern.compile(regex);
// 创建Matcher对象
if(StringUtils.isNotBlank(detailInfo.getCxzz())){
Matcher matcher = pattern.matcher(detailInfo.getCxzz());//产线组长
// 查找匹配项
if (matcher.find()) {
// 提取括号内的内容，即id=和&fileName之间的部分
String value = matcher.group(1);
SysFile sysFile1 = new SysFile();
sysFile1.setUrl(value);
byte[] byte0 = remoteFileService.downLoadFileByte(sysFile1);
bytes.add(byte0);
}
}else{
bytes.add(null);
}
if(StringUtils.isNotBlank(detailInfo.getJgy())){
Matcher matcher2 = pattern.matcher(detailInfo.getJgy());//机管员
// 查找匹配项
if (matcher2.find()) {
// 提取括号内的内容，即id=和&fileName之间的部分
String value = matcher2.group(1);
SysFile sysFile1 = new SysFile();
sysFile1.setUrl(value);
byte[] byte0 = remoteFileService.downLoadFileByte(sysFile1);
bytes.add(byte0);
}
}else{
bytes.add(null);
}
Matcher matcher3 = pattern.matcher(detailInfo.getPgy());//机管员
if(StringUtils.isNotBlank(detailInfo.getPgy())){
// 查找匹配项
if (matcher3.find()) {
// 提取括号内的内容，即id=和&fileName之间的部分
String value = matcher3.group(1);
SysFile sysFile1 = new SysFile();
sysFile1.setUrl(value);
byte[] byte0 = remoteFileService.downLoadFileByte(sysFile1);
bytes.add(byte0);
}
}else{
bytes.add(null);
}
Map<String,String> detailMap = new HashMap<>();
detailMap.put("orderType",detailInfo.getOrderType());
detailMap.put("title","（黑蚊香）首检确认表");
detailMap.put("incomeBatchNo",detailInfo.getIncomeBatchNo());
detailMap.put("checkNo",detailInfo.getCheckNo());
detailMap.put("materialCode",detailInfo.getMaterialCode());
detailMap.put("materialName",detailInfo.getMaterialName());
detailMap.put("checkLoc",detailInfo.getCheckLoc());
detailMap.put("reason",detailInfo.getReason());
detailMap.put("checkType",detailInfo.getCheckType());
detailMap.put("standardNo",detailInfo.getStandardNo());
detailMap.put("incomeTime",DateUtils.parseDateToStr("yyyy-MM-dd",detailInfo.getIncomeTime()));
if(StringUtils.isNotBlank(detailInfo.getCheckResult())){
detailMap.put("checkResult",detailInfo.getCheckResult().equals("Y")?"√合格":"×不合格");
}
detailMap.put("checkManName",detailInfo.getCheckManName());
detailMap.put("remark",detailInfo.getRemark());
//表格结构数据
ArrayList<ExcelCol> excelCols = new ArrayList<>();
excelCols.add(new ExcelCol("检验项目", "projectRuleName", 30));
excelCols.add(new ExcelCol("内容", "ruleName", 30));
excelCols.add(new ExcelCol("实际检测结果", "actualValue", 30));
excelCols.add(new ExcelCol("判定", "status", 30));
excelCols.add(new ExcelCol("附件", "files", 30));
String sheetName = "首检检验报告";
SXSSFWorkbook workbook = null;
try {
//设置响应头
response.setHeader("Content-disposition",
"attachment; filename=" + sheetName);
response.setContentType("application/octet-stream;charset=UTF-8");
ServletOutputStream outputStream = response.getOutputStream();
//调用工具类
workbook = ExcelSCReportMapUtil.initWorkbook(sheetName, "-", excelCols, list, detailMap,bytes);
workbook.write(outputStream);
} catch (Exception e) {
e.printStackTrace();
} finally {
if (workbook != null) {
workbook.dispose();
}
}
}
/**
* 获取来料检验详细信息
*/

61
op-modules/op-quality/src/main/java/com/op/quality/controller/QcCheckReportProductController.java
Unescape Escape View File

@ -1,8 +1,12 @@
package com.op.quality.controller;
import com.op.common.core.domain.ExcelCol;
import com.op.common.core.utils.DateUtils;
import com.op.common.core.utils.StringUtils;
import com.op.common.core.utils.bean.BeanUtils;
import com.op.common.core.utils.poi.ExcelCPReportMapUtil;
import com.op.common.core.utils.poi.ExcelSCReportMapUtil;
import com.op.common.core.utils.poi.ExcelUtil;
import com.op.common.core.web.controller.BaseController;
import com.op.common.core.web.domain.AjaxResult;
@ -13,16 +17,20 @@ import com.op.common.security.annotation.RequiresPermissions;
import com.op.common.security.utils.SecurityUtils;
import com.op.quality.domain.*;
import com.op.quality.service.IQcCheckReportProductService;
import com.op.system.api.domain.SysFile;
import com.op.system.api.domain.SysUser;
import org.apache.commons.lang.StringUtils;
import org.apache.poi.xssf.streaming.SXSSFWorkbook;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* 来料检验Controller
@ -96,7 +104,58 @@ public class QcCheckReportProductController extends BaseController {
ExcelUtil<ProductReportDTO> util = new ExcelUtil<ProductReportDTO>(ProductReportDTO.class);
util.exportExcel(response, list, "成品检验报告明细数据");
}
@RequiresPermissions("quality:productReport:export")
@Log(title = "成品报告导出", businessType = BusinessType.EXPORT)
@PostMapping("/CPReportExport")
public void SCReportExport(HttpServletResponse response, QcCheckTaskIncome qcCheckTaskIncome) {
List<List<Map>> list = qcCheckReportProductService.getCkeckProjectMap(qcCheckTaskIncome.getRecordId());
QcCheckReportIncome detailInfo = qcCheckReportProductService.selectQcCheckReportIncomeByRecordId(qcCheckTaskIncome.getRecordId());
Map<String,String> detailMap = new HashMap<>();
detailMap.put("orderType",detailInfo.getOrderType());
detailMap.put("title","成品检验报告");
detailMap.put("checkNo",detailInfo.getCheckNo());
detailMap.put("incomeBatchNo",detailInfo.getIncomeBatchNo());
detailMap.put("materialCode",detailInfo.getMaterialCode());
detailMap.put("materialName",detailInfo.getMaterialName());
detailMap.put("checkLoc",detailInfo.getCheckLoc());
detailMap.put("quality",detailInfo.getQuality().toString());
detailMap.put("checkType",detailInfo.getCheckType());
detailMap.put("standardNo",detailInfo.getStandardNo());
detailMap.put("incomeTime",DateUtils.parseDateToStr("yyyy-MM-dd HH:mm:ss",detailInfo.getIncomeTime()));
detailMap.put("checkTime",DateUtils.parseDateToStr("yyyy-MM-dd HH:mm:ss",detailInfo.getCheckTime()));
if(StringUtils.isNotBlank(detailInfo.getCheckResult())){
detailMap.put("checkResult",detailInfo.getCheckResult().equals("Y")?"√合格":"×不合格");
}
detailMap.put("checkManName",detailInfo.getCheckManName());
detailMap.put("remark",detailInfo.getRemark());
//表格结构数据
ArrayList<ExcelCol> excelCols = new ArrayList<>();
excelCols.add(new ExcelCol("检验项目", "projectRuleName", 30));
excelCols.add(new ExcelCol("标准要求", "checkStandard", 30));
excelCols.add(new ExcelCol("抽检数(PC)", "samplePlan", 30));
excelCols.add(new ExcelCol("实际检测结果", "actualValue", 30));
excelCols.add(new ExcelCol("判定", "status", 30));
String sheetName = "成品检验报告";
SXSSFWorkbook workbook = null;
try {
//设置响应头
response.setHeader("Content-disposition",
"attachment; filename=" + sheetName);
response.setContentType("application/octet-stream;charset=UTF-8");
ServletOutputStream outputStream = response.getOutputStream();
//调用工具类
workbook = ExcelCPReportMapUtil.initWorkbook(sheetName, "-", excelCols, list.get(0),list.get(1), detailMap);
workbook.write(outputStream);
} catch (Exception e) {
e.printStackTrace();
} finally {
if (workbook != null) {
workbook.dispose();
}
}
}
/**
* 获取来料检验详细信息
*/

64
op-modules/op-quality/src/main/java/com/op/quality/controller/QcCheckTaskIncomeController.java
Unescape Escape View File

@ -10,18 +10,21 @@ import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import javax.annotation.Resource;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.op.quality.service.IQcCheckReportIncomeService;
import com.alibaba.fastjson2.JSONArray;
import com.alibaba.fastjson2.JSONObject;
import com.baomidou.dynamic.datasource.DynamicRoutingDataSource;
import com.baomidou.dynamic.datasource.annotation.DS;
import com.baomidou.dynamic.datasource.spring.boot.autoconfigure.DataSourceProperty;
import com.baomidou.dynamic.datasource.toolkit.DynamicDataSourceContextHolder;
import com.op.common.core.domain.ExcelCol;
import com.op.common.core.domain.R;
import com.op.common.core.utils.DateUtils;
import com.op.common.core.utils.bean.BeanUtils;
import com.op.common.core.utils.poi.ExcelReportMapUtil;
import com.op.common.datasource.creator.DynamicDatasourceCreator;
import com.op.common.security.utils.SecurityUtils;
import com.op.quality.domain.*;
@ -31,6 +34,7 @@ import com.op.system.api.domain.DataSourcePropertyDTO;
import com.op.system.api.domain.SysUser;
import com.op.system.api.domain.quality.QcCheckTaskIncomeDTO;
import org.apache.commons.lang.StringUtils;
import org.apache.poi.xssf.streaming.SXSSFWorkbook;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.CollectionUtils;
import org.springframework.web.bind.annotation.GetMapping;
@ -64,6 +68,9 @@ public class QcCheckTaskIncomeController extends BaseController {
@Autowired
private IQcCheckTaskIncomeService qcCheckTaskIncomeService;
@Autowired
private IQcCheckReportIncomeService qcCheckReportIncomeService;
@Autowired
private RemoteUserService remoteUserService;
@ -105,7 +112,7 @@ public class QcCheckTaskIncomeController extends BaseController {
* 导出来料检验列表
*/
@RequiresPermissions("quality:qcIncome:export")
@Log(title = "来料检验", businessType = BusinessType.EXPORT)
@Log(title = "来料检验导出", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, QcCheckTaskIncome qcCheckTaskIncome) {
@ -128,7 +135,60 @@ public class QcCheckTaskIncomeController extends BaseController {
ExcelUtil<QcCheckTaskIncome> util = new ExcelUtil<QcCheckTaskIncome>(QcCheckTaskIncome.class);
util.exportExcel(response, list, "来料检验数据");
}
@RequiresPermissions("quality:qcIncome:export")
@Log(title = "来料检验报告导出", businessType = BusinessType.EXPORT)
@PostMapping("/reportExport")
public void reportExport(HttpServletResponse response, QcCheckTaskIncome qcCheckTaskIncome) {
List<Map> list = qcCheckTaskIncomeService.getCkeckProjectMapList(qcCheckTaskIncome);
QcCheckReportIncome detailInfo = qcCheckReportIncomeService.selectQcCheckReportIncomeByRecordId(qcCheckTaskIncome.getRecordId());
Map<String,String> detailMap = new HashMap<>();
detailMap.put("orderType",detailInfo.getOrderType());
if(detailInfo.getOrderType().equals("bp")){
detailMap.put("title","白坯检验报告");
}else{
detailMap.put("title","包材检验报告");
}
detailMap.put("productGroupName",detailInfo.getProductGroupName());
detailMap.put("incomeBatchNo",detailInfo.getIncomeBatchNo());
detailMap.put("checkNo",detailInfo.getCheckNo());
detailMap.put("materialCode",detailInfo.getMaterialCode());
detailMap.put("materialName",detailInfo.getMaterialName());
detailMap.put("supplierName",detailInfo.getSupplierName());
detailMap.put("supplierCode",detailInfo.getSupplierCode());
detailMap.put("quality",detailInfo.getQuality().toString());
detailMap.put("unit",detailInfo.getUnit());
detailMap.put("checkType",detailInfo.getCheckType());
detailMap.put("standardNo",detailInfo.getStandardNo());
detailMap.put("incomeTime",DateUtils.parseDateToStr("yyyy-MM-dd",detailInfo.getIncomeTime()));
detailMap.put("checkResult",detailInfo.getCheckResult().equals("Y")?"√合格":"×不合格");
detailMap.put("checkManName",detailInfo.getCheckManName());
//表格结构数据
ArrayList<ExcelCol> excelCols = new ArrayList<>();
excelCols.add(new ExcelCol("检验项目", "ruleName", 30));
excelCols.add(new ExcelCol("标准要求", "checkStandard", 30));
excelCols.add(new ExcelCol("实测结果", "actualValue", 30));
excelCols.add(new ExcelCol("判定", "status", 30));
excelCols.add(new ExcelCol("附件", "fileUrls", 30));
String sheetName = "来料检验报告";
SXSSFWorkbook workbook = null;
try {
//设置响应头
response.setHeader("Content-disposition",
"attachment; filename=" + sheetName);
response.setContentType("application/octet-stream;charset=UTF-8");
ServletOutputStream outputStream = response.getOutputStream();
//调用工具类
workbook = ExcelReportMapUtil.initWorkbook(sheetName, "未启用", excelCols, list, detailMap);
workbook.write(outputStream);
} catch (Exception e) {
e.printStackTrace();
} finally {
if (workbook != null) {
workbook.dispose();
}
}
}
/**
* 获取来料检验详细信息
*/

27
op-modules/op-quality/src/main/java/com/op/quality/controller/QcProductCpkUpdownController.java
Unescape Escape View File

@ -8,6 +8,7 @@ import com.op.common.core.utils.DateUtils;
import com.op.common.core.utils.poi.ExcelUtil;
import com.op.common.core.utils.uuid.IdUtils;
import com.op.common.security.utils.SecurityUtils;
import com.op.quality.domain.QcMaterialCheckStandarDTO;
import com.op.quality.domain.QcProductCpkUpdown;
import com.op.quality.service.IQcProductCpkUpdownService;
import org.apache.catalina.security.SecurityUtil;
@ -39,11 +40,10 @@ public class QcProductCpkUpdownController extends BaseController {
@Autowired
private IQcProductCpkUpdownService qcProductCpkUpdownService;
/**
* 查询CPK上下限维护列表
*/
@GetMapping("/list")
/**
* 查询CPK上下限维护列表
*/
@GetMapping("/list")
public TableDataInfo list(QcProductCpkUpdown qcProductCpkUpdown) {
startPage();
List<QcProductCpkUpdown> list = qcProductCpkUpdownService.selectQcProductCpkUpdownList(qcProductCpkUpdown);
@ -108,4 +108,21 @@ public class QcProductCpkUpdownController extends BaseController {
public AjaxResult remove(@PathVariable String[] ids) {
return toAjax(qcProductCpkUpdownService.deleteQcProductCpkUpdownByIds(ids));
}
/**
* 物料检验标准列表
*/
@GetMapping("/getMaterialCheckStandarList")
public TableDataInfo getMaterialCheckStandarList(QcMaterialCheckStandarDTO dto) {
startPage();
List<QcMaterialCheckStandarDTO> list = qcProductCpkUpdownService.getMaterialCheckStandarList(dto);
return getDataTable(list);
}
@Log(title = "物料检验标准列表导出", businessType = BusinessType.EXPORT)
@PostMapping("/getMaterialCheckStandarExport")
public void getMaterialCheckStandarExport(HttpServletResponse response, QcMaterialCheckStandarDTO dto) {
List<QcMaterialCheckStandarDTO> list = qcProductCpkUpdownService.getMaterialCheckStandarList(dto);
ExcelUtil<QcMaterialCheckStandarDTO> util = new ExcelUtil<QcMaterialCheckStandarDTO>(QcMaterialCheckStandarDTO. class);
util.exportExcel(response, list, "物料检验标准");
}
}

10
op-modules/op-quality/src/main/java/com/op/quality/domain/QcCheckReportIncome.java
Unescape Escape View File

@ -54,7 +54,7 @@ public class QcCheckReportIncome extends BaseEntity {
*/
@Excel(name = "物料名称")
private String materialName;
private String productGroupName;
/**
* 收货数量
*/
@ -618,6 +618,14 @@ public class QcCheckReportIncome extends BaseEntity {
return delFlag;
}
public String getProductGroupName() {
return productGroupName;
}
public void setProductGroupName(String productGroupName) {
this.productGroupName = productGroupName;
}
@Override
public String toString() {
return new ToStringBuilder(this, ToStringStyle.MULTI_LINE_STYLE)

88
op-modules/op-quality/src/main/java/com/op/quality/domain/QcMaterialCheckStandarDTO.java
Unescape Escape View File

@ -0,0 +1,88 @@
package com.op.quality.domain;
import com.op.common.core.annotation.Excel;
import com.op.common.core.web.domain.BaseEntity;
import org.apache.commons.lang3.builder.ToStringBuilder;
import org.apache.commons.lang3.builder.ToStringStyle;
import java.math.BigDecimal;
/**
*
* @author Open Platform
* @date 2024-12-2
*/
public class QcMaterialCheckStandarDTO extends BaseEntity {
private static final long serialVersionUID=1L;
@Excel(name = "物料号")
private String materialCode;
@Excel(name = "物料名称")
private String materialName;
@Excel(name = "检验标准")
private String standNo;
@Excel(name = "检验物料组名称")
private String groupName;
@Excel(name = "物料组编码")
private String productGroup;
@Excel(name = "物料组名称")
private String productGroupName;
@Excel(name = "工厂")
private String siteCode;
public String getMaterialCode() {
return materialCode;
}
public void setMaterialCode(String materialCode) {
this.materialCode = materialCode;
}
public String getMaterialName() {
return materialName;
}
public void setMaterialName(String materialName) {
this.materialName = materialName;
}
public String getStandNo() {
return standNo;
}
public void setStandNo(String standNo) {
this.standNo = standNo;
}
public String getGroupName() {
return groupName;
}
public void setGroupName(String groupName) {
this.groupName = groupName;
}
public String getProductGroup() {
return productGroup;
}
public void setProductGroup(String productGroup) {
this.productGroup = productGroup;
}
public String getProductGroupName() {
return productGroupName;
}
public void setProductGroupName(String productGroupName) {
this.productGroupName = productGroupName;
}
public String getSiteCode() {
return siteCode;
}
public void setSiteCode(String siteCode) {
this.siteCode = siteCode;
}
}

1
op-modules/op-quality/src/main/java/com/op/quality/mapper/QcCheckReportIncomeMapper.java
Unescape Escape View File

@ -92,4 +92,5 @@ public interface QcCheckReportIncomeMapper {
public List<QcCheckReportIncome> getPrintXJList(QcCheckReportIncome qcCheckReportIncome);
Long getActProductQty(String workOrderCode);
}

3
op-modules/op-quality/src/main/java/com/op/quality/mapper/QcProductCpkUpdownMapper.java
Unescape Escape View File

@ -1,5 +1,6 @@
package com.op.quality.mapper;
import com.op.quality.domain.QcMaterialCheckStandarDTO;
import com.op.quality.domain.QcProductCpkUpdown;
import java.util.List;
@ -61,4 +62,6 @@ public interface QcProductCpkUpdownMapper {
public int deleteQcProductCpkUpdownByIds(String[] ids);
QcProductCpkUpdown checkCpkUpdown(QcProductCpkUpdown qcProductCpkUpdown);
List<QcMaterialCheckStandarDTO> getMaterialCheckStandarList(QcMaterialCheckStandarDTO dto);
}

3
op-modules/op-quality/src/main/java/com/op/quality/service/IQcCheckReportProduceService.java
Unescape Escape View File

@ -4,6 +4,7 @@ import com.op.quality.domain.*;
import com.op.system.api.domain.SysUser;
import java.util.List;
import java.util.Map;
/**
* 生产过程报告Service接口
@ -75,4 +76,6 @@ public interface IQcCheckReportProduceService {
QcCheckReportIncome getTaskInfo(QcCheckReportIncome qcCheckReportIncome);
int submitConfirm(QcCheckReportIncome qcCheckReportIncome);
List<Map> getCkeckProjectMap(String recordId);
}

3
op-modules/op-quality/src/main/java/com/op/quality/service/IQcCheckReportProductService.java
Unescape Escape View File

@ -7,6 +7,7 @@ import com.op.quality.domain.QcSupplier;
import com.op.system.api.domain.SysUser;
import java.util.List;
import java.util.Map;
/**
* 成品入库报告Service接口
@ -74,4 +75,6 @@ public interface IQcCheckReportProductService {
List<QcCheckTaskDetail> getCkeckProjectList(QcCheckTaskDetail qcCheckTaskDetail);
public List<QcCheckReportIncome> getPrintData(QcCheckReportIncome qcCheckReportIncome);
List<List<Map>> getCkeckProjectMap(String recordId);
}

3
op-modules/op-quality/src/main/java/com/op/quality/service/IQcCheckTaskIncomeService.java
Unescape Escape View File

@ -2,6 +2,7 @@ package com.op.quality.service;
import java.util.Date;
import java.util.List;
import java.util.Map;
import com.op.quality.domain.*;
import com.op.system.api.domain.SysUser;
@ -119,4 +120,6 @@ public interface IQcCheckTaskIncomeService {
int changeTaskDetail(QcCheckTaskIncome task);
List<QcCheckTaskIncome> getWarehouseList(QcCheckTaskIncome task);
List<Map> getCkeckProjectMapList(QcCheckTaskIncome qcCheckTaskIncome);
}

3
op-modules/op-quality/src/main/java/com/op/quality/service/IQcProductCpkUpdownService.java
Unescape Escape View File

@ -1,5 +1,6 @@
package com.op.quality.service;
import com.op.quality.domain.QcMaterialCheckStandarDTO;
import com.op.quality.domain.QcProductCpkUpdown;
import java.util.List;
@ -61,4 +62,6 @@ public interface IQcProductCpkUpdownService {
public int deleteQcProductCpkUpdownById(String id);
QcProductCpkUpdown checkCpkUpdown(QcProductCpkUpdown qcProductCpkUpdown);
List<QcMaterialCheckStandarDTO> getMaterialCheckStandarList(QcMaterialCheckStandarDTO dto);
}

96
op-modules/op-quality/src/main/java/com/op/quality/service/impl/QcCheckReportProduceServiceImpl.java
Unescape Escape View File

@ -8,6 +8,8 @@ import com.op.quality.domain.*;
import com.op.quality.mapper.*;
import com.op.quality.service.IQcCheckReportProduceService;
import com.op.quality.service.IQcStaticTableService;
import com.op.system.api.RemoteFileService;
import com.op.system.api.domain.SysFile;
import com.op.system.api.domain.SysUser;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
@ -22,6 +24,8 @@ import javax.servlet.http.HttpServletRequest;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
/**
@ -48,7 +52,8 @@ public class QcCheckReportProduceServiceImpl implements IQcCheckReportProduceSer
private QcCheckTaskDetailMapper qcCheckTaskDetailMapper;
@Autowired
private IQcStaticTableService qcStaticTableService;
@Autowired
private QMSFileMapper qmsFileMapper;
/**
* 查询来生产过程中验
*
@ -211,6 +216,77 @@ public class QcCheckReportProduceServiceImpl implements IQcCheckReportProduceSer
return qcCheckReportIncomeMapper.getCkeckProjectList(qcCheckTaskDetail);
}
@Override
@DS("#header.poolName")
public List<Map> getCkeckProjectMap(String recordId) {
QcCheckTaskDetail qcCheckTaskDetail = new QcCheckTaskDetail();
qcCheckTaskDetail.setRecordId(recordId);
List<QcCheckTaskDetail> dtos = qcCheckReportIncomeMapper.getCkeckProjectList(qcCheckTaskDetail);
for (QcCheckTaskDetail dto : dtos) {
if(com.op.common.core.utils.StringUtils.isNotBlank(dto.getSamplePlan())){
dto.setSamplePlan(dto.getSamplePlan().replace(".00",""));
}
List<BaseFile> files = qmsFileMapper.getBaseFileBatch(dto.getRecordId());
if (!CollectionUtils.isEmpty(files)) {
dto.setFiles(files);
}
//实测结果,定量的用测量值，定性的用remark
if(StringUtils.isNotBlank(dto.getActualValue())){
dto.setActualValue(dto.getActualValue());
}else if(com.op.common.core.utils.StringUtils.isNotBlank(dto.getRemark())){
dto.setActualValue(dto.getRemark());
}
if(StringUtils.isNotBlank(dto.getActualValue()) && dto.getActualValue().equals("[\"/\"]")){
dto.setStatus("未检验");
}
//检验项目
String ruleName = dto.getRuleName();
if(com.op.common.core.utils.StringUtils.isNotBlank(ruleName)){
String projectRuleName0 = ruleName.split("]")[0];
if(com.op.common.core.utils.StringUtils.isNotBlank(projectRuleName0)){
dto.setProjectRuleName(projectRuleName0.replace("[",""));
}
}
}
// 定义正则表达式，匹配id=后面的内容直到&fileName之前的部分
String regex = "id=([^&]+)&fileName";
// 创建Pattern对象
Pattern pattern = Pattern.compile(regex);
List<Map> maps = new ArrayList<>();
int n = 1;
for(QcCheckTaskDetail dto:dtos){
Map mapdto = new HashMap();
mapdto.put("xh",n++);
mapdto.put("projectRuleName",dto.getProjectRuleName());
mapdto.put("ruleName",dto.getRuleName());
mapdto.put("actualValue",dto.getActualValue());
if(dto.getStatus().equals("Y")){
mapdto.put("status","✓");
}else if(dto.getStatus().equals("N")){
mapdto.put("status","✘");
}
if(!CollectionUtils.isEmpty(dto.getFiles())){
// 创建Matcher对象
Matcher matcher = pattern.matcher(dto.getFiles().get(0).getFileAddress());
// 查找匹配项
if (matcher.find()) {
// 提取括号内的内容，即id=和&fileName之间的部分
String value = matcher.group(1);
mapdto.put("files",value);
}
}else{
mapdto.put("files",null);
}
maps.add(mapdto);
}
return maps;
}
@Override
@DS("#header.poolName")
public QcCheckTaskProduce getProduceReportXJ(QcCheckTaskProduce qcCheckTaskProduce) {
@ -327,5 +403,23 @@ public class QcCheckReportProduceServiceImpl implements IQcCheckReportProduceSer
}
return 0;
}
public static void main(String args[]){
String input = "http://192.168.202.34:30000/prod-api/file/downLoadFile?id=6751554b850718721ec2c04c&fileName=17333839494841.png";
// 定义正则表达式，匹配id=后面的内容直到&fileName之前的部分
String regex = "id=([^&]+)&fileName";
// 创建Pattern对象
Pattern pattern = Pattern.compile(regex);
// 创建Matcher对象
Matcher matcher = pattern.matcher(input);
// 查找匹配项
if (matcher.find()) {
// 提取括号内的内容，即id=和&fileName之间的部分
String value = matcher.group(1);
System.out.println("Extracted value: " + value);
} else {
System.out.println("No match found.");
}
}
}

74
op-modules/op-quality/src/main/java/com/op/quality/service/impl/QcCheckReportProductServiceImpl.java
Unescape Escape View File

@ -1,5 +1,6 @@
package com.op.quality.service.impl;
import com.alibaba.nacos.shaded.org.checkerframework.checker.units.qual.A;
import com.baomidou.dynamic.datasource.annotation.DS;
import com.op.common.core.utils.DateUtils;
import com.op.common.core.utils.uuid.IdUtils;
@ -16,8 +17,8 @@ import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import javax.servlet.http.HttpServletRequest;
import java.util.Date;
import java.util.List;
import java.math.BigDecimal;
import java.util.*;
/**
* 来料检验Service业务层处理
@ -40,6 +41,8 @@ public class QcCheckReportProductServiceImpl implements IQcCheckReportProductSer
private QcCheckTaskDetailMapper qcCheckTaskDetailMapper;
@Autowired
private QcStaticTableMapper qcStaticTableMapper;
@Autowired
private QMSFileMapper qmsFileMapper;
/**
* 查询来料检验
*
@ -58,6 +61,11 @@ public class QcCheckReportProductServiceImpl implements IQcCheckReportProductSer
//汇总批次号
List<String> batchs = qcCheckReportIncomeMapper.getBatchsByTaskId(recordId);
dto.setIncomeBatchNo(StringUtils.join(batchs, ";"));
//实际生产数量
Long actVal = qcCheckReportIncomeMapper.getActProductQty(dto.getOrderNo());
if(actVal != null){
dto.setQuality(new BigDecimal(actVal));
}
return dto;
}
@ -219,5 +227,67 @@ public class QcCheckReportProductServiceImpl implements IQcCheckReportProductSer
public List<QcCheckReportIncome> getPrintData(QcCheckReportIncome qcCheckReportIncome) {
return null;
}
@Override
@DS("#header.poolName")
public List<List<Map>> getCkeckProjectMap(String recordId) {
QcCheckTaskDetail qcCheckTaskDetail = new QcCheckTaskDetail();
qcCheckTaskDetail.setRecordId(recordId);
List<QcCheckTaskDetail> dtos = qcCheckReportIncomeMapper.getCkeckProjectList(qcCheckTaskDetail);
for (QcCheckTaskDetail dto : dtos) {
if(com.op.common.core.utils.StringUtils.isNotBlank(dto.getSamplePlan())){
dto.setSamplePlan(dto.getSamplePlan().replace(".00",""));
}
// List<BaseFile> files = qmsFileMapper.getBaseFileBatch(dto.getRecordId());
// if (!CollectionUtils.isEmpty(files)) {
// dto.setFiles(files);
// }
//实测结果,定量的用测量值，定性的用remark
if(com.op.common.core.utils.StringUtils.isNotBlank(dto.getActualValue())){
dto.setActualValue(dto.getActualValue());
}else if(com.op.common.core.utils.StringUtils.isNotBlank(dto.getRemark())){
dto.setActualValue(dto.getRemark());
}
if(com.op.common.core.utils.StringUtils.isNotBlank(dto.getActualValue()) && dto.getActualValue().equals("[\"/\"]")){
dto.setStatus("未检验");
}
//检验项目
String ruleName = dto.getRuleName();
if(com.op.common.core.utils.StringUtils.isNotBlank(ruleName)){
String projectRuleName0 = ruleName.split("]")[0];
if(com.op.common.core.utils.StringUtils.isNotBlank(projectRuleName0)){
dto.setProjectRuleName(projectRuleName0.replace("[",""));
}
}
}
List<List<Map>> listmaps = new ArrayList<>();
List<Map> maps0 = new ArrayList<>();
List<Map> maps1 = new ArrayList<>();
Map map = null;
for(QcCheckTaskDetail dto:dtos){
map = new HashMap();
map.put("projectRuleName",dto.getProjectRuleName());
map.put("checkStandard",dto.getCheckStandard());
map.put("samplePlan",dto.getSamplePlan());
map.put("actualValue",dto.getActualValue());
if("Y".equals(dto.getStatus())){
map.put("status","合格");
}else if("N".equals(dto.getStatus())){
map.put("status","不合格");
}else{
map.put("status","/");
}
if(dto.getItemType().equals("1")){
maps0.add(map);
}else{
maps1.add(map);
}
}
listmaps.add(maps0);
listmaps.add(maps1);
return listmaps;
}
}

61
op-modules/op-quality/src/main/java/com/op/quality/service/impl/QcCheckTaskIncomeServiceImpl.java
Unescape Escape View File

@ -751,6 +751,20 @@ public class QcCheckTaskIncomeServiceImpl<QcCheckUnqualifiedService> implements
System.out.println("base_file:"+n);
}
/**去掉测量值0**/
String actualValueStr = detail.getActualValue();
if(StringUtils.isNotBlank(actualValueStr)){
if(actualValueStr.indexOf("[")>=0 && actualValueStr.indexOf("]")>=0){
JSONArray codeArray = JSONArray.parseArray(actualValueStr);
for (int c1 = 0; c1 < codeArray.size(); c1++) {
if(codeArray.get(c1).toString().indexOf(":0")>=0&&codeArray.get(c1).toString().indexOf(".")<0) {
codeArray.remove(codeArray.get(c1));
}
}
detail.setActualValue(JSONArray.toJSONString(codeArray));
}
}
}
if(qcCheckTaskIncome.getSampleQuality()!=null && qcCheckTaskIncome.getSampleQuality().equals(BigDecimal.ZERO)){
qcCheckTask.setSampleQuality(sampleQuality);
@ -1029,16 +1043,18 @@ public class QcCheckTaskIncomeServiceImpl<QcCheckUnqualifiedService> implements
System.out.println("base_file:"+n);
}
// /**去掉测量值0**/
/**去掉测量值0**/
// String actualValueStr = detail.getActualValue();
// if(StringUtils.isNotBlank(actualValueStr)){
// JSONArray codeArray = JSONArray.parseArray(actualValueStr);
// for (int c1 = 0; c1 < codeArray.size(); c1++) {
// if(codeArray.get(c1).toString().indexOf(":0")>=0&&codeArray.get(c1).toString().indexOf(".")<0) {
// codeArray.remove(codeArray.get(c1));
// if(actualValueStr.indexOf("[")>=0 && actualValueStr.indexOf("]")>=0){
// JSONArray codeArray = JSONArray.parseArray(actualValueStr);
// for (int c1 = 0; c1 < codeArray.size(); c1++) {
// if(codeArray.get(c1).toString().indexOf(":0")>=0&&codeArray.get(c1).toString().indexOf(".")<0) {
// codeArray.remove(codeArray.get(c1));
// }
// }
// detail.setActualValue(JSONArray.toJSONString(codeArray));
// }
// detail.setActualValue(codeArray.toJSONString());
// }
}
@ -1369,6 +1385,39 @@ public class QcCheckTaskIncomeServiceImpl<QcCheckUnqualifiedService> implements
return qcCheckTaskIncomeMapper.getWarehouseList();
}
@Override
@DS("#header.poolName")
public List<Map> getCkeckProjectMapList(QcCheckTaskIncome qcCheckTaskIncome) {
QcCheckTaskDetail qcCheckTaskDetail = new QcCheckTaskDetail();
qcCheckTaskDetail.setBelongTo(qcCheckTaskIncome.getRecordId());//TODO
List<QcCheckTaskDetail> dtos = qcCheckTaskIncomeMapper.getCkeckProjectList(qcCheckTaskDetail);
List<Map> mapDtos = new ArrayList<>();
for(QcCheckTaskDetail detail:dtos){
Map mapdto = new HashMap();
mapdto.put("ruleName",detail.getRuleName());
mapdto.put("checkStandard",detail.getCheckStandard());
mapdto.put("actualValue",detail.getActualValue());
if("Y".equals(detail.getStatus())){
mapdto.put("status","合格");
}else if("N".equals(detail.getStatus())){
mapdto.put("status","不合格");
}else{
mapdto.put("status","/");
}
List<BaseFile> files = qmsFileMapper.getBaseFileBatch(detail.getRecordId());
if (!CollectionUtils.isEmpty(files)) {
List<String> urls = files.stream().map(BaseFile::getFileAddress).collect(Collectors.toList());
detail.setFiles(files);
detail.setFileUrls(urls);
mapdto.put("fileUrls",urls);
}
mapDtos.add(mapdto);
}
return mapDtos;
}
public static void main(String args[]){
String actualValueStr = "[\"1:0.03\",\"2:0\",\"3:0.34\"]";
try {

14
op-modules/op-quality/src/main/java/com/op/quality/service/impl/QcProductCpkUpdownServiceImpl.java
Unescape Escape View File

@ -4,11 +4,16 @@ import java.util.List;
import com.baomidou.dynamic.datasource.annotation.DS;
import com.op.common.core.utils.DateUtils;
import com.op.quality.domain.QcMaterialCheckStandarDTO;
import com.op.quality.domain.QcProductCpkUpdown;
import com.op.quality.mapper.QcProductCpkUpdownMapper;
import com.op.quality.service.IQcProductCpkUpdownService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import javax.servlet.http.HttpServletRequest;
/**
@ -101,4 +106,13 @@ public class QcProductCpkUpdownServiceImpl implements IQcProductCpkUpdownService
public QcProductCpkUpdown checkCpkUpdown(QcProductCpkUpdown qcProductCpkUpdown) {
return qcProductCpkUpdownMapper.checkCpkUpdown(qcProductCpkUpdown);
}
@Override
@DS("#header.poolName")
public List<QcMaterialCheckStandarDTO> getMaterialCheckStandarList(QcMaterialCheckStandarDTO dto) {
HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
String key = "#header.poolName";
dto.setSiteCode(request.getHeader(key.substring(8)).replace("ds_", ""));
return qcProductCpkUpdownMapper.getMaterialCheckStandarList(dto);
}
}

6
op-modules/op-quality/src/main/java/com/op/quality/service/impl/QcStaticTableServiceImpl.java
Unescape Escape View File

@ -1313,7 +1313,11 @@ public class QcStaticTableServiceImpl implements IQcStaticTableService {
if(act!=null){
String actArrayStr = act.getQuality().replace("[", "")
.replace("]", "")
.replace("\"", "");
.replace("\"", "")
.replace("/", "")
.replace("／", "")
.replace(",,", ",")
.replace("\\", "");
List<String> actArray0 = Arrays.asList(actArrayStr.split(","));
List<String> actArray = new ArrayList<>();
for(String avg:actArray0){

9
op-modules/op-quality/src/main/resources/mapper/quality/QcCheckReportIncomeMapper.xml
Unescape Escape View File

@ -46,6 +46,8 @@
<result property="workorderCodeSap" column="workorder_code_sap"/>
<result property="modelType" column="modelType"/>
<result property="remark" column="remark"/>
<result property="productGroupName" column="product_group_name"/>
</resultMap>
<sql id="selectQcCheckReportIncomeVo">
@ -101,7 +103,7 @@
qct.check_status, qct.check_man_code, qct.check_man_name,
qct.check_time, qct.check_result, qct.status, qct.check_type, qct.attr1, qct.attr2, qct.attr3, qct.attr4,
qct.create_by, qct.create_time, qct.update_by, qct.update_time,
qct.factory_code, qct.del_flag,qct.reason,qct.product_type,qct.order_type,qct.jgy,qct.pgy,qct.cxzz,
qct.factory_code, qct.del_flag,qct.reason,qct.product_type,qct.order_type,bp.product_group_name,qct.jgy,qct.pgy,qct.cxzz,
ISNULL(bp.mvgr5, '09JS08S-048B') standardNo
from qc_check_task qct
left join base_product bp on bp.product_code = qct.material_code
@ -169,7 +171,7 @@
qctp.down_diff downDiff,
qctp.sample,
td.sample_quality samplePlan,
qctp.item_type itemType,
qcp.item_type itemType,
qctp.judge_rate judgeRate,
qpt.standard_no standardNo,
qctp.upper_diff upperDiff,
@ -316,6 +318,9 @@
<if test="typeCode != null ">and qct.type_code = #{typeCode}</if>
</where>
</select>
<select id="getActProductQty" resultType="java.lang.Long">
select sum(quantity_feedback) from mes_report_work where workorder_code = #{workOrderCode} and del_flag = '0'
</select>
<insert id="insertQcCheckReportIncome" parameterType="QcCheckReportIncome">
insert into qc_check_task

2
op-modules/op-quality/src/main/resources/mapper/quality/QcCheckTaskProduceMapper.xml
Unescape Escape View File

@ -131,7 +131,7 @@
#{supplierName}, '%')
</if>
<if test="incomeTime != null ">and qct.income_time = #{incomeTime}</if>
<if test="checkLoc != null and checkLoc != ''">and qct.check_loc = #{checkLoc}</if>
<if test="checkLoc != null and checkLoc != ''">and qct.check_loc like concat('%',#{checkLoc}, '%')</if>
<if test="checkStatus != null and checkStatus != ''">and qct.check_status = #{checkStatus}</if>
<if test="checkManCode != null and checkManCode != ''">and qct.check_man_code = #{checkManCode}</if>
<if test="checkManName != null and checkManName != ''">and qct.check_man_name like concat('%',

2
op-modules/op-quality/src/main/resources/mapper/quality/QcCheckTaskWarehousingMapper.xml
Unescape Escape View File

@ -71,7 +71,7 @@
#{supplierName}, '%')
</if>
<if test="incomeTime != null ">and qct.income_time = #{incomeTime}</if>
<if test="checkLoc != null and checkLoc != ''">and qct.check_loc = #{checkLoc}</if>
<if test="checkLoc != null and checkLoc != ''">and qct.check_loc like concat('%',#{checkLoc}, '%')</if>
<if test="checkStatus != null and checkStatus != ''">and qct.check_status = #{checkStatus}</if>
<if test="checkManCode != null and checkManCode != ''">and qct.check_man_code = #{checkManCode}</if>
<if test="checkManName != null and checkManName != ''">and qct.check_man_name like concat('%',

6
op-modules/op-quality/src/main/resources/mapper/quality/QcProCheckMapper.xml
Unescape Escape View File

@ -73,6 +73,10 @@
<result property="bNoOkquality" column="bNoOkquality"/>
<result property="cNoOkquality" column="cNoOkquality"/>
<result property="sampleQuality" column="sample_quality"/>
<result property="cxzz" column="cxzz"/>
<result property="jgy" column="jgy"/>
<result property="pgy" column="pgy"/>
</resultMap>
<sql id="selectQuaVo">
select id,rfid,factory_id,factory_code,order_id,machine_id,bad_meg,product_id,isqua,file_id,attr1,attr2,
@ -258,7 +262,7 @@
qct.status,qct.create_by,qct.create_time,qct.check_type,
qct.noOk_quality,qct.aNoOkquality,qct.bNoOkquality,qct.cNoOkquality,qct.sample_quality
<if test='checkType=="checkTypeSCXJ" or checkType=="checkTypeSC"'>
,pow.workorder_code_sap workorderCodeSap
,pow.workorder_code_sap workorderCodeSap,cxzz,jgy,pgy
</if>
from qc_check_task qct
left join qc_check_task_user qctu on qctu.belong_to = qct.record_id

30
op-modules/op-quality/src/main/resources/mapper/quality/QcProductCpkUpdownMapper.xml
Unescape Escape View File

@ -82,6 +82,36 @@
and material_code = #{materialCode}
and rule_code = #{ruleCode}
</select>
<select id="getMaterialCheckStandarList" resultType="com.op.quality.domain.QcMaterialCheckStandarDTO">
select
bp.product_code materialCode,
bp.product_desc_zh materialName,
bp.mvgr5 standNo,
qmg.group_name groupName,
bp.product_group productGroup,
bp.product_group_name productGroupName,
#{siteCode} siteCode
from base_product bp
left join qc_material_group qmg on qmg.group_code = bp.mvgr5
left join base_product_attached bpa on concat('0000000',bpa.product_code) = bp.product_code
where bp.del_flag = '0' and(
bp.product_code like '00000001%' or bp.product_code like '00000002%' or bp.product_code like '00000003%'
or bp.product_code like '00000004%' or bp.product_code like '00000005%' or bp.product_code like '00000006%'
or bp.product_code like '00000007%')
<if test="materialCode != null ">
and bp.product_code like concat('%', #{materialCode}, '%')
</if>
<if test="materialName != null ">
and bp.product_desc_zh like concat('%', #{materialName}, '%')
</if>
<if test="groupName != null ">
and qmg.group_name like concat('%', #{groupName}, '%')
</if>
<if test="standNo != null ">
and bp.mvgr5 like concat('%', #{standNo}, '%')
</if>
order by bp.product_code
</select>
<insert id="insertQcProductCpkUpdown" parameterType="QcProductCpkUpdown">
insert into qc_product_cpk_updown

2
op-modules/op-quality/src/main/resources/mapper/quality/QcStaticTableMapper.xml
Unescape Escape View File

@ -531,7 +531,7 @@
qcp.rule_name ruleName
from qc_check_type_project qctp
left join qc_check_project qcp on qctp.project_id = qcp.id
where qctp.type_id = #{checkType} and qctp.property_code = '1'
where qctp.type_id = #{checkType} and qctp.property_code = '1' and qctp.del_flag = '0'
and qctp.material_code is null and qcp.rule_name is not null
</select>
<select id="getUpAndDown" resultType="com.op.quality.domain.QcStaticTable">

9
op-modules/op-wms/src/main/java/com/op/wms/controller/OdsProcureOrderController.java
Unescape Escape View File

@ -49,11 +49,18 @@ public class OdsProcureOrderController extends BaseController {
List<OdsProcureOrder> list = odsProcureOrderService.selectOdsProcureOrderList(odsProcureOrder);
return getDataTable(list);
}
/**获取标识卡**/
/**获取标识卡
* 修改，优法现有收货功能：在包材采购单打印的时候选择区位产生记录直接写到包材库存明细---暂收的时候，贴完标示卡后，仓管员手持扫描送货单号进行暂收；
*冲销要随之修改---明细不进行删除而是进行修改状态改为未入库，总库存进行删除，其他的照旧，或许是有问题的，看使用问题了
* 还有操作问题--即如果打印了单子，收了一部分，--但是他要重新打印，这是不可以的，收了一部分后不能重新打印，
* 重新了解了下，不直接加进行明细了，而是在前端手持上加上一键收货
*
**/
@PostMapping("/getIdCardList")
public AjaxResult getIdCardList(@RequestBody OdsProcureOrder odsProcureOrder) {
return success(odsProcureOrderService.getIdCardList(odsProcureOrder));
}
@PostMapping("/getIdCardListTH")
public AjaxResult getIdCardListTH(@RequestBody OdsProcureOrder odsProcureOrder) {
return success(odsProcureOrderService.getIdCardListTH(odsProcureOrder));

8
op-modules/op-wms/src/main/java/com/op/wms/controller/WmsOdsMateStorageNewsSnController.java
Unescape Escape View File

@ -106,10 +106,16 @@ public class WmsOdsMateStorageNewsSnController extends BaseController {
public AjaxResult cardDy(@RequestBody List<WmsOdsMateStorageNewsSn> list) {
return success(wmsOdsMateStorageNewsSnService.cardDy(list));
}
//特殊出库
//补打
@PostMapping("/cardBD")
public AjaxResult cardBD( @RequestBody List<OdsProcureOutOrder> orderList) {
String result = wmsOdsMateStorageNewsSnService.cardBD(orderList);
return success(result);
}
//删除
@PostMapping("/Removecard")
public AjaxResult Removecard( @RequestBody List<OdsProcureOutOrder> orderList) {
String result = wmsOdsMateStorageNewsSnService.Removecard(orderList);
return success(result);
}
}

30
op-modules/op-wms/src/main/java/com/op/wms/controller/WmsToWCSmissionController.java
Unescape Escape View File

@ -272,6 +272,9 @@ public class WmsToWCSmissionController {
@PostMapping("/SweepMaterialCardSC")
public AjaxResult SweepMaterialCardSC(@RequestBody WmsOdsMateStorageNewsSn wmsOdsMateStorageNewsSn) {
WmsOdsMateStorageNewsSn wmsOdsMateStorageNewsSn1 = odsProcureOrderService.SweepMaterialCardSC(wmsOdsMateStorageNewsSn);
if(wmsOdsMateStorageNewsSn1==null){
return success("仓库没有这个标识卡");
}
if (wmsOdsMateStorageNewsSn1.getUserDefined3().equals("0")){//userDefined3
return error("未105过账");
}
@ -948,5 +951,32 @@ public class WmsToWCSmissionController {
public AjaxResult add(@RequestBody BpRawMaterialInDetail bpRawMaterialInDetail){
return success(bpRawMaterialInDetailService.insertBpRawMaterialInDetailSC(bpRawMaterialInDetail));
}
//根据送货单选择标识卡---非必须条件有送货单
@PostMapping("/selectCardList")
public AjaxResult selectCardList(@RequestBody OdsProcureOrder odsProcureOrder) {
return success(odsProcureOrderService.selectCardList(odsProcureOrder));
}
/**
* 最最新的的收货确认接口
* @param order
* @return
*/
@PostMapping("/addOrderCardXNew")
public AjaxResult addOrderCardXNew(@RequestBody OdsProcureOrder order) {
String result = odsProcureOrderService.addOrderCardXNew(order);
return success(result);
}
/**
* 修改标识卡---要可以修改入库数量的操作（）按照最新修改的收货操作下，---要想实现的话，标识卡应该有应入数量（），已入数量（），最新要操作数量（User_Defined9），并且，
* 操作数量在操作了一次后加到已入数量里面后，--并且计算（应收减去已收）好下次应该收的数量放入最新要操作数量
*这个接口就是用来修改的
* @param order
* @return
*/
@PostMapping("upbatCardXNew")
public AjaxResult upbatCardXNew(@RequestBody OdsProcureOrder order) {
String result = odsProcureOrderService.upbatCardXNew(order);
return success(result);
}
}

9
op-modules/op-wms/src/main/java/com/op/wms/domain/BaseProduct.java
Unescape Escape View File

@ -362,6 +362,15 @@ public class BaseProduct extends BaseEntity {
private String palletNum;
private String warehouseCycle;
private String packType;
private String waCode;
public String getWaCode() {
return waCode;
}
public void setWaCode(String waCode) {
this.waCode = waCode;
}
public String getBoxType() {
return boxType;

9
op-modules/op-wms/src/main/java/com/op/wms/domain/BaseProductAttached.java
Unescape Escape View File

@ -127,6 +127,15 @@ public class BaseProductAttached extends BaseEntity {
private String packType;
private String cpkType;
private String cpkTypeName;
private String waCode;
public String getWaCode() {
return waCode;
}
public void setWaCode(String waCode) {
this.waCode = waCode;
}
public String getCpkType() {
return cpkType;

11
op-modules/op-wms/src/main/java/com/op/wms/domain/OdsProcureOrder.java
Unescape Escape View File

@ -204,6 +204,16 @@ public class OdsProcureOrder extends BaseEntity {
*/
@Excel(name = "计划数量")
private BigDecimal planNumber;
//操作数量
private BigDecimal temNumber;
public BigDecimal getTemNumber() {
return temNumber;
}
public void setTemNumber(BigDecimal temNumber) {
this.temNumber = temNumber;
}
private BigDecimal buNumber;
@ -392,7 +402,6 @@ public class OdsProcureOrder extends BaseEntity {
private String SapTempStatus;
private String SAPstatus;
private String SAPmessage;
public String getSapTempInfor() {
return SapTempInfor;
}

2
op-modules/op-wms/src/main/java/com/op/wms/domain/WmsRawOrderIn.java
Unescape Escape View File

@ -163,7 +163,7 @@ public class WmsRawOrderIn extends BaseEntity {
private String qualityStatus;
/**
* 0创建1拒收2收货完成3上架完成4入库完成
* 0创建1拒收2收货完成3上架完成4入库完成,5是冲销
*/
@Excel(name = "0创建1拒收2收货完成3上架完成4入库完成")
private String orderStatus;

3
op-modules/op-wms/src/main/java/com/op/wms/mapper/BaseAreaMapper.java
Unescape Escape View File

@ -4,6 +4,7 @@ import java.util.List;
import com.op.wms.domain.BaseArea;
import com.op.wms.domain.BaseWarehouse;
import org.apache.ibatis.annotations.Param;
/**
* 库区Mapper接口
@ -67,4 +68,6 @@ public interface BaseAreaMapper {
public String checkAreaDescUnique(BaseArea baseArea);
BaseWarehouse selectBaseWarehouse(BaseArea baseArea);
String selectBaseAreaListnew(@Param("baseArea")String baseArea);
}

2
op-modules/op-wms/src/main/java/com/op/wms/mapper/BaseProductAttachedMapper.java
Unescape Escape View File

@ -58,4 +58,6 @@ public interface BaseProductAttachedMapper {
* @return 结果
*/
public int deleteBaseProductAttachedByIds(String[] ids);
String selectBaseAreaListnew(String waCode1);
}

36
op-modules/op-wms/src/main/java/com/op/wms/mapper/OdsProcureOrderMapper.java
Unescape Escape View File

@ -3,6 +3,7 @@ package com.op.wms.mapper;
import java.util.List;
import com.op.wms.domain.OdsProcureOrder;
import com.op.wms.domain.WmsRawOrderIn;
import org.apache.ibatis.annotations.Param;
/**
@ -60,27 +61,27 @@ public interface OdsProcureOrderMapper {
*/
public int deleteOdsProcureOrderByIDs(String[] IDs);
Integer updateRealityNuById(OdsProcureOrder odsProcureOrder);
public Integer updateRealityNuById(OdsProcureOrder odsProcureOrder);
String selectBaseSupplier(OdsProcureOrder odsProcureOrder);
public String selectBaseSupplier(OdsProcureOrder odsProcureOrder);
List<OdsProcureOrder> selectOdsProcureOrderAlreadyList(OdsProcureOrder odsProcureOrder);
public List<OdsProcureOrder> selectOdsProcureOrderAlreadyList(OdsProcureOrder odsProcureOrder);
void updateOdsProcureOrderAddOperationNumber(OdsProcureOrder odsProcureOrder);
public void updateOdsProcureOrderAddOperationNumber(OdsProcureOrder odsProcureOrder);
List<OdsProcureOrder> selectOdsProcureOrderAlreadyReaderList(OdsProcureOrder odsProcureOrder);
public List<OdsProcureOrder> selectOdsProcureOrderAlreadyReaderList(OdsProcureOrder odsProcureOrder);
void updateOdsProcureOrderByProcureCode(OdsProcureOrder odsProcureOrder);
public void updateOdsProcureOrderByProcureCode(OdsProcureOrder odsProcureOrder);
List<OdsProcureOrder> getIdCardList(OdsProcureOrder odsProcureOrder);
public List<OdsProcureOrder> getIdCardList(OdsProcureOrder odsProcureOrder);
void addBatchPallet(@Param("list")List<OdsProcureOrder> dtos);
public void addBatchPallet(@Param("list")List<OdsProcureOrder> dtos);
OdsProcureOrder selectOdsProcureOrderCard(OdsProcureOrder odsProcureOrder);
public OdsProcureOrder selectOdsProcureOrderCard(OdsProcureOrder odsProcureOrder);
void updateodsProcureOrderCard(OdsProcureOrder order1);
public void updateodsProcureOrderCard(OdsProcureOrder order1);
OdsProcureOrder selectOdsProcureOrderByIDAndSap(String id);
public OdsProcureOrder selectOdsProcureOrderByIDAndSap(String id);
/**
* 查询包材采购单列表
@ -109,4 +110,17 @@ public interface OdsProcureOrderMapper {
public String selectOdsProcureOrderUserDefined7New(@Param("formattedTEM")String formattedDate);
public List<OdsProcureOrder> selectOdsProcureOrderListSH(OdsProcureOrder order2);
public void deleteBatchPalletBycard(@Param("wlCode")String wlCode);
public void updateOdsProcureOrderBy(WmsRawOrderIn wmsRawOrderIn);
public List<OdsProcureOrder> selectCardList(OdsProcureOrder odsProcureOrder);
public List<OdsProcureOrder> selectCardListSH(OdsProcureOrder odsProcureOrder);
public OdsProcureOrder selectOdsProcureOrderCardByUserDefined1new(OdsProcureOrder order);
public void updateodsProcureOrderCardTemNumber(OdsProcureOrder order);
public void updateodsProcureOrderCardByu1(OdsProcureOrder order1);
}

13
op-modules/op-wms/src/main/java/com/op/wms/mapper/WmsOdsMateStorageNewsMapper.java
Unescape Escape View File

@ -6,6 +6,7 @@ import com.op.wms.domain.WCSInventoryPlan;
import com.op.wms.domain.WmsOdsEmStorageNews;
import com.op.wms.domain.WmsOdsMateStorageNews;
import com.op.wms.domain.WmsToWCSDTO;
import org.apache.ibatis.annotations.Param;
/**
* 包材库存主表Mapper接口
@ -69,13 +70,17 @@ public interface WmsOdsMateStorageNewsMapper {
public void updateWmsOdsMateStorageNewsUpdateStorageAmount(WmsOdsMateStorageNews wmsOdsMateStorageNews);
List<WmsOdsMateStorageNews> selectWmsOdsMateStorageNewslsList(WmsOdsMateStorageNews wmsOdsMateStorageNews);
public List<WmsOdsMateStorageNews> selectWmsOdsMateStorageNewslsList(WmsOdsMateStorageNews wmsOdsMateStorageNews);
WmsOdsMateStorageNews selectWmsOdsMateStorageNewsLSByStorageId(String storageId);
public WmsOdsMateStorageNews selectWmsOdsMateStorageNewsLSByStorageId(String storageId);
public List<WmsOdsMateStorageNews> selectWmsOdsMateStorageNewsNEWSList(WmsOdsMateStorageNews wmsOdsMateStorageNews);
List<WmsOdsMateStorageNews> listWmsOdsMateStorageNews(WmsOdsMateStorageNews wmsOdsMateStorageNews);
public List<WmsOdsMateStorageNews> listWmsOdsMateStorageNews(WmsOdsMateStorageNews wmsOdsMateStorageNews);
List<WmsOdsMateStorageNews> listwmsFpStorageNews(WmsOdsMateStorageNews wmsOdsMateStorageNews);
public List<WmsOdsMateStorageNews> listwmsFpStorageNews(WmsOdsMateStorageNews wmsOdsMateStorageNews);
public void deleteWmsOdsMateStorageNewsBycard(@Param("wlCode")String wlCode);
public void updateodsProcureOrderCard(@Param("userDefined6")String userDefined6);
}

6
op-modules/op-wms/src/main/java/com/op/wms/mapper/WmsOdsMateStorageNewsSnMapper.java
Unescape Escape View File

@ -79,7 +79,9 @@ public interface WmsOdsMateStorageNewsSnMapper {
public void updateWmsOdsMateStorageNewsSnTWM(WmsOdsMateStorageNewsSn wmsRawOrderInNewsSn);
List<WmsOdsMateStorageNewsSn> cardDy(@Param("list")List<WmsOdsMateStorageNewsSn> list);
public List<WmsOdsMateStorageNewsSn> cardDy(@Param("list")List<WmsOdsMateStorageNewsSn> list);
String selectWmsOdsMateStorageNewsSnBC(OdsProcureOutOrder order);
public String selectWmsOdsMateStorageNewsSnBC(OdsProcureOutOrder order);
public void deleteWmsOdsMateStorageNewsSnBycard(@Param("wlCode")String wlCode);
}

13
op-modules/op-wms/src/main/java/com/op/wms/mapper/WmsRawOrderInSnMapper.java
Unescape Escape View File

@ -3,6 +3,7 @@ package com.op.wms.mapper;
import java.util.List;
import com.op.wms.domain.*;
import org.apache.ibatis.annotations.Param;
/**
* 原材料收货明细Mapper接口
@ -59,14 +60,16 @@ public interface WmsRawOrderInSnMapper {
*/
public int deleteWmsRawOrderInSnByRawOrderInSnIds(Long[] rawOrderInSnIds);
WmsRawOrderInSn selectwmsRfidNo(WmsToWCSDTO wmsToWCSDTO);
public WmsRawOrderInSn selectwmsRfidNo(WmsToWCSDTO wmsToWCSDTO);
void updateU1Byid(WmsRawOrderInSn wmsRawOrderInSn);
public void updateU1Byid(WmsRawOrderInSn wmsRawOrderInSn);
List<WmsRawOrderInSn> selecPurchaseOrderdeliPdaList(OdsProcureOrder odsProcureOrder);
public List<WmsRawOrderInSn> selecPurchaseOrderdeliPdaList(OdsProcureOrder odsProcureOrder);
void insertWmsLogotypeTable(WmsLogotypeTable wmsLogotypeTable);
public void insertWmsLogotypeTable(WmsLogotypeTable wmsLogotypeTable);
WmsRawOrderInSn selecPurchaseOrderdeliPdaById(OdsProcureOrder odsProcureOrder);
public WmsRawOrderInSn selecPurchaseOrderdeliPdaById(OdsProcureOrder odsProcureOrder);
public void deleteWmsRawOrderInByu5(@Param("dnNo")String dnNo,@Param("kem")String kem);
}

6
op-modules/op-wms/src/main/java/com/op/wms/service/IOdsProcureOrderService.java
Unescape Escape View File

@ -147,4 +147,10 @@ public interface IOdsProcureOrderService {
String handleUpdateSAP103(List<OdsProcureOrder> odsProcureOrder);
String handleUpdateSAP105(List<OdsProcureOrder> odsProcureOrder);
List<OdsProcureOrder> selectCardList(OdsProcureOrder odsProcureOrder);
String addOrderCardXNew(OdsProcureOrder orderList);
String upbatCardXNew(OdsProcureOrder order);
}

2
op-modules/op-wms/src/main/java/com/op/wms/service/IWmsOdsMateStorageNewsSnService.java
Unescape Escape View File

@ -63,4 +63,6 @@ public interface IWmsOdsMateStorageNewsSnService {
String cardDy(List<WmsOdsMateStorageNewsSn> list);
String cardBD(List<OdsProcureOutOrder> orderList);
String Removecard(List<OdsProcureOutOrder> orderList);
}

356
op-modules/op-wms/src/main/java/com/op/wms/service/impl/OdsProcureOrderServiceImpl.java
Unescape Escape View File

@ -9,6 +9,8 @@ import com.alibaba.fastjson.JSONObject;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*;
@ -84,7 +86,7 @@ public class OdsProcureOrderServiceImpl implements IOdsProcureOrderService {
@Autowired
private BaseProductAttachedMapper baseProductAttachedMapper;
private BaseAreaMapper baseAreaMapper;
@Value("${dayin.url1}")
private String dayinUrl1;
/**
@ -1064,6 +1066,7 @@ public class OdsProcureOrderServiceImpl implements IOdsProcureOrderService {
}
@Override
@DS("#header.poolName")
public void OutboundPostingSAPfc(List<OdsProcureOutOrder> orderList) {
// * 退料的移动类型为 262
// * 领料的移动类型为 261
@ -1086,12 +1089,16 @@ public class OdsProcureOrderServiceImpl implements IOdsProcureOrderService {
sapBackflushMPQuery.setMatnr(odsProcureOutOrder.getMaterialCode());//物料号
sapBackflushMPQuery.setQuantity(odsProcureOutOrder.getOutNumber().toString()); //数量
sapBackflushMPQuery.setMeins(odsProcureOutOrder.getUnit()); //基本计量单位
sapBackflushMPQuery.setBatch(odsProcureOutOrder.getUserDefined2()); //批号
sapBackflushMPQuery.setBatch(odsProcureOutOrder.getUserDefined1()); //批量
// sapBackflushMPQuery.setBatch(odsProcureOutOrder.getUserDefined1());
sapMaterialPostingFCList.add(sapBackflushMPQuery);
orderList2FC.add(odsProcureOutOrder);
}
if (sapMaterialPostingFCList.size() > 0) {
//反冲过账
for (SapBackflushMPQuery sapBackflushMPQuery:sapMaterialPostingFCList){
System.out.println(sapBackflushMPQuery.toString());
}
R result2 = remoteSapService.sapBackflushMP(sapMaterialPostingFCList);//x
int code = result2.getCode();
OdsProcureOutOrder order = new OdsProcureOutOrder();
@ -1121,7 +1128,6 @@ public class OdsProcureOrderServiceImpl implements IOdsProcureOrderService {
@Override
@DS("#header.poolName")
public String getIdCardList(OdsProcureOrder odsProcureOrder) {
// DynamicDataSourceContextHolder.push("ds_" + odsProcureOrder.getFactoryCode());
List<OdsProcureOrder> dtos = new ArrayList<>();
OdsProcureOrder order=odsProcureOrderMapper.selectOdsProcureOrderByID(odsProcureOrder.getID());
//根据采购单获取一托盘要装多少
@ -1133,6 +1139,23 @@ public class OdsProcureOrderServiceImpl implements IOdsProcureOrderService {
//没有配置附属信息
return "没有配置附属信息";
}
String waCode1 = baseProductAttacheds.get(0).getWaCode();
if (waCode1==null|| waCode1.isEmpty()){
//没有配置附属信息
return "没有配置库区";
}
// BaseArea baseArea=new BaseArea();
// baseArea.setAreaCode(baseProductAttacheds.get(0).getWaCode());
//根据库区查询仓库
String whCode= baseProductAttachedMapper.selectBaseAreaListnew(waCode1);
if (whCode==null){
//没有配置附属信息
return "库区配置错误，查询不到对应仓库";
}
// String whCode = baseAreas.get(0).getWhCode();//仓库
String waCode = baseProductAttacheds.get(0).getWaCode();//库区
String name = odsProcureOrderMapper.selectBaseSupplier(order);
order.setSupplierName(name);
List<OdsProcureOrder> dtos0= odsProcureOrderMapper.getIdCardList(order);
@ -1142,7 +1165,6 @@ public class OdsProcureOrderServiceImpl implements IOdsProcureOrderService {
int i = 1;
String palletNum = baseProductAttacheds.get(0).getPalletNum();
Date nowDate = DateUtils.getNowDate();
if(palletNum!=null){
BigDecimal pall = order.getPlanNumber();
BigDecimal pn = new BigDecimal(palletNum);
@ -1155,6 +1177,7 @@ public class OdsProcureOrderServiceImpl implements IOdsProcureOrderService {
pw.setMaterialCode(order.getMaterialCode());
pw.setMaterialDesc(order.getMaterialDesc());
pw.setPlanNumber(pn);
pw.setTemNumber(pn);
pw.setSupplierCode(order.getSupplierCode());
pw.setSupplierName(order.getSupplierName());
pw.setUserDefined8(order.getUserDefined8());
@ -1165,19 +1188,23 @@ public class OdsProcureOrderServiceImpl implements IOdsProcureOrderService {
pw.setUnit(order.getUnit());
if(pall.compareTo(pn)<0) {//最后一托盘
pw.setPlanNumber(pall);
pw.setTemNumber(pall);
}else{
pw.setPlanNumber(pn);
pw.setTemNumber(pn);
}
pw.setCardNum(String.valueOf(i++));
String dateString = pw.getUserDefined11().replace("-", "");
pw.setUserDefined1(pw.getProcureCode()+"-"+pw.getUserDefined3()+"-"+pw.getUserDefined8()+"-"+dateString+"-"+odsProcureOrder.getID()+"-"+pw.getCardNum());//采购单+行项目+类型+日期+板次
pw.setCreateTime(nowDate);
pw.setActive("1");
pw.setUserDefined5(whCode);
pw.setUserDefined6(waCode);
pw.setRealityNumber(new BigDecimal("0"));
dtos.add(pw);
pall = pall.subtract(pn);
}
}
if(!CollectionUtils.isEmpty(dtos)){
int tem= dtos.size();
int ken=1;
@ -1209,6 +1236,7 @@ public class OdsProcureOrderServiceImpl implements IOdsProcureOrderService {
pw.setMaterialCode(order.getMaterialCode());
pw.setMaterialDesc(order.getMaterialDesc());
pw.setPlanNumber(pn);
pw.setTemNumber(pn);
pw.setSupplierCode(order.getSupplierCode());
pw.setSupplierName(order.getSupplierName());
pw.setUserDefined8(order.getUserDefined8());
@ -1219,14 +1247,19 @@ public class OdsProcureOrderServiceImpl implements IOdsProcureOrderService {
pw.setUnit(order.getUnit());
if(pall.compareTo(pn)<0) {//最后一托盘
pw.setPlanNumber(pall);
pw.setTemNumber(pall);
}else{
pw.setPlanNumber(pn);
pw.setTemNumber(pn);
}
pw.setCardNum(String.valueOf(i++));
String dateString = pw.getUserDefined11().replace("-", "");
pw.setUserDefined1(pw.getProcureCode()+"-"+pw.getUserDefined3()+"-"+pw.getUserDefined8()+"-"+dateString+"-"+odsProcureOrder.getID()+"-"+pw.getCardNum());//采购单+行项目+类型+日期+板次
pw.setCreateTime(nowDate);
pw.setActive("1");
pw.setUserDefined5(whCode);
pw.setUserDefined6(waCode);
pw.setRealityNumber(new BigDecimal("0"));
dtos.add(pw);
pall = pall.subtract(pn);
}
@ -1260,6 +1293,278 @@ public class OdsProcureOrderServiceImpl implements IOdsProcureOrderService {
String msg= dayin(dtos);
return msg;
}
@Override
public List<OdsProcureOrder> selectCardList(OdsProcureOrder odsProcureOrder) {
DynamicDataSourceContextHolder.push("ds_" + odsProcureOrder.getFactoryCode());
List<OdsProcureOrder> orderList= odsProcureOrderMapper.selectCardList(odsProcureOrder);
return orderList;
}
@Override
public String addOrderCardXNew(OdsProcureOrder ordernew) {
String factoryCode = ordernew.getFactoryCode();
//现在是传了个list标识卡集合
String result1="操作成功";
DynamicDataSourceContextHolder.push("ds_" + factoryCode);
List<OdsProcureOrder> orderList= odsProcureOrderMapper.selectCardListSH(ordernew);
if (orderList.size()==0){
result1="生成的标识卡已经暂收完成";
return result1;
}
//到货单生成
LocalDateTime now = LocalDateTime.now(); // 获取当前时间
// 格式化当前时间为指定的字符串格式
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyyMMddHHmmss"); // 定义时间格式
String dnNo = "sn" + now.format(formatter); // 生成流水号
String receiptNoCode = dnNo;
//如果这样的话，就区分出来单子和对应的物料。然后根据集合放入暂收集合中
List<OdsProcureOrder> orderList1=new ArrayList<>();//
for (OdsProcureOrder order:
orderList) {
OdsProcureOrder order1= odsProcureOrderMapper.selectOdsProcureOrderCardByUserDefined1(order);
order.setUserDefined7(order1.getUserDefined7());//批次
order.setPoLine(order1.getUserDefined3());
order.setUnit(order1.getUnit());
order.setID(order1.getID());
// order1.setReceiptNoCode(dnNo);
order.setReceiptNoCode(dnNo);
if (orderList1.size()>0){
String tem="0";
for (OdsProcureOrder odsProcureOrder:orderList1){
if (odsProcureOrder.getID().equals(order1.getID())){
tem="1";//已经保存对应订单了
}
}
if (tem.equals("0")){
orderList1.add(order1);
}
}else {
orderList1.add(order1);
}
}
for (OdsProcureOrder odsProcureOrder:
orderList1) {
//单子
BigDecimal czNumber=new BigDecimal("0");
for ( OdsProcureOrder order :
orderList) {
if (order.getID().equals(odsProcureOrder.getID())){
czNumber=czNumber.add(order.getPlanNumber());//累计操作数量
}
}
odsProcureOrder.setCzNumber(czNumber);//累计的操作数量
}
List<Map> mapList = new ArrayList<>();
for (OdsProcureOrder order :
orderList1) {
Map paramMap=new HashMap<>();
paramMap.put("EBELN",order.getProcureCode());//
paramMap.put("EBELP",order.getUserDefined3());//行项目
paramMap.put("MATNR",order.getMaterialCode());//物料
paramMap.put("WERKS",order.getSiteCode());//工厂
paramMap.put("QUANTITY",order.getCzNumber());//数量
paramMap.put("P_LFSNR",order.getUserDefined5());//送
mapList.add(paramMap);
}
R result2 = remoteSapService.temporarilyCollected(mapList);
int code = result2.getCode();
if (code == 200){
//对应采购单的标识卡
for (OdsProcureOrder order1k:
orderList) {
//标识卡信息
//wms_raw_order_in_sn
WmsRawOrderInSn wmsRawOrderInSn = new WmsRawOrderInSn();
wmsRawOrderInSn.setRawOrderInSnId(IdUtils.fastSimpleUUID());
wmsRawOrderInSn.setUserDefined1("1");//１是收货，２是入库
wmsRawOrderInSn.setUserDefined2(order1k.getUserDefined7());//批次
wmsRawOrderInSn.setWhCode(order1k.getWhCode());//厂库编号
wmsRawOrderInSn.setWaCode(order1k.getWaCode());
wmsRawOrderInSn.setWlCode(order1k.getSn());//库位设置为托盘
wmsRawOrderInSn.setPoNo(order1k.getProcureCode());//采购单号
wmsRawOrderInSn.setPoLine(order1k.getPoLine());//行项目
wmsRawOrderInSn.setMaterialCode(order1k.getMaterialCode());
wmsRawOrderInSn.setMaterialDesc(order1k.getMaterialDesc());
wmsRawOrderInSn.setAmount(order1k.getPlanNumber());//实际输入数量
wmsRawOrderInSn.setFactoryCode(order1k.getFactoryCode());
wmsRawOrderInSn.setCreateBy(order1k.getCreateBy());
wmsRawOrderInSn.setGmtCreate(new Date());
wmsRawOrderInSn.setActiveFlag("1");
wmsRawOrderInSn.setUserDefined4(order1k.getUnit());//单位
wmsRawOrderInSn.setSn(order1k.getSn());//托盘号
wmsRawOrderInSn.setFactoryCode(order1k.getFactoryCode());
wmsRawOrderInSn.setUserDefined3(order1k.getID());
wmsRawOrderInSn.setUserDefined5(order1k.getReceiptNoCode());
//wmsRawOrderInSn.setd
wmsRawOrderInSn.setUserDefined6(order1k.getUserDefined6());//标识码绑定
wmsRawOrderInSnMapper.insertWmsRawOrderInSn(wmsRawOrderInSn);//入库库明细记录
//标识码绑定----这个托盘绑定标识卡的用不上了已经--因为操作里面没有托盘
// if (order1k.getUserDefined6()!=null){
// WmsLogotypeTable wmsLogotypeTable=new WmsLogotypeTable();
// wmsLogotypeTable.setId(IdUtils.fastSimpleUUID());
// wmsLogotypeTable.setLogotype(order1k.getUserDefined6());
// wmsLogotypeTable.setSn(order1k.getSn());
// wmsLogotypeTable.setActiveFlag("1");
// wmsRawOrderInSnMapper.insertWmsLogotypeTable(wmsLogotypeTable);
// }
OdsProcureOrder order=new OdsProcureOrder();
order.setUserDefined1(order1k.getSn());
OdsProcureOrder order1= odsProcureOrderMapper.selectOdsProcureOrderCard(order);
//判断状态，
BigDecimal realityNumber1 = order1.getRealityNumber();//累出库数
BigDecimal realityNumber = order1.getPlanNumber();//计划
BigDecimal planNumber = order1k.getPlanNumber();//本次实际数量
BigDecimal tem = realityNumber1.add(planNumber);
if (tem.compareTo(realityNumber)>= 0) {
order1.setRealityNumber(tem);
order1.setTemNumber(new BigDecimal("0"));
order1.setOrderStatus("1");//完全收货
} else {
order1.setRealityNumber(tem);
order1.setTemNumber(realityNumber.subtract(tem));
order1.setOrderStatus("2");//部分收货
}
odsProcureOrderMapper.updateodsProcureOrderCardByu1(order1);//更新标识卡。状态为1
}
Map map = new HashMap();
map = (Map) result2.getData();
String MATERIALDOCUMENT = (String) map.get("MATERIALDOCUMENT");
String MATDOCUMENTYEAR = (String) map.get("MATDOCUMENTYEAR");
for (OdsProcureOrder odsProcureOrder:
orderList1) {
BigDecimal planNumber= odsProcureOrder.getPlanNumber();
;//操作数量
odsProcureOrder.setOrderStatus("1");
BigDecimal result = odsProcureOrder.getRealityNumber().add(odsProcureOrder.getCzNumber());
System.out.println(result);
if (result.compareTo(planNumber)== 0) {
odsProcureOrder.setOrderStatus("2");
}
odsProcureOrder.setPlanNumber(odsProcureOrder.getCzNumber());
odsProcureOrderMapper.updateRealityNuById(odsProcureOrder);
}
for (OdsProcureOrder odsProcureOrder:
orderList1) {
//标识卡记录已经录入，订单已经修改完成
OdsProcureOrder order1 = odsProcureOrderMapper.selectOdsProcureOrderByID(odsProcureOrder.getID());
order1.setSapTempInfor(result2.getMsg());
WmsRawOrderIn wmsRawOrderIn=new WmsRawOrderIn();
wmsRawOrderIn.setRawOrderInId(IdUtils.fastSimpleUUID());
wmsRawOrderIn.setFactoryCode(odsProcureOrder.getFactoryCode());
wmsRawOrderIn.setOrderNo(order1.getUserDefined5());//送货单
wmsRawOrderIn.setDnNo(receiptNoCode);//有问提
wmsRawOrderIn.setPoNo(odsProcureOrder.getProcureCode());
wmsRawOrderIn.setPoLine(odsProcureOrder.getUserDefined3());//有问题
wmsRawOrderIn.setMaterialCode(odsProcureOrder.getMaterialCode());
wmsRawOrderIn.setMaterialDesc(odsProcureOrder.getMaterialDesc());
wmsRawOrderIn.setRequestAmount(odsProcureOrder.getCzNumber());
wmsRawOrderIn.setUnit(odsProcureOrder.getUnit());
wmsRawOrderIn.setRequestTime(new Date());
wmsRawOrderIn.setOrderStatus("0");//暂收
wmsRawOrderIn.setActiveFlag("1");
wmsRawOrderIn.setSupplyCode(odsProcureOrder.getSupplierCode());
//wmsRawOrderIn.setUserDefined1();
wmsRawOrderIn.setAccountingStatus("0");//0是暂收
wmsRawOrderIn.setUserDefined1(MATERIALDOCUMENT);//物料凭证编号
wmsRawOrderIn.setUserDefined2(MATDOCUMENTYEAR);//年凭证号
wmsRawOrderIn.setUserDefined3(result2.getMsg());//暂收信息
//wmsRawOrderIn.setAccountingMessage(result2.getMsg());
wmsRawOrderIn.setSapFactoryCode(factoryCode);
wmsRawOrderIn.setCreateBy(odsProcureOrder.getCreateBy());
wmsRawOrderIn.setGmtCreate(new Date());
wmsRawOrderInMapper.insertWmsRawOrderIn(wmsRawOrderIn);//到货单
order1.setSapTempStatus("1");//0是失败。1是成功
odsProcureOrderMapper.updateOdsProcureOrder(order1);//采购单秀改
}
for (OdsProcureOrder odsProcureOrder1:orderList){
//收货
WmsOdsMateStorageNewsSn wmsOdsMateStorageNewsSn = new WmsOdsMateStorageNewsSn();
wmsOdsMateStorageNewsSn.setWhCode(odsProcureOrder1.getWhCode());//仓库编码
wmsOdsMateStorageNewsSn.setWaCode(odsProcureOrder1.getWaCode());
wmsOdsMateStorageNewsSn.setWlCode(odsProcureOrder1.getSn());//库位编码-
wmsOdsMateStorageNewsSn.setMaterialCode(odsProcureOrder1.getMaterialCode());
wmsOdsMateStorageNewsSn.setMaterialDesc(odsProcureOrder1.getMaterialDesc());
wmsOdsMateStorageNewsSn.setSn(odsProcureOrder1.getSn());
wmsOdsMateStorageNewsSn.setCreateBy(odsProcureOrder1.getCreateBy());
wmsOdsMateStorageNewsSn.setGmtCreate(new Date());
wmsOdsMateStorageNewsSn.setUserDefined2(odsProcureOrder1.getUserDefined7());//批次
wmsOdsMateStorageNewsSn.setUserDefined1("RK");
wmsOdsMateStorageNewsSn.setFactoryCode(odsProcureOrder1.getFactoryCode());
wmsOdsMateStorageNewsSn.setSapFactoryCode(odsProcureOrder1.getFactoryCode());
wmsOdsMateStorageNewsSn.setActiveFlag("1");
List<WmsOdsMateStorageNewsSn> wmsOdsMateStorageNewsSnList= wmsOdsMateStorageNewsSnMapper.selectWmsOdsMateStorageNewsSnList(wmsOdsMateStorageNewsSn);
if (wmsOdsMateStorageNewsSnList.size()>0){//更新
WmsOdsMateStorageNewsSn wmsOdsMateStorageNewsSn1= wmsOdsMateStorageNewsSnList.get(0);
wmsOdsMateStorageNewsSn1.setAmount(wmsOdsMateStorageNewsSn1.getAmount().add(odsProcureOrder1.getPlanNumber()));
wmsOdsMateStorageNewsSnMapper.updateWmsOdsMateStorageNewsSn(wmsOdsMateStorageNewsSn1);
}else {//插入
wmsOdsMateStorageNewsSn.setUserDefined3("0");//0是暂收，1是真收
wmsOdsMateStorageNewsSn.setAmount(odsProcureOrder1.getPlanNumber());
wmsOdsMateStorageNewsSn.setMateOrderInSnId(IdUtils.fastSimpleUUID());
wmsOdsMateStorageNewsSnMapper.insertWmsOdsMateStorageNewsSn(wmsOdsMateStorageNewsSn);//插入库存
}
//２，修改库存－－－／加库存数量-/-冻结数量
WmsOdsEmStorageNews wmsOdsEmStorageNews = new WmsOdsEmStorageNews();
wmsOdsEmStorageNews.setWhCode(odsProcureOrder1.getWhCode());//仓库编码
wmsOdsEmStorageNews.setWlCode(odsProcureOrder1.getSn());//库位编码
wmsOdsEmStorageNews.setWaCode(odsProcureOrder1.getWaCode());//库位编码
wmsOdsEmStorageNews.setMaterialCode(odsProcureOrder1.getMaterialCode());
wmsOdsEmStorageNews.setUserDefined2(odsProcureOrder1.getUserDefined7());//批次
wmsOdsEmStorageNews.setAmount(odsProcureOrder1.getPlanNumber());
//添加库存--这个要有个判断有没有这个库存如果没有的话，就插入
WmsOdsMateStorageNews wmsOdsMateStorageNews = wmsOdsMateStorageNewsMapper.selectByWhCodeAndMate(wmsOdsEmStorageNews);
if (wmsOdsMateStorageNews == null) {
WmsOdsMateStorageNews wmsOdsMateStorageNews1 = new WmsOdsMateStorageNews();
wmsOdsMateStorageNews1.setStorageId(IdUtils.fastSimpleUUID());
wmsOdsMateStorageNews1.setWhCode(odsProcureOrder1.getWhCode());
wmsOdsMateStorageNews1.setWlCode(odsProcureOrder1.getSn());
wmsOdsMateStorageNews1.setWaCode(odsProcureOrder1.getWaCode());
wmsOdsMateStorageNews1.setAmount(odsProcureOrder1.getPlanNumber());
wmsOdsMateStorageNews1.setStorageAmount(odsProcureOrder1.getPlanNumber());
wmsOdsMateStorageNews1.setMaterialCode(odsProcureOrder1.getMaterialCode());
wmsOdsMateStorageNews1.setMaterialDesc(odsProcureOrder1.getMaterialDesc());
wmsOdsMateStorageNews1.setStorageType("BC");
wmsOdsMateStorageNews1.setCreateBy(odsProcureOrder1.getCreateBy());
wmsOdsMateStorageNews1.setGmtCreate(new Date());
wmsOdsMateStorageNews1.setActiveFlag("1");
wmsOdsMateStorageNews1.setFactoryCode(odsProcureOrder1.getFactoryCode());
wmsOdsMateStorageNews1.setSapFactoryCode(odsProcureOrder1.getFactoryCode());
wmsOdsMateStorageNews1.setUserDefined1(odsProcureOrder1.getUnit());//单位
wmsOdsMateStorageNewsMapper.insertWmsOdsMateStorageNews(wmsOdsMateStorageNews1);
} else {
wmsOdsMateStorageNewsSnMapper.updateAdd(wmsOdsEmStorageNews);
}
// wmsRawOrderInSnMapper.updateU1Byid(wmsRawOrderInSn);//入库
}
}else {////失败|
result1="暂收失败";
for (OdsProcureOrder order :
orderList1) {
OdsProcureOrder order2 = odsProcureOrderMapper.selectOdsProcureOrderByID(order.getID());
order2.setSapTempInfor(result2.getMsg());
order2.setSapTempStatus("0");//0是失败。1是成功
odsProcureOrderMapper.updateOdsProcureOrder(order2);
}
return result1;
}
return result1;
}
@Override
public String upbatCardXNew(OdsProcureOrder order) {
String result="修改成功";
DynamicDataSourceContextHolder.push("ds_" + order.getFactoryCode());
odsProcureOrderMapper.updateodsProcureOrderCardTemNumber(order);//更新标识卡。状态为1
return result;
}
@Override
@DS("#header.poolName")
@ -2627,6 +2932,7 @@ public class OdsProcureOrderServiceImpl implements IOdsProcureOrderService {
* @return
*/
@Override
@DS("#header.poolName")
public String handleUpdateSAP103(List<OdsProcureOrder> odsProcureOrders) {
String result="操作成功";
for (OdsProcureOrder order: odsProcureOrders){
@ -2635,8 +2941,8 @@ public class OdsProcureOrderServiceImpl implements IOdsProcureOrderService {
//暂收状态的--其中备用字段1是用来保存暂收的凭证的，，
Map paramMap=new HashMap<>();
List<Map> mapList = new ArrayList<>();
paramMap.put("S_MBLNR",wmsRawOrderIn.getUserDefined1());
paramMap.put("S_MJAHR",wmsRawOrderIn.getUserDefined2());
paramMap.put("S_MBLNR",wmsRawOrderIn.getUserDefined1());//参考凭证的凭证号
paramMap.put("S_MJAHR",wmsRawOrderIn.getUserDefined2());//参考凭证会计年度
paramMap.put("S_MATNR",wmsRawOrderIn.getMaterialCode());
paramMap.put("incomeBatchNo",wmsRawOrderIn.getIncomeBatchNo()); //批次
paramMap.put("ebelp",wmsRawOrderIn.getPoLine());
@ -2652,8 +2958,7 @@ public class OdsProcureOrderServiceImpl implements IOdsProcureOrderService {
//成功了--成功了,根据
WmsRawOrderInSn wmsRawOrderInSn=new WmsRawOrderInSn();
wmsRawOrderInSn.setUserDefined5(wmsRawOrderIn.getDnNo());
wmsRawOrderInSn.setUserDefined1("1");//暂收--１是收货，２是入库，，3是103冲销
wmsRawOrderInSn.setUserDefined1("1");//暂收--１是收货，２是入库，，
wmsRawOrderInSn.setUserDefined3(wmsRawOrderIn.getKem());
List<WmsRawOrderInSn> wmsRawOrderInSnList= wmsRawOrderInSnMapper.selectWmsRawOrderInSnList(wmsRawOrderInSn);
for (WmsRawOrderInSn wmsRawOrderInSn1:
@ -2664,30 +2969,31 @@ public class OdsProcureOrderServiceImpl implements IOdsProcureOrderService {
wmsRawOrderInNewsSn.setWhCode(wmsRawOrderInSn1.getWhCode());
wmsRawOrderInNewsSn.setWlCode(wmsRawOrderInSn1.getWlCode());
wmsRawOrderInNewsSn.setUserDefined3("1");
wmsOdsMateStorageNewsSnMapper.updateWmsOdsMateStorageNewsSnTWM(wmsRawOrderInNewsSn);//wms_ods_mate_storage_news_sn
wmsRawOrderInSn1.setUserDefined1("2");
wmsRawOrderInSnMapper.updateWmsRawOrderInSn(wmsRawOrderInSn1);
wmsOdsMateStorageNewsSnMapper.deleteWmsOdsMateStorageNewsSnBycard(wmsRawOrderInNewsSn.getWlCode());//wms_ods_mate_storage_news_sn
wmsRawOrderInSn1.setUserDefined1("2");//直接删掉
WmsOdsMateStorageNews wmsOdsMateStorageNews=new WmsOdsMateStorageNews();
wmsOdsMateStorageNews.setMaterialCode(wmsRawOrderInSn1.getMaterialCode());
wmsOdsMateStorageNews.setWaCode(wmsRawOrderInSn1.getWaCode());
wmsOdsMateStorageNews.setWlCode(wmsRawOrderInSn1.getWlCode());
wmsOdsMateStorageNews.setWhCode(wmsRawOrderInSn1.getWhCode());
wmsOdsMateStorageNews.setStorageAmount(wmsRawOrderInSn1.getAmount());
wmsOdsMateStorageNewsMapper.updateWmsOdsMateStorageNewsUpdateStorageAmount(wmsOdsMateStorageNews);
wmsOdsMateStorageNewsMapper.deleteWmsOdsMateStorageNewsBycard(wmsOdsMateStorageNews.getWlCode());
//修改card
wmsOdsMateStorageNewsMapper.updateodsProcureOrderCard(wmsRawOrderInSn1.getUserDefined6());
}
wmsRawOrderIn.setOrderStatus("1");
wmsRawOrderIn.setAccountingTime(new Date());
wmsRawOrderIn.setAccountingMessage(result2.getMsg());
wmsRawOrderIn.setUserDefined4(MATERIALDOCUMENT);
wmsRawOrderIn.setUserDefined5(MATDOCUMENTYEAR);
wmsRawOrderInSnMapper.deleteWmsRawOrderInByu5(wmsRawOrderIn.getDnNo(),wmsRawOrderIn.getKem());//---原材料收货明细
wmsRawOrderIn.setOrderStatus("5");//冲销
wmsRawOrderIn.setGmtModified(new Date());
wmsRawOrderIn.setUserDefined9(result2.getMsg());
wmsRawOrderIn.setUserDefined6(MATERIALDOCUMENT);
wmsRawOrderIn.setUserDefined7(MATDOCUMENTYEAR);
wmsRawOrderInMapper.updateWmsRawOrderIn(wmsRawOrderIn);
odsProcureOrderMapper.updateOdsProcureOrderBy(wmsRawOrderIn);
}else {
//失败了
wmsRawOrderIn.setAccountingTime(new Date());
wmsRawOrderIn.setAccountingMessage(result2.getMsg());
wmsRawOrderIn.setGmtModified(new Date());
wmsRawOrderIn.setUserDefined9(result2.getMsg());
wmsRawOrderInMapper.updateWmsRawOrderIn(wmsRawOrderIn);
}
}
return result;
@ -2702,7 +3008,7 @@ public class OdsProcureOrderServiceImpl implements IOdsProcureOrderService {
String result="操作成功";
for (OdsProcureOrder order: odsProcureOrders){
OdsProcureOrder odsProcureOrder = order;
WmsRawOrderIn wmsRawOrderIn= wmsRawOrderInMapper.selectWmsRawOrderInByRawOrderInIdTWO(odsProcureOrder.getID());
WmsRawOrderIn wmsRawOrderIn= wmsRawOrderInMapper.selectWmsRawOrderInByRawOrderInIdThress(odsProcureOrder.getID());
//这个地方
Map paramMap=new HashMap<>();
List<Map> mapList = new ArrayList<>();
@ -2713,7 +3019,7 @@ public class OdsProcureOrderServiceImpl implements IOdsProcureOrderService {
paramMap.put("ebelp",wmsRawOrderIn.getPoLine());
paramMap.put("poNo",wmsRawOrderIn.getPoNo());
mapList.add(paramMap);
R result2 = remoteSapService.sap105temporarilyCollected(mapList);
R result2 = remoteSapService.handleUpdateSAP105(mapList);
if (result2.getCode()==200){
Map map = new HashMap();
map = (Map) result2.getData();
@ -2763,6 +3069,8 @@ public class OdsProcureOrderServiceImpl implements IOdsProcureOrderService {
return result;
}
// @Override
// public String addReturnSC(List<OdsProcureOrder> orderList) {
// String factoryCode = orderList.get(0).getFactoryCode();

59
op-modules/op-wms/src/main/java/com/op/wms/service/impl/WmsOdsMateStorageNewsSnServiceImpl.java
Unescape Escape View File

@ -10,9 +10,8 @@ import com.alibaba.fastjson2.JSONArray;
import com.baomidou.dynamic.datasource.annotation.DS;
import com.op.common.core.utils.uuid.IdUtils;
import com.op.common.security.utils.SecurityUtils;
import com.op.wms.domain.OdsProcureOrder;
import com.op.wms.domain.OdsProcureOutOrder;
import com.op.wms.domain.WmsOdsMateStorageNews;
import com.op.wms.domain.*;
import com.op.wms.mapper.BaseProductAttachedMapper;
import com.op.wms.mapper.OdsProcureOrderMapper;
import com.op.wms.mapper.WmsOdsMateStorageNewsMapper;
import okhttp3.*;
@ -20,7 +19,6 @@ import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import com.op.wms.mapper.WmsOdsMateStorageNewsSnMapper;
import com.op.wms.domain.WmsOdsMateStorageNewsSn;
import com.op.wms.service.IWmsOdsMateStorageNewsSnService;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
@ -45,6 +43,9 @@ public class WmsOdsMateStorageNewsSnServiceImpl implements IWmsOdsMateStorageNew
private OdsProcureOrderMapper odsProcureOrderMapper;
@Autowired
private WmsOdsMateStorageNewsMapper wmsOdsMateStorageNewsMapper;
@Autowired
private BaseProductAttachedMapper baseProductAttachedMapper;
/**
* 查询包材库存明细表
*
@ -160,7 +161,7 @@ public class WmsOdsMateStorageNewsSnServiceImpl implements IWmsOdsMateStorageNew
*/
@Override
@DS("#header.poolName")
public String cardBD(List<OdsProcureOutOrder> orderList) {//
public String cardBD(List<OdsProcureOutOrder> orderList) {
//获取当前所选工厂
HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
String key = "#header.poolName";
@ -168,7 +169,29 @@ public class WmsOdsMateStorageNewsSnServiceImpl implements IWmsOdsMateStorageNew
String factoryCode = request.getHeader(key.substring(8)).replace("ds_", "");
for (OdsProcureOutOrder order:
orderList) {
//入参是物料，仓库，库区，数量，生成标识卡，
//不需要前端传仓库和库区
BaseProductAttached baseProductAttached=new BaseProductAttached();
String trimmedMaterialCode = order.getMaterialCode().substring(7);
baseProductAttached.setProductCode(trimmedMaterialCode);
List<BaseProductAttached> baseProductAttacheds= baseProductAttachedMapper.selectBaseProductAttachedList(baseProductAttached);
if (baseProductAttacheds.size()==0){
//没有配置附属信息
return "没有配置附属信息";
}
String waCode1 = baseProductAttacheds.get(0).getWaCode();
if (waCode1==null|| waCode1.isEmpty()){
//没有配置附属信息
return "没有配置库区";
}
// BaseArea baseArea=new BaseArea();
// baseArea.setAreaCode(baseProductAttacheds.get(0).getWaCode());
//根据库区查询仓库
String whCode= baseProductAttachedMapper.selectBaseAreaListnew(waCode1);
if (whCode==null){
//没有配置附属信息
return "库区配置错误，查询不到对应仓库";
}
//入参是物料，仓库，库区，数量，生成标识卡，
String BC= wmsOdsMateStorageNewsSnMapper.selectWmsOdsMateStorageNewsSnBC(order);
List<OdsProcureOrder> dtos0=new ArrayList<>();
String setid=IdUtils.fastSimpleUUID();//
@ -197,7 +220,6 @@ public class WmsOdsMateStorageNewsSnServiceImpl implements IWmsOdsMateStorageNew
odsProcureOrder.setActive("1");
dtos0.add(odsProcureOrder);
odsProcureOrderMapper.addBatchPallet(dtos0);
WmsOdsMateStorageNews wmsOdsMateStorageNews3 = new WmsOdsMateStorageNews();
wmsOdsMateStorageNews3.setStorageId(IdUtils.fastSimpleUUID());
wmsOdsMateStorageNews3.setWhCode(order.getLocCode());
@ -214,7 +236,7 @@ public class WmsOdsMateStorageNewsSnServiceImpl implements IWmsOdsMateStorageNew
wmsOdsMateStorageNews3.setFactoryCode(factoryCode);
wmsOdsMateStorageNews3.setSapFactoryCode(factoryCode);
wmsOdsMateStorageNews3.setUserDefined1(order.getUnit());//单位
wmsOdsMateStorageNewsMapper.insertWmsOdsMateStorageNews(wmsOdsMateStorageNews3);
// wmsOdsMateStorageNewsMapper.insertWmsOdsMateStorageNews(wmsOdsMateStorageNews3);
WmsOdsMateStorageNewsSn wmsOdsMateStorageNewsSn = new WmsOdsMateStorageNewsSn();
wmsOdsMateStorageNewsSn.setMateOrderInSnId(IdUtils.fastSimpleUUID());
wmsOdsMateStorageNewsSn.setWhCode(order.getLocCode());//仓库编码
@ -246,6 +268,27 @@ public class WmsOdsMateStorageNewsSnServiceImpl implements IWmsOdsMateStorageNew
return msg;
}
@Override
@DS("#header.poolName")
public String Removecard(List<OdsProcureOutOrder> orderList) {
//获取当前所选工厂
HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
String key = "#header.poolName";
String msg="删除成功";
// String factoryCode = request.getHeader(key.substring(8)).replace("ds_", "");
for (OdsProcureOutOrder order:
orderList) {
//入参是物料，仓库，库区，数量，生成标识卡，
odsProcureOrderMapper.deleteBatchPalletBycard(order.getWlCode());//更具标识卡删除
wmsOdsMateStorageNewsMapper.deleteWmsOdsMateStorageNewsBycard(order.getWlCode());
wmsOdsMateStorageNewsSnMapper.deleteWmsOdsMateStorageNewsSnBycard(order.getWlCode());
}
return msg;
}
public String dayin( List<OdsProcureOrder> orderList) {
// 定义请求的URL地址
String url = dayinUrl1;

10
op-modules/op-wms/src/main/java/com/op/wms/service/impl/WmsProductPutServiceImpl.java
Unescape Escape View File

@ -298,7 +298,7 @@ public class WmsProductPutServiceImpl implements IWmsProductPutService {
map.put("BATCH", wmsProductPut3.getAttr4());
map.put("STCK_TYPE", wmsProductPut1.getAttr3());
if (wmsProductPut3.getBatchNumber().length()==24){
if (wmsProductPut3.getBatchNumber().trim().length()==24){
String HSDAT = InterceptionSJRules(wmsProductPut3.getBatchNumber());
map.put("HSDAT", HSDAT);
@ -516,8 +516,8 @@ public class WmsProductPutServiceImpl implements IWmsProductPutService {
map.put("ERFME", mesReportWork.getUnit());
map.put("BATCH", mesReportWork.getBatchSK());
map.put("STCK_TYPE", selectedType);
if (mesReportWork.getBatch().length()==24){
//String batch = mesReportWork.getBatch().substring(12);
if (mesReportWork.getBatch().trim().length()==24){
String HSDAT = InterceptionSJRules(mesReportWork.getBatch());
map.put("HSDAT", HSDAT);
}else {
@ -559,7 +559,7 @@ public class WmsProductPutServiceImpl implements IWmsProductPutService {
map.put("ERFME", mesReportWork.getUnit());
map.put("BATCH", mesReportWork.getBatchSK());
map.put("STCK_TYPE", selectedType);
if (mesReportWork.getBatch().length()==24){
if (mesReportWork.getBatch().trim().length()==24){
//String batch = mesReportWork.getBatch().substring(12);
String HSDAT = InterceptionSJRules(mesReportWork.getBatch());
map.put("HSDAT", HSDAT);
@ -1172,7 +1172,7 @@ public class WmsProductPutServiceImpl implements IWmsProductPutService {
wmsProductPutk.setStatus("2");//
wmsProductPutk.setSapStatus("0");
wmsProductPutk.setAttr3(formattedDate);//
if (wmsProductPutk.getBatchNumber().length()==24){
if (wmsProductPutk.getBatchNumber().trim().length()==24){
//String batch = mesReportWork.getBatch().substring(12);
String batch = InterceptionRules(wmsProductPutk.getBatchNumber());
wmsProductPutk.setAttr4(batch);

10
op-modules/op-wms/src/main/resources/mapper/wms/BaseAreaMapper.xml
Unescape Escape View File

@ -76,11 +76,17 @@
<if test="userDefined3 != null and userDefined3 != ''">and user_defined3 = #{userDefined3}</if>
<if test="activeFlag != null and activeFlag != ''">and active_flag = #{activeFlag}</if>
<if test="factoryCode != null and factoryCode != ''">and factory_code = #{factoryCode}</if>
<if test="factoryCode != null and factoryCode != ''">and factory_code = #{factoryCode}</if>
and del_flag = '0'
</where>
</select>
<select id="selectBaseAreaListnew" resultType="java.lang.String">
SELECT
wh_code
FROM
base_area
where area_code like concat('%', #{baseArea}, '%')
</select>
<select id="selectBaseAreaByAreaId" parameterType="String" resultMap="BaseAreaResult">
<include refid="selectBaseAreaVo"/>
where area_id = #{areaId}

3
op-modules/op-wms/src/main/resources/mapper/wms/BaseEquipmentMapper.xml
Unescape Escape View File

@ -203,7 +203,8 @@
<if test="inventoryNumber != null and inventoryNumber != ''">and inventory_number = #{inventoryNumber}</if>
<if test="unitMeasurement != null and unitMeasurement != ''">and unit_measurement = #{unitMeasurement}</if>
<if test="sapCode != null and sapCode != ''">and sap_code = #{sapCode}</if>
<if test="sapName != null and sapName != ''">and sap_name = #{sapName}</if>
<if test="sapName != null and sapName != ''">and (sap_name like concat('%',#{sapName},'%') or sap_code like concat('%',#{sapName},'%'))
</if>
<if test="factoryWorkshop != null and factoryWorkshop != ''">and factory_workshop like concat('%', #{factoryWorkshop},'%')</if>
and del_flag ='0'
</where>

17
op-modules/op-wms/src/main/resources/mapper/wms/BaseProductAttachedMapper.xml
Unescape Escape View File

@ -25,11 +25,11 @@
<result property="other" column="other"/>
<result property="palletNum" column="pallet_num"/>
<result property="cpkType" column="cpk_type"/>
<result property="waCode" column="wa_code"/>
</resultMap>
<sql id="selectBaseProductAttachedVo">
select id, product_code, category, pc, iei, man_standar, spray_way, blank_diameter, blank_no, spray_volume, liquid_no, endometrial_dosage, outer_film_dosage, support, support_no, pvc, support_plate, pallet_num, other from base_product_attached
select id, product_code, category, pc, iei, man_standar, spray_way, blank_diameter, blank_no, spray_volume, liquid_no, endometrial_dosage, outer_film_dosage, support, support_no, pvc, support_plate, pallet_num, other,wa_code from base_product_attached
</sql>
<select id="selectBaseProductAttachedList" parameterType="BaseProductAttached"
@ -53,6 +53,7 @@
<if test="pvc != null ">and pvc = #{pvc}</if>
<if test="supportPlate != null ">and support_plate = #{supportPlate}</if>
<if test="other != null and other != ''">and other = #{other}</if>
<if test="waCode != null and waCode != ''">and wa_code = #{waCode}</if>
</where>
</select>
@ -106,6 +107,7 @@
<if test="pvc != null">pvc,</if>
<if test="supportPlate != null">support_plate,</if>
<if test="other != null">other,</if>
<if test="waCode != null">wa_code,</if>
</trim>
<trim prefix="values (" suffix=")" suffixOverrides=",">
<if test="id != null">#{id},</if>
@ -130,6 +132,7 @@
<if test="pvc != null">#{pvc},</if>
<if test="supportPlate != null">#{supportPlate},</if>
<if test="other != null">#{other},</if>
<if test="waCode != null">#{waCode},</if>
</trim>
</insert>
@ -167,7 +170,8 @@
pack_type = #{packType},
category=#{category},
other=#{other},
cpk_type=#{cpkType}
cpk_type=#{cpkType},
wa_code=#{waCode}
where id = #{id}
</update>
@ -181,4 +185,11 @@
#{id}
</foreach>
</delete>
<select id="selectBaseAreaListnew" resultType="java.lang.String">
SELECT
wh_code
FROM
base_area
where area_code like concat('%', #{baseArea}, '%')
</select>
</mapper>

10
op-modules/op-wms/src/main/resources/mapper/wms/BaseProductMapper.xml
Unescape Escape View File

@ -73,6 +73,7 @@
<result property="palletNum" column="palletNum"/>
<result property="warehouseCycle" column="warehouse_cycle"/>
<result property="packType" column="pack_type"/>
<result property="waCode" column="wa_code"/>
<!--附属属性-->
<result property="id" column="id"/>
@ -153,7 +154,11 @@
<if test="reportRate != null and reportRate != ''">and bp.report_rate = #{reportRate}</if>
<if test="mvgr5 != null and mvgr5 != ''">and bp.mvgr5 like concat('%', #{mvgr5},'%') </if>
<if test="cpkType != null and cpkType != ''">and bpa.cpk_type =#{cpkType} </if>
and bp.del_flag = '0' and bp.product_code not like '00000000%'
and bp.del_flag = '0' and (
bp.product_code like '00000001%' or bp.product_code like '00000002%' or bp.product_code like '00000003%'
or bp.product_code like '00000004%' or bp.product_code like '00000005%' or bp.product_code like '00000006%'
or bp.product_code like '00000007%'
)
</where>
order by bp.product_code asc
</select>
@ -222,7 +227,8 @@
bpa.pvc,
bpa.support_plate,
bpa.other,bpa.warehouse_cycle,bpa.pallet_num palletNum,
bpa.pack_type,bpa.cpk_type
bpa.pack_type,bpa.cpk_type,
bpa.wa_code
from base_product bp
left join base_product_attached bpa on bpa.product_code = right(bp.product_code,11)
where product_id = #{productId}

3
op-modules/op-wms/src/main/resources/mapper/wms/BpProcureOrderMapper.xml
Unescape Escape View File

@ -42,11 +42,14 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
<if test="attr4 != null and attr4 != ''"> and attr4 = #{attr4}</if>
<if test="attr5 != null and attr5 != ''"> and attr5 = #{attr5}</if>
</where>
ORDER BY
attr1 DESC
</select>
<select id="selectBpProcureOrderByID" parameterType="String" resultMap="BpProcureOrderResult">
<include refid="selectBpProcureOrderVo"/>
where ID = #{ID}
</select>
<select id="selectBpProcureOrderByProcureCode" parameterType="BpProcureOrder" resultMap="BpProcureOrderResult">

130
op-modules/op-wms/src/main/resources/mapper/wms/OdsProcureOrderMapper.xml
Unescape Escape View File

@ -41,6 +41,12 @@
<result property="sn" column="sn"/>
<result property="palletNum" column="pallet_num"/>
<result property="returnNumber" column="returnNumber"/>
<result property="whCode" column="whCode"/>
<result property="waCode" column="waCode"/>
<result property="factoryCode" column="factoryCode"/>
<result property="SapTempInfor" column="Sap_Temp_Infor"/>
<result property="temNumber" column="tem_number"/>
</resultMap>
<sql id="selectOdsProcureOrderVo">
@ -482,6 +488,7 @@
<if test="dto.enterpriseId != null">Enterprise_Id,</if>
<!-- 如果enterpriseCode不为null，则添加列名Enterprise_Code -->
<if test="dto.enterpriseCode != null">Enterprise_Code,</if>
<if test="dto.temNumber != null">tem_number,</if>
</trim>
<!-- 使用<trim>标签来处理值，这样可以自动去掉最后一个逗号 -->
<trim prefix="values (" suffix=")" suffixOverrides=",">
@ -549,6 +556,7 @@
<if test="dto.enterpriseId != null">#{dto.enterpriseId},</if>
<!-- 如果enterpriseCode不为null，则添加对应的值 -->
<if test="dto.enterpriseCode != null">#{dto.enterpriseCode},</if>
<if test="dto.temNumber != null">#{dto.temNumber},</if>
</trim>
</foreach>
</insert>
@ -559,6 +567,7 @@
card.Material_Code ,
card.Material_Desc ,
card.User_Defined3 ,
COALESCE ( card.Reality_Number, 0 ) Reality_Number,
card.User_Defined4 ,
card.User_Defined1 sn,
card.Plan_Number ,
@ -621,6 +630,7 @@
o.Last_Update_Date,
o.Active,
o.Enterprise_Id,
o.Sap_Temp_Infor,
o.Enterprise_Code,
base_product_attached.pallet_num, COALESCE ( Operation_Number, 0 ) Operation_Number
FROM
@ -671,6 +681,18 @@
SET User_Defined10 = '1'
where User_Defined1 = #{userDefined6}
</update>
<update id="updateodsProcureOrderCardByu1">
update ods_procure_order_card
SET User_Defined10 = #{orderStatus},
Reality_Number=#{realityNumber},
tem_number = #{temNumber}
where User_Defined1 = #{userDefined1}
</update>
<update id="updateodsProcureOrderCardTemNumber">
update ods_procure_order_card
SET tem_number = #{temNumber}
where User_Defined1 = #{userDefined1}
</update>
<select id="selectOdsProcureOrderCardByUserDefined1" parameterType="OdsProcureOrder" resultMap="OdsProcureOrderResult">
SELECT
ods_procure_order.Site_code,
@ -757,6 +779,9 @@
#{item.ID}
</foreach>
</delete>
<delete id="deleteBatchPalletBycard" >
delete from ods_procure_order_card where User_Defined1=#{wlCode}
</delete>
<select id="getIdCardListByU1" parameterType="OdsProcureOrder" resultMap="OdsProcureOrderResult">
SELECT
Site_code,
@ -811,5 +836,110 @@
AND (Plan_Number-COALESCE ( Operation_Number, 0 ))>0
order by Create_Date desc
</select>
<update id="updateOdsProcureOrderBy" >
update ods_procure_order
SET Order_Status = '1',
Reality_Number = COALESCE(Reality_Number, 0) - #{requestAmount}
where ID = #{kem}
</update>
<select id="selectCardList" resultMap="OdsProcureOrderResult">
SELECT
ods_procure_order_card.Site_code,
ods_procure_order_card.ID,
ods_procure_order_card.Procure_Code,
ods_procure_order_card.Material_Code,
ods_procure_order_card.Material_Desc,
ods_procure_order_card.Plan_Date,
ods_procure_order_card.Plan_Number,
ods_procure_order_card.Unit,
COALESCE ( ods_procure_order_card.Reality_Number, 0 ) Reality_Number,
ods_procure_order_card.card_num cardNum,
ods_procure_order_card.User_Defined1,
ods_procure_order_card.User_Defined2,
ods_procure_order_card.User_Defined3,
ods_procure_order_card.User_Defined4,
ods_procure_order_card.User_Defined5 whCode,
ods_procure_order_card.User_Defined6 waCode,
ods_procure_order_card.User_Defined7,
ods_procure_order_card.User_Defined8,
ods_procure_order_card.User_Defined9,
ods_procure_order_card.User_Defined10,
ods_procure_order_card.User_Defined11,
ods_procure_order_card.Supplier_Code,
ods_procure_order_card.Supplier_Name,
ods_procure_order_card.Remark,
ods_procure_order_card.Create_By,
ods_procure_order_card.Create_Date,
ods_procure_order_card.Last_Update_By,
ods_procure_order_card.Last_Update_Date,
ods_procure_order_card.Active,
ods_procure_order_card.Enterprise_Id,
ods_procure_order_card.Enterprise_Code,
ods_procure_order_card.tem_number,
ods_procure_order.user_defined5 User_Defined5,
COALESCE ( ods_procure_order_card.Operation_Number, 0 ) Operation_Number
FROM
ods_procure_order_card
LEFT JOIN ods_procure_order ON ods_procure_order.ID = TRY_CAST(ods_procure_order_card.User_Defined4 AS INT)
WHERE ods_procure_order.user_defined5=#{userDefined5}
</select>
<select id="selectCardListSH" resultMap="OdsProcureOrderResult">
SELECT
ods_procure_order_card.Site_code factoryCode,
ods_procure_order_card.Procure_Code,
ods_procure_order_card.Material_Code,
ods_procure_order_card.Material_Desc,
ods_procure_order_card.tem_number Plan_Number,
ods_procure_order_card.User_Defined1 User_Defined6,
ods_procure_order_card.User_Defined1 sn,
ods_procure_order_card.User_Defined5 whCode,
ods_procure_order_card.User_Defined6 waCode,
ods_procure_order.user_defined5 User_Defined5
FROM
ods_procure_order_card
LEFT JOIN ods_procure_order ON ods_procure_order.ID = TRY_CAST(ods_procure_order_card.User_Defined4 AS INT)
WHERE ods_procure_order.user_defined5=#{userDefined5}
AND ods_procure_order_card.User_Defined10='0'
</select>
<select id="selectOdsProcureOrderCardByUserDefined1new" parameterType="OdsProcureOrder" resultMap="OdsProcureOrderResult">
SELECT
ods_procure_order.Site_code,
ods_procure_order.ID,
ods_procure_order.Procure_Code,
ods_procure_order.Material_Code,
ods_procure_order.Material_Desc,
ods_procure_order.Plan_Date,
ods_procure_order.Plan_Number,
ods_procure_order.Unit,
COALESCE ( ods_procure_order.Reality_Number, 0 ) Reality_Number,
ods_procure_order.Order_Status,
ods_procure_order.User_Defined1,
ods_procure_order.User_Defined2,
ods_procure_order.User_Defined3,
ods_procure_order.User_Defined4,
ods_procure_order.User_Defined5,
ods_procure_order.User_Defined6,
ods_procure_order.User_Defined7,
ods_procure_order.User_Defined8,
ods_procure_order.User_Defined9,
ods_procure_order.User_Defined10,
ods_procure_order.User_Defined11,
ods_procure_order.Supplier_Code,
ods_procure_order.Supplier_Name,
ods_procure_order.Remark,
ods_procure_order.Create_By,
ods_procure_order.Create_Date,
ods_procure_order.Last_Update_By,
ods_procure_order.Last_Update_Date,
ods_procure_order.Active,
ods_procure_order.Enterprise_Id,
ods_procure_order.Enterprise_Code,
COALESCE ( ods_procure_order.Operation_Number, 0 ) Operation_Number
FROM
ods_procure_order_card
LEFT JOIN ods_procure_order ON ods_procure_order_card.User_Defined4= ods_procure_order.ID
WHERE
ods_procure_order_card.User_Defined1= #{userDefined1}
</select>
</mapper>

9
op-modules/op-wms/src/main/resources/mapper/wms/WmsOdsMateStorageNewsMapper.xml
Unescape Escape View File

@ -382,7 +382,9 @@
<delete id="deleteWmsOdsMateStorageNewsByStorageId" parameterType="String">
delete from wms_ods_mate_storage_news where storage_id = #{storageId}
</delete>
<delete id="deleteWmsOdsMateStorageNewsBycard" >
delete from wms_ods_mate_storage_news where wl_code = #{wlCode}
</delete>
<delete id="deleteWmsOdsMateStorageNewsByStorageIds" parameterType="String">
delete from wms_ods_mate_storage_news where storage_id in
<foreach item="storageId" collection="array" open="(" separator="," close=")">
@ -429,4 +431,9 @@
<if test="materialCode != null">product_code = #{materialCode}</if>
</where>
</select>
<update id="updateodsProcureOrderCard" >
update ods_procure_order_card
SET User_Defined10 = '0'
where User_Defined1 = #{userDefined6}
</update>
</mapper>

4
op-modules/op-wms/src/main/resources/mapper/wms/WmsOdsMateStorageNewsSnMapper.xml
Unescape Escape View File

@ -238,7 +238,9 @@
<delete id="deleteWmsOdsMateStorageNewsSnByMateOrderInSnId" parameterType="Long">
delete from wms_ods_mate_storage_news_sn where mate_order_in_sn_id = #{mateOrderInSnId}
</delete>
<delete id="deleteWmsOdsMateStorageNewsSnBycard" >
delete from wms_ods_mate_storage_news_sn where wl_code=#{wlCode}
</delete>
<delete id="deleteWmsOdsMateStorageNewsSnByMateOrderInSnIds" parameterType="String">
delete from wms_ods_mate_storage_news_sn where mate_order_in_sn_id in
<foreach item="mateOrderInSnId" collection="array" open="(" separator="," close=")">

1
op-modules/op-wms/src/main/resources/mapper/wms/WmsRawOrderInMapper.xml
Unescape Escape View File

@ -250,6 +250,7 @@
FROM
wms_raw_order_in
LEFT JOIN wms_raw_order_in_sn ON wms_raw_order_in.dn_no=wms_raw_order_in_sn.user_defined5 AND wms_raw_order_in_sn.po_no=wms_raw_order_in.po_no
AND wms_raw_order_in.material_code= wms_raw_order_in_sn.material_code
LEFT JOIN ods_procure_order ON ods_procure_order.ID= wms_raw_order_in_sn.user_defined3
where wms_raw_order_in.raw_order_in_id = #{rawOrderInId}
and wms_raw_order_in.order_status='0'

3
op-modules/op-wms/src/main/resources/mapper/wms/WmsRawOrderInSnMapper.xml
Unescape Escape View File

@ -254,4 +254,7 @@
#{activeFlag}
)
</insert>
<delete id="deleteWmsRawOrderInByu5" >
delete from wms_raw_order_in_sn where user_defined5 = #{dnNo} and user_defined3=#{kem}
</delete>
</mapper>

Write Preview
Loading…
Cancel
Save