Demo entry 6684320

java

   

Submitted by java on Dec 15, 2017 at 06:46
Language: Java. Code size: 30.9 kB.

    package ms.smarthr.salarypay.server.controller;  
      
    import java.io.UnsupportedEncodingException;  
    import java.net.URLDecoder;  
    import java.util.HashMap;  
    import java.util.LinkedList;  
    import java.util.List;  
    import java.util.Map;  
      
    import org.slf4j.Logger;  
    import org.slf4j.LoggerFactory;  
    import org.springframework.beans.factory.annotation.Autowired;  
      
    import ms.service.annotation.Body;  
    import ms.service.annotation.IceApi;  
    import ms.service.annotation.Param;  
    import ms.service.common.Service;  
    import ms.smarthr.salarypay.server.service.SalaryPlanService;  
    import ms.smarthr.salarypay.server.util.PageList;  
      
    /** 
     * 薪资计划的Controller 
     *  
     * @version 1.0 2017-10-19 
     *  
     * @since JDK 1.8 
     *  
     * @category Smart-HR 
     * */  
    @IceApi//必须要加此注解,表示对外提供接口服务  
    public class SalaryPlanController extends Service  {  
          
        private static final long serialVersionUID = 1L;  
        Logger log = LoggerFactory.getLogger(LoginController.class);  
          
        @Autowired SalaryPlanService salaryPlanService;  
          
        /** 
         * 获取用户选择的模板及所拥有项目数量 
         *  
         * @param cid 公司ID 
         *  
         * @param mouldID模板ID 
         * */  
        public Map<String, Object> querySalaryMouldNumByID(@Param int cid,@Param int mouldID){  
            try {  
                //封装参数  
                Map<String, Object> paramMap = new HashMap<String, Object>();  
                paramMap.put("cid", cid);  
                paramMap.put("mouldID", mouldID);  
                  
                Map<String, Object> resultMap = salaryPlanService.querySalaryMouldNumByID(paramMap);  
                  
                log.info("|querySalaryMouldNumByID|获取用户选择的模板及所拥有项目数量返回数据,Map:{}", resultMap);  
                return resultMap;  
            } catch (Exception e) {  
                e.printStackTrace();  
                  
                log.error("|querySalaryMouldNumByID|获取用户选择的模板及所拥有项目数量时发生异常:{}",e.getMessage());  
                return null;  
            }  
        }  
          
        /** 
         * 验证计划编号或名称是否存在。大于0说明存在 
         * */  
        public int verificationPlanExist(@Param int cid,String planNum,String planName){  
            try {  
                //封装查询参数  
                Map<String, Object> paramMap = new HashMap<String, Object>();  
                paramMap.put("cid", cid);  
                paramMap.put("planNum", planNum==null?"":planNum);  
                paramMap.put("planName", planName==null?"":planName);  
                  
                int cnt = salaryPlanService.verificationPlanExist(paramMap);  
                  
                log.info("|verificationPlanExist|判断计划编号或名称重复返回数据,count:{}", cnt);  
                return cnt;  
            } catch (Exception e) {  
                e.printStackTrace();  
                  
                log.error("|verificationPlanExist|判断计划编号或名称重复时发生异常:{}",e.getMessage());  
                return 0;  
            }  
        }  
          
        /** 
         * 生成存储导入数据的KeyID 
         *  
         * @param cid 公司ID 
         *  
         * @param uid 用户ID 
         *  
         * @param importDatas 导入数据 
         * */  
        public Map<String, Object> createImpDataTempTable(@Param int cid,@Param int uid){  
            try {  
                //封装查询参数  
                Map<String, Object> paramMap = new HashMap<String, Object>();  
                paramMap.put("CID", cid);  
                paramMap.put("OperatorID", uid);  
                  
                Map<String, Object> map = salaryPlanService.createImpDataTempTable(paramMap);  
                  
                log.info("|createImpDataTempTable|生成存储导入数据的KeyID返回数据result{}",map);  
                return map;  
            } catch (Exception e) {  
                e.printStackTrace();  
                  
                log.error("|createImpDataTempTable|生成存储导入数据的KeyID时发生异常:{}",e.getMessage());  
                return null;  
            }  
        }  
          
        /** 
         * 处理导入的计划数据 
         *  
         * @param cid 公司ID 
         *  
         * @param uid 用户ID 
         *  
         * @param uname 用户名称 
         *  
         * @param mouldID 模板ID 
         *  
         * @param mouldName 模板名称 
         *  
         * @param importDatas 导入数据 
         * */  
        public List<Map<String, Object>> importPlanData(@Param int cid,@Param int uid,@Param String importKeyID,@Param int mouldID,  
                @Param String importDatas){  
            try {  
                //封装查询参数  
                Map<String, Object> paramMap = new HashMap<String, Object>();  
                paramMap.put("CID", cid);  
                paramMap.put("MouldID", mouldID);  
                importDatas = URLDecoder.decode(importDatas, "UTF-8");  
                paramMap.put("ImportData", importDatas);  
                paramMap.put("OperatorID", uid);  
                paramMap.put("ImportKeyID", importKeyID);  
                  
                List<Map<String, Object>> list = salaryPlanService.importPlanData(paramMap);  
                  
                log.info("|importPlanData|处理导入的计划数据返回数据result{}",list);  
                return list;  
            } catch (UnsupportedEncodingException ue) {  
                ue.printStackTrace();  
                  
                log.error("|importPlanData|处理导入的计划数据时发生异常",ue);  
                return null;  
            }catch (Exception e) {  
                e.printStackTrace();  
                  
                log.error("|importPlanData|处理导入的计划数据时发生异常:{}",e.getMessage());  
                return null;  
            }  
        }  
          
        /** 
         * 清除已经导入保存的数据 
         * */  
        public void dropImportTempTable(@Param int cid,@Param String importKeyID){  
            try {  
                Map<String, Object> dropMap = new HashMap<String, Object>();  
                dropMap.put("CID",cid);  
                dropMap.put("ImportKeyID", importKeyID);  
                  
                salaryPlanService.dropImportTempTable(dropMap);  
                  
                log.info("|dropImportTempTable|清除已经导入保存的数据成功");  
            } catch (Exception e) {  
                e.printStackTrace();  
                  
                log.error("|dropImportTempTable|清除已经导入保存的数据时发生异常:{}",e.getMessage());  
            }  
        }  
          
        /** 
         * 新增计划 
         * */  
        public Map<String, Object> createSalaryPlan(@Body Map<String, Object> requestMap){  
            try {  
                //封装参数  
                Map<String, Object> paramMap = new HashMap<String, Object>();  
                paramMap.put("cid", requestMap.get("cid"));  
                paramMap.put("uid", requestMap.get("uid"));  
                paramMap.put("uname", requestMap.get("uname"));  
                paramMap.put("mouldID", requestMap.get("mouldID")==null?0:requestMap.get("mouldID"));  
                paramMap.put("planName", requestMap.get("planName")==null?"":requestMap.get("planName"));  
                paramMap.put("planNum", requestMap.get("planNum")==null?"":requestMap.get("planNum"));  
                paramMap.put("payDate", requestMap.get("payDate")==null?0:requestMap.get("payDate"));  
                paramMap.put("importKeyID", requestMap.get("importKeyID")==null?"":requestMap.get("importKeyID"));  
          
                Map<String, Object> resultMap = salaryPlanService.createSalaryPlan(paramMap);  
                log.info("|createSalaryMould|新增计划成功,返回结果result{}",resultMap);  
                  
                return resultMap;  
            } catch (Exception e) {  
                e.printStackTrace();  
                log.error("|createSalaryMould|新增计划时发生异常:{}",e.getMessage());  
                  
                return null;  
            }  
        }  
          
        /** 
         * 验证是否存在计划信息和结果表信息 
         * */  
        public Map<String, Object> getPlanInfo(@Param int cid,@Param int planID){  
            try {  
                Map<String,Object> checkMap = new HashMap<String, Object>();  
                checkMap.put("cid", cid);  
                checkMap.put("planID", planID);  
                  
                Map<String, Object> resultMap = salaryPlanService.getPlanInfo(checkMap);  
                log.info("|checkExistResultTable|验证是否存在计划信息和导入信息返回结果result{}",resultMap);  
                return resultMap;             
            } catch (Exception e) {  
                e.printStackTrace();  
                  
                log.error("|checkExistResultTable|验证是否存在计划信息和导入信息时发生异常:{}",e.getMessage());  
                return null;  
            }  
        }  
          
        /** 
         * 获取计划导入的详细信息 
         * */  
        public PageList queryPlanDetailsList(@Param int cid,@Param int planID,  
                String employeeName,String IDCard,String taxReturn,  
                @Param String resultTableName,@Param int start,@Param int limit){  
            try {  
                //封装查询参数  
                Map<String, Object> paramMap = new HashMap<String, Object>();  
                paramMap.put("cid", cid);  
                paramMap.put("planID", planID);  
                paramMap.put("employeeName", employeeName==null?"":employeeName);  
                paramMap.put("IDCard", IDCard==null?"":IDCard);  
                paramMap.put("taxReturn", taxReturn==null?"":taxReturn);  
                paramMap.put("resultTableName", resultTableName==null?"":resultTableName);  
                paramMap.put("start", start);  
                paramMap.put("limit", limit);  
                PageList page = salaryPlanService.queryPlanDetailsList(paramMap);  
                  
                log.info("|queryPlanDetailsList|获取计划导入的详细信息返回数据,Map:{}", page);  
                return page;  
            } catch (Exception e) {  
                e.printStackTrace();  
                  
                log.error("|queryPlanDetailsList|获取计划导入的详细信息时发生异常:{}",e.getMessage());  
                return null;  
            }  
        }  
          
        /** 
         * 删除详情中的一条记录 
         * */  
        public Map<String, Object> deleteDetailRecord(@Param int detailID,@Param String s100020,@Param String resultTableName){  
            try {  
                Map<String,Object> delMap = new HashMap<String, Object>();  
                delMap.put("detailID", detailID);  
                delMap.put("s100020", s100020);  
                delMap.put("resultTableName", resultTableName);  
                  
                Map<String, Object> resultMap = salaryPlanService.deleteDetailRecord(delMap);  
                log.info("|deleteDetailRecord|删除记录返回结果result{}",resultMap);  
                return resultMap;             
            } catch (Exception e) {  
                e.printStackTrace();  
                  
                log.error("|deleteDetailRecord|删除记录时发生异常:{}",e.getMessage());  
                return null;  
            }  
        }  
          
        /** 
         * 导入薪资信息 
         * */  
        public List<Map<String, Object>> addPlanDetailsData(@Param int cid,@Param int uid,@Param int planID,  
                @Param String importData,@Param String resultTableName){  
            try {  
                Map<String,Object> impMap = new HashMap<String, Object>();  
                impMap.put("CID", cid);  
                impMap.put("PlanID", planID);  
                impMap.put("ImportData", importData);  
                impMap.put("OperatorID", uid);  
                impMap.put("ResultTableName", resultTableName);  
                  
                List<Map<String, Object>> list = salaryPlanService.addPlanDetailsData(impMap);  
                log.info("|addPlanDetailsData|导入薪资信息返回结果result{}",list);  
                return list;  
            } catch (Exception e) {  
                e.printStackTrace();  
                log.error("|addPlanDetailsData|导入薪资信息时发生异常:{}",e.getMessage());  
                return null;  
            }  
        }  
          
        /** 
         * 作废计划 
         * */  
        public void invalidSalaryPlan(@Param int cid,@Param int uid,@Param String uname,@Param int planID){  
            try {  
                Map<String,Object> invMap = new HashMap<String, Object>();  
                invMap.put("CID", cid);  
                invMap.put("PlanID", planID);  
                invMap.put("OperatorID", uid);  
                invMap.put("OperatorName", uname);  
                  
                salaryPlanService.invalidSalaryPlan(invMap);  
                log.info("|invalidSalaryPlan|作废计划成功");  
            } catch (Exception e) {  
                e.printStackTrace();  
                  
                log.error("|invalidSalaryPlan|作废计划时发生异常:{}",e.getMessage());  
            }  
        }  
          
        /** 
         * 删除计划 
         * */  
        public void deleteSalaryPlan(@Param int cid,@Param int planID){  
            try {  
                Map<String,Object> delMap = new HashMap<String, Object>();  
                delMap.put("CID", cid);  
                delMap.put("PlanID", planID);  
                  
                salaryPlanService.deleteSalaryPlan(delMap);  
                log.info("|deleteSalaryPlan|删除计划成功");  
            } catch (Exception e) {  
                e.printStackTrace();  
                  
                log.error("|deleteSalaryPlan|删除计划时发生异常:{}",e.getMessage());  
            }  
        }  
          
        /** 
         * 获取账单信息 
         * */  
        public LinkedList<Map<String, Object>> queryPlanBill(@Param int cid,@Param int planID,@Param String resultTableName){  
            try {  
                Map<String,Object> impMap = new HashMap<String, Object>();  
                impMap.put("CID", cid);  
                impMap.put("PlanID", planID);  
                impMap.put("ResultTableName", resultTableName);  
                  
                LinkedList<Map<String, Object>> list = salaryPlanService.queryPlanBill(impMap);  
                log.info("|queryPlanBill|获取账单信息返回结果result{}",list);  
                return list;  
            } catch (Exception e) {  
                e.printStackTrace();  
                log.error("|queryPlanBill|获取账单信息时发生异常:{}",e.getMessage());  
                return null;  
            }  
        }  
          
        /** 
         * 确认账单 
         * */   
        public void confirmBill(@Param int cid,@Param int uid,@Param String uname,@Param int planID,@Param String resultTableName){  
            try {  
                Map<String,Object> confMap = new HashMap<String, Object>();  
                confMap.put("CID", cid);  
                confMap.put("PlanID", planID);  
                confMap.put("ResultTableName", resultTableName);  
                confMap.put("OperatorID", uid);  
                confMap.put("OperatorName", uname);  
                  
                salaryPlanService.confirmBill(confMap);  
                log.info("|invalidSalaryPlan|确认账单成功");  
            } catch (Exception e) {  
                e.printStackTrace();  
                  
                log.error("|invalidSalaryPlan|确认账单时发生异常:{}",e.getMessage());  
            }  
        }  
          
        /** 
         * 获取计划导入的详细信息 
         * */  
        public PageList queryPayList(@Param int cid,@Param int planStatus,  
                String startCreateDate,String endCreateDate,  
                String startPayDate,String endPayDate,  
                @Param int start,@Param int limit,String stintStatus){  
            try {  
                //封装查询参数  
                Map<String, Object> paramMap = new HashMap<String, Object>();  
                paramMap.put("cid", cid);  
                paramMap.put("planStatus", planStatus);  
                paramMap.put("startCreateDate", startCreateDate==null?"":startCreateDate);  
                paramMap.put("endCreateDate", endCreateDate==null?"":endCreateDate);  
                paramMap.put("startPayDate", startPayDate==null?"0":startPayDate);  
                paramMap.put("endPayDate", endPayDate==null?"0":endPayDate);  
                paramMap.put("start", start);  
                paramMap.put("limit", limit);  
                paramMap.put("stintStatus", stintStatus == null ? "":stintStatus);  
                  
                PageList page = salaryPlanService.queryPayList(paramMap);  
                  
                log.info("|queryPlanDetailsList|获取计划导入的详细信息返回数据,Map:{}", page);  
                return page;  
            } catch (Exception e) {  
                e.printStackTrace();  
                  
                log.error("|queryPlanDetailsList|获取计划导入的详细信息时发生异常:{}",e.getMessage());  
                return null;  
            }  
        }  
          
        /** 
         * 获取申请付款的数据 
         * */  
        public Map<String, Object> queryApplyToPayList(@Param int cid,@Param int uid,@Param int planID,@Param String applyID,  
                String requestURL,String resultStatus,String resultDetail,String resultJson){  
            try {  
                Map<String,Object> queryMap = new HashMap<String, Object>();  
                queryMap.put("CID", cid);  
                queryMap.put("PlanID", planID);  
                queryMap.put("ApplyID", applyID);  
                queryMap.put("RequestURL", requestURL);  
                queryMap.put("ResultStatus", resultStatus);  
                queryMap.put("ResultDetail", resultDetail);  
                queryMap.put("ResultJson", resultJson);  
                queryMap.put("OperatorID", uid);  
                  
                Map<String, Object> resultMap = salaryPlanService.queryApplyToPayList(queryMap);  
                log.info("|queryApplyToPayList|获取申请付款的数据返回结果result{}",resultMap);  
                  
                return resultMap;  
            } catch (Exception e) {  
                e.printStackTrace();  
                log.error("|queryApplyToPayList|获取申请付款的数据时发生异常:{}",e.getMessage());  
                return null;  
            }  
        }  
          
        /** 
         * 回填申请付款的数据 
         * */  
        public void setApplyToPayResult(@Param int cid,@Param int uid,@Param int planID,@Param String applyID,  
                String requestURL,String resultStatus,String resultDetail,String resultJson){  
            try {  
                Map<String,Object> queryMap = new HashMap<String, Object>();  
                queryMap.put("CID", cid);  
                queryMap.put("PlanID", planID);  
                queryMap.put("ApplyID", applyID);  
                queryMap.put("RequestURL", requestURL);  
                queryMap.put("ResultStatus", resultStatus);  
                queryMap.put("ResultDetail", resultDetail);  
                queryMap.put("ResultJson", resultJson);  
                queryMap.put("OperatorID", uid);  
                  
                salaryPlanService.setApplyToPayResult(queryMap);  
                log.info("|setApplyToPayResult|回填申请付款的数据成功");  
                  
            } catch (Exception e) {  
                e.printStackTrace();  
                log.error("|setApplyToPayResult|回填申请付款的数据时发生异常:{}",e.getMessage());  
            }  
        }  
          
        /** 
         * 接受异步推送的支付结果 
         * */  
        public Map<String, Object> receiveAsynPushPayResult(@Body Map<String, String> requestMap){  
            try {  
                //接受参数  
                Map<String,Object> paramMap= new HashMap<String,Object>();  
                paramMap.put("CID", requestMap.get("cid") == null ? "":requestMap.get("cid"));  
                paramMap.put("UID", requestMap.get("uid") == null ? "":requestMap.get("uid"));  
                paramMap.put("AsyncType", requestMap.get("asyncType") == null ? "":requestMap.get("asyncType"));  
                paramMap.put("ApplyID", requestMap.get("applyID") == null ? "":requestMap.get("applyID"));  
                  
                Map<String, Object> resultMap = salaryPlanService.receiveAsynPushPayResult(paramMap);  
                  
                log.info("|receiveAsynPushPayResult|接受异步推送的支付结果成功,返回数据:{}",resultMap);  
                return resultMap;  
            } catch (Exception e) {  
                e.printStackTrace();  
                log.error("|receiveAsynPushPayResult|接受异步推送的支付结果时发生异常:{}",e.getMessage());  
                return null;  
            }  
        }  
          
        /** 
         * 根据CID和PlanID修改计划的状态 
         * */  
        public void updatePlanStatus(@Param int cid,@Param int uid,@Param String uname,@Param int planID,@Param int status){  
            try {  
                Map<String,Object> updMap= new HashMap<String,Object>();  
                updMap.put("cid", cid);  
                updMap.put("uid", uid);  
                updMap.put("uname", uname);  
                updMap.put("status", status);  
                updMap.put("planID", planID);  
                  
                log.info("|updatePlanStatus|修改计划状态参数为:map:{}",updMap);  
                  
                salaryPlanService.updatePlanStatus(updMap);  
                  
                log.info("|updatePlanStatus|修改计划状态成功");  
            } catch (Exception e) {  
                e.printStackTrace();  
                log.error("|updatePlanStatus|修改计划状态时发生异常:{}",e.getMessage());  
            }  
        }  
          
        /** 
         * 获取发送邮件所需信息 
         * */  
        public Map<String, Object> querySendMailInfo(@Param int cid,@Param int planID){  
            try {  
                Map<String,Object> queryMap = new HashMap<String, Object>();  
                queryMap.put("CID", cid);  
                queryMap.put("PlanID", planID);  
                  
                Map<String, Object> resultMap = salaryPlanService.querySendMailInfo(queryMap);  
                log.info("|querySendMailInfo|获取发送邮件所需信息返回结果result{}",resultMap);  
                  
                return resultMap;  
            } catch (Exception e) {  
                e.printStackTrace();  
                log.error("|querySendMailInfo|获取发送邮件所需信息时发生异常:{}",e.getMessage());  
                return null;  
            }  
        }  
          
        /** 
         * 获取所有公司信息 
         * */  
        public List<Map<String, Object>> queryAllCompany() {  
            try {  
                List<Map<String, Object>> resultMap = salaryPlanService.queryAllCompany();  
                log.info("|queryAllCompany|获取所有公司信息结果result{}", resultMap);  
                return resultMap;  
            } catch (Exception e) {  
                e.printStackTrace();  
                log.error("|queryAllCompany|获取所有公司信息时发生异常:{}", e.getMessage());  
                return null;  
            }  
        }  
          
        /** 
         * 获取计划详细信息-为大后台提供接口 
         * */  
        public PageList queryXopPlanDetailsList(@Param int cid, @Param int planID, String employeeName, String IDCard,  
                String BankCard, String taxReturn, @Param String resultTableName, @Param int start, @Param int limit,  
                @Param String status) {  
            try {  
                //封装查询参数  
                Map<String, Object> paramMap = new HashMap<String, Object>();  
                paramMap.put("cid", cid);  
                paramMap.put("planID", planID);  
                paramMap.put("employeeName", employeeName == null ? "" : employeeName);  
                paramMap.put("IDCard", IDCard == null ? "" : IDCard);  
                paramMap.put("BankCard", BankCard == null ? "" : BankCard);  
                paramMap.put("taxReturn", taxReturn == null ? "" : taxReturn);  
                paramMap.put("resultTableName", resultTableName == null ? "" : resultTableName);  
                paramMap.put("status", status == null ? "" : status);  
                paramMap.put("start", start);  
                paramMap.put("limit", limit);  
                PageList page = salaryPlanService.queryXopPlanDetailsList(paramMap);  
      
                log.info("|queryXopPlanDetailsList|获取计划详细信息-为大后台提供接口返回数据,Map:{}", page);  
                return page;  
            } catch (Exception e) {  
                e.printStackTrace();  
      
                log.error("|queryXopPlanDetailsList|获取计划详细信息-为大后台提供接口信息时发生异常:{}", e.getMessage());  
                return null;  
            }  
        }  
          
        /** 
         * 修改员工薪资代发状态-为大后台提供接口返回数据 
         * */  
        public int batchUpdPlanEmpStatus(@Param int cid, @Param int planID, @Param String resultTableName) {  
            try {  
                //封装参数  
                Map<String, Object> paramMap = new HashMap<String, Object>();  
                paramMap.put("CID", cid);  
                paramMap.put("PlanID", planID);  
                paramMap.put("ResultTableName", resultTableName == null ? "" : resultTableName);  
                int result = salaryPlanService.batchUpdPlanEmpStatus(paramMap);  
      
                log.info("|updateEmpSalaryPayStatus|修改员工薪资代发状态-为大后台提供接口返回数据,result:{}", result);  
                return result;  
            } catch (Exception e) {  
                e.printStackTrace();  
                log.error("|updateEmpSalaryPayStatus|修改员工薪资代发状态-为大后台提供接口信息时发生异常:{}", e.getMessage());  
                return -1;  
            }  
        }  
          
      
        /** 
         * 导入反馈结果修改员工薪资代发状态-为大后台提供接口返回数据 
         * */  
        public List<Map<String, Object>> impUpdPlanEmpStatus(@Param int cid, @Param int planID, @Param String resultTableName, @Param String feedbackDatas) {  
            try {  
                //封装参数  
                Map<String, Object> paramMap = new HashMap<String, Object>();  
                paramMap.put("CID", cid);  
                paramMap.put("PlanID", planID);  
                paramMap.put("ResultTableName", resultTableName == null ? "" : resultTableName);  
                paramMap.put("FeedbackJSON", URLDecoder.decode(feedbackDatas, "UTF-8"));  
                List<Map<String, Object>> result = salaryPlanService.impUpdPlanEmpStatus(paramMap);  
      
                log.info("|impUpdPlanEmpStatus|导入反馈结果修改员工薪资代发状态-为大后台提供接口返回数据,result:{}", result);  
                return result;  
            } catch (Exception e) {  
                e.printStackTrace();  
                log.error("|impUpdPlanEmpStatus|导入反馈结果修改员工薪资代发状态-为大后台提供接口信息时发生异常:{}", e.getMessage());  
                return null;  
            }  
        }  
          
        /** 
         * 获取需要修正的员工数据 
         * */  
        public PageList queryFixedDetailsList(@Param int cid,@Param int planID,  
                String employeeName,String IDCard,String taxReturn,@Param int detailStatus,  
                @Param String resultTableName,@Param int start,@Param int limit){  
            try {  
                //封装查询参数  
                Map<String, Object> paramMap = new HashMap<String, Object>();  
                paramMap.put("cid", cid);  
                paramMap.put("planID", planID);  
                paramMap.put("employeeName", employeeName==null?"":employeeName);  
                paramMap.put("IDCard", IDCard==null?"":IDCard);  
                paramMap.put("taxReturn", taxReturn==null?"":taxReturn);  
                paramMap.put("detailStatus", detailStatus);  
                paramMap.put("resultTableName", resultTableName==null?"":resultTableName);  
                paramMap.put("start", start);  
                paramMap.put("limit", limit);  
                PageList page = salaryPlanService.queryFixedDetailsList(paramMap);  
                  
                log.info("|queryFixedDetailsList|获取需要修正的员工数据,Map:{}", page);  
                return page;  
            } catch (Exception e) {  
                e.printStackTrace();  
                  
                log.error("|queryFixedDetailsList|获取需要修正的员工数据:{}",e.getMessage());  
                return null;  
            }  
        }  
          
        /** 
         * 修正员工信息 
         * */  
        public Map<String, Object> updFixedDetails(@Param int cid,@Param int planID,@Param String resultTableName,@Param String fixdeDataJSON){  
            try {  
                Map<String,Object> updMap = new HashMap<String, Object>();  
                updMap.put("CID", cid);  
                updMap.put("PlanID", planID);  
                updMap.put("ResultTableName", resultTableName);  
                updMap.put("FixdeDataJSON", URLDecoder.decode(fixdeDataJSON, "UTF-8"));  
                  
                Map<String, Object> resultMap = salaryPlanService.updFixedDetails(updMap);  
                log.info("|updFixedDetails|修正员工信息返回结果result{}",resultMap);  
                  
                return resultMap;  
            } catch (Exception e) {  
                e.printStackTrace();  
                log.error("|updFixedDetails|修正员工信息时发生异常:{}",e.getMessage());  
                return null;  
            }  
        }  
          
        /** 
         *  重发逾期计划 
         * */  
        public Map<String, Object> resendOverduePlan(@Param int cid,@Param int uid,@Param int planID,@Param int newPayDate){  
            try {  
                Map<String,Object> resendMap = new HashMap<String, Object>();  
                resendMap.put("CID", cid);  
                resendMap.put("PlanID", planID);  
                resendMap.put("NewPayDate",newPayDate);  
                resendMap.put("ResendID", uid);  
                  
                Map<String, Object> resultMap = salaryPlanService.resendOverduePlan(resendMap);  
                log.info("|resendOverduePlan|重发逾期计划返回结果result{}",resultMap);  
                  
                return resultMap;  
            } catch (Exception e) {  
                e.printStackTrace();  
                log.error("|resendOverduePlan|重发逾期计划时发生异常:{}",e.getMessage());  
                return null;  
            }  
        }  
    }  

This snippet took 0.04 seconds to highlight.

Back to the Entry List or Home.

Delete this entry (admin only).