财务模块 自动决算

src/main/java/com/jeeplus/modules/sg/audit/information/mapper/InformationMapper.java

@@ -9,6 +9,7 @@ import com.jeeplus.modules.sg.audit.information.entity.Information;
 import com.jeeplus.modules.sg.audit.information.entity.append;
 import com.jeeplus.modules.sg.audit.information.entity.constant;
 import com.jeeplus.modules.sg.audit.material.entity.Material;
+import com.jeeplus.modules.sg.financial.expense.entity.Expense;
 import org.apache.ibatis.annotations.Param;
 
 import java.util.List;
@@ -68,4 +69,7 @@ public interface InformationMapper extends BaseMapper<Information> {
 
     //通过查询条件，查询所有未完成领退料的信息
     List<Information> findNoFinishList(List<String> strings);
+    //根据id列表 查询甲供材项目信息
+    List<Information> findListMain(List<String> ids);
+
 }

src/main/java/com/jeeplus/modules/sg/audit/information/mapper/xml/InformationMapper.xml

@@ -636,4 +636,18 @@
 		</foreach>
 		)
 	</select>
+
+	<select id="findListMain" parameterType="java.util.List" resultType="Information">
+		select
+		*
+		FROM sj_project_information a
+		WHERE a.del_flag = '0'
+		and a.project_id in
+		<if test="list != null">
+			<foreach collection="list" index="index" item="item" open="("
+					 separator="," close=")">
+				#{item}
+			</foreach>
+		</if>
+	</select>
 </mapper>

src/main/java/com/jeeplus/modules/sg/audit/information/service/InformationService.java

@@ -444,4 +444,12 @@ public class InformationService extends CrudService<InformationMapper, Informati
 	public List<Information> findListWord(Information entity) {
 		return informationMapper.findListWord(entity);
 	}
+	/**
+	 * 根据id列表 获取甲供材项目信息
+	 * @param strings
+	 * @return
+	 */
+	public List<Information> getFindListMain(List<String> ids){
+		return informationMapper.findListMain(ids);
+	}
 }

src/main/java/com/jeeplus/modules/sg/financial/erpcredit/entity/ErpAccount.java

@@ -5,6 +5,9 @@ import com.jeeplus.common.utils.excel.annotation.ExcelField;
 
 import java.io.Serializable;
 
+/**
+ * erp明细账 对应单行数据
+ */
 public class ErpAccount implements Serializable {
     private static final long serialVersionUID = 1L;
 

src/main/java/com/jeeplus/modules/sg/financial/erpcredit/entity/ErpCredit.java

@@ -4,8 +4,13 @@ import com.jeeplus.common.utils.excel.annotation.ExcelField;
 import com.jeeplus.core.persistence.DataEntity;
 
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
+/**
+ * 项目明细账初步处理结果 对象
+ */
 public class ErpCredit extends DataEntity<ErpCredit>{
     private static final long serialVersionUID = 1L;
 
@@ -15,9 +20,9 @@ public class ErpCredit extends DataEntity<ErpCredit>{
     private Double transferAssets;//移交生产的资产总值
     private Double consBuildingFee;//施工：建筑费
     private Double consInstallFee;//施工：安装费
-    private Double consTotalFee;//施工：总计
-    private Double otherSupervisorFee;//其他：监理费
-    private Double otherDesignFee;//其他设计费
+    private double consTotalFee;//施工：总计
+    private double otherSupervisorFee;//其他：监理费
+    private double otherDesignFee;//其他设计费
     private Double otherBeWorkFee;//项目前期工作费
     private Double otherBuildLoan;//建设期贷款利息
     private Double otherLineDamages;//线路施工赔偿费
@@ -33,17 +38,36 @@ public class ErpCredit extends DataEntity<ErpCredit>{
     private String supplierName;//供应商名称
     private String cableTube;//电缆管信息
     private String status;//状态
-    private List<ErpCreditEquipment> erpCreditChild1s = new ArrayList<ErpCreditEquipment>();
-    private List<ErpCreditMaterial> erpCreditChild2s = new ArrayList<ErpCreditMaterial>();
+    private List<ErpCreditEquipment> erpCreditChild1s = new ArrayList<ErpCreditEquipment>();//设备列表
+    private List<ErpCreditMaterial> erpCreditChild2s = new ArrayList<ErpCreditMaterial>();//材料列表
+    private Map<String,ErpCreditEquipment> equipmentMap = new HashMap<>();//以物料描述为key值的设备map
+    private Map<String,ErpCreditMaterial> materialMap = new HashMap<>();//以物料描述为key的物料map
 
     private Double designFeePayable;//设计费应付金额
     private Double constructionFeePayable;//施工费应付金额
     private Double supervisorFeePayable;//监理费应付金额
 
-    private String designStatus;//存在问题状态
+    private String designStatus;//设计费问题状态 2：应付金额>实付金额，人工判断  1：应付金额<实付金额，有问题
     private String constructionStatus;
     private String supervisorStatus;
 
+
+    public Map<String, ErpCreditEquipment> getEquipmentMap() {
+        return equipmentMap;
+    }
+
+    public void setEquipmentMap(Map<String, ErpCreditEquipment> equipmentMap) {
+        this.equipmentMap = equipmentMap;
+    }
+
+    public Map<String, ErpCreditMaterial> getMaterialMap() {
+        return materialMap;
+    }
+
+    public void setMaterialMap(Map<String, ErpCreditMaterial> materialMap) {
+        this.materialMap = materialMap;
+    }
+
     public String getDesignStatus() {
         return designStatus;
     }

src/main/java/com/jeeplus/modules/sg/financial/erpcredit/entity/ErpJudgeAccount.java

@@ -1,10 +1,20 @@
 package com.jeeplus.modules.sg.financial.erpcredit.entity;
 
-public class ErpJudgeAccount {
+import java.io.Serializable;
+
+/**
+ * 项目费用入账、甲供材验证信息
+ */
+public class ErpJudgeAccount implements Serializable {
+    public static final String NO_DATA = "无数据";
+    public static final String NOT_FINISHED = "未完成领退料";
+
     private String itemId;//项目id
     private String itemName;//项目名称
     private String flagItem;//是否有信息
     private String itemSupplierName;//供应商名称
+    private String expenseStatus;//费用入账状态
+    private String informationStatus;//甲供材状态
     private String status;
 
     public String getStatus() {
@@ -46,4 +56,22 @@ public class ErpJudgeAccount {
     public void setItemSupplierName(String itemSupplierName) {
         this.itemSupplierName = itemSupplierName;
     }
+
+    public String getExpenseStatus() {
+        return expenseStatus;
+    }
+
+    public void setExpenseStatus(String expenseStatus) {
+        this.expenseStatus = expenseStatus;
+    }
+
+    public String getInformationStatus() {
+        return informationStatus;
+    }
+
+    public void setInformationStatus(String informationStatus) {
+        this.informationStatus = informationStatus;
+    }
+
+
 }

src/main/java/com/jeeplus/modules/sg/financial/erpcredit/entity/ErpJudgeArtificial.java

@@ -1,6 +1,8 @@
 package com.jeeplus.modules.sg.financial.erpcredit.entity;
 
-public class ErpJudgeArtificial {
+import java.io.Serializable;
+
+public class ErpJudgeArtificial implements Serializable {
     private String itemId;//项目id
 
 //    private String constructionFeePayable;//施工费应付金额

src/main/java/com/jeeplus/modules/sg/financial/erpcredit/entity/ErpJudgeExport.java

@@ -2,7 +2,12 @@ package com.jeeplus.modules.sg.financial.erpcredit.entity;
 
 import com.jeeplus.common.utils.excel.annotation.ExcelField;
 
-public class ErpJudgeExport {
+import java.io.Serializable;
+
+/**
+ * 项目付款金额对象
+ */
+public class ErpJudgeExport implements Serializable {
     private String itemId;//项目id
     private String itemName;//项目名称
     private String constructionFeePayable;//施工费应付金额

src/main/java/com/jeeplus/modules/sg/financial/erpcredit/service/ErpCreditService.java

@@ -6,6 +6,7 @@ package com.jeeplus.modules.sg.financial.erpcredit.service;
 import com.jeeplus.common.utils.StringUtils;
 import com.jeeplus.core.persistence.Page;
 import com.jeeplus.core.service.CrudService;
+import com.jeeplus.core.servlet.ValidateCodeServlet;
 import com.jeeplus.modules.sg.audit.information.entity.Information;
 import com.jeeplus.modules.sg.audit.information.service.InformationService;
 import com.jeeplus.modules.sg.audit.information.utils.RandomUtil;
@@ -19,6 +20,7 @@ import com.jeeplus.modules.sg.financial.erpcredit.mapper.ErpCreditMaterialMapper
 import com.jeeplus.modules.sg.financial.erpcredit.util.ErpInfo;
 import com.jeeplus.modules.sg.financial.erpcredit.util.ExportTemplate;
 import com.jeeplus.modules.sg.financial.erpcredit.util.ExportUtil;
+import com.jeeplus.modules.sg.financial.erpcredit.util.ValidationUtils;
 import com.jeeplus.modules.sg.financial.settlement.entity.MaintainData;
 import com.jeeplus.modules.sg.financial.settlement.mapper.DataMaintenanceMapper;
 import com.jeeplus.modules.sg.financial.settlement.service.DataMaintenanceService;
@@ -56,55 +58,79 @@ public class ErpCreditService extends CrudService<ErpCreditMapper,ErpCredit> {
     @Autowired
     private DataMaintenanceService dataMaintenanceService;
 
-    public List<ErpCredit> getListErpCredit(List<String> itemId,String status){
-        List<ErpCredit> erpCreditList = new ArrayList<ErpCredit>();
-        List<ErpCredit> erpCredits = erpCreditMapper.findErpCreditList(itemId);
-        for (ErpCredit erpCredit:erpCredits){
-            if (erpCredit.getStatus().equals(status)){
-                erpCreditList.add(erpCredit);
-            }
-        }
-        List<String> strings = new ArrayList<String>();
-        for (ErpCredit erpCredit:erpCreditList){
-            strings.add(erpCredit.getId());
-        }
-        List<ErpCreditEquipment> erpCreditChild1List = erpCreditEquipmentMapper.findErpCreditChild1List(strings);
-        List<ErpCreditMaterial> erpCreditChild2List = erpCreditMaterialMapper.findErpCreditChild2List(strings);
-        if (null!=erpCreditList&&erpCreditList.size()>0){
-            for (ErpCredit erpCredit:erpCreditList){
-                if (null!=erpCreditChild1List&&erpCreditChild1List.size()>0){
-                    for (ErpCreditEquipment erpCreditEquipment:erpCreditChild1List){
-                        if (erpCredit.getId().equals(erpCreditEquipment.getErpCredit().getId())){
-                            erpCredit.getErpCreditChild1s().add(erpCreditEquipment);
-                        }
-                    }
-                }
-                if (null!=erpCreditChild2List&&erpCreditChild2List.size()>0){
-                    for (ErpCreditMaterial erpCreditChild2:erpCreditChild2List){
-                        if (erpCredit.getId().equals(erpCreditChild2.getErpCredit().getId())){
-                            erpCredit.getErpCreditChild2s().add(erpCreditChild2);
-                        }
-                    }
-                }
-            }
-        }
-        return erpCreditList;
-    }
+//    public List<ErpCredit> getListErpCredit(List<String> itemId,String status){
+//        List<ErpCredit> erpCreditList = new ArrayList<ErpCredit>();
+//        List<ErpCredit> erpCredits = erpCreditMapper.findErpCreditList(itemId);
+//        for (ErpCredit erpCredit:erpCredits){
+//            if (erpCredit.getStatus().equals(status)){
+//                erpCreditList.add(erpCredit);
+//            }
+//        }
+//        List<String> strings = new ArrayList<String>();
+//        for (ErpCredit erpCredit:erpCreditList){
+//            strings.add(erpCredit.getId());
+//        }
+//        List<ErpCreditEquipment> erpCreditChild1List = erpCreditEquipmentMapper.findErpCreditChild1List(strings);
+//        List<ErpCreditMaterial> erpCreditChild2List = erpCreditMaterialMapper.findErpCreditChild2List(strings);
+//        if (null!=erpCreditList&&erpCreditList.size()>0){
+//            for (ErpCredit erpCredit:erpCreditList){
+//                if (null!=erpCreditChild1List&&erpCreditChild1List.size()>0){
+//                    for (ErpCreditEquipment erpCreditEquipment:erpCreditChild1List){
+//                        if (erpCredit.getId().equals(erpCreditEquipment.getErpCredit().getId())){
+//                            erpCredit.getErpCreditChild1s().add(erpCreditEquipment);
+//                        }
+//                    }
+//                }
+//                if (null!=erpCreditChild2List&&erpCreditChild2List.size()>0){
+//                    for (ErpCreditMaterial erpCreditChild2:erpCreditChild2List){
+//                        if (erpCredit.getId().equals(erpCreditChild2.getErpCredit().getId())){
+//                            erpCredit.getErpCreditChild2s().add(erpCreditChild2);
+//                        }
+//                    }
+//                }
+//            }
+//        }
+//        return erpCreditList;
+//    }
+
+    /**
+     * 根据id获取erpCredit对象，同时获取属于它的设备和材料列表
+     * @param id
+     * @return
+     */
     public ErpCredit get(String id) {
         ErpCredit erpCredit = super.get(id);
         List<ErpCreditEquipment> eqmList = erpCreditEquipmentMapper.findList(new ErpCreditEquipment(erpCredit));
-        List<ErpCreditEquipment> equSures = ErpInfo.getEquNumbers(eqmList);//特殊情况处理   物料信息
-        erpCredit.setErpCreditChild1s(equSures);
+//        List<ErpCreditEquipment> equSures = ErpInfo.getEquNumbers(eqmList);//特殊情况处理   物料信息
+        erpCredit.setErpCreditChild1s(eqmList);
         erpCredit.setErpCreditChild2s(erpCreditMaterialMapper.findList(new ErpCreditMaterial(erpCredit)));
         return erpCredit;
     }
 
-    public List<ErpCredit> findList(ErpCredit erpCredit) {
-        return super.findList(erpCredit);
-    }
+//    public List<ErpCredit> findList(ErpCredit erpCredit) {
+//        return super.findList(erpCredit);
+//    }
+//
+//    public Page<ErpCredit> findPage(Page<ErpCredit> page, ErpCredit erpCredit) {
+//        return super.findPage(page, erpCredit);
+//    }
 
-    public Page<ErpCredit> findPage(Page<ErpCredit> page, ErpCredit erpCredit) {
-        return super.findPage(page, erpCredit);
+    /**
+     * 替换数据库中所有erpCredit及其设备、物料数据
+     * @param erpCredits
+     */
+    @Transactional(readOnly = false)
+    public void replaceAll(List<ErpCredit> erpCredits){
+        String random  = ErpInfo.getStatus();
+        deleteAll();//清空原来表数据
+        for (int i = 0; i < erpCredits.size()/1000+1; i++) {
+            int end=(i+1)*1000;
+            if (end>erpCredits.size()){
+                end=erpCredits.size();
+            }
+            List<ErpCredit> subList = erpCredits.subList(i * 1000, end);
+            saveList(subList,random);
+        }
     }
 
     @Transactional(readOnly = false)
@@ -176,6 +202,9 @@ public class ErpCreditService extends CrudService<ErpCreditMapper,ErpCredit> {
         erpCreditMaterialMapper.delete(new ErpCreditMaterial(erpCredit));
     }
 
+    /**
+     * 删除所有erpCredit及其设备物料数据
+     */
     @Transactional(readOnly = false)
     public void deleteAll(){
         erpCreditMapper.deleteAll();
@@ -183,13 +212,22 @@ public class ErpCreditService extends CrudService<ErpCreditMapper,ErpCredit> {
         erpCreditMaterialMapper.deleteAll();
     }
 
-    //维护表
+    /**
+     * 根据id查找相应概预算信息
+     * @param strings
+     * @return
+     */
     public List<MaintainData> getFindListMain(List<String> strings){
         return dataMaintenanceMapper.findListMain(strings);
     }
 
-    //导出
-    public void getExport(List<ErpCredit> erpCreditList, HttpServletResponse response){
+    /**
+     * 导出自动决算书
+     * @param request
+     * @param response
+     */
+    public void getExport(HttpServletRequest request, HttpServletResponse response){
+        List<ErpCredit> erpCreditList = ValidationUtils.getSessionRedisList(request,ValidationUtils.CREDIT_KEY_PREFIX,ErpCredit.class);
         List<String> strs = new ArrayList<String>();
         for (ErpCredit erpCredit1:erpCreditList){
             strs.add(erpCredit1.getItemId());
@@ -271,6 +309,89 @@ public class ErpCreditService extends CrudService<ErpCreditMapper,ErpCredit> {
         }
     }
 
+//    //导出
+//    public void getExport(List<ErpCredit> erpCreditList, HttpServletResponse response){
+//        List<String> strs = new ArrayList<String>();
+//        for (ErpCredit erpCredit1:erpCreditList){
+//            strs.add(erpCredit1.getItemId());
+//        }
+//        List<MaintainData> maintainDatas = getFindListMain(strs);
+//        ExportTemplate exportTemplate = new ExportTemplate();
+//        File newFile = exportTemplate.createNewFile();
+//        // 新文件写入数据，并下载
+//        InputStream inputStream = null;
+//        XSSFWorkbook workbook = null;
+//        XSSFFont font=null;
+//        XSSFSheet sheetOverView = null;
+//        XSSFSheet sheetView = null;
+//        XSSFSheet sheetOtherFee = null;//定义其他费用明细表费用
+//        XSSFSheet sheetAssetsTotal= null;//资产总表
+//        XSSFSheet sheetLine1 = null;//移交生产总值一览表
+//        XSSFSheet sheetEquip=null;//移交总值设备表
+//        XSSFSheet sheetEquipMaterial=null;//设备材料费用
+//        XSSFSheet sheetSettlement=null;//结算表
+//        XSSFSheet sheetLine2=null;//线路2
+//        XSSFSheet sheetEquip2=null;//设备2
+//        try {
+//            inputStream = new FileInputStream(newFile);// 将excel文件转为输入流
+//            workbook = new XSSFWorkbook(inputStream);// 创建个workbook，
+//            font = workbook.createFont();
+//            sheetOverView =workbook.getSheetAt(0);//概述表
+//            sheetView = workbook.getSheetAt(1);//定义一览表
+//            sheetOtherFee = workbook.getSheetAt(2);//其他费用表
+//            sheetAssetsTotal = workbook.getSheetAt(3);//移交生产总值
+//            sheetLine1=workbook.getSheetAt(4);//线路1
+//            sheetEquip=workbook.getSheetAt(5);//设备1
+//            sheetEquipMaterial=workbook.getSheetAt(6);//设备材料清单表
+//            sheetSettlement=workbook.getSheetAt(7);//结算表
+//            sheetLine2=workbook.getSheetAt(9);//线路2
+//            sheetEquip2=workbook.getSheetAt(10);//设备2
+//        } catch (Exception e1) {
+//            e1.printStackTrace();
+//        }
+//        try {
+//            // 写数据
+//            FileOutputStream fos = new FileOutputStream(newFile);
+//            ExportUtil.getSheetOverView(sheetOverView,erpCreditList,maintainDatas);
+//            ExportUtil.getSheetView(sheetView,erpCreditList,maintainDatas,workbook);//调用一览表写入方法
+//            ExportUtil.getSheetOtherFee(sheetOtherFee,erpCreditList,maintainDatas);
+//            ExportUtil.getSheetAssetsTotal(sheetAssetsTotal,erpCreditList,maintainDatas);
+//            ExportUtil.getSheetLine1(sheetLine1,erpCreditList,workbook);
+//            ExportUtil.getSheetEquip(sheetEquip,erpCreditList,maintainDatas,workbook);
+//            ExportUtil.getSheetEquipMaterial(sheetEquipMaterial,erpCreditList,workbook);
+//            ExportUtil.getSheetSettlement(sheetSettlement,erpCreditList,maintainDatas);
+//            ExportUtil.getSheetLine2(sheetLine2,erpCreditList,workbook);
+//            ExportUtil.getSheetEquip2(sheetEquip2,erpCreditList,maintainDatas,workbook);
+//            workbook.write(fos);
+//            fos.flush();
+//            fos.close();
+//            InputStream fis = new BufferedInputStream(new FileInputStream(
+//                    newFile));
+//            byte[] buffer = new byte[fis.available()];
+//            fis.read(buffer);
+//            fis.close();
+//            response.reset();
+//            response.setContentType("text/html;charset=UTF-8");
+//            OutputStream toClient = new BufferedOutputStream(response.getOutputStream());
+//            response.setContentType("application/x-msdownload");
+//            String newName = URLEncoder.encode("财务竣工决算表" + System.currentTimeMillis() + ".xlsx","UTF-8");
+//            response.addHeader("Content-Disposition","attachment;filename=\"" + newName + "\"");
+//            response.addHeader("Content-Length", "" + newFile.length());
+//            toClient.write(buffer);
+//            toClient.flush();
+//        } catch (Exception e) {
+//            e.printStackTrace();
+//        } finally {
+//            try {
+//                if (null != inputStream) {
+//                    inputStream.close();
+//                }
+//            } catch (Exception e) {
+//                e.printStackTrace();
+//            }
+//        }
+//    }
+
     //验证：该预算数据
     //验证汇总
     public List<ErpJudge> getAllCheck(List<ErpCredit> erpCredits){

src/main/java/com/jeeplus/modules/sg/financial/erpcredit/util/CostAccountUnits.java

@@ -1,5 +1,6 @@
 package com.jeeplus.modules.sg.financial.erpcredit.util;
 
+import com.jeeplus.common.utils.StringUtils;
 import com.jeeplus.modules.sg.audit.information.entity.Information;
 import com.jeeplus.modules.sg.financial.erpcredit.entity.ErpAccount;
 import com.jeeplus.modules.sg.financial.erpcredit.entity.ErpCredit;
@@ -17,360 +18,543 @@ import java.util.Map;
  * 费用入账工具类
  */
 public class CostAccountUnits {
-    public static List<Expense> getQCExpense(List<ErpCredit> erpCredits,List<Expense> expenses){
-        List<Expense> expenseList = new ArrayList<Expense>();
-        boolean flag = false;
-        for (Expense expense:expenses){
-            flag = false;
-            for (ErpCredit erpCredit1:erpCredits){
-                if (expense.getProjectId().equals(erpCredit1.getItemId())){
-                    flag = true;
-                    break;
-                }
+
+    public static final String BEFORE_2020 = "1";//项目年份判断：2020年以前项目
+    public static final String AFTER_2020 = "0";//2020及以后项目
+
+    public static final String OVER_PAY_AMOUNT = "1"; //应付金额<实付金额 时费用状态
+    public static final String PAY_LESS_AMOUNT = "2"; //应付金额>实付金额 时费用状态
+
+    public static final String OVER_PAY_LIST_KEY = "OVERPAY";//多付钱项目列表
+    public static final String PAY_LESS_LIST_KEY = "PAYLESS";//少付钱项目列表
+
+
+    /**
+     * 验证项目的费用入账情况，即应付金额与实付金额的比较。然后返回一个异常情况的map
+     * @param erpCredits
+     * @param expenses  费用入账列表
+     * @param informationList 甲供材列表
+     * @param maintainDatas  概预算列表
+     * @return
+     */
+    public static Map<String,List<ErpCredit>> getJudgeMap(List<ErpCredit> erpCredits, List<Expense> expenses,List<Information> informationList,List<MaintainData> maintainDatas){
+        //根据费用入账批次号判断项目时间为2020前后，并赋予状态
+        judgeTime(expenses);
+        //获得几个以项目id为key的map
+        Map<String,Expense> expenseMap = new HashMap<>();
+        Map<String,Information> informationMap = new HashMap<>();
+        Map<String,MaintainData> maintainDataMap = new HashMap<>();
+        for(Expense expense:expenses){
+            expenseMap.put(expense.getProjectId(),expense);
+        }
+        for(Information information:informationList){
+            informationMap.put(information.getProjectId(),information);
+        }
+        for(MaintainData data:maintainDatas){
+            maintainDataMap.put(data.getProjectId(),data);
+        }
+        //判断设计费、监理费付款情况
+        judgeDesignSupervisionAmount(erpCredits,expenseMap,maintainDataMap);
+        //判断施工费付款情况
+        judgeConstructionAmount(erpCredits,expenseMap,informationMap);
+        //整理有付款情况问题的list
+        Map<String,List<ErpCredit>> map = new HashMap<>();
+        List<ErpCredit> overpayList = new ArrayList<>();
+        List<ErpCredit> paylessList = new ArrayList<>();
+        for(ErpCredit credit:erpCredits){
+            if(OVER_PAY_AMOUNT.equals(credit.getDesignStatus())||OVER_PAY_AMOUNT.equals(credit.getSupervisorStatus())||
+                    OVER_PAY_AMOUNT.equals(credit.getConstructionStatus())){
+                overpayList.add(credit);
             }
-            if (flag){
-                expenseList.add(expense);
+            if(PAY_LESS_AMOUNT.equals(credit.getDesignStatus())||PAY_LESS_AMOUNT.equals(credit.getSupervisorStatus())||
+                    PAY_LESS_AMOUNT.equals(credit.getConstructionStatus())){
+                paylessList.add(credit);
             }
         }
-        return getOneErpListJudge(expenseList);
+        map.put(OVER_PAY_LIST_KEY,overpayList);
+        map.put(PAY_LESS_LIST_KEY,paylessList);
+        return map;
     }
 
-    //得到 2020年项目
-    public static List<Expense> getOneErpListJudge(List<Expense> expenses){
-        String projectBatch = "";
-//        List<Expense> expensesList = new ArrayList<Expense>();
-        boolean yearJudgment = false;
-        for (Expense expense:expenses){
-            projectBatch = expense.getProjectBatch();
-            if (null!=projectBatch&&!"".equals(projectBatch)){
-               yearJudgment = getYearJudgment(projectBatch);
-               if (yearJudgment){
-                  expense.setStatus("0");
-               }else {
-                   expense.setStatus("1");
-               }
-            }
-        }
-        return expenses;
-    }
+    /**
+     * 判断设计费、监理费付款情况
+     * @param creditList
+     * @param expenseMap
+     * @param dataMap
+     */
+    private static void judgeDesignSupervisionAmount(List<ErpCredit> creditList,Map<String,Expense> expenseMap,Map<String,MaintainData> dataMap){
+        for(ErpCredit credit:creditList){
+            String projectId = credit.getItemId();
+            Expense expense = expenseMap.get(projectId);
+            MaintainData maintainData = dataMap.get(projectId);
 
-    //判断项目时间
-    public static boolean getYearJudgment(String projectBatch){
-        Integer yearNumber = 2020;
-        if (projectBatch.length()>=4){
-            projectBatch = projectBatch.substring(0,4);
-            yearNumber = new Integer(projectBatch);
-            if (yearNumber>=2020){
-                return true;
+            Double investment = Double.valueOf(maintainData.getInvestment());//发文总投资
+            //概算总金额 概预算中金额相加除10000取两位小数
+            Double estimateTotal = DoubleUtil.round2(DoubleUtil.add(maintainData.getDesignFee(),maintainData.getBuildingFee(),maintainData.getEquipmentFee(),
+                    maintainData.getMaterialFee(),maintainData.getInstallFee(),maintainData.getSupervisionFee(),maintainData.getPreliminaryWorkFee(),
+                    maintainData.getDamages(),maintainData.getManagementFee())/10000);
+            double texRate = 1.06; //设计费(监理费)含税应付金额--》不含税应付金额 需要乘以的系数，2020后为1.06，以前为/1.06
+            if(BEFORE_2020.equals(expense.getStatus())){
+                texRate = 1/1.06;
             }
-        }
-        return false;
-    }
-    //2020之前的项目费用入账判断(无问题)设计费 实际付款金额
-    public static Map<String,List<ErpCredit>> getJudgeDesign(List<ErpCredit> erpCredits, List<Expense> expenses){
-        Map<String,List<ErpCredit>> designMap = new HashMap<String, List<ErpCredit>>();
-        //若应付金额（不含税价）=实付金额（不含税价）,差异若在0.01则忽略不计，则费用入账核实无问题 集合
-        List<ErpCredit> erpCredits1 = new ArrayList<ErpCredit>();
-        //若应付金额（不含税价）>实付金额（不含税价）,需要进入人工判断，若人工判断通过，则费用入账核实无问题，若人工判断不通过则费用入账核实存在问题；
-        List<ErpCredit> erpCredits2 = new ArrayList<ErpCredit>();
-        //若应付金额（不含税价）<实付金额（不含税价）,需要导出差异情况，同时费用入账核实存在问题
-        List<ErpCredit> erpCredits3 = new ArrayList<ErpCredit>();
-        Double otherDesignFee = 0.0;//=ERP明细账生成数据中设计费入账金额(不含税价)
-        for (ErpCredit erpCredit:erpCredits){
-            otherDesignFee = erpCredit.getOtherDesignFee();
-            for (Expense expense:expenses){
-                if (erpCredit.getItemId().equals(expense.getProjectId())){
-                    erpCredit.setDesignFeePayable(expense.getDesignFeePayable());//设计费应付金额
-                    //若应付金额（不含税价）=实付金额（不含税价）,差异若在0.01则忽略不计，则费用入账核实无问题
-                    if (expense.getDesignFeePayable()>= otherDesignFee-0.01 && expense.getDesignFeePayable()<= otherDesignFee+0.01){
-                        erpCredits1.add(erpCredit);//无问题
-                    }else if (expense.getDesignFeePayable()>otherDesignFee){
-                        erpCredit.setDesignStatus("2");
-                        erpCredit.setDesignFeePayable(expense.getDesignFeePayable());
-                        erpCredits2.add(erpCredit);//存在问题
-                    }else {
-                        erpCredit.setDesignStatus("1");
-                        erpCredit.setDesignFeePayable(expense.getDesignFeePayable());
-                        erpCredits3.add(erpCredit);//<存在问题
-                    }
-                    break;
-                }
-            }
-        }
-        designMap.put("designNoProblem",erpCredits1);//无问题
-        designMap.put("designThanProblem",erpCredits2);//人工判断
-        designMap.put("designYesProblem",erpCredits3);//存在问题导出
-        return designMap;
-    }
+            double designFee = maintainData.getDesignFee();//概算中设计费
+            double designCost = expense.getDesignCost();//设计费合同折扣
+            double designTypicalCost = expense.getDesignTypeicalCost();//设计费典型折扣
+            double documentDesignFee = expense.getDocumentDesignCost();//发文中设计费金额（不含税）
+            double designFeePayable; //设计费应付金额
 
-    //项目费用入账判断设计费 设计费应付金额
-    public static List<Expense> getJudgeDesignActual(List<Expense> expenses, List<MaintainData> maintainDatas){
-        double investment = 0.0;    //发文总投资
-        double estimateTotal = 0.0;//概算总金额
-        double designFee = 0.0;//概预算中设计费设计费
-        double designCost = 0.0;//设计费合同则扣
-        double designTypeicalCost =0.0;//设计费典型设计折扣
-        double documentDesignCost = 0.0;//发文中设计费金额（不含税）
-        double designFeePayable = 0.0;//设计费应付金额 不含税价
-        List<Expense> expenseList = new ArrayList<Expense>();
-        for (Expense expense:expenses){
-            designCost = expense.getDesignCost();
-            designTypeicalCost = expense.getDesignTypeicalCost();
-            documentDesignCost = expense.getDocumentDesignCost();//发文中设计费金额（不含税）
-            for (MaintainData maintainData:maintainDatas){
-                //项目定义号相同
-               if (expense.getProjectId().equals(maintainData.getProjectId())){
-                   investment = Double.valueOf(maintainData.getInvestment());//发文总投资
-                   estimateTotal = maintainData.getDesignFee()+maintainData.getBuildingFee()+maintainData.getEquipmentFee()+maintainData.getMaterialFee()+maintainData
-                           .getInstallFee()+maintainData.getSupervisionFee()+maintainData.getPreliminaryWorkFee()+maintainData.getDamages()+maintainData.getManagementFee();
-                   estimateTotal = estimateTotal/10000;//发文总金额（----------------------------------------）
-                    if (expense.getStatus().equals("1")){//2020年之前项目
-                        if (investment<=estimateTotal+0.01 && investment>=estimateTotal-0.01){
-                            designFee = maintainData.getDesignFee();//该预算中设计费
-                            designFeePayable = designFee*designCost*designTypeicalCost/1.06;//不含税价
-                        }else {
-                            designFeePayable =  documentDesignCost*designCost*designTypeicalCost/1.06;//不换税价
-                        }
-                    }else {//2020年之后项目
-                        if (investment<=estimateTotal+0.01 && investment>=estimateTotal-0.01){
-                            designFee = maintainData.getDesignFee();//该预算中设计费
-                            designFeePayable = designFee*designCost*designTypeicalCost*1.06;
-                        }else {
-                            designFeePayable =  documentDesignCost*designCost*designTypeicalCost*1.06;
-                        }
-                    }
-                   expense.setDesignFeePayable(designFeePayable);//设计费应付金额
-                   expenseList.add(expense);
-                   break;
-               }
+            double supervisionFee = maintainData.getSupervisionFee();//概算中监理费
+            double supervisionCost = expense.getSupervisionCost();//监理费合同折扣
+            double supervisionTypicalCost = expense.getSupervisionTypeicalCost();//监理费典型折扣
+            double documentSupervisionFee = expense.getDocumentSupervisionCost();//发文中监理费金额（不含税）
+            double supervisionFeePayable;//监理费应付金额
+
+            //判断概算总金额与发文总投资相差是否超过0.01
+            if(Math.abs(DoubleUtil.sub(investment,estimateTotal))<=0.01){
+                designFeePayable = designFee*designCost*designTypicalCost*texRate;
+                supervisionFeePayable = supervisionFee*supervisionCost*supervisionTypicalCost*texRate;
+            }else{
+                designFeePayable = documentDesignFee*designCost*designTypicalCost*texRate;
+                supervisionFeePayable = documentSupervisionFee*supervisionCost*supervisionTypicalCost*texRate;
             }
-        }
-        return expenses;
-    }
-    //2020之前的项目费用入账判断(无问题)监理费 实际付款金额
-    public static Map<String,List<ErpCredit>> getJudgeSupervisorFee(List<ErpCredit> erpCredits, List<Expense> expenses){
-        Map<String,List<ErpCredit>> supervisorFeeMap = new HashMap<String, List<ErpCredit>>();
-        //若应付金额（不含税价）=实付金额（不含税价）,差异若在0.01则忽略不计，则费用入账核实无问题 集合
-        List<ErpCredit> erpCredits1 = new ArrayList<ErpCredit>();
-        //若应付金额（不含税价）>实付金额（不含税价）,需要进入人工判断，若人工判断通过，则费用入账核实无问题，若人工判断不通过则费用入账核实存在问题；
-        List<ErpCredit> erpCredits2 = new ArrayList<ErpCredit>();
-        //若应付金额（不含税价）<实付金额（不含税价）,需要导出差异情况，同时费用入账核实存在问题
-        List<ErpCredit> erpCredits3 = new ArrayList<ErpCredit>();
-        Double otherSupervisorFee = 0.0;//=ERP明细账生成数据中监理费入账金额(不含税价)
-        for (ErpCredit erpCredit:erpCredits){
-            otherSupervisorFee = erpCredit.getOtherSupervisorFee();
-            for (Expense expense:expenses){
-                if (erpCredit.getItemId().equals(expense.getProjectId())){
-                    erpCredit.setSupervisorFeePayable(expense.getSupervisorFeePayable());//监理费
-                    //若应付金额（不含税价）=实付金额（不含税价）,差异若在0.01则忽略不计，则费用入账核实无问题
-                    if (expense.getSupervisorFeePayable()>= otherSupervisorFee-0.01 && expense.getSupervisorFeePayable()<= otherSupervisorFee+0.01){
-                        erpCredits1.add(erpCredit);//无问题
-                    }else if (expense.getSupervisorFeePayable()>otherSupervisorFee){
-                        erpCredit.setSupervisorStatus("2");
-                        erpCredit.setSupervisorFeePayable(expense.getSupervisorFeePayable());
-                        erpCredits2.add(erpCredit);//存在问题
-                    }else {
-                        erpCredit.setSupervisorStatus("1");
-                        erpCredit.setSupervisorFeePayable(expense.getSupervisorFeePayable());
-                        erpCredits3.add(erpCredit);//<存在问题
-                    }
-                    break;
-                }
+            credit.setDesignFeePayable(DoubleUtil.round2(designFeePayable));
+            credit.setSupervisorFeePayable(DoubleUtil.round2(supervisionFeePayable));
+
+            Double actuallyPaidDesign = credit.getOtherDesignFee();//实付设计费
+            if(Math.abs(DoubleUtil.sub(actuallyPaidDesign,designFeePayable))<=0.01){
+
+            }else if(actuallyPaidDesign>designFeePayable){
+                credit.setDesignStatus(OVER_PAY_AMOUNT);
+            }else{
+                credit.setDesignStatus(PAY_LESS_AMOUNT);
             }
-        }
-        supervisorFeeMap.put("supervisorNoProblem",erpCredits1);//无问题
-        supervisorFeeMap.put("supervisorThanProblem",erpCredits2);//人工判断
-        supervisorFeeMap.put("supervisorYesProblem",erpCredits3);//存在问题导出
-        return supervisorFeeMap;
-    }
+            Double actuallyPaidSupervision = credit.getOtherSupervisorFee();
+            if(Math.abs(DoubleUtil.sub(actuallyPaidSupervision,supervisionFeePayable))<=0.01){
 
-    //项目费用入账判断监理费 监理费应付金额
-    public static List<Expense> getJudgeSupervisorFeeActual(List<Expense> expenses, List<MaintainData> maintainDatas){
-        double investment = 0.0;    //发文总投资
-        double estimateTotal = 0.0;//概算总金额
-        double supervisionFee = 0.0;//概预算中监理费
-        double supervisionCost = 0.0;//监理费合同则扣
-        double supervisionTypeicalCost =0.0;//监理费典型设计折扣
-        double documentSupervisionCost = 0.0;//发文中监理费金额（不含税）
-        double supervisorFeePayable = 0.0;//监理费应付金额
-        List<Expense> expenseList = new ArrayList<Expense>();
-        for (Expense expense:expenses){
-            supervisionCost = expense.getSupervisionCost();//监理费合同则扣
-            supervisionTypeicalCost = expense.getSupervisionTypeicalCost();//监理费典型设计折扣
-            documentSupervisionCost = expense.getDocumentSupervisionCost();//监理费应付金额 不含税价
-            for (MaintainData maintainData:maintainDatas){
-                //项目定义号相同
-                if (expense.getProjectId().equals(maintainData.getProjectId())){
-                    investment = Double.valueOf(maintainData.getInvestment());//发文总投资
-                    estimateTotal = maintainData.getDesignFee()+maintainData.getBuildingFee()+maintainData.getEquipmentFee()+maintainData.getMaterialFee()+maintainData
-                            .getInstallFee()+maintainData.getSupervisionFee()+maintainData.getPreliminaryWorkFee()+maintainData.getDamages()+maintainData.getManagementFee();
-                    estimateTotal = estimateTotal/10000;//发文总金额（----------------------------------------）
-                    if (expense.getStatus().equals("1")){//2020年之前项目
-                        if (investment<=estimateTotal+0.01 && investment>=estimateTotal-0.01){
-                            supervisionFee = maintainData.getSupervisionFee();//概预算中监理费金额
-                            supervisorFeePayable = supervisionFee*supervisionCost*supervisionTypeicalCost/1.06;//不含税价
-                        }else {
-                            supervisorFeePayable =  documentSupervisionCost*supervisionCost*supervisionTypeicalCost/1.06;//不换税价
-                        }
-                    }else {//2020年之后项目
-                        if (investment<=estimateTotal+0.01 && investment>=estimateTotal-0.01){
-                            supervisionFee = maintainData.getSupervisionFee();//概预算中监理费金额
-                            supervisorFeePayable = supervisionFee*supervisionCost*supervisionTypeicalCost*1.06;
-                        }else {
-                            supervisorFeePayable =  documentSupervisionCost*supervisionCost*supervisionTypeicalCost*1.06;
-                        }
-                    }
-                    expense.setSupervisorFeePayable(supervisorFeePayable);//设计费应付金额
-                    expenseList.add(expense);
-                    break;
-                }
+            }else if(actuallyPaidSupervision>supervisionFeePayable){
+                credit.setSupervisorStatus(OVER_PAY_AMOUNT);
+            }else{
+                credit.setSupervisorStatus(PAY_LESS_AMOUNT);
             }
+
         }
-        return expenses;
     }
 
-    //2020之前的项目费用入账判断(无问题)施工费 实际付款金额
-    public static Map<String,List<ErpCredit>> getJudgeConsFee(List<ErpCredit> erpCredits, List<Expense> expenses){
-        Map<String,List<ErpCredit>> consFeeMap = new HashMap<String, List<ErpCredit>>();
-        //若应付金额（不含税价）=实付金额（不含税价）,差异若在0.01则忽略不计，则费用入账核实无问题 集合
-        List<ErpCredit> erpCredits1 = new ArrayList<ErpCredit>();
-        //若应付金额（不含税价）>实付金额（不含税价）,需要进入人工判断，若人工判断通过，则费用入账核实无问题，若人工判断不通过则费用入账核实存在问题；
-        List<ErpCredit> erpCredits2 = new ArrayList<ErpCredit>();
-        //若应付金额（不含税价）<实付金额（不含税价）,需要导出差异情况，同时费用入账核实存在问题
-        List<ErpCredit> erpCredits3 = new ArrayList<ErpCredit>();
-        Double consTotalFee = 0.0;//=ERP明细账生成数据中监理费入账金额(不含税价)
-        for (ErpCredit erpCredit:erpCredits){
-            consTotalFee = erpCredit.getConsTotalFee();
-            for (Expense expense:expenses){
-                if (erpCredit.getItemId().equals(expense.getProjectId())){
-                    //施工费
-                    erpCredit.setConstructionFeePayable(expense.getConstructionFeePayable());
-                    //若应付金额（不含税价）=实付金额（不含税价）,差异若在0.01则忽略不计，则费用入账核实无问题
-                    if (expense.getConstructionFeePayable()>= consTotalFee-0.01 && expense.getSupervisorFeePayable()<= consTotalFee+0.01){
-                        erpCredits1.add(erpCredit);//无问题
-                    }else if (expense.getConstructionFeePayable()>consTotalFee){
-                        erpCredit.setConstructionStatus("2");
-                        erpCredit.setConstructionFeePayable(expense.getConstructionFeePayable());
-                        erpCredits2.add(erpCredit);//存在问题
-                    }else {
-                        erpCredit.setConstructionStatus("1");
-                        erpCredit.setConstructionFeePayable(expense.getConstructionFeePayable());
-                        erpCredits3.add(erpCredit);//<存在问题
-                    }
-                    break;
-                }
+    /**
+     * 判断施工费付款情况
+     * @param creditList
+     * @param expenseMap
+     * @param informationMap
+     */
+    private static void judgeConstructionAmount(List<ErpCredit> creditList,Map<String,Expense> expenseMap,Map<String,Information> informationMap){
+        for(ErpCredit credit:creditList){
+            String projectId = credit.getItemId();
+            Expense expense = expenseMap.get(projectId);
+            Information info = informationMap.get(projectId);
+
+            Double settlementPrice = info.getSettlementPrice();//结算审定施工费
+            Double constructionCost = expense.getConstructionCost();//施工费合同折扣
+            Double construnctionPayable = settlementPrice*constructionCost/1.09;//施工费应付金额（不含税）
+
+            credit.setConstructionFeePayable(DoubleUtil.round2(construnctionPayable));
+
+            Double actuallyPaid = credit.getConsTotalFee();//实付施工费费
+            if(Math.abs(DoubleUtil.sub(actuallyPaid,construnctionPayable))<=0.01){
+
+            }else if(actuallyPaid>construnctionPayable){
+                credit.setConstructionStatus(OVER_PAY_AMOUNT);
+            }else{
+                credit.setConstructionStatus(PAY_LESS_AMOUNT);
             }
         }
-        consFeeMap.put("consNoProblem",erpCredits1);//无问题
-        consFeeMap.put("consThanProblem",erpCredits2);//人工判断
-        consFeeMap.put("consYesProblem",erpCredits3);//存在问题导出
-        return consFeeMap;
-    }
 
-    //项目费用入账判断施工费 施工费应付金额
-    public static List<Expense> getJudgeConsFeeActual(List<Information> informationList,List<Expense> expenses){
-        Double constructionFeePayable=0.0;//施工费应付金额
-        Double constructionCost = 0.0; //施工费合同折扣
-        Double settlementPrice = 1.0;//结算审定施工费金额（含税价）
-        for (Expense expense:expenses){
-            settlementPrice = 1.0;
-            constructionFeePayable=0.0;
-            constructionCost = expense.getConstructionCost();//施工合同折扣
-            for (Information information:informationList){
-                if (expense.getProjectId().equals(information.getProjectId())){
-                    //结算审定施工费金额（含税价）如果不为空则赋值
-                    if (null!=information.getSettlementPrice()){
-                        settlementPrice = information.getSettlementPrice();
-                    }
-                    //2020年前的项目
-                    if (expense.getStatus().equals("1")){
-                        constructionFeePayable = constructionCost*settlementPrice/1.09;
-                    }else {//2020后的项目
-                        constructionFeePayable = constructionCost*settlementPrice/1.09;
+    }
+    /**
+     * 判断项目年份，并设置状态
+     * 判断逻辑：项目批次号前4位，如果为数字前大于2020，则为2020年以后， 剩余为以前
+     * @param expenseList
+     */
+    private static void judgeTime(List<Expense> expenseList){
+        if(expenseList==null||expenseList.size()==0){
+            return;
+        }
+        for(Expense expense:expenseList){
+            expense.setStatus(BEFORE_2020);
+            String projectBatch = expense.getProjectBatch();
+            if(StringUtils.isNotBlank(projectBatch)&&projectBatch.length()>=4){
+                String yearStr = projectBatch.substring(0,4);
+                try {
+                    Integer year = Integer.parseInt(yearStr);
+                    if(year>=2020){
+                        expense.setStatus(AFTER_2020);
                     }
-                    expense.setConstructionFeePayable(constructionFeePayable);
-                    break;
+                } catch (NumberFormatException e) {
                 }
             }
         }
-        return expenses;
     }
 
+
+//    public static List<Expense> getQCExpense(List<ErpCredit> erpCredits,List<Expense> expenses){
+//        List<Expense> expenseList = new ArrayList<Expense>();
+//        boolean flag = false;
+//        for (Expense expense:expenses){
+//            flag = false;
+//            for (ErpCredit erpCredit1:erpCredits){
+//                if (expense.getProjectId().equals(erpCredit1.getItemId())){
+//                    flag = true;
+//                    break;
+//                }
+//            }
+//            if (flag){
+//                expenseList.add(expense);
+//            }
+//        }
+//        return getOneErpListJudge(expenseList);
+//    }
+
+
+
+    //得到 2020年项目
+//    public static List<Expense> getOneErpListJudge(List<Expense> expenses){
+//        String projectBatch = "";
+////        List<Expense> expensesList = new ArrayList<Expense>();
+//        boolean yearJudgment = false;
+//        for (Expense expense:expenses){
+//            projectBatch = expense.getProjectBatch();
+//            if (null!=projectBatch&&!"".equals(projectBatch)){
+//               yearJudgment = getYearJudgment(projectBatch);
+//               if (yearJudgment){
+//                  expense.setStatus("0");
+//               }else {
+//                   expense.setStatus("1");
+//               }
+//            }
+//        }
+//        return expenses;
+//    }
+//
+//    //判断项目时间
+//    public static boolean getYearJudgment(String projectBatch){
+//        Integer yearNumber = 2020;
+//        if (projectBatch.length()>=4){
+//            projectBatch = projectBatch.substring(0,4);
+//            yearNumber = new Integer(projectBatch);
+//            if (yearNumber>=2020){
+//                return true;
+//            }
+//        }
+//        return false;
+//    }
+
+
+    //2020之前的项目费用入账判断(无问题)设计费 实际付款金额
+//    public static Map<String,List<ErpCredit>> getJudgeDesign(List<ErpCredit> erpCredits, List<Expense> expenses){
+//        Map<String,List<ErpCredit>> designMap = new HashMap<String, List<ErpCredit>>();
+//        //若应付金额（不含税价）=实付金额（不含税价）,差异若在0.01则忽略不计，则费用入账核实无问题 集合
+//        List<ErpCredit> erpCredits1 = new ArrayList<ErpCredit>();
+//        //若应付金额（不含税价）>实付金额（不含税价）,需要进入人工判断，若人工判断通过，则费用入账核实无问题，若人工判断不通过则费用入账核实存在问题；
+//        List<ErpCredit> erpCredits2 = new ArrayList<ErpCredit>();
+//        //若应付金额（不含税价）<实付金额（不含税价）,需要导出差异情况，同时费用入账核实存在问题
+//        List<ErpCredit> erpCredits3 = new ArrayList<ErpCredit>();
+//        Double otherDesignFee = 0.0;//=ERP明细账生成数据中设计费入账金额(不含税价)
+//        for (ErpCredit erpCredit:erpCredits){
+//            otherDesignFee = erpCredit.getOtherDesignFee();
+//            for (Expense expense:expenses){
+//                if (erpCredit.getItemId().equals(expense.getProjectId())){
+//                    erpCredit.setDesignFeePayable(expense.getDesignFeePayable());//设计费应付金额
+//                    //若应付金额（不含税价）=实付金额（不含税价）,差异若在0.01则忽略不计，则费用入账核实无问题
+//                    if (expense.getDesignFeePayable()>= otherDesignFee-0.01 && expense.getDesignFeePayable()<= otherDesignFee+0.01){
+//                        erpCredits1.add(erpCredit);//无问题
+//                    }else if (expense.getDesignFeePayable()>otherDesignFee){
+//                        erpCredit.setDesignStatus("2");
+//                        erpCredit.setDesignFeePayable(expense.getDesignFeePayable());
+//                        erpCredits2.add(erpCredit);//存在问题
+//                    }else {
+//                        erpCredit.setDesignStatus("1");
+//                        erpCredit.setDesignFeePayable(expense.getDesignFeePayable());
+//                        erpCredits3.add(erpCredit);//<存在问题
+//                    }
+//                    break;
+//                }
+//            }
+//        }
+//        designMap.put("designNoProblem",erpCredits1);//无问题
+//        designMap.put("designThanProblem",erpCredits2);//人工判断
+//        designMap.put("designYesProblem",erpCredits3);//存在问题导出
+//        return designMap;
+//    }
+//
+//    //项目费用入账判断设计费 设计费应付金额
+//    public static List<Expense> getJudgeDesignActual(List<Expense> expenses, List<MaintainData> maintainDatas){
+//        double investment = 0.0;    //发文总投资
+//        double estimateTotal = 0.0;//概算总金额
+//        double designFee = 0.0;//概预算中设计费设计费
+//        double designCost = 0.0;//设计费合同则扣
+//        double designTypeicalCost =0.0;//设计费典型设计折扣
+//        double documentDesignCost = 0.0;//发文中设计费金额（不含税）
+//        double designFeePayable = 0.0;//设计费应付金额 不含税价
+//        List<Expense> expenseList = new ArrayList<Expense>();
+//        for (Expense expense:expenses){
+//            designCost = expense.getDesignCost();
+//            designTypeicalCost = expense.getDesignTypeicalCost();
+//            documentDesignCost = expense.getDocumentDesignCost();//发文中设计费金额（不含税）
+//            for (MaintainData maintainData:maintainDatas){
+//                //项目定义号相同
+//               if (expense.getProjectId().equals(maintainData.getProjectId())){
+//                   investment = Double.valueOf(maintainData.getInvestment());//发文总投资
+//                   estimateTotal = maintainData.getDesignFee()+maintainData.getBuildingFee()+maintainData.getEquipmentFee()+maintainData.getMaterialFee()+maintainData
+//                           .getInstallFee()+maintainData.getSupervisionFee()+maintainData.getPreliminaryWorkFee()+maintainData.getDamages()+maintainData.getManagementFee();
+//                   estimateTotal = estimateTotal/10000;//发文总金额（----------------------------------------）
+//                    if (expense.getStatus().equals("1")){//2020年之前项目
+//                        if (investment<=estimateTotal+0.01 && investment>=estimateTotal-0.01){
+//                            designFee = maintainData.getDesignFee();//该预算中设计费
+//                            designFeePayable = designFee*designCost*designTypeicalCost/1.06;//不含税价
+//                        }else {
+//                            designFeePayable =  documentDesignCost*designCost*designTypeicalCost/1.06;//不换税价
+//                        }
+//                    }else {//2020年之后项目
+//                        if (investment<=estimateTotal+0.01 && investment>=estimateTotal-0.01){
+//                            designFee = maintainData.getDesignFee();//该预算中设计费
+//                            designFeePayable = designFee*designCost*designTypeicalCost*1.06;
+//                        }else {
+//                            designFeePayable =  documentDesignCost*designCost*designTypeicalCost*1.06;
+//                        }
+//                    }
+//                   expense.setDesignFeePayable(designFeePayable);//设计费应付金额
+//                   expenseList.add(expense);
+//                   break;
+//               }
+//            }
+//        }
+//        return expenses;
+//    }
+//
+//
+//    //2020之前的项目费用入账判断(无问题)监理费 实际付款金额
+//    public static Map<String,List<ErpCredit>> getJudgeSupervisorFee(List<ErpCredit> erpCredits, List<Expense> expenses){
+//        Map<String,List<ErpCredit>> supervisorFeeMap = new HashMap<String, List<ErpCredit>>();
+//        //若应付金额（不含税价）=实付金额（不含税价）,差异若在0.01则忽略不计，则费用入账核实无问题 集合
+//        List<ErpCredit> erpCredits1 = new ArrayList<ErpCredit>();
+//        //若应付金额（不含税价）>实付金额（不含税价）,需要进入人工判断，若人工判断通过，则费用入账核实无问题，若人工判断不通过则费用入账核实存在问题；
+//        List<ErpCredit> erpCredits2 = new ArrayList<ErpCredit>();
+//        //若应付金额（不含税价）<实付金额（不含税价）,需要导出差异情况，同时费用入账核实存在问题
+//        List<ErpCredit> erpCredits3 = new ArrayList<ErpCredit>();
+//        Double otherSupervisorFee = 0.0;//=ERP明细账生成数据中监理费入账金额(不含税价)
+//        for (ErpCredit erpCredit:erpCredits){
+//            otherSupervisorFee = erpCredit.getOtherSupervisorFee();
+//            for (Expense expense:expenses){
+//                if (erpCredit.getItemId().equals(expense.getProjectId())){
+//                    erpCredit.setSupervisorFeePayable(expense.getSupervisorFeePayable());//监理费
+//                    //若应付金额（不含税价）=实付金额（不含税价）,差异若在0.01则忽略不计，则费用入账核实无问题
+//                    if (expense.getSupervisorFeePayable()>= otherSupervisorFee-0.01 && expense.getSupervisorFeePayable()<= otherSupervisorFee+0.01){
+//                        erpCredits1.add(erpCredit);//无问题
+//                    }else if (expense.getSupervisorFeePayable()>otherSupervisorFee){
+//                        erpCredit.setSupervisorStatus("2");
+//                        erpCredit.setSupervisorFeePayable(expense.getSupervisorFeePayable());
+//                        erpCredits2.add(erpCredit);//存在问题
+//                    }else {
+//                        erpCredit.setSupervisorStatus("1");
+//                        erpCredit.setSupervisorFeePayable(expense.getSupervisorFeePayable());
+//                        erpCredits3.add(erpCredit);//<存在问题
+//                    }
+//                    break;
+//                }
+//            }
+//        }
+//        supervisorFeeMap.put("supervisorNoProblem",erpCredits1);//无问题
+//        supervisorFeeMap.put("supervisorThanProblem",erpCredits2);//人工判断
+//        supervisorFeeMap.put("supervisorYesProblem",erpCredits3);//存在问题导出
+//        return supervisorFeeMap;
+//    }
+//
+//    //项目费用入账判断监理费 监理费应付金额
+//    public static List<Expense> getJudgeSupervisorFeeActual(List<Expense> expenses, List<MaintainData> maintainDatas){
+//        double investment = 0.0;    //发文总投资
+//        double estimateTotal = 0.0;//概算总金额
+//        double supervisionFee = 0.0;//概预算中监理费
+//        double supervisionCost = 0.0;//监理费合同则扣
+//        double supervisionTypeicalCost =0.0;//监理费典型设计折扣
+//        double documentSupervisionCost = 0.0;//发文中监理费金额（不含税）
+//        double supervisorFeePayable = 0.0;//监理费应付金额
+//        List<Expense> expenseList = new ArrayList<Expense>();
+//        for (Expense expense:expenses){
+//            supervisionCost = expense.getSupervisionCost();//监理费合同则扣
+//            supervisionTypeicalCost = expense.getSupervisionTypeicalCost();//监理费典型设计折扣
+//            documentSupervisionCost = expense.getDocumentSupervisionCost();//监理费应付金额 不含税价
+//            for (MaintainData maintainData:maintainDatas){
+//                //项目定义号相同
+//                if (expense.getProjectId().equals(maintainData.getProjectId())){
+//                    investment = Double.valueOf(maintainData.getInvestment());//发文总投资
+//                    estimateTotal = maintainData.getDesignFee()+maintainData.getBuildingFee()+maintainData.getEquipmentFee()+maintainData.getMaterialFee()+maintainData
+//                            .getInstallFee()+maintainData.getSupervisionFee()+maintainData.getPreliminaryWorkFee()+maintainData.getDamages()+maintainData.getManagementFee();
+//                    estimateTotal = estimateTotal/10000;//发文总金额（----------------------------------------）
+//                    if (expense.getStatus().equals("1")){//2020年之前项目
+//                        if (investment<=estimateTotal+0.01 && investment>=estimateTotal-0.01){
+//                            supervisionFee = maintainData.getSupervisionFee();//概预算中监理费金额
+//                            supervisorFeePayable = supervisionFee*supervisionCost*supervisionTypeicalCost/1.06;//不含税价
+//                        }else {
+//                            supervisorFeePayable =  documentSupervisionCost*supervisionCost*supervisionTypeicalCost/1.06;//不换税价
+//                        }
+//                    }else {//2020年之后项目
+//                        if (investment<=estimateTotal+0.01 && investment>=estimateTotal-0.01){
+//                            supervisionFee = maintainData.getSupervisionFee();//概预算中监理费金额
+//                            supervisorFeePayable = supervisionFee*supervisionCost*supervisionTypeicalCost*1.06;
+//                        }else {
+//                            supervisorFeePayable =  documentSupervisionCost*supervisionCost*supervisionTypeicalCost*1.06;
+//                        }
+//                    }
+//                    expense.setSupervisorFeePayable(supervisorFeePayable);//设计费应付金额
+//                    expenseList.add(expense);
+//                    break;
+//                }
+//            }
+//        }
+//        return expenses;
+//    }
+//
+//    //2020之前的项目费用入账判断(无问题)施工费 实际付款金额
+//    public static Map<String,List<ErpCredit>> getJudgeConsFee(List<ErpCredit> erpCredits, List<Expense> expenses){
+//        Map<String,List<ErpCredit>> consFeeMap = new HashMap<String, List<ErpCredit>>();
+//        //若应付金额（不含税价）=实付金额（不含税价）,差异若在0.01则忽略不计，则费用入账核实无问题 集合
+//        List<ErpCredit> erpCredits1 = new ArrayList<ErpCredit>();
+//        //若应付金额（不含税价）>实付金额（不含税价）,需要进入人工判断，若人工判断通过，则费用入账核实无问题，若人工判断不通过则费用入账核实存在问题；
+//        List<ErpCredit> erpCredits2 = new ArrayList<ErpCredit>();
+//        //若应付金额（不含税价）<实付金额（不含税价）,需要导出差异情况，同时费用入账核实存在问题
+//        List<ErpCredit> erpCredits3 = new ArrayList<ErpCredit>();
+//        Double consTotalFee = 0.0;//=ERP明细账生成数据中监理费入账金额(不含税价)
+//        for (ErpCredit erpCredit:erpCredits){
+//            consTotalFee = erpCredit.getConsTotalFee();
+//            for (Expense expense:expenses){
+//                if (erpCredit.getItemId().equals(expense.getProjectId())){
+//                    //施工费
+//                    erpCredit.setConstructionFeePayable(expense.getConstructionFeePayable());
+//                    //若应付金额（不含税价）=实付金额（不含税价）,差异若在0.01则忽略不计，则费用入账核实无问题
+//                    if (expense.getConstructionFeePayable()>= consTotalFee-0.01 && expense.getSupervisorFeePayable()<= consTotalFee+0.01){
+//                        erpCredits1.add(erpCredit);//无问题
+//                    }else if (expense.getConstructionFeePayable()>consTotalFee){
+//                        erpCredit.setConstructionStatus("2");
+//                        erpCredit.setConstructionFeePayable(expense.getConstructionFeePayable());
+//                        erpCredits2.add(erpCredit);//存在问题
+//                    }else {
+//                        erpCredit.setConstructionStatus("1");
+//                        erpCredit.setConstructionFeePayable(expense.getConstructionFeePayable());
+//                        erpCredits3.add(erpCredit);//<存在问题
+//                    }
+//                    break;
+//                }
+//            }
+//        }
+//        consFeeMap.put("consNoProblem",erpCredits1);//无问题
+//        consFeeMap.put("consThanProblem",erpCredits2);//人工判断
+//        consFeeMap.put("consYesProblem",erpCredits3);//存在问题导出
+//        return consFeeMap;
+//    }
+//
+//    //项目费用入账判断施工费 施工费应付金额
+//    public static List<Expense> getJudgeConsFeeActual(List<Information> informationList,List<Expense> expenses){
+//        Double constructionFeePayable=0.0;//施工费应付金额
+//        Double constructionCost = 0.0; //施工费合同折扣
+//        Double settlementPrice = 1.0;//结算审定施工费金额（含税价）
+//        for (Expense expense:expenses){
+//            settlementPrice = 1.0;
+//            constructionFeePayable=0.0;
+//            constructionCost = expense.getConstructionCost();//施工合同折扣
+//            for (Information information:informationList){
+//                if (expense.getProjectId().equals(information.getProjectId())){
+//                    //结算审定施工费金额（含税价）如果不为空则赋值
+//                    if (null!=information.getSettlementPrice()){
+//                        settlementPrice = information.getSettlementPrice();
+//                    }
+//                    //2020年前的项目
+//                    if (expense.getStatus().equals("1")){
+//                        constructionFeePayable = constructionCost*settlementPrice/1.09;
+//                    }else {//2020后的项目
+//                        constructionFeePayable = constructionCost*settlementPrice/1.09;
+//                    }
+//                    expense.setConstructionFeePayable(constructionFeePayable);
+//                    break;
+//                }
+//            }
+//        }
+//        return expenses;
+//    }
+
     //方法整合
-    public static Map<String,List<ErpCredit>> getJudgeEnterAccount(List<ErpCredit> erpCredits, List<Expense> expenses,List<Information> informationList,List<MaintainData> maintainDatas){
-        Map<String,List<ErpCredit>> listMap = new HashMap<String, List<ErpCredit>>();
-        //设计费
-        //项目费用入账判断设计费 设计费应付金额
-        List<Expense> judgeDesignActual = getJudgeDesignActual(expenses, maintainDatas);
-        //项目费用入账判断(无问题)设计费 实际付款金额
-        Map<String, List<ErpCredit>> judgeDesign = getJudgeDesign(erpCredits, judgeDesignActual);
-        //监理费
-        List<Expense> judgeSupervisorFeeActual = getJudgeSupervisorFeeActual(expenses, maintainDatas);
-        Map<String, List<ErpCredit>> judgeSupervisorFee = getJudgeSupervisorFee(erpCredits, judgeSupervisorFeeActual);
-        //施工费
-        List<Expense> judgeConsFeeActual = getJudgeConsFeeActual(informationList, expenses);
-        Map<String, List<ErpCredit>> judgeConsFee = getJudgeConsFee(erpCredits, judgeConsFeeActual);
-
-        //获取存在集合的且有问题（应付金额（不含税价）>实付金额（不含税价））
-        List<ErpCredit> designThanProblem = judgeDesign.get("designThanProblem");//获取设计费
-        List<ErpCredit> supervisorThanProblem = judgeSupervisorFee.get("supervisorThanProblem");//获取监理费
-        List<ErpCredit> consThanProblem = judgeConsFee.get("consThanProblem");//获取施工费
-        List<ErpCredit> judgeEnterAccountTwo = getJudgeEnterAccount(designThanProblem, supervisorThanProblem, consThanProblem,"2");
-
-        //若应付金额（不含税价）<实付金额（不含税价）,需要导出差异情况，同时费用入账核实存在问题。
-        List<ErpCredit> designYesProblem = judgeDesign.get("designYesProblem");//获取设计费
-        List<ErpCredit> supervisorYesProblem = judgeSupervisorFee.get("supervisorYesProblem");//获取监理费
-        List<ErpCredit> consYesProblem = judgeConsFee.get("consYesProblem");//获取施工费
-        List<ErpCredit> judgeEnterAccountThree = getJudgeEnterAccount(designYesProblem, supervisorYesProblem, consYesProblem,"1");
-        listMap.put("judgeEnterAccountTwo",judgeEnterAccountTwo);
-        listMap.put("judgeEnterAccountThree",judgeEnterAccountThree);
-        return listMap;
-    }
+//    public static Map<String,List<ErpCredit>> getJudgeEnterAccount(List<ErpCredit> erpCredits, List<Expense> expenses,List<Information> informationList,List<MaintainData> maintainDatas){
+//        Map<String,List<ErpCredit>> listMap = new HashMap<String, List<ErpCredit>>();
+//        //设计费
+//        //项目费用入账判断设计费 设计费应付金额
+//        List<Expense> judgeDesignActual = getJudgeDesignActual(expenses, maintainDatas);
+//        //项目费用入账判断(无问题)设计费 实际付款金额
+//        Map<String, List<ErpCredit>> judgeDesign = getJudgeDesign(erpCredits, judgeDesignActual);
+//        //监理费
+//        List<Expense> judgeSupervisorFeeActual = getJudgeSupervisorFeeActual(expenses, maintainDatas);
+//        Map<String, List<ErpCredit>> judgeSupervisorFee = getJudgeSupervisorFee(erpCredits, judgeSupervisorFeeActual);
+//        //施工费
+//        List<Expense> judgeConsFeeActual = getJudgeConsFeeActual(informationList, expenses);
+//        Map<String, List<ErpCredit>> judgeConsFee = getJudgeConsFee(erpCredits, judgeConsFeeActual);
+//
+//        //获取存在集合的且有问题（应付金额（不含税价）>实付金额（不含税价））
+//        List<ErpCredit> designThanProblem = judgeDesign.get("designThanProblem");//获取设计费
+//        List<ErpCredit> supervisorThanProblem = judgeSupervisorFee.get("supervisorThanProblem");//获取监理费
+//        List<ErpCredit> consThanProblem = judgeConsFee.get("consThanProblem");//获取施工费
+//        List<ErpCredit> judgeEnterAccountTwo = getJudgeEnterAccount(designThanProblem, supervisorThanProblem, consThanProblem,"2");
+//
+//        //若应付金额（不含税价）<实付金额（不含税价）,需要导出差异情况，同时费用入账核实存在问题。
+//        List<ErpCredit> designYesProblem = judgeDesign.get("designYesProblem");//获取设计费
+//        List<ErpCredit> supervisorYesProblem = judgeSupervisorFee.get("supervisorYesProblem");//获取监理费
+//        List<ErpCredit> consYesProblem = judgeConsFee.get("consYesProblem");//获取施工费
+//        List<ErpCredit> judgeEnterAccountThree = getJudgeEnterAccount(designYesProblem, supervisorYesProblem, consYesProblem,"1");
+//        listMap.put("judgeEnterAccountTwo",judgeEnterAccountTwo);
+//        listMap.put("judgeEnterAccountThree",judgeEnterAccountThree);
+//        return listMap;
+//    }
 
 
     //统一list
-    public static List<ErpCredit> getJudgeEnterAccount(List<ErpCredit> erpCredits1,List<ErpCredit> erpCredits2,List<ErpCredit> erpCredits3,String status){
-        List<ErpCredit> list = new ArrayList<ErpCredit>();
-        List<ErpCredit> sureList = new ArrayList<ErpCredit>();
-        for (ErpCredit erpCredit1:erpCredits1){
-            list.add(erpCredit1);
-        }
-        for (ErpCredit erpCredit2:erpCredits2){
-            list.add(erpCredit2);
-        }
-        for (ErpCredit erpCredit3:erpCredits3){
-            list.add(erpCredit3);
-        }
-        boolean flag = true;
-        for (ErpCredit erpCredit:list){
-            flag = true;
-            for (ErpCredit sureErp:sureList){
-                if (erpCredit.getItemId().equals(sureErp.getItemId())){
-                    if (null!=erpCredit.getDesignStatus()){//设计费存在问题
-                      if (erpCredit.getDesignStatus().equals(status)){
-                          sureErp.setDesignStatus(status);
-                          sureErp.setDesignFeePayable(erpCredit.getDesignFeePayable());
-                      }
-                    }
-                    if (null!=erpCredit.getConstructionStatus()){
-                       if (erpCredit.getConstructionStatus().equals(status)){
-                           sureErp.setConstructionStatus(status);
-                           sureErp.setConstructionFeePayable(erpCredit.getConstructionFeePayable());
-                       }
-                    }
-                    if (null!=erpCredit.getSupervisorStatus()){
-                        if (erpCredit.getSupervisorStatus().equals(status)){
-                            sureErp.setSupervisorStatus(status);
-                            sureErp.setSupervisorFeePayable(erpCredit.getSupervisorFeePayable());
-                        }
-                    }
-                    flag = false;
-                }
-            }
-            if (flag){
-                sureList.add(erpCredit);
-            }
-        }
-        return sureList;
-    }
+//    public static List<ErpCredit> getJudgeEnterAccount(List<ErpCredit> erpCredits1,List<ErpCredit> erpCredits2,List<ErpCredit> erpCredits3,String status){
+//        List<ErpCredit> list = new ArrayList<ErpCredit>();
+//        List<ErpCredit> sureList = new ArrayList<ErpCredit>();
+//        for (ErpCredit erpCredit1:erpCredits1){
+//            list.add(erpCredit1);
+//        }
+//        for (ErpCredit erpCredit2:erpCredits2){
+//            list.add(erpCredit2);
+//        }
+//        for (ErpCredit erpCredit3:erpCredits3){
+//            list.add(erpCredit3);
+//        }
+//        boolean flag = true;
+//        for (ErpCredit erpCredit:list){
+//            flag = true;
+//            for (ErpCredit sureErp:sureList){
+//                if (erpCredit.getItemId().equals(sureErp.getItemId())){
+//                    if (null!=erpCredit.getDesignStatus()){//设计费存在问题
+//                      if (erpCredit.getDesignStatus().equals(status)){
+//                          sureErp.setDesignStatus(status);
+//                          sureErp.setDesignFeePayable(erpCredit.getDesignFeePayable());
+//                      }
+//                    }
+//                    if (null!=erpCredit.getConstructionStatus()){
+//                       if (erpCredit.getConstructionStatus().equals(status)){
+//                           sureErp.setConstructionStatus(status);
+//                           sureErp.setConstructionFeePayable(erpCredit.getConstructionFeePayable());
+//                       }
+//                    }
+//                    if (null!=erpCredit.getSupervisorStatus()){
+//                        if (erpCredit.getSupervisorStatus().equals(status)){
+//                            sureErp.setSupervisorStatus(status);
+//                            sureErp.setSupervisorFeePayable(erpCredit.getSupervisorFeePayable());
+//                        }
+//                    }
+//                    flag = false;
+//                }
+//            }
+//            if (flag){
+//                sureList.add(erpCredit);
+//            }
+//        }
+//        return sureList;
+//    }
 }

src/main/java/com/jeeplus/modules/sg/financial/erpcredit/util/DoubleUtil.java

@@ -0,0 +1,62 @@
+package com.jeeplus.modules.sg.financial.erpcredit.util;
+
+import java.math.BigDecimal;
+
+public class DoubleUtil {
+
+    /**
+     * 返回double保留两位小数点的值
+     * @param num
+     * @return
+     */
+    public static double round2(double num){
+        return (double) Math.round(num * 100) / 100;
+    }
+
+    /**
+     * 返回double类型 value1减去value2的准确值
+     * @param value1
+     * @param value2
+     * @return
+     */
+    public static double sub(Double value1, Double value2) {
+        value1 = value1 != null?value1:0.00;
+        value2 = value2 != null?value2:0.00;
+        BigDecimal b1 = new BigDecimal(Double.toString(value1));
+        BigDecimal b2 = new BigDecimal(Double.toString(value2));
+        return b1.subtract(b2).doubleValue();
+    }
+
+    /**
+     * 返回double类型 获得value1加上value2的精确值
+     * @param value1
+     * @param value2
+     * @return
+     */
+    public static double add(Double value1, Double value2) {
+        value1 = value1 != null?value1:0.00;
+        value2 = value2 != null?value2:0.00;
+        BigDecimal b1 = new BigDecimal(Double.toString(value1));
+        BigDecimal b2 = new BigDecimal(Double.toString(value2));
+        return b1.add(b2).doubleValue();
+    }
+
+    /**
+     * 返回多个Double的精确相加值
+     * @param value1
+     * @param values
+     * @return
+     */
+    public static double add(Double value1,Double...values){
+        value1 = value1 != null?value1:0.00;
+        BigDecimal b1 = new BigDecimal(Double.toString(value1));
+        for(int i=0;i<values.length;i++){
+            Double value2 = values[i];
+            value2 = value2!=null?value2:0.00;
+            BigDecimal b2 = new BigDecimal(Double.toString(value2));
+            b1 = b1.add(b2);
+        }
+        return b1.doubleValue();
+    }
+
+}

src/main/java/com/jeeplus/modules/sg/financial/erpcredit/util/SerializeUtil.java

@@ -0,0 +1,60 @@
+package com.jeeplus.modules.sg.financial.erpcredit.util;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+
+public class SerializeUtil {
+    /*
+     * 序列化
+     * */
+    public static byte[] serizlize(Object object) {
+        ObjectOutputStream oos = null;
+        ByteArrayOutputStream baos = null;
+        try {
+            baos = new ByteArrayOutputStream();
+            oos = new ObjectOutputStream(baos);
+            oos.writeObject(object);
+            byte[] bytes = baos.toByteArray();
+            return bytes;
+        } catch (Exception e) {
+            e.printStackTrace();
+        } finally {
+            try {
+                if (baos != null) {
+                    baos.close();
+                }
+                if (oos != null) {
+                    oos.close();
+                }
+            } catch (Exception e2) {
+                e2.printStackTrace();
+            }
+        }
+        return null;
+    }
+
+    /*
+     * 反序列化
+     * */
+    public static Object deserialize(byte[] bytes) {
+        ByteArrayInputStream bais = null;
+        ObjectInputStream ois = null;
+        try {
+            bais = new ByteArrayInputStream(bytes);
+            ois = new ObjectInputStream(bais);
+            return ois.readObject();
+        } catch (Exception e) {
+            e.printStackTrace();
+        } finally {
+            try {
+
+            } catch (Exception e2) {
+                e2.printStackTrace();
+            }
+        }
+        return null;
+
+    }
+}

src/main/java/com/jeeplus/modules/sg/financial/erpcredit/util/ValidationUtils.java

@@ -1,20 +1,33 @@
 package com.jeeplus.modules.sg.financial.erpcredit.util;
 
+import com.alibaba.fastjson.JSON;
+import com.jeeplus.common.utils.StringUtils;
 import com.jeeplus.modules.sg.audit.information.entity.Information;
-import com.jeeplus.modules.sg.financial.erpcredit.entity.ErpCredit;
-import com.jeeplus.modules.sg.financial.erpcredit.entity.ErpJudgeAccount;
-import com.jeeplus.modules.sg.financial.erpcredit.entity.ErpJudgeArtificial;
-import com.jeeplus.modules.sg.financial.erpcredit.entity.ErpJudgeExport;
+import com.jeeplus.modules.sg.financial.erpcredit.entity.*;
 import com.jeeplus.modules.sg.financial.expense.entity.Expense;
 import com.jeeplus.modules.sg.financial.settlement.entity.MaintainData;
 import com.jeeplus.modules.sg.managementcenter.project.entity.Project;
+import net.oschina.j2cache.CacheChannel;
+import net.oschina.j2cache.J2Cache;
+import net.oschina.j2cache.redis.RedisCacheProvider;
+import net.oschina.j2cache.redis.RedisClient;
+import net.oschina.j2cache.redis.RedisUtils;
 
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.servlet.http.HttpSession;
 import java.text.DecimalFormat;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;
 
 public class ValidationUtils {
 
+    public static final String JUDGE_KEY_PREFIX = "erpjudge:";//甲供材、费用入账存在性验证不通过，存储key
+    public static final String CREDIT_KEY_PREFIX = "erpcredit:";//明细账转化中间数据存储key
+    public static final String EXPENSE_KEY_PREFIX = "erpexpense:";//实付大于应付数据对象 存储key
+    public static final String ARTIFICIAL_KEY_PREFIX = "erpartificial";//应付金额大于实付金额数据对象 存储key
+
     //验证概预算信息是否存在
     public static String getDataMainJudge(List<ErpCredit> erpCredits, List<MaintainData> maintainDatas){
         List<ErpJudgeAccount> list = new ArrayList<ErpJudgeAccount>();
@@ -144,7 +157,12 @@ public class ValidationUtils {
         }
         return "";
     }
-    //拼接
+
+    /**
+     * 拼接项目验证信息
+     * @param erpJudgeAccounts
+     * @return
+     */
     public static String getJoiningTogether(List<ErpJudgeAccount> erpJudgeAccounts){
         String str = "";
         for (ErpJudgeAccount erpJudgeAccount:erpJudgeAccounts){
@@ -198,6 +216,8 @@ public class ValidationUtils {
         }
         return "";
     }
+
+
     //若应付金额（不含税价）<实付金额（不含税价）,需要导出差异情况，同时费用入账核实存在问题。
     public static String getJudgeThree(List<ErpCredit> listThree){
         DecimalFormat decimalFormat   = new DecimalFormat("#0.00");
@@ -240,6 +260,77 @@ public class ValidationUtils {
         str = str.substring(0,str.length()-1);
         return str;
     }
+
+    public static List<ErpJudgeExport> getOverPayExportList(List<ErpCredit> creditList){
+        DecimalFormat decimalFormat  = new DecimalFormat("#0.00");
+        List<ErpJudgeExport> exportList = new ArrayList<>();
+        for(ErpCredit credit:creditList){
+            ErpJudgeExport export = new ErpJudgeExport();
+            export.setItemId(credit.getItemId());
+            export.setItemName(credit.getItemName());
+            boolean hasOverPay = false;
+            if(CostAccountUnits.OVER_PAY_AMOUNT.equals(credit.getConstructionStatus())){
+                hasOverPay = true;
+                export.setConsTotalFee(decimalFormat.format(credit.getConsTotalFee()));
+                export.setConstructionFeePayable(decimalFormat.format(credit.getConstructionFeePayable()));
+            }
+            if(CostAccountUnits.OVER_PAY_AMOUNT.equals(credit.getDesignStatus())){
+                hasOverPay = true;
+                export.setOtherDesignFee(decimalFormat.format(credit.getOtherDesignFee()));
+                export.setDesignFeePayable(decimalFormat.format(credit.getDesignFeePayable()));
+            }
+            if(CostAccountUnits.OVER_PAY_AMOUNT.equals(credit.getSupervisorStatus())){
+                hasOverPay = true;
+                export.setOtherSupervisorFee(decimalFormat.format(credit.getOtherSupervisorFee()));
+                export.setSupervisorFeePayable(decimalFormat.format(credit.getSupervisorFeePayable()));
+            }
+            if(hasOverPay){
+                exportList.add(export);
+            }
+        }
+        return exportList;
+    }
+
+    public static List<ErpJudgeArtificial> getPayLessArtificialList(List<ErpCredit> creditList){
+        List<ErpJudgeArtificial> artificialList = new ArrayList<ErpJudgeArtificial>();
+        String str = "";
+        for (ErpCredit erpCredit:creditList){
+            StringBuffer buffer = new StringBuffer();
+            //施工费
+            if(CostAccountUnits.PAY_LESS_AMOUNT.equals(erpCredit.getConstructionStatus())){
+                buffer.append("施工费应付金额为");
+                buffer.append(erpCredit.getConstructionFeePayable());
+                buffer.append(";实际金额");
+                buffer.append(erpCredit.getConsTotalFee());
+                buffer.append(";");
+            }
+            //设计费
+            if (CostAccountUnits.PAY_LESS_AMOUNT.equals(erpCredit.getDesignStatus())){
+                buffer.append("设计费应付金额为");
+                buffer.append(erpCredit.getDesignFeePayable());
+                buffer.append(";实际金额");
+                buffer.append(erpCredit.getOtherDesignFee());
+                buffer.append(";");
+            }
+            //监理费
+            if (CostAccountUnits.PAY_LESS_AMOUNT.equals(erpCredit.getSupervisorStatus())){
+                buffer.append("监理费应付金额为");
+                buffer.append(erpCredit.getSupervisorFeePayable());
+                buffer.append(";实际金额");
+                buffer.append(erpCredit.getOtherSupervisorFee());
+                buffer.append(";");
+            }
+            String msg = buffer.toString();
+            if(StringUtils.isNotBlank(msg)){
+                ErpJudgeArtificial artificial = new ErpJudgeArtificial();
+                artificial.setItemId(erpCredit.getItemId());
+                artificial.setNotTheSame(msg);
+                artificialList.add(artificial);
+            }
+        }
+        return artificialList;
+    }
+
     //导出差异
     public static List<ErpJudgeExport> getErpJudgeExport(String string){
         String[] split = string.split(",");
@@ -271,6 +362,58 @@ public class ValidationUtils {
         return string;
     }
 
+    /**
+     * 验证资本成本 返回提示信息
+     * 判断方式 项目定义编码 ‘1’开头为资本项目，‘B’开头为成本项目
+     * @param credits
+     * @return
+     */
+    public static String verifyCapital(List<ErpCredit> credits){
+        if(credits==null||credits.size()==0){
+            return "未导入项目明细账！";
+        }
+        for(ErpCredit credit:credits){
+            String itemId = credit.getItemId();
+            if(itemId.trim().startsWith("B")){
+                return "项目明细账中存在成本项目！";
+            }
+        }
+        return "";
+    }
+
+    /**
+     * 验证概预算信息 若存在明细账项目无相应概预算信息 返回错误信息 否则返回空字符串
+     * @param ids   明细账项目编码
+     * @param datas  找到的概预算信息
+     * @return
+     */
+    public static String verifyMaintain(List<String> ids,List<MaintainData> datas){
+        if(datas==null||datas.size()==0){
+            return "项目明细账中项目都没有概预算信息！";
+        }
+        List<String> maintainIds = new ArrayList<>();
+        for(MaintainData data:datas){
+            maintainIds.add(data.getProjectId());
+        }
+        //标志验证通过
+        boolean ok = true;
+        StringBuffer buffer = new StringBuffer();
+        for(String id:ids){
+            if(!maintainIds.contains(id)){
+                buffer.append(id);
+                buffer.append(";");
+                ok = false;
+            }
+        }
+        if(ok){
+            return "";
+        }else{
+            buffer.append(" 等项目不存在概预算信息！");
+            return buffer.toString();
+        }
+    }
+
+
     //验证资本和成本
     public static String getTheCostOfCapital(List<ErpCredit> erpCredits,List<Project> project1s){
         String type = "";
@@ -297,4 +440,118 @@ public class ValidationUtils {
         }
         return "3";
     }
+
+    /**
+     * 获取credits所有id
+     * @param erpCredits
+     * @return
+     */
+    public static List<String> getItemIds(List<ErpCredit> erpCredits){
+        List<String> ids = new ArrayList<>();
+        if(erpCredits!=null&&erpCredits.size()!=0){
+            for(ErpCredit credit:erpCredits){
+                ids.add(credit.getItemId());
+            }
+        }
+        return ids;
+    }
+
+    public static void verifyExpense(List<ErpCredit> creditList, List<Expense> expenseList, Map<String,ErpJudgeAccount> map){
+        List<String> ids = new ArrayList<>();
+        if(creditList.size()==expenseList.size()){
+            return;
+        }
+        if(expenseList!=null){
+            for(Expense expense:expenseList){
+                ids.add(expense.getProjectId());
+            }
+        }
+        for(ErpCredit credit:creditList){
+            String itemId = credit.getItemId();
+            if(!ids.contains(itemId)){
+                ErpJudgeAccount judge = map.get(itemId);
+                if(judge==null){
+                    judge = new ErpJudgeAccount();
+                    judge.setItemId(itemId);
+                    judge.setItemName(credit.getItemName());
+                    judge.setItemSupplierName(credit.getSupplierName());
+                    map.put(itemId,judge);
+                }
+                judge.setExpenseStatus(ErpJudgeAccount.NO_DATA);
+            }
+        }
+    }
+
+    public static void verifyInformation(List<ErpCredit> creditList,List<Information> hasInfoList,
+                                         List<Information> notFinishList,Map<String,ErpJudgeAccount> map){
+        if(hasInfoList.size()<creditList.size()){
+            List<String> ids = new ArrayList<>();
+            if(hasInfoList!=null){
+                for(Information info:hasInfoList){
+                    ids.add(info.getProjectId());
+                }
+            }
+            for(ErpCredit credit:creditList){
+                String itemId = credit.getItemId();
+                if(!ids.contains(itemId)){
+                    ErpJudgeAccount judge = map.get(itemId);
+                    if(judge==null){
+                        judge = new ErpJudgeAccount();
+                        judge.setItemId(itemId);
+                        judge.setItemName(credit.getItemName());
+                        judge.setItemSupplierName(credit.getSupplierName());
+                        map.put(itemId,judge);
+                    }
+                    judge.setInformationStatus(ErpJudgeAccount.NO_DATA);
+                }
+            }
+        }
+        if(notFinishList!=null&&notFinishList.size()>0){
+            List<String> ids = new ArrayList<>();
+            for(Information info:notFinishList){
+                ids.add(info.getProjectId());
+            }
+            for(ErpCredit credit:creditList){
+                String itemId = credit.getItemId();
+                if(ids.contains(itemId)){
+                    ErpJudgeAccount judge = map.get(itemId);
+                    if(judge==null){
+                        judge = new ErpJudgeAccount();
+                        judge.setItemId(itemId);
+                        judge.setItemName(credit.getItemName());
+                        judge.setItemSupplierName(credit.getSupplierName());
+                        map.put(itemId,judge);
+                    }
+                    judge.setInformationStatus(ErpJudgeAccount.NOT_FINISHED);
+                }
+            }
+        }
+    }
+
+
+    public static  void storeListToRedis(HttpServletRequest request,List list,String prefix){
+        HttpSession session = request.getSession();
+        String key = prefix+session.getId();
+        CacheChannel channel = J2Cache.getChannel();
+        RedisClient client = ((RedisCacheProvider)channel.getL2Provider()).getRedisClient();
+        try {
+            client.get().setex(key.getBytes(),120, SerializeUtil.serizlize(list));
+        } finally {
+            client.release();
+        }
+    }
+
+    public static <T> List<T> getSessionRedisList(HttpServletRequest request,String prefix,Class T){
+        List<T> list = null;
+        HttpSession session = request.getSession();
+        String key = prefix + session.getId();
+        CacheChannel channel = J2Cache.getChannel();
+        RedisClient client = ((RedisCacheProvider)channel.getL2Provider()).getRedisClient();
+        try {
+            list  = (List<T>) SerializeUtil.deserialize(client.get().get(key.getBytes()));
+        } finally {
+            client.release();
+        }
+        return list;
+    }
 }

src/main/java/com/jeeplus/modules/sg/financial/erpcredit/web/ErpCreditController.java

@@ -36,6 +36,7 @@ import javax.servlet.http.HttpServletResponse;
 import javax.servlet.http.HttpSession;
 import java.io.*;
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
@@ -99,38 +100,56 @@ public class ErpCreditController extends BaseController {
 		model.addAttribute("erpCredit", erpCredit);
 		return "modules/sg/financial/erp/erpCreditForm";
 	}
-	/*
-		提示
+
+	/**
+	 * 项目明细账对应甲供材、费用入账信息存在性验证不通过提示页面
+	 * @param model
+	 * @param request
+	 * @param response
+	 * @return
+	 * @throws UnsupportedEncodingException
 	 */
 	@RequestMapping(value = "tips")
 	public String Tips(Model model, HttpServletRequest request, HttpServletResponse response) throws UnsupportedEncodingException {
-		String ftpErpList = erpCreditService.getFtpErpList(request);
-		String[] split = ftpErpList.split(",");
-		List<ErpJudgeAccount> erpJudgeAccounts = new ArrayList<ErpJudgeAccount>();
-		ErpJudgeAccount erpJudgeAccount = null;
-		for (int i = 0; i < split.length; i+=4) {
-			erpJudgeAccount = new ErpJudgeAccount();
-			erpJudgeAccount.setItemId(split[i]);
-			erpJudgeAccount.setItemName(split[i+1]);
-			erpJudgeAccount.setFlagItem(split[i+2]);
-//			erpJudgeAccount.setItemSupplierName(split[i+3]);
-			erpJudgeAccounts.add(erpJudgeAccount);
-		}
-		model.addAttribute("erpJudgeAccounts",erpJudgeAccounts);
+//		String ftpErpList = erpCreditService.getFtpErpList(request);
+//		String[] split = ftpErpList.split(",");
+//		List<ErpJudgeAccount> erpJudgeAccounts = new ArrayList<ErpJudgeAccount>();
+//		ErpJudgeAccount erpJudgeAccount = null;
+//		for (int i = 0; i < split.length; i+=4) {
+//			erpJudgeAccount = new ErpJudgeAccount();
+//			erpJudgeAccount.setItemId(split[i]);
+//			erpJudgeAccount.setItemName(split[i+1]);
+//			erpJudgeAccount.setFlagItem(split[i+2]);
+////			erpJudgeAccount.setItemSupplierName(split[i+3]);
+//			erpJudgeAccounts.add(erpJudgeAccount);
+//		}
+//		List<ErpJudgeAccount> judgeAccountList = ValidationUtils.getJudgeList(request);
+		List<ErpJudgeAccount> judgeAccountList = ValidationUtils.getSessionRedisList(request,ValidationUtils.JUDGE_KEY_PREFIX,ErpJudgeAccount.class);
+		model.addAttribute("erpJudgeAccounts",judgeAccountList);
 		return "modules/sg/financial/erp/erpCreditTips";
 	}
+
+	/**
+	 *费用入账 应付金额>实付金额 提示页面
+	 * @param model
+	 * @param request
+	 * @param response
+	 * @return
+	 * @throws UnsupportedEncodingException
+	 */
 	@RequestMapping(value = "tips1")
 	public String Tips1(Model model, HttpServletRequest request, HttpServletResponse response) throws UnsupportedEncodingException {
-		String ftpErpList = erpCreditService.getFtpErpList(request);
-		String[] split = ftpErpList.split(",");
-		List<ErpJudgeArtificial> erpJudgeArtificials = new ArrayList<ErpJudgeArtificial>();
-		ErpJudgeArtificial erpJudgeArtificial = null;
-		for (int i = 0; i < split.length; i+=2) {
-			erpJudgeArtificial = new ErpJudgeArtificial();
-			erpJudgeArtificial.setItemId(split[i]);
-			erpJudgeArtificial.setNotTheSame(split[i+1]);
-			erpJudgeArtificials.add(erpJudgeArtificial);
-		}
+//		String ftpErpList = erpCreditService.getFtpErpList(request);
+//		String[] split = ftpErpList.split(",");
+//		List<ErpJudgeArtificial> erpJudgeArtificials = new ArrayList<ErpJudgeArtificial>();
+//		ErpJudgeArtificial erpJudgeArtificial = null;
+//		for (int i = 0; i < split.length; i+=2) {
+//			erpJudgeArtificial = new ErpJudgeArtificial();
+//			erpJudgeArtificial.setItemId(split[i]);
+//			erpJudgeArtificial.setNotTheSame(split[i+1]);
+//			erpJudgeArtificials.add(erpJudgeArtificial);
+//		}
+		List<ErpJudgeArtificial> erpJudgeArtificials = ValidationUtils.getSessionRedisList(request,ValidationUtils.ARTIFICIAL_KEY_PREFIX,ErpJudgeArtificial.class);
 		model.addAttribute("erpJudgeArtificials",erpJudgeArtificials);
 		return "modules/sg/financial/erp/erpTipsUserJudge";
 	}
@@ -209,7 +228,7 @@ public class ErpCreditController extends BaseController {
 		return j;
 	}
 	/**
-	 * 导出excel列表文件
+	 * 导出费用入账验证中 实付金额>应付金额 部分的信息
 	 */
 	@ResponseBody
 	@RequestMapping(value = "exportYesStatus")
@@ -217,9 +236,10 @@ public class ErpCreditController extends BaseController {
 		Result j = new Result();
 		try {
 			String fileName = "费用入账差异信息"+DateUtils.getDate("yyyyMMddHHmmss")+".xlsx";
-			String ftpErpList = erpCreditService.getFtpErpList(request);
-			List<ErpJudgeExport> erpJudgeExport = ValidationUtils.getErpJudgeExport(ftpErpList);
-			new ExportExcel("费用入账差异信息", ErpJudgeExport.class).setDataList(erpJudgeExport).write(response, fileName).dispose();
+//			String ftpErpList = erpCreditService.getFtpErpList(request);
+//			List<ErpJudgeExport> erpJudgeExport = ValidationUtils.getErpJudgeExport(ftpErpList);
+			List<ErpJudgeExport> exportList = ValidationUtils.getSessionRedisList(request,ValidationUtils.EXPENSE_KEY_PREFIX,ErpJudgeExport.class);
+			new ExportExcel("费用入账差异信息", ErpJudgeExport.class).setDataList(exportList).write(response, fileName).dispose();
 			j.setSuccess(true);
 			j.setMsg("导出成功！");
 		}catch (Exception e){
@@ -247,8 +267,9 @@ public class ErpCreditController extends BaseController {
 		Result j = new Result();
 		HttpSession session = request.getSession();
 		try {
-			List<ErpCredit> erpCreditsList = (List<ErpCredit>)session.getAttribute("erpCreditsList");
-			erpCreditService.getExport(erpCreditsList,response);
+//			List<ErpCredit> erpCreditsList = (List<ErpCredit>)session.getAttribute("erpCreditsList");
+//			erpCreditService.getExport(erpCreditsList,response);
+			erpCreditService.getExport(request,response);
 			j.setSuccess(true);
 			j.setMsg("导出成功！");
 		}catch (Exception e){
@@ -263,13 +284,20 @@ public class ErpCreditController extends BaseController {
 	}
 
 
+	/**
+	 * 获取erpCredit完整信息（包括设备、物料）
+	 * @param id
+	 * @return
+	 */
 	@ResponseBody
 	@RequestMapping(value = "detail")
 	public ErpCredit detail(String id) {
 		return erpCreditService.get(id);
 	}
+
+
 	/**
-	 * 导入Excel数据
+	 * 导入erp明细账
 	 */
 	@ResponseBody
 	@RequiresPermissions("sg:financial:erpCredit:import")
@@ -278,9 +306,10 @@ public class ErpCreditController extends BaseController {
 		Result j = new Result();
 		String str = "";
 		try {
-			int successNum = 0;
-			int failureNum = 0;
+//			int successNum = 0;
+//			int failureNum = 0;
 			StringBuilder failureMsg = new StringBuilder();
+//			读取第一个页签 根据表头两个字段判断是否符合规范。。
 			ImportUtil importUtil = new ImportUtil(file, 0, 0);
             Boolean erpJugde = ErpInfo.getErpJugde(importUtil);
             if (erpJugde){
@@ -288,111 +317,187 @@ public class ErpCreditController extends BaseController {
                 j.setMsg("导入失败！失败信息："+"表不符合规范");
                 return j;
             }
-			List<ErpAccount> erpAccounts = ErpInfo.getErpAccount(importUtil);//获取表格数据
+//            获取明细账数据 一个ErpAccount对象表示一行有效数据
+			List<ErpAccount> erpAccounts = ErpInfo.getErpAccount(importUtil);
+//            获取明细账处理数据 对应送审决算列表页面
 			List<ErpCredit> erpCredits = ErpInfo.getAllErpCreditList(erpAccounts);//获取单条数据
-
+			//可导出判断标志，只要概预算信息存在，且全都是资本项目就可以导出
+//			boolean exportAble = true;
+			//不能导出原因  同时验证所有项目都是资本项目
+			String unExportMsg = ValidationUtils.verifyCapital(erpCredits);
+			if(!"".equals(unExportMsg)){
+				j.setSuccess(false);
+				j.setMsg(unExportMsg);
+				return j;
+			}
+			//根据credits的id查找对应概预算信息 若找到的概预算数量少于credits数量，说明存在无概预算信息项目
+			List<String> ids = ValidationUtils.getItemIds(erpCredits);
+			List<MaintainData> maintainDataList = erpCreditService.getFindListMain(ids);
+			unExportMsg = ValidationUtils.verifyMaintain(ids,maintainDataList);
+			if(!"".equals(unExportMsg)){
+				j.setSuccess(false);
+				j.setMsg(unExportMsg);
+				return j;
+			}
+			ValidationUtils.storeListToRedis(request,erpCredits,ValidationUtils.CREDIT_KEY_PREFIX);
+			erpCreditService.replaceAll(erpCredits);
 
             //需求基本信息验证
-            List<Project> project1s = projectService.findList(new Project());
-			String projectJudge = ValidationUtils.getProjectJudge(erpCredits, project1s);
-            if (!"".equals(projectJudge)){
-                erpCreditService.getFtpList(request,projectJudge);
-                j.setSuccess(false);
-                j.setFlag(true);
-                j.setMsg("无需求基本信息数据");
-                return j;
-            }
+//            List<Project> project1s = projectService.findList(new Project());
+//			String projectJudge = ValidationUtils.getProjectJudge(erpCredits, project1s);
+//            if (!"".equals(projectJudge)){
+//                erpCreditService.getFtpList(request,projectJudge);
+////                j.setSuccess(false);
+//                j.setSuccess(true);
+//                j.setFlag(true);
+//                j.setMsg("无需求基本信息数据");
+//                return j;
+//            }
             //项目资本和成本验证
-			String theCostOfCapital = ValidationUtils.getTheCostOfCapital(erpCredits, project1s);
-			if (theCostOfCapital.equals("3")){
-				j.setSuccess(false);
-				j.setMsg("导入失败,项目不能同时存在资本和成本!");
+//			String theCostOfCapital = ValidationUtils.getTheCostOfCapital(erpCredits, project1s);
+//			if (theCostOfCapital.equals("3")){
+//				j.setSuccess(false);
+//				j.setMsg("导入失败,项目不能同时存在资本和成本!");
+//				return j;
+//			}
+//			//验证概预算信息方法
+//			List<MaintainData> maintainDatas = dataMaintenanceService.getJudge();//所有概预算信息
+//			String dataMainJudge = ValidationUtils.getDataMainJudge(erpCredits, maintainDatas);
+//            if (!"".equals(dataMainJudge)){
+//                erpCreditService.getFtpList(request,dataMainJudge);
+////                j.setSuccess(false);
+//                j.setSuccess(false);
+//                j.setFlag(true);
+//                j.setMsg("概预算信息没有项目数据");
+//                return j;
+//            }
+//			if(!"".equals(dataMainJudge)){
+//				exportAble = false;
+//				unExportMsg = "概预算信息没有项目数据";
+//			}
+			//查询费用入账所有信息
+//			List<Expense> expenses = expenseService.findList(new Expense());
+//			String expenseJudge = ValidationUtils.getExpenseJudge(erpCredits, expenses);
+//            if (!"".equals(expenseJudge)){
+//                erpCreditService.getFtpList(request,expenseJudge);
+//                j.setSuccess(false);
+//                j.setFlag(true);
+//                j.setMsg("费用入账没有项目信息数据");
+//                return j;
+//            }
+//			//验证甲供材
+//			List<Information> informationList = informationService.findList(new Information());
+//			String informationJudge = ValidationUtils.getInformationJudge(erpCredits, informationList);
+//            if (!"".equals(informationJudge)){
+//                erpCreditService.getFtpList(request,informationJudge);
+//                j.setSuccess(false);
+//                j.setFlag(true);
+//                j.setMsg("甲供物资核实没有项目信息数据");
+//                return j;
+//            }
+//			List<Information> infoFlag = erpCreditService.getInfoFlag(erpCredits);
+//			String informationJudge1 = ValidationUtils.getInformationJudge1(erpCredits, infoFlag);
+//            if (!"".equals(informationJudge1)){
+//                erpCreditService.getFtpList(request,informationJudge1);
+//                j.setSuccess(false);
+//                j.setFlag(true);
+//                j.setMsg("甲供物资核实没有完成施工项目");
+//                return j;
+//            }
+
+            Map<String,ErpJudgeAccount> judgeAccountMap = new HashMap<>();
+            //验证费用入账信息 若明细账中项目找不到费用入账信息 则生成一个验证信息对象存入map
+            List<Expense> expenseList = expenseService.getFindListMain(ids);
+            ValidationUtils.verifyExpense(erpCredits,expenseList,judgeAccountMap);
+            //验证甲供材信息 无甲供材信息、有但为完成领退料 分别验证
+            List<Information> hasInfosList = informationService.getFindListMain(ids);
+            List<Information> notFinishList = informationService.findNoFinishList(ids);
+			ValidationUtils.verifyInformation(erpCredits,hasInfosList,notFinishList,judgeAccountMap);
+			if(judgeAccountMap.size()>0){
+				List<ErpJudgeAccount> judgeList = new ArrayList<>(judgeAccountMap.values());
+				ValidationUtils.storeListToRedis(request,judgeList,ValidationUtils.JUDGE_KEY_PREFIX);
+				j.setSuccess(true);
+				j.setFlag(true);//flag为true表示 费用入账或甲供材存在性验证不通过
 				return j;
 			}
-			//验证概预算信息方法
-			List<MaintainData> maintainDatas = dataMaintenanceService.getJudge();//所有概预算信息
-			String dataMainJudge = ValidationUtils.getDataMainJudge(erpCredits, maintainDatas);
-            if (!"".equals(dataMainJudge)){
-                erpCreditService.getFtpList(request,dataMainJudge);
-                j.setSuccess(false);
-                j.setFlag(true);
-                j.setMsg("概预算信息没有项目数据");
-                return j;
-            }
-			//查询费用入账所有信息
-			List<Expense> expenses = expenseService.findList(new Expense());
-			String expenseJudge = ValidationUtils.getExpenseJudge(erpCredits, expenses);
-            if (!"".equals(expenseJudge)){
-                erpCreditService.getFtpList(request,expenseJudge);
-                j.setSuccess(false);
-                j.setFlag(true);
-                j.setMsg("费用入账没有项目信息数据");
-                return j;
-            }
-			//验证甲供材
-			List<Information> informationList = informationService.findList(new Information());
-			String informationJudge = ValidationUtils.getInformationJudge(erpCredits, informationList);
-            if (!"".equals(informationJudge)){
-                erpCreditService.getFtpList(request,informationJudge);
-                j.setSuccess(false);
-                j.setFlag(true);
-                j.setMsg("甲供物资核实没有项目信息数据");
-                return j;
-            }
-			List<Information> infoFlag = erpCreditService.getInfoFlag(erpCredits);
-			String informationJudge1 = ValidationUtils.getInformationJudge1(erpCredits, infoFlag);
-            if (!"".equals(informationJudge1)){
-                erpCreditService.getFtpList(request,informationJudge1);
-                j.setSuccess(false);
-                j.setFlag(true);
-                j.setMsg("甲供物资核实没有完成施工项目");
-                return j;
-            }
+
 			//整合 验证费用入账模块
-			List<Expense> expenseList = CostAccountUnits.getQCExpense(erpCredits,expenses);//库存信息区分2020年前和年后
+//			List<Expense> expenseList = CostAccountUnits.getQCExpense(erpCredits,expenses);//库存信息区分2020年前和年后
+//			CostAccountUnits.judgeTime(expenseList);
 			//得到验证数据
-			Map<String, List<ErpCredit>> judgeEnterAccount = CostAccountUnits.getJudgeEnterAccount(erpCredits, expenseList, informationList, maintainDatas);
+//			Map<String, List<ErpCredit>> judgeEnterAccount = CostAccountUnits.getJudgeEnterAccount(erpCredits, expenseList, informationList, maintainDatas);
 			//若应付金额（不含税价）<实付金额（不含税价）,需要导出差异情况，同时费用入账核实存在问题。
-			List<ErpCredit> listThree = judgeEnterAccount.get("judgeEnterAccountThree");
-			String judgeThree = ValidationUtils.getJudgeThree(listThree);
-			if (!"".equals(listThree)){
-				erpCreditService.getFtpList(request,judgeThree);
-				j.setSuccess(false);
-				j.setYesStatus(true);
-				j.setMsg("导入失败：费用入账存在差异信息，正在导出差异信息");
-				return j;
-			}
-			request.getSession().setAttribute("erpCreditsList",erpCredits);
-			String random  = ErpInfo.getStatus();
-            erpCreditService.deleteAll();//清空原来表数据
-			for (int i = 0; i < erpCredits.size()/1000+1; i++) {
-				int end=(i+1)*1000;
-				if (end>erpCredits.size()){
-					end=erpCredits.size();
-				}
-				List<ErpCredit> erpCredits1 = erpCredits.subList(i * 1000, end);
-				erpCreditService.saveList(erpCredits1,random);
-			}
-//			若应付金额（不含税价）>实付金额（不含税价）,需要进入人工判断，若人工判断通过，则费用入账核实无问题，若人工判断不通过则费用入账核实存在问题
-			List<ErpCredit> listTwo = judgeEnterAccount.get("judgeEnterAccountTwo");
-			String judgeTwo = ValidationUtils.getJudgeTwo(listTwo);
-			if ("".equals(judgeTwo)){
-				erpCreditService.getFtpList(request,judgeTwo);
-				j.setSuccess(false);
+//			List<ErpCredit> listThree = judgeEnterAccount.get("judgeEnterAccountThree");
+//			String judgeThree = ValidationUtils.getJudgeThree(listThree);
+//			if (!"".equals(listThree)){
+//				erpCreditService.getFtpList(request,judgeThree);
+//				j.setSuccess(false);
+//				j.setYesStatus(true);
+//				j.setMsg("导入失败：费用入账存在差异信息，正在导出差异信息");
+//				return j;
+//			}
+			Map<String, List<ErpCredit>> judgeMap = CostAccountUnits.getJudgeMap(erpCredits, expenseList, hasInfosList, maintainDataList);
+			List<ErpCredit> overpayCredits = judgeMap.get(CostAccountUnits.OVER_PAY_LIST_KEY);
+			List<ErpJudgeExport> overpayExports = ValidationUtils.getOverPayExportList(overpayCredits);
+			if(overpayExports.size()>0){
+				ValidationUtils.storeListToRedis(request,overpayExports,ValidationUtils.EXPENSE_KEY_PREFIX);
+				j.setSuccess(true);
 				j.setFlag(false);
-				j.setNoStatus(true);
-				j.setMsg("部分数据（应付金额>实付金额）,请人工判断");
+				j.setYesStatus(true);//这里yesStatus为true表示有实际付款>应付金额的情况存在
+				j.setMsg("费用入账存在差异信息，正在导出差异信息");
 				return j;
 			}
-			//允许项目关闭
-			if (theCostOfCapital.equals("0")){
+			List<ErpCredit> paylessCredits = judgeMap.get(CostAccountUnits.PAY_LESS_LIST_KEY);
+			List<ErpJudgeArtificial> paylessArtificials = ValidationUtils.getPayLessArtificialList(paylessCredits);
+			if(paylessArtificials.size()>0){
+				ValidationUtils.storeListToRedis(request,paylessArtificials,ValidationUtils.ARTIFICIAL_KEY_PREFIX);
 				j.setSuccess(true);
-				j.setMsg("导入成功：允许项目关闭");
+				j.setFlag(false);
+				j.setYesStatus(false);
+				j.setNoStatus(true);//这里nostatus为true表示有应付金额>实付金额的情况存在
+				j.setMsg("");
 				return j;
 			}
-			if (failureNum>0){
-				failureMsg.insert(0, "，失败 "+erpCredits.size()+" 条送审决算记录。");
-			}
+//			if ("".equals(judgeTwo)){
+//				erpCreditService.getFtpList(request,judgeTwo);
+//				j.setSuccess(false);
+//				j.setFlag(false);
+//				j.setNoStatus(true);
+//				j.setMsg("部分数据（应付金额>实付金额）,请人工判断");
+//				return j;
+//			}
+//
+//			request.getSession().setAttribute("erpCreditsList",erpCredits);
+//			String random  = ErpInfo.getStatus();
+//            erpCreditService.deleteAll();//清空原来表数据
+//			for (int i = 0; i < erpCredits.size()/1000+1; i++) {
+//				int end=(i+1)*1000;
+//				if (end>erpCredits.size()){
+//					end=erpCredits.size();
+//				}
+//				List<ErpCredit> erpCredits1 = erpCredits.subList(i * 1000, end);
+//				erpCreditService.saveList(erpCredits1,random);
+//			}
+////			若应付金额（不含税价）>实付金额（不含税价）,需要进入人工判断，若人工判断通过，则费用入账核实无问题，若人工判断不通过则费用入账核实存在问题
+//			List<ErpCredit> listTwo = judgeEnterAccount.get("judgeEnterAccountTwo");
+//			String judgeTwo = ValidationUtils.getJudgeTwo(listTwo);
+//			if ("".equals(judgeTwo)){
+//				erpCreditService.getFtpList(request,judgeTwo);
+//				j.setSuccess(false);
+//				j.setFlag(false);
+//				j.setNoStatus(true);
+//				j.setMsg("部分数据（应付金额>实付金额）,请人工判断");
+//				return j;
+//			}
+////			允许项目关闭
+//			if (theCostOfCapital.equals("0")){
+//				j.setSuccess(true);
+//				j.setMsg("导入成功：允许项目关闭");
+//				return j;
+//			}
+//			if (failureNum>0){
+//				failureMsg.insert(0, "，失败 "+erpCredits.size()+" 条送审决算记录。");
+//			}
 			j.setMsg( "已成功导入 "+erpCredits.size()+" 条送审决算记录"+failureMsg);
 		} catch (Exception e) {
 			j.setSuccess(false);

src/main/java/com/jeeplus/modules/sg/financial/expense/entity/Expense.java

@@ -4,6 +4,9 @@ import com.jeeplus.common.utils.excel.annotation.ExcelField;
 import com.jeeplus.core.persistence.ActEntity;
 import com.jeeplus.modules.echarts.web.scatter.ScatterSample1;
 
+/**
+ * 费用入账数据
+ */
 public class Expense extends ActEntity<Expense> {
     //项目名称
     private String projectName;
@@ -26,7 +29,7 @@ public class Expense extends ActEntity<Expense> {
     //发文中监理费金额（不含税）
     private Double documentSupervisionCost;
 
-    private String status;
+    private String status; //项目年份判断 0:2020及以后   1:2020以前
     private Double designFeePayable;//设计费应付金额
     private Double constructionFeePayable;//施工费应付金额
     private Double supervisorFeePayable;//监理费应付金额

src/main/java/com/jeeplus/modules/sg/financial/expense/mapper/ExpenseMapper.java

@@ -15,7 +15,7 @@ import java.util.List;
 
 @MyBatisMapper
 public interface ExpenseMapper extends BaseMapper<Expense> {
-    void deleteData(String id);
+    void deleteDatas(List<String> ids);
 
     void insertData(Expense expense);
 
@@ -24,4 +24,6 @@ public interface ExpenseMapper extends BaseMapper<Expense> {
     Expense selectByProjectId(String projectId);
 
     void insertList(@Param("expense") List<Expense> expenseList);
+
+    List<Expense> findListMain(List<String> strings);
 }

src/main/java/com/jeeplus/modules/sg/financial/expense/mapper/xml/ExpenseMapper.xml

@@ -30,7 +30,7 @@
 		where
 		1=1
 			<if test="projectId!=null and projectId != '' ">
-				and projectId=${projectId}
+				and projectId=#{projectId}
 			</if>
 		<choose>
             <when test="page !=null and page.orderBy != null and page.orderBy != ''">
@@ -135,10 +135,15 @@
 			del_flag = #{DEL_FLAG_DELETE}
 		WHERE id = #{id}
 	</update>
-	<!--批量删除-->
-	<update id="deleteData">
+	<!--批量物理删除-->
+	<update id="deleteDatas">
 		DELETE FROM js_expense_entry
-		WHERE id = #{id}
+		WHERE id
+		in(
+			<foreach collection="list" index="index" item="id" separator=",">
+				#{id}
+			</foreach>
+		)
 	</update>
 
 	<select id="selectByProjectId" resultType="com.jeeplus.modules.sg.financial.expense.entity.Expense">
@@ -188,4 +193,18 @@
 		)
 		</foreach>
 	</insert>
+
+	<select id="findListMain" parameterType="java.util.List" resultType="Expense">
+		select
+		<include refid="expenseColumns"/>
+		FROM js_expense_entry a
+		WHERE a.del_flag = '0'
+		and a.projectId in
+		<if test="list != null">
+			<foreach collection="list" index="index" item="item" open="("
+					 separator="," close=")">
+				#{item}
+			</foreach>
+		</if>
+	</select>
 </mapper>

src/main/java/com/jeeplus/modules/sg/financial/expense/service/ExpenseService.java

@@ -75,8 +75,8 @@ public class ExpenseService extends CrudService<ExpenseMapper, Expense> {
     }
 
     @Transactional(readOnly = false)
-    public void deleteData(String id){
-        expenseMapper.deleteData(id);
+    public void deleteDatas(List<String> ids){
+        expenseMapper.deleteDatas(ids);
     }
 
     @Transactional(readOnly = false)
@@ -102,4 +102,13 @@ public class ExpenseService extends CrudService<ExpenseMapper, Expense> {
         }
         expenseMapper.insertList(expenseList);
     }
+
+    /**
+     * 根据id查找相应费用入账信息
+     * @param strings
+     * @return
+     */
+    public List<Expense> getFindListMain(List<String> strings){
+        return expenseMapper.findListMain(strings);
+    }
 }

src/main/java/com/jeeplus/modules/sg/financial/expense/web/ExpenseController.java

@@ -31,13 +31,12 @@ import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import javax.validation.ConstraintViolationException;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
 
 /**
- * 票务代理Controller
- * @author liugf
- * @version 2018-06-12
+ * 费用入账管理
  */
 @Controller
 @RequestMapping(value = "${adminPath}/sg/financial/expense")
@@ -59,7 +58,7 @@ public class ExpenseController extends BaseController {
 	}
 	
 	/**
-	 * 票务代理列表页面
+	 * 费用入账 列表页面
 	 */
 //	@RequiresPermissions("sg:financial:expense:list")
 	@RequestMapping(value = {"list", ""})
@@ -67,25 +66,42 @@ public class ExpenseController extends BaseController {
 		model.addAttribute("expense", expense);
 		return "modules/sg/financial/expense/expenseList";
 	}
-	
 
-	 //票务代理列表数据
+
+	/**
+	 * 获取费用入账列表数据
+	 * @param expense
+	 * @param request
+	 * @param response
+	 * @param model
+	 * @return
+	 */
 	@ResponseBody
-	@RequiresPermissions("test:onetomany:form:testDataMain2:list")
+//	@RequiresPermissions("test:onetomany:form:testDataMain2:list")
 	@RequestMapping(value = "data")
 	public Map<String, Object> data(Expense expense, HttpServletRequest request, HttpServletResponse response, Model model) {
 		Page<Expense> page = expenseService.findPage(new Page<Expense>(request, response), expense);
 		return getBootstrapData(page);
 	}
 
-	//添加数据页面
+	/**
+	 * 新增费用入账页面
+	 * @param expense
+	 * @param model
+	 * @return
+	 */
 	@RequestMapping(value = "addForm")
 	public String addForm(Expense expense, Model model) {
 		model.addAttribute("expense", expense);
 		return "modules/sg/financial/expense/expenseForm";
 	}
 
-	//添加数据页面
+	/**
+	 * 编辑费用入账页面
+	 * @param expense
+	 * @param model
+	 * @return
+	 */
 	@RequestMapping(value = "editForm")
 	public String editForm(Expense expense, Model model) {
 		model.addAttribute("expense", expense);
@@ -99,27 +115,22 @@ public class ExpenseController extends BaseController {
 	@RequestMapping(value = "deleteAll")
 	public AjaxJson deleteAll(String ids) {
 		AjaxJson j = new AjaxJson();
-		String idArray[] =ids.split(",");
-		for(String id : idArray){
-			expenseService.deleteData(id);
+		if(StringUtils.isBlank(ids)){
+			j.setSuccess(false);
+			j.setMsg("请选择要删除的项目定义号！");
+		}else{
+			String idArray[] =ids.split(",");
+			List<String> idList = Arrays.asList(idArray);
+			expenseService.deleteDatas(idList);
+			j.setMsg("删除成功");
 		}
-		j.setMsg("删除成功");
 		return j;
 	}
 
-	/*		*	*//**
-	 * 查看，增加，编辑票务代理表单页面
-	 *//*
-	@RequiresPermissions(value={"test:onetomany:form:testDataMain2:view","test:onetomany:form:testDataMain2:add","test:onetomany:form:testDataMain2:edit"},logical=Logical.OR)
-	@RequestMapping(value = "form/{mode}")
-	public String form(@PathVariable String mode, TestDataMain2 testDataMain2, Model model) {
-		model.addAttribute("testDataMain2", testDataMain2);
-		model.addAttribute("mode", mode);
-		return "modules/test/onetomany/form/testDataMain2Form";
-	}*/
+
 
 	/**
-	 * 保存票务代理
+	 * 保存费用入账页面 对项目定义号做验证
 	 */
 	@ResponseBody
 	@RequestMapping(value = "save")
@@ -138,7 +149,7 @@ public class ExpenseController extends BaseController {
 	}
 
 	/**
-	 * 修改
+	 * 更新
 	 */
 	@ResponseBody
 	@RequestMapping(value = "update")
@@ -197,34 +208,34 @@ public class ExpenseController extends BaseController {
 				String documentDesignCost = ei.getCellValue(row, 8).toString();
 				String documentSupervisionCost = ei.getCellValue(row, 9).toString();
 				if ("".equals(projectId)) {
-					failureMsg.append("有数据填写有误");
+					failureMsg.append("第 "+i+" 行未填写项目定义号</br>");
 					continue;
 				} else if ("".equals(projectName)) {
-					failureMsg.append("有数据填写有误");
+					failureMsg.append("项目："+projectId+";未填写项目名称</br>");
 					continue;
 				}else if ("".equals(projectBatch)) {
-					failureMsg.append("有数据填写有误");
+					failureMsg.append("项目："+projectId+";未填写项目批次</br>");
 					continue;
 				}else if ("".equals(constructionCost)||!constructionCost.matches(reg)) {
-					failureMsg.append(projectId+"有数据填写有误</br>");
+					failureMsg.append("项目："+projectId+";未正确填写施工费合同折扣</br>");
 					continue;
 				}else if ("".equals(designCost)||!designCost.matches(reg)) {
-					failureMsg.append(projectId+"有数据填写有误</br>");
+					failureMsg.append("项目："+projectId+";未正确填写设计费合同折扣</br>");
 					continue;
 				}else if ("".equals(designTypeicalCost)||!designTypeicalCost.matches(reg)) {
-					failureMsg.append(projectId+"有数据填写有误</br>");
+					failureMsg.append("项目："+projectId+";未正确填写设计费典型折扣</br>");
 					continue;
 				}else if ("".equals(supervisionCost)||!supervisionCost.matches(reg)) {
-					failureMsg.append(projectId+"有数据填写有误</br>");
+					failureMsg.append("项目："+projectId+";未正确填写监理费合同折扣</br>");
 					continue;
 				}else if ("".equals(supervisionTypeicalCost)||!supervisionTypeicalCost.matches(reg)) {
-					failureMsg.append(projectId+"有数据填写有误</br>");
+					failureMsg.append("项目："+projectId+";未正确填写监理费典型折扣</br>");
 					continue;
 				}else if ("".equals(documentDesignCost)||!documentDesignCost.matches(reg)) {
-					failureMsg.append(projectId+"有数据填写有误</br>");
+					failureMsg.append("项目："+projectId+";未发文中设计费金额</br>");
 					continue;
 				} else if ("".equals(documentSupervisionCost)||!documentSupervisionCost.matches(reg)) {
-					failureMsg.append(projectId+"有数据填写有误</br>");
+					failureMsg.append("项目："+projectId+";发文中监理费金额</br>");
 					continue;
 				} else {
 					insertExpense.setProjectId(projectId);
@@ -243,14 +254,14 @@ public class ExpenseController extends BaseController {
 			if (expenseList.size() > 0) {
 				expenseService.insertList(expenseList);
 				j.setSuccess(true);
-				j.setMsg("已成功导入 " + expenseList.size() + " 条费用入账记录" + failureMsg);
+				j.setMsg("已成功导入 " + expenseList.size() + " 条费用入账记录</br>" + failureMsg);
 			} else {
 				j.setSuccess(true);
 				j.setMsg( "没有符合规定的数据");
 			}
 		} catch (Exception e) {
 			j.setSuccess(false);
-			j.setMsg("导入票务代理失败！失败信息："+e.getMessage());
+			j.setMsg("导入费用入账失败！失败信息："+e.getMessage());
 		}
         return j;
     }

src/main/java/com/jeeplus/modules/sg/financial/settlement/entity/MaintainData.java

@@ -7,6 +7,9 @@ import com.jeeplus.core.persistence.DataEntity;
 import java.util.Arrays;
 import java.util.Date;
 
+/**
+ * 概预算基本信息对象
+ */
 public class MaintainData extends DataEntity<MaintainData> {
     private String projectId;     //项目定义号
     private String designUnits;    //设计单位
@@ -28,7 +31,7 @@ public class MaintainData extends DataEntity<MaintainData> {
     private Double managementFee;   //法人管理费
     private Double totalFee;      //合计
     private String state;
-
+    private String[] projectIds;  //项目定义号数组
 
     public String getState() {
         return state;
@@ -38,7 +41,7 @@ public class MaintainData extends DataEntity<MaintainData> {
         this.state = state;
     }
 
-    private String[] projectIds;  //项目定义号数组
+
 
     public String[] getProjectIds() {
         return projectIds;

src/main/java/com/jeeplus/modules/sg/financial/settlement/mapper/xml/DataMaintenanceMapper.xml

@@ -85,7 +85,6 @@
 	
 	<insert id="insert">
 		INSERT INTO js_maintain_data(
-
 			create_by,
 			create_date,
 			update_by,
@@ -112,7 +111,6 @@
 			management_fee,
 			total_fee
 		) VALUES (
-
 			#{createBy.id},
 			#{createDate},
 			#{updateBy.id},

src/main/java/com/jeeplus/modules/sg/financial/settlement/service/DataMaintenanceService.java

@@ -40,7 +40,14 @@ public class DataMaintenanceService extends CrudService<DataMaintenanceMapper, M
 	public List<MaintainData> findList(MaintainData maintainData) {
 		return super.findList(maintainData);
 	}
-	
+
+	/**
+	 * 查询概预算分页数据，这里实际调用mapper的findList方法
+	 * 该方法有一个特点，projectId模糊匹配，projectIds精准匹配
+	 * @param page 分页对象
+	 * @param maintainData
+	 * @return
+	 */
 	public Page<MaintainData> findPage(Page<MaintainData> page, MaintainData maintainData) {
 		return super.findPage(page, maintainData);
 	}

src/main/java/com/jeeplus/modules/sg/financial/settlement/web/DataMaintenanceController.java

@@ -37,7 +37,7 @@ import java.util.List;
 import java.util.Map;
 
 /**
- * 数据维护
+ * 概预算基本信息维护
  */
 @Controller
 @RequestMapping(value = "${adminPath}/sg/settlement")
@@ -69,7 +69,7 @@ public class DataMaintenanceController extends BaseController {
 	}
 
 
-		/**
+	/**
 	 * 列表数据
 	 */
 	@ResponseBody
@@ -79,6 +79,7 @@ public class DataMaintenanceController extends BaseController {
 		String id = UserUtils.getUser().getId();
 		String state = maintainData.getState();
 		String st = "";
+//		这里state不知道代表什么含义
 		if(state.equals("0")) {
 			st = (String) session.getAttribute(id);
 		}else {
@@ -88,6 +89,7 @@ public class DataMaintenanceController extends BaseController {
 		if(StringUtils.isNotBlank(projectId)){
 			st = projectId;
 		}
+//		对查询的id进行处理，若只有一个id设置projectId模糊匹配，若有多个设置projectIds精准匹配
 		if(StringUtils.isNotBlank(st)){
 			String[] sts = st.split("\\s+");
 			if(sts.length == 1){

src/main/webapp/webpage/modules/sg/financial/erp/erpCreditList.js

@@ -298,39 +298,74 @@ $(document).ready(function() {
 			    btn1: function(index, layero){
 						var iframeWin = layero.find('iframe')[0]; //得到iframe页的窗口对象，执行iframe页的方法：iframeWin.method();
 						iframeWin.contentWindow.importExcel('${ctx}/sg/financial/erpCredit/import', function (data) {
+                            // if (data.success) {
+                            //     jp.success(data.msg);
+                            //     jp.downloadFile('${ctx}/sg/financial/erpCredit/export');
+                            //     refresh();
+                            //     // if(data.flag){
+                            //      //    jp.error("导入失败");
+                            //      //    jp.openViewDialog(data.msg, "${ctx}/sg/financial/erpCredit/tips", '800px', '500px');
+								// // }
+                            // } else if (data.flag) {
+                            //     jp.error("导入失败");
+                            //     jp.openViewDialog(data.msg, "${ctx}/sg/financial/erpCredit/tips", '800px', '500px');
+                            // } else if (data.noStatus) {
+                            //     jp.error("导入失败");
+                            //     top.layer.open({
+                            //         type: 2,
+                            //         area: ['800px', '500px'],
+                            //         title: data.msg,
+                            //         maxmin: true, //开启最大化最小化按钮
+                            //         content: '${ctx}/sg/financial/erpCredit/tips1' ,
+                            //         btn: ['继续操作', '停止操作'],
+                            //         btn1: function(index1, layero){
+                            //             jp.downloadFile('${ctx}/sg/financial/erpCredit/export');
+                            //             jp.close(index1);
+                            //         },
+                            //         btn2: function(index1, layero){
+                            //         	window.location.href="${ctx}/sg/financial/erpCredit/clearFileAllSession";
+                            //             // jp.downloadFile('${ctx}/sg/financial/erpCredit/clearFileAllSession');
+                            //             location.reload();
+                            //             jp.close(index1);
+                            //         }
+                            //     });
+                            // }else if (data.yesStatus){
+                            //     jp.error(data.msg);
+                            //     jp.downloadFile('${ctx}/sg/financial/erpCredit/exportYesStatus');
+                            // }else {
+                            //     jp.error(data.msg);
+                            // }
+                            // jp.close(index);
                             if (data.success) {
                                 jp.success(data.msg);
-                                jp.downloadFile('${ctx}/sg/financial/erpCredit/export');
-                                refresh();
-                            } else if (data.flag) {
-                                jp.error("导入失败");
-                                jp.openViewDialog(data.msg, "${ctx}/sg/financial/erpCredit/tips", '800px', '500px');
-                            } else if (data.noStatus) {
-                                jp.error("导入失败");
-                                top.layer.open({
-                                    type: 2,
-                                    area: ['800px', '500px'],
-                                    title: data.msg,
-                                    maxmin: true, //开启最大化最小化按钮
-                                    content: '${ctx}/sg/financial/erpCredit/tips1' ,
-                                    btn: ['继续操作', '停止操作'],
-                                    btn1: function(index1, layero){
-                                        jp.downloadFile('${ctx}/sg/financial/erpCredit/export');
-                                        jp.close(index1);
-                                    },
-                                    btn2: function(index1, layero){
-                                    	window.location.href="${ctx}/sg/financial/erpCredit/clearFileAllSession";
-                                        // jp.downloadFile('${ctx}/sg/financial/erpCredit/clearFileAllSession');
-                                        location.reload();
-                                        jp.close(index1);
-                                    }
-                                });
-                            }else if (data.yesStatus){
+                                jp.downloadFile('${ctx}/sg/financial/erpCredit/export','finalAccount');//给个name是为了能够在某些条件下下载两个文件
+                                // refresh();
+                                if(data.flag){
+                                    jp.openViewDialog(data.msg, "${ctx}/sg/financial/erpCredit/tips", '800px', '500px');
+                                }else if(data.yesStatus){
+                                    jp.error(data.msg);
+                                    // jp.alert(data.msg);
+                                    jp.downloadFile('${ctx}/sg/financial/erpCredit/exportYesStatus','errorMsg');
+                                }else if(data.noStatus){
+                                    top.layer.open({
+                                        type: 2,
+                                        area: ['800px', '500px'],
+                                        title: data.msg,
+                                        maxmin: true, //开启最大化最小化按钮
+                                        content: '${ctx}/sg/financial/erpCredit/tips1' ,
+                                        btn: ['确定'],
+                                        btn1: function(index1, layero){
+                                            window.location.href="${ctx}/sg/financial/erpCredit/clearFileAllSession";
+                                            // jp.downloadFile('${ctx}/sg/financial/erpCredit/clearFileAllSession');
+                                            // location.reload();
+                                            jp.close(index1);
+                                        },
+                                    });
+                                }
+                            }else {
                                 jp.error(data.msg);
-                                jp.downloadFile('${ctx}/sg/financial/erpCredit/exportYesStatus');
-                        	}else {
-                                jp.error(data.msg);
-							}
+                                jp.alert(data.msg);
+                            }
                             jp.close(index);
                         });//调用保存事件
                     return false;

src/main/webapp/webpage/modules/sg/financial/erp/erpCreditTips.jsp

@@ -11,7 +11,9 @@
 	<tr>
 		<th>项目定义编号</th>
 		<th>项目名称</th>
-		<th>(是否存在数据/是否完成甲供物资)</th>
+		<%--<th>(是否存在数据/是否完成甲供物资)</th>--%>
+		<th>费用入账</th>
+		<th>甲供材</th>
 		<%--<th>供应商名称</th>--%>
 	</tr>
 	</thead>
@@ -20,7 +22,9 @@
 			<tr>
 				<td>${erp.itemId}</td>
 				<td>${erp.itemName}</td>
-				<td>${erp.flagItem}</td>
+				<%--<td>${erp.flagItem}</td>--%>
+				<td>${erp.expenseStatus}</td>
+				<td>${erp.informationStatus}</td>
 				<%--<td>${erp.itemSupplierName}</td>--%>
 			</tr>
 		</c:forEach>

src/main/webapp/webpage/modules/sg/financial/expense/expenseList.js

@@ -159,7 +159,7 @@ $(document).ready(function() {
             btn2: function(index, layero){
                 var iframeWin = layero.find('iframe')[0]; //得到iframe页的窗口对象，执行iframe页的方法：iframeWin.method();
                 iframeWin.contentWindow.importExcel('${ctx}/sg/financial/expense/importExpense', function (data) {
-                    top.layer.msg(data.msg, {icon:1})
+                    top.layer.alert(data.msg, {icon:1})
                     refresh()
                     jp.close(index);
                 });//调用保存事件

src/main/webapp/webpage/modules/sg/financial/settlement/dataMaintenanceList.js

@@ -338,7 +338,7 @@ $(document).ready(function() {
 
 
   
-   function edit(id){//没有权限时，不显示确定按钮
+  function edit(id){//没有权限时，不显示确定按钮
        if(id == undefined){
 	      id = getIdSelections();
 	}

src/main/webapp/webpage/modules/sg/financial/settlement/dataMaintenanceList.jsp

@@ -72,9 +72,15 @@
 				<%--<i class="fa fa-search-plus"></i> 查看--%>
 			<%--</button>--%>
 		<%--</shiro:hasPermission>--%>
+
 		<shiro:hasPermission name="sg:settlement:import">
 			<button id="btnImport" class="btn btn-info"><i class="fa fa-folder-open-o"></i> 导入</button>
 		</shiro:hasPermission>
+		<shiro:hasPermission name="sg:settlement:export">
+			<button id="export" class="btn btn-warning">
+				<i class="fa fa-file-excel-o"></i> 导出
+			</button>
+		</shiro:hasPermission>
 		<shiro:hasPermission name="sg:settlement:import">
 			<button id="btnSearch" class="btn btn-info"><i class="fa fa-folder-open-o"></i> 导入查询
 			</button>
@@ -85,14 +91,7 @@
 			</button>
 		</shiro:hasPermission>
 
-			<shiro:hasPermission name="sg:settlement:export">
-	        		<button id="export" class="btn btn-warning">
-					<i class="fa fa-file-excel-o"></i> 导出
-				</button>
-			 </shiro:hasPermission>
-
-
-		    </div>
+	</div>
 		
 	<!-- 表格 -->
 	<table id="dataTable" style="table-layout:fixed"  data-toolbar="#toolbar"></table>