修改

src/main/java/com/jeeplus/modules/sg/managementcenter/materialInventory/entity/MaterialInventory.java

@@ -0,0 +1,76 @@
+/**
+ * Copyright &copy; 2015-2020 <a href="http://www.jeeplus.org/">JeePlus</a> All rights reserved.
+ */
+package com.jeeplus.modules.sg.managementcenter.materialInventory.entity;
+
+import com.jeeplus.common.utils.excel.annotation.ExcelField;
+import com.jeeplus.core.persistence.DataEntity;
+
+public class MaterialInventory extends DataEntity<MaterialInventory> {
+	private static final long serialVersionUID = 1L;
+	private String materialCode;   //物料编码
+	private String materialDetail;   //物料描述
+	private Double stockQuantity;   //非限制库存数量
+	private Double frozenQuantity;   //已冻结库存数量
+	private Double availableStockQuantity;   //可用库存数量
+	private Double requireCount;//需求数量
+	private Double outCount;//已经出库数量
+	@ExcelField(title="需求数量", align=2, sort=5)
+	public Double getRequireCount() {
+		return requireCount;
+	}
+
+	public void setRequireCount(Double requireCount) {
+		this.requireCount = requireCount;
+	}
+	@ExcelField(title="已出库数量", align=2, sort=6)
+	public Double getOutCount() {
+		return outCount;
+	}
+
+	public void setOutCount(Double outCount) {
+		this.outCount = outCount;
+	}
+
+	@ExcelField(title="物料编码", align=2, sort=1)
+	public String getMaterialCode() {
+		return materialCode;
+	}
+
+	public void setMaterialCode(String materialCode) {
+		this.materialCode = materialCode;
+	}
+	@ExcelField(title="物料描述", align=2, sort=2)
+	public String getMaterialDetail() {
+		return materialDetail;
+	}
+
+	public void setMaterialDetail(String materialDetail) {
+		this.materialDetail = materialDetail;
+	}
+	@ExcelField(title="非限制库存数量", align=2, sort=3)
+	public Double getStockQuantity() {
+		return stockQuantity;
+	}
+
+	public void setStockQuantity(Double stockQuantity) {
+		this.stockQuantity = stockQuantity;
+	}
+	@ExcelField(title="已冻结库存数量", align=2, sort=4)
+	public Double getFrozenQuantity() {
+		return frozenQuantity;
+	}
+
+	public void setFrozenQuantity(Double frozenQuantity) {
+		this.frozenQuantity = frozenQuantity;
+	}
+	@ExcelField(title="可用库存数量", align=2, sort=7)
+	public Double getAvailableStockQuantity() {
+		return availableStockQuantity;
+	}
+
+	public void setAvailableStockQuantity(Double availableStockQuantity) {
+		this.availableStockQuantity = availableStockQuantity;
+	}
+}
+

src/main/java/com/jeeplus/modules/sg/managementcenter/materialInventory/util/ImportPro.java

@@ -0,0 +1,172 @@
+package com.jeeplus.modules.sg.managementcenter.materialInventory.util;
+import com.jeeplus.modules.sg.managementcenter.materialInventory.entity.MaterialInventory;
+import com.jeeplus.modules.sg.managementcenter.materialInventory.entity.MaterialRequisition;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.poi.ss.usermodel.Row;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+
+public class ImportPro {
+    /**
+     * 获取库存表格数据
+     * @param importUtil
+     * @return List<ErpAccount> 导入表格数据
+     */
+    public static List<MaterialInventory> getMaterialInventoryUtil(ImportUtil importUtil)  {
+        int lastRow = importUtil.getLastDataRowNum();
+        List<MaterialInventory> list = new ArrayList<MaterialInventory>();
+        MaterialInventory materialInventory = null;
+        String materialCode="";//物料编码
+        for(int i=1; i<lastRow;i++){
+            materialInventory = new MaterialInventory();
+            Row row = importUtil.getRow(i);
+            materialCode = (String)importUtil.getCellValue(row,3);
+            if (StringUtils.isNotBlank(materialCode)){
+                materialInventory.setMaterialCode(materialCode);
+                materialInventory.setMaterialDetail((String)importUtil.getCellValue(row,4));//物料描述
+                materialInventory.setStockQuantity(new Double((String)importUtil.getCellValue(row,6)));//非限制库存数量
+                materialInventory.setFrozenQuantity(new Double((String)importUtil.getCellValue(row,8)));//已冻结库存数量
+                list.add(materialInventory);
+            }
+        }
+        return list;
+    }
+
+    /**
+     * 获取领料单表格数据
+     * @param importUtil
+     * @return List<ErpAccount> 导入表格数据
+     */
+    public static List<MaterialRequisition> getMaterialRequisitionUtil(ImportUtil importUtil)  {
+        int lastRow = importUtil.getLastDataRowNum();
+        List<MaterialRequisition> list = new ArrayList<MaterialRequisition>();
+        MaterialRequisition materialRequisition = null;
+        String materialCode="";//物料编码
+        for(int i=1; i<lastRow;i++){
+            materialRequisition = new MaterialRequisition();
+            Row row = importUtil.getRow(i);
+            materialCode = (String)importUtil.getCellValue(row,12);
+            if (StringUtils.isNotBlank(materialCode)){
+               if (!materialCode.contains("物料")){
+                   materialRequisition.setMaterialCode(materialCode);//物料编码
+                   materialRequisition.setRequireCount(new Double((String)importUtil.getCellValue(row,15)));//需求数量
+                   materialRequisition.setOutCount(new Double((String)importUtil.getCellValue(row,16)));//已出库数量
+                   list.add(materialRequisition);
+               }
+            }
+        }
+        return list;
+    }
+    /*
+        得到可使用库存数量
+     */
+    public static List<MaterialInventory> getMaterial(List<MaterialInventory> materialInventories,List<MaterialRequisition> materialRequisitions){
+        Double availableStockQuantity = 0.0;
+        Double requireCount =0.0;
+        Double outCount = 0.0;
+        for (MaterialInventory materialInventory:materialInventories){
+            for (MaterialRequisition materialRequisition:materialRequisitions){
+                if (materialInventory.getMaterialCode().equals(materialRequisition.getMaterialCode())){
+                    availableStockQuantity = materialRequisition.getRequireCount()-materialRequisition.getOutCount();
+                    requireCount = materialRequisition.getRequireCount();
+                    outCount = materialRequisition.getOutCount();
+                    break;
+                }
+            }
+            materialInventory.setRequireCount(requireCount);
+            materialInventory.setOutCount(outCount);
+            availableStockQuantity = materialInventory.getStockQuantity() - availableStockQuantity;
+            materialInventory.setAvailableStockQuantity(availableStockQuantity);
+        }
+        return materialInventories;
+    }
+
+    /*
+     * 去重库存表
+     */
+    public static List<MaterialInventory> getSetMaterialInvenntory(List<MaterialInventory> materialInventories){
+        List<MaterialInventory> materialInventoryList = new ArrayList<MaterialInventory>();
+        boolean flag = true;
+        MaterialInventory material = null;
+        double count = 0.0;
+        for (MaterialInventory materialInventory:materialInventories){
+            flag = true;
+            for (MaterialInventory materialInventory1:materialInventoryList){
+                if (materialInventory1.getMaterialCode().equals(materialInventory.getMaterialCode())){
+                    count = materialInventory.getStockQuantity()+materialInventory1.getStockQuantity();
+                    materialInventory1.setStockQuantity(count);//非限制库存数量
+                    count = materialInventory.getFrozenQuantity()+materialInventory1.getFrozenQuantity();
+                    materialInventory1.setFrozenQuantity(count);//已冻结库存数量
+                    flag = false;
+                    break;
+                }
+            }
+            if (flag){
+                material = new MaterialInventory();
+                material.setMaterialCode(materialInventory.getMaterialCode());//物料编码
+                material.setMaterialDetail(materialInventory.getMaterialDetail());//物料描述
+                material.setStockQuantity(materialInventory.getStockQuantity());//非限制库存数量
+                material.setFrozenQuantity(materialInventory.getFrozenQuantity());//已冻结库存数量
+                materialInventoryList.add(material);
+            }
+        }
+        for (MaterialInventory materialInventory:materialInventoryList){
+            System.out.println(materialInventory);
+        }
+        return materialInventoryList;
+    }
+
+    /*
+     * 去重 附件5
+     */
+    public static List<MaterialRequisition> getSetMaterialRequisition(List<MaterialRequisition> requisitions){
+        List<MaterialRequisition> requisitionList = new ArrayList<MaterialRequisition>();
+        boolean flag = true;
+        MaterialRequisition requisition = null;
+        double count = 0.0;
+        for (MaterialRequisition materialRequisition:requisitions){
+            flag = true;
+            for (MaterialRequisition materialRequisition1:requisitionList){
+                if (materialRequisition.getMaterialCode().equals(materialRequisition1.getMaterialCode())){
+                    count = materialRequisition.getRequireCount()+materialRequisition1.getRequireCount();
+                    materialRequisition1.setRequireCount(count);
+                    count = materialRequisition.getOutCount()+materialRequisition1.getOutCount();
+                    materialRequisition1.setOutCount(count);
+                    flag = false;
+                }
+            }
+            if (flag){
+                requisition = new MaterialRequisition();
+                requisition.setMaterialCode(materialRequisition.getMaterialCode());
+                requisition.setRequireCount(materialRequisition.getRequireCount());
+                requisition.setOutCount(materialRequisition.getOutCount());
+                requisitionList.add(requisition);
+            }
+        }
+        return requisitionList;
+    }
+    //验证库存表
+    public static boolean getJudgeInventory(ImportUtil importUtil){
+        boolean flag = false;
+        Row row = importUtil.getRow(0);
+        String materialCode = (String) importUtil.getCellValue(row,3);//物理编码
+        String materialDetails = (String) importUtil.getCellValue(row,4);//物料描述
+        if (!materialCode.contains("编码")||!materialDetails.contains("描述")){
+            return true;
+        }
+        return false;
+    }
+    //验证库存表
+    public static boolean getJudgeRequisition(ImportUtil importUtil){
+        boolean flag = false;
+        Row row = importUtil.getRow(3);
+        String requireCount = (String) importUtil.getCellValue(row,15);//物理编码
+        String outCount = (String) importUtil.getCellValue(row,16);//物料描述
+        if (!requireCount.contains("需求")||!outCount.contains("出库")){
+            return true;
+        }
+        return false;
+    }
+}

src/main/java/com/jeeplus/modules/sg/managementcenter/materialInventory/util/ImportUtil.java

@@ -0,0 +1,394 @@
+/**
+ * Copyright &copy; 2015-2020 <a href="http://www.jeeplus.org/">JeePlus</a> All rights reserved.
+ */
+package com.jeeplus.modules.sg.managementcenter.materialInventory.util;
+
+import com.google.common.collect.Lists;
+import com.jeeplus.common.utils.Reflections;
+import com.jeeplus.common.utils.excel.annotation.ExcelField;
+import com.jeeplus.modules.sys.entity.Area;
+import com.jeeplus.modules.sys.entity.Office;
+import com.jeeplus.modules.sys.entity.User;
+import com.jeeplus.modules.sys.utils.DictUtils;
+import com.jeeplus.modules.sys.utils.UserUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.poi.hssf.usermodel.HSSFDateUtil;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
+import org.apache.poi.openxml4j.exceptions.InvalidFormatException;
+import org.apache.poi.ss.usermodel.Cell;
+import org.apache.poi.ss.usermodel.Row;
+import org.apache.poi.ss.usermodel.Sheet;
+import org.apache.poi.ss.usermodel.Workbook;
+import org.apache.poi.xssf.usermodel.XSSFWorkbook;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.web.multipart.MultipartFile;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.text.NumberFormat;
+import java.text.SimpleDateFormat;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Date;
+import java.util.List;
+
+/**
+ * 导入Excel文件（支持“XLS”和“XLSX”格式）
+ * @author jeeplus
+ * @version 2016-03-10
+ */
+public class ImportUtil {
+
+	private static Logger log = LoggerFactory.getLogger(ImportUtil.class);
+
+	/**
+	 * 工作薄对象
+	 */
+	private Workbook wb;
+
+	/**
+	 * 工作表对象
+	 */
+	private Sheet sheet;
+
+	/**
+	 * 标题行号
+	 */
+	private int headerNum;
+
+	/**
+	 * 构造函数
+	 * @param path 导入文件，读取第一个工作表
+	 * @param headerNum 标题行号，数据行号=标题行号+1
+	 * @throws InvalidFormatException
+	 * @throws IOException
+	 */
+	public ImportUtil(String fileName, int headerNum)
+			throws InvalidFormatException, IOException {
+		this(new File(fileName), headerNum);
+	}
+
+	/**
+	 * 构造函数
+	 * @param path 导入文件对象，读取第一个工作表
+	 * @param headerNum 标题行号，数据行号=标题行号+1
+	 * @throws InvalidFormatException
+	 * @throws IOException
+	 */
+	public ImportUtil(File file, int headerNum)
+			throws InvalidFormatException, IOException {
+		this(file, headerNum, 0);
+	}
+
+	/**
+	 * 构造函数
+	 * @param path 导入文件
+	 * @param headerNum 标题行号，数据行号=标题行号+1
+	 * @param sheetIndex 工作表编号
+	 * @throws InvalidFormatException
+	 * @throws IOException
+	 */
+	public ImportUtil(String fileName, int headerNum, int sheetIndex)
+			throws InvalidFormatException, IOException {
+		this(new File(fileName), headerNum, sheetIndex);
+	}
+
+	/**
+	 * 构造函数
+	 * @param path 导入文件对象
+	 * @param headerNum 标题行号，数据行号=标题行号+1
+	 * @param sheetIndex 工作表编号
+	 * @throws InvalidFormatException
+	 * @throws IOException
+	 */
+	public ImportUtil(File file, int headerNum, int sheetIndex)
+			throws InvalidFormatException, IOException {
+		this(file.getName(), new FileInputStream(file), headerNum, sheetIndex);
+	}
+
+	/**
+	 * 构造函数
+	 * @param file 导入文件对象
+	 * @param headerNum 标题行号，数据行号=标题行号+1
+	 * @param sheetIndex 工作表编号
+	 * @throws InvalidFormatException
+	 * @throws IOException
+	 */
+	public ImportUtil(MultipartFile multipartFile, int headerNum, int sheetIndex)
+			throws InvalidFormatException, IOException {
+		this(multipartFile.getOriginalFilename(), multipartFile.getInputStream(), headerNum, sheetIndex);
+	}
+
+	/**
+	 * 构造函数
+	 * @param path 导入文件对象
+	 * @param headerNum 标题行号，数据行号=标题行号+1
+	 * @param sheetIndex 工作表编号
+	 * @throws InvalidFormatException
+	 * @throws IOException
+	 */
+	public ImportUtil(String fileName, InputStream is, int headerNum, int sheetIndex)
+			throws InvalidFormatException, IOException {
+		if (StringUtils.isBlank(fileName)){
+			throw new RuntimeException("导入文档为空!");
+		}else if(fileName.toLowerCase().endsWith("xls")){    
+			this.wb = new HSSFWorkbook(is);    
+        }else if(fileName.toLowerCase().endsWith("xlsx")){  
+        	this.wb = new XSSFWorkbook(is);
+        }else{  
+        	throw new RuntimeException("文档格式不正确!");
+        }  
+		if (this.wb.getNumberOfSheets()<sheetIndex){
+			throw new RuntimeException("文档中没有工作表!");
+		}
+		this.sheet = this.wb.getSheetAt(sheetIndex);
+		this.headerNum = headerNum;
+		log.debug("Initialize success.");
+	}
+	
+	/**
+	 * 获取行对象
+	 * @param rownum
+	 * @return
+	 */
+	public Row getRow(int rownum){
+		return this.sheet.getRow(rownum);
+	}
+
+	/**
+	 * 获取数据行号
+	 * @return
+	 */
+	public int getDataRowNum(){
+		return headerNum+1;
+	}
+	
+	/**
+	 * 获取最后一个数据行号
+	 * @return
+	 */
+	public int getLastDataRowNum(){
+		return this.sheet.getLastRowNum()+headerNum;
+	}
+	
+	/**
+	 * 获取最后一个列号
+	 * @return
+	 */
+	public int getLastCellNum(){
+		return this.getRow(headerNum).getLastCellNum();
+	}
+	
+	/**
+	 * 获取单元格值
+	 * @param row 获取的行
+	 * @param column 获取单元格列号
+	 * @return 单元格值
+	 */
+	public Object getCellValue(Row row, int column) {
+		Object val = "";
+		try {
+			Cell cell = row.getCell(column);
+			if (cell != null) {
+				if (cell.getCellType() == Cell.CELL_TYPE_NUMERIC) {
+					// val = cell.getNumericCellValue();
+					// 当excel 中的数据为数值或日期是需要特殊处理
+					if (HSSFDateUtil.isCellDateFormatted(cell)) {
+						double d = cell.getNumericCellValue();
+						Date date = HSSFDateUtil.getJavaDate(d);
+						SimpleDateFormat dformat = new SimpleDateFormat(
+								"yyyy-MM-dd");
+						val = dformat.format(date);
+					} else {
+						NumberFormat nf = NumberFormat.getInstance();
+						nf.setGroupingUsed(false);// true时的格式：1,234,567,890
+						val = nf.format(cell.getNumericCellValue());// 数值类型的数据为double，所以需要转换一下
+					}
+				} else if (cell.getCellType() == Cell.CELL_TYPE_STRING) {
+					val = cell.getStringCellValue();
+				} else if (cell.getCellType() == Cell.CELL_TYPE_FORMULA) {
+					val = cell.getCellFormula();
+				} else if (cell.getCellType() == Cell.CELL_TYPE_BOOLEAN) {
+					val = cell.getBooleanCellValue();
+				} else if (cell.getCellType() == Cell.CELL_TYPE_ERROR) {
+					val = cell.getErrorCellValue();
+				}
+			}
+		} catch (Exception e) {
+			return val;
+		}
+		return val;
+	}
+	
+	/**
+	 * 获取导入数据列表
+	 * @param cls 导入对象类型
+	 * @param groups 导入分组
+	 */
+	public <E> List<E> getDataList(Class<E> cls, int... groups) throws InstantiationException, IllegalAccessException{
+		List<Object[]> annotationList = Lists.newArrayList();
+		// Get annotation field 
+		Field[] fs = cls.getDeclaredFields();
+		for (Field f : fs){
+			ExcelField ef = f.getAnnotation(ExcelField.class);
+			if (ef != null && (ef.type()==0 || ef.type()==2)){
+				if (groups!=null && groups.length>0){
+					boolean inGroup = false;
+					for (int g : groups){
+						if (inGroup){
+							break;
+						}
+						for (int efg : ef.groups()){
+							if (g == efg){
+								inGroup = true;
+								annotationList.add(new Object[]{ef, f});
+								break;
+							}
+						}
+					}
+				}else{
+					annotationList.add(new Object[]{ef, f});
+				}
+			}
+		}
+		// Get annotation method
+		Method[] ms = cls.getDeclaredMethods();
+		for (Method m : ms){
+			ExcelField ef = m.getAnnotation(ExcelField.class);
+			if (ef != null && (ef.type()==0 || ef.type()==2)){
+				if (groups!=null && groups.length>0){
+					boolean inGroup = false;
+					for (int g : groups){
+						if (inGroup){
+							break;
+						}
+						for (int efg : ef.groups()){
+							if (g == efg){
+								inGroup = true;
+								annotationList.add(new Object[]{ef, m});
+								break;
+							}
+						}
+					}
+				}else{
+					annotationList.add(new Object[]{ef, m});
+				}
+			}
+		}
+		// Field sorting
+		Collections.sort(annotationList, new Comparator<Object[]>() {
+			public int compare(Object[] o1, Object[] o2) {
+				return new Integer(((ExcelField)o1[0]).sort()).compareTo(
+						new Integer(((ExcelField)o2[0]).sort()));
+			};
+		});
+		//log.debug("Import column count:"+annotationList.size());
+		// Get excel data
+		List<E> dataList = Lists.newArrayList();
+		for (int i = this.getDataRowNum(); i < this.getLastDataRowNum(); i++) {
+			E e = (E)cls.newInstance();
+			int column = 0;
+			Row row = this.getRow(i);
+			StringBuilder sb = new StringBuilder();
+			for (Object[] os : annotationList){
+				Object val = this.getCellValue(row, column++);
+				if (val != null){
+					ExcelField ef = (ExcelField)os[0];
+					// If is dict type, get dict value
+					if (StringUtils.isNotBlank(ef.dictType())){
+						val = DictUtils.getDictValue(val.toString(), ef.dictType(), "");
+						//log.debug("Dictionary type value: ["+i+","+colunm+"] " + val);
+					}
+					// Get param type and type cast
+					Class<?> valType = Class.class;
+					if (os[1] instanceof Field){
+						valType = ((Field)os[1]).getType();
+					}else if (os[1] instanceof Method){
+						Method method = ((Method)os[1]);
+						if ("get".equals(method.getName().substring(0, 3))){
+							valType = method.getReturnType();
+						}else if("set".equals(method.getName().substring(0, 3))){
+							valType = ((Method)os[1]).getParameterTypes()[0];
+						}
+					}
+					//log.debug("Import value type: ["+i+","+column+"] " + valType);
+					try {
+						//如果导入的java对象，需要在这里自己进行变换。
+						if (valType == String.class){
+							String s = String.valueOf(val.toString());
+							if(StringUtils.endsWith(s, ".0")){
+								val = StringUtils.substringBefore(s, ".0");
+							}else{
+								val = String.valueOf(val.toString());
+							}
+						}else if (valType == Integer.class){
+							val = Double.valueOf(val.toString()).intValue();
+						}else if (valType == Long.class){
+							val = Double.valueOf(val.toString()).longValue();
+						}else if (valType == Double.class){
+							val = Double.valueOf(val.toString());
+						}else if (valType == Float.class){
+							val = Float.valueOf(val.toString());
+						}else if (valType == Date.class){
+							SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
+							val=sdf.parse(val.toString()); 
+						}else if (valType == User.class){
+							val = UserUtils.getByUserName(val.toString());
+						}else if (valType == Office.class){
+							val = UserUtils.getByOfficeName(val.toString());
+						}else if (valType == Area.class){
+							val = UserUtils.getByAreaName(val.toString());
+						}else{
+							if (ef.fieldType() != Class.class){
+								val = ef.fieldType().getMethod("getValue", String.class).invoke(null, val.toString());
+							}else{
+								val = Class.forName(this.getClass().getName().replaceAll(this.getClass().getSimpleName(), 
+										"fieldtype."+valType.getSimpleName()+"Type")).getMethod("getValue", String.class).invoke(null, val.toString());
+							}
+						}
+					} catch (Exception ex) {
+						log.info("Get cell value ["+i+","+column+"] error: " + ex.toString());
+						val = null;
+					}
+					// set entity value
+					if (os[1] instanceof Field){
+						Reflections.invokeSetter(e, ((Field)os[1]).getName(), val);
+					}else if (os[1] instanceof Method){
+						String mthodName = ((Method)os[1]).getName();
+						if ("get".equals(mthodName.substring(0, 3))){
+							mthodName = "set"+StringUtils.substringAfter(mthodName, "get");
+						}
+						Reflections.invokeMethod(e, mthodName, new Class[] {valType}, new Object[] {val});
+					}
+				}
+				sb.append(val+", ");
+			}
+			dataList.add(e);
+			log.debug("Read success: ["+i+"] "+sb.toString());
+		}
+		return dataList;
+	}
+
+//	/**
+//	 * 导入测试
+//	 */
+//	public static void main(String[] args) throws Throwable {
+//		
+//		ImportExcel ei = new ImportExcel("target/export.xlsx", 1);
+//		
+//		for (int i = ei.getDataRowNum(); i < ei.getLastDataRowNum(); i++) {
+//			Row row = ei.getRow(i);
+//			for (int j = 0; j < ei.getLastCellNum(); j++) {
+//				Object val = ei.getCellValue(row, j);
+//				System.out.print(val+", ");
+//			}
+//			System.out.print("\n");
+//		}
+//		
+//	}
+}