【佳毅兴】【顺丰对接】

src/main/java/com/uas/eis/controller/EventCallbackController.java

@@ -1,56 +0,0 @@
-package com.uas.eis.controller;
-
-import com.uas.eis.beans.arg.CrmCallBackArg;
-import com.uas.eis.beans.result.CrmCallBackResult;
-import com.uas.eis.utils.SignUtil;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.web.bind.annotation.*;
-
-@Slf4j
-@RestController
-@RequestMapping("/event/")
-public class EventCallbackController extends BaseController{
-    private static final String SUCCESS = "success";
-    private String aesKey = "cXdlcnR5dWlvcGFzZGZnaGprbHp4Y3Zibm1xd2VycXc=";
-
-    @ResponseBody
-    @RequestMapping(value = "crmCallback", method = RequestMethod.POST, produces = "application/json;charset=UTF-8")
-    public CrmCallBackResult crmCallBack(CrmCallBackArg arg) throws Exception {
-        Integer retryTimes = arg.getRetryTimes();
-        String signature = null;
-        if (retryTimes != null) {
-            signature = SignUtil.shaEncode(arg.getTimestamp() + arg.getNonce() + arg.getMessageId() + retryTimes + arg.getEnterpriseAccount() + arg.getEncryptedContent() + aesKey);
-        } else {
-            signature = SignUtil.shaEncode(arg.getTimestamp() + arg.getNonce() + arg.getMessageId() + arg.getEnterpriseAccount() + arg.getEncryptedContent() + aesKey);
-        }
-        //校验signature
-        if (!arg.getSignature().equals(signature)) {
-            Long returnTimestamp = System.currentTimeMillis();
-            String returnEncryptedResult = SignUtil.encryptAes("sinature is wrong", aesKey);
-            String returnNonce = (int) (Math.random() * 100000) + "";
-            String returnSignature = SignUtil.shaEncode(returnTimestamp + returnNonce + returnEncryptedResult + aesKey);
-            CrmCallBackResult crmCallBackResult = new CrmCallBackResult();
-            crmCallBackResult.setTimestamp(returnTimestamp);
-            crmCallBackResult.setEncryptedResult(returnEncryptedResult);
-            crmCallBackResult.setNonce(returnNonce);
-            crmCallBackResult.setSignature(returnSignature);
-            log.warn("crmCallBack={}", crmCallBackResult);
-            return crmCallBackResult;
-        }
-        //处理第三方业务逻辑
-        String json = SignUtil.decryptAes(arg.getEncryptedContent(), aesKey);
-        //....
-        //返回结果
-        Long returnTimestamp = System.currentTimeMillis();
-        String returnEncryptedResult = SignUtil.encryptAes("success", aesKey);
-        String returnNonce = (int) (Math.random() * 1000000) + "";
-        String returnSignature = SignUtil.shaEncode(returnTimestamp + returnNonce + returnEncryptedResult + aesKey);
-        CrmCallBackResult crmCallBackResult = new CrmCallBackResult();
-        crmCallBackResult.setTimestamp(returnTimestamp);
-        crmCallBackResult.setEncryptedResult(returnEncryptedResult);
-        crmCallBackResult.setNonce(returnNonce);
-        crmCallBackResult.setSignature(returnSignature);
-        log.info("json={},crmCallBack={}", json, crmCallBackResult);
-        return crmCallBackResult;
-    }
-}

src/main/java/com/uas/eis/controller/LoginController.java

@@ -1,51 +0,0 @@
-package com.uas.eis.controller;
-
-import java.util.HashMap;
-import java.util.Map;
-
-import javax.servlet.http.HttpServletRequest;
-
-import com.uas.eis.entity.ErrorMsg;
-import com.uas.eis.exception.SystemException;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RestController;
-
-import com.uas.eis.service.QueryService;
-import com.uas.eis.utils.BaseUtil;
-
-@RestController
-public class LoginController {
-
-	@Autowired
-	private QueryService queryService;
-	
-	/**
-	 * 首次登录请求token
-	 */
-	@RequestMapping("/login")
-	public Object login(HttpServletRequest request, String username, String password){
-		Map<String, Object> res = new HashMap<String, Object>();
-		String token = queryService.login(username, password);
-		request.getSession().removeAttribute("token");
-		if(token != null) {
-			request.getSession().setAttribute("token", token);
-			res.put("success", true);
-			res.put("token", token);
-		}else {
-			throw new SystemException(ErrorMsg.BAD_USERINFO);
-		}
-		return res;
-	}
-	
-	/**
-	 * 退出登录
-	 */
-	@RequestMapping("/logout")
-	public Object logout(HttpServletRequest request){
-		Map<String, Object> res = new HashMap<String, Object>();
-		request.getSession().removeAttribute("token");
-		res.put("success", true);
-		return res;
-	}
-}

src/main/java/com/uas/eis/controller/MESController.java

@@ -1,126 +0,0 @@
-package com.uas.eis.controller;
-
-import com.uas.eis.sdk.entity.ApiResult;
-import com.uas.eis.service.MESService;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RestController;
-
-import javax.servlet.http.HttpServletRequest;
-
-/**
- * @author koul
- * @email koul@usoftchina.com
- * @date 2021-12-07 15:36
- */
-@RestController
-public class MESController {
-
-    @Autowired
-    private MESService mesService;
-
-    /**
-     * 获取ERP收料单
-     * @param
-     * @return
-     */
-    @RequestMapping("/mes/checkVerifyApply")
-    public ApiResult<String> checkVerifyApply(HttpServletRequest request){
-        return mesService.checkVerifyApply(request);
-    }
-
-    /**
-     * 确认入库
-     * @param
-     * @return
-     */
-    @RequestMapping("/mes/purcCheckin")
-    public ApiResult<String> purcCheckin(HttpServletRequest request){
-        return mesService.purcCheckin(request);
-    }
-
-    /**
-     * 成品半成品入库
-     * @return
-     */
-    @RequestMapping("/mes/prodInOutMakeIn")
-    public ApiResult<String> prodInOutMakeIn(HttpServletRequest request){
-        return mesService.prodInOutMakeIn(request);
-    }
-
-    /**
-     * 工单删除校验接口
-     * @param
-     * @return
-     */
-    @RequestMapping("/mes/makeDeleteCheck")
-    public ApiResult<String> makeDeleteCheck(HttpServletRequest request){
-        return mesService.makeDeleteCheck(request);
-    }
-
-    /**
-     * 报废单
-     * @param
-     * @return
-     */
-    @RequestMapping("/mes/initMakeScrap")
-    public ApiResult<String> initMakeScrap(HttpServletRequest request){
-        return mesService.initMakeScrap(request);
-    }
-
-
-    /**
-     * 原材料出库
-     * @return
-     */
-    @RequestMapping("/mes/prodInOutOtherOut")
-    public ApiResult<String> prodInOutOtherOut(HttpServletRequest request){
-        return mesService.prodInOutOtherOut(request);
-    }
-
-    /**
-     * 生产领料
-     * @return
-     */
-    @RequestMapping("/mes/prodInOutPicking")
-    public ApiResult<String> prodInOutPicking(HttpServletRequest request){
-        return mesService.prodInOutPicking(request);
-    }
-
-    /**
-     * 生产退料
-     * @return
-     */
-    @RequestMapping("/mes/prodInOutMakeReturn")
-    public ApiResult<String> prodInOutMakeReturn(HttpServletRequest request){
-        return mesService.prodInOutMakeReturn(request);
-    }
-
-    /**
-     * 库存转移
-     * @return
-     */
-    @RequestMapping("/mes/prodInOutAppropriationOut")
-    public ApiResult<String> prodInOutAppropriationOut(HttpServletRequest request){
-        return mesService.prodInOutAppropriationOut(request);
-    }
-
-    /**
-     * 制造单发料校验
-     * @param request
-     * @return
-     */
-    @RequestMapping("/mes/makeCheckOutStock")
-    public ApiResult<String> makeCheckOutStock(HttpServletRequest request){
-        return mesService.makeCheckOutStock(request);
-    }
-    /**
-     * 制造单ECN和ECN变更校验
-     * @param request
-     * @return
-     */
-    @RequestMapping("/mes/makeECNCheck")
-    ApiResult<String> makeECNCheck(HttpServletRequest request) {
-        return mesService.makeECNCheck(request);
-    }
-}

src/main/java/com/uas/eis/controller/QueryController.java

@@ -1,39 +0,0 @@
-package com.uas.eis.controller;
-
-import java.util.HashMap;
-import java.util.Map;
-
-import com.uas.eis.sdk.entity.ApiResult;
-import com.uas.eis.sdk.resp.ApiResponse;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RestController;
-
-import com.uas.eis.service.QueryService;
-
-import javax.servlet.http.HttpServletRequest;
-
-@RestController
-public class QueryController {
-
-	@Autowired
-	private QueryService queryService;
-	
-	@RequestMapping("/api/query")
-	public Object query(String code, String param){
-		Map<String, Object> map = new HashMap<String, Object>();
-		return queryService.query(code, param);
-	}
-	
-	@RequestMapping("/api/doAction")
-	public Object doAction(String code, String param){
-		Map<String, Object> map = new HashMap<String, Object>();
-		return queryService.doAction(code, param);
-	}
-
-	@RequestMapping("/api/queryProduct")
-	public ApiResult<String> queryProduct(HttpServletRequest request, String data){
-		return ApiResponse.successRsp("0",request.getHeader("RequestId"),queryService.queryProduct(data));
-	}
-	
-}

src/main/java/com/uas/eis/core/WebAppConfig.java

@@ -3,7 +3,6 @@ package com.uas.eis.core;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.uas.eis.core.support.ApiSignLoginInterceptor;
 import com.uas.eis.core.support.DataSourceInterceptor;
-import com.uas.eis.core.support.LoginInterceptor;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.http.converter.HttpMessageConverter;
@@ -20,11 +19,6 @@ import java.util.List;
 @Configuration
 public class WebAppConfig extends WebMvcConfigurationSupport{
 
-	@Bean
-	public LoginInterceptor loginInterceptor(){
-		return new LoginInterceptor();
-	}
-
 	@Bean
 	public ApiSignLoginInterceptor apiSignLoginInterceptor(){
 		return new ApiSignLoginInterceptor();
@@ -34,7 +28,6 @@ public class WebAppConfig extends WebMvcConfigurationSupport{
 	public void addInterceptors(InterceptorRegistry registry){
 		registry.addInterceptor(apiSignLoginInterceptor()).addPathPatterns("/api/**","/mes/**")
 				.excludePathPatterns("/login", "/erp/**");
-		//registry.addInterceptor(loginInterceptor()).addPathPatterns("/**").excludePathPatterns("/EIS/login");
 		registry.addInterceptor(new DataSourceInterceptor()).addPathPatterns("/*/**");
 	}
 	

src/main/java/com/uas/eis/core/enums/ElecInVoiceSpecificFactor.java

@@ -1,54 +0,0 @@
-package com.uas.eis.core.enums;
-
-/**
- * @author: WUYX
- * @date: 2023/08/02
- * @desc: 发票特定要素
- *  0-普通 1-成品油发票 3-建筑服务 4-货物运输服务 6-不动产经营租赁服务 9-旅客运输服务 16-农产品收购 31-建安发票 32-房地产销售发票 33-二手车发票反向开具 34-电子烟 35-矿产品
- */
-public enum ElecInVoiceSpecificFactor {
-    PT(0,"普通"),
-    CPYFP(1,"成品油发票"),
-    JZFW(3,"建筑服务"),
-    HWYXFU(4,"货物运输服务"),
-    BDCJYZLFW(6,"不动产经营租赁服务"),
-    LKYSFW(9,"旅客运输服务"),
-    NCPSG(16,"农产品收购"),
-    JAFP(31,"建安发票"),
-    FDCXSFP(32,"房地产销售发票"),
-    ESCFPFXKJ(33,"二手车发票反向开具"),
-    DZY(34,"电子烟"),
-    KCP(35,"矿产品")
-    ;
-    private int sid;
-    private String description;
-
-    private ElecInVoiceSpecificFactor(int sid,String description){
-        this.sid = sid;
-        this.description = description;
-    }
-
-    public int getSid() {
-        return sid;
-    }
-
-    public void setSid(int sid) {
-        this.sid = sid;
-    }
-
-    public String getDescription() {
-        return description;
-    }
-
-    public void setDescription(String description) {
-        this.description = description;
-    }
-    public static String getDescription(int sid_) {
-        for (ElecInVoiceSpecificFactor sf : values()) {
-            if (sf.getSid() == sid_) {
-                return sf.getDescription();
-            }
-        }
-        return String.valueOf(sid_);
-    }
-}

src/main/java/com/uas/eis/core/enums/ElecInVoicekind.java

@@ -1,81 +0,0 @@
-package com.uas.eis.core.enums;
-
-/**
- * @author: WUYX
- * @date: 2023/08/02
- * @desc: 发票特定要素
- *  发票种类
- *  合并冲销时为空
- *  p：普通发票（电票）
- *  c：普通发票（纸票）
- *  s：专用发票（纸票）
- *  b：专用发票（电子）
- *  e：收购发票（电票）
- *  f：收购发票（纸质）
- *  r：普通发票（卷式）
- *  bs：数电专票（电子）
- *  pc：数电普票（电子）
- *  es：数电专票（纸质）
- *  ec：数电普票（纸质）
- * 发票种类，
- * 增值税电子普通发票、增值税普通发票、专用发票(电子)、增值税专用发票、收购发票(电子)、收购发票(纸质)、增值税普通发票(卷式)、机动车销售统一发票、
- * 二手车销售统一发票、电子发票(增值税专用发票)、电子发票(普通发票)、全电纸质发票(增值税专用发票)、全电纸质发票(普通发票)；
- * 备注：电子发票(增值税专用发票)即 数电专票(电子)，电子发票(普通发票)即 数电普票(电子)
- *
- */
-public enum ElecInVoicekind {
-    P("p","普通发票（电票）","增值税普通发票"),
-    C("c","普通发票（纸票）","增值税电子普通发票"),
-    S("s","专用发票（纸票）","增值税专用发票"),
-    B("b","专用发票（电子）","专用发票(电子)"),
-    E("e","收购发票（电票）","收购发票(电子)"),
-    F("f","收购发票（纸质）","收购发票(纸质)"),
-    R("r","普通发票（卷式）","增值税普通发票(卷式)"),
-    BS("bs","数电专票（电子）","电子发票(增值税专用发票)"),
-    PC("pc","数电普票（电子）","电子发票(普通发票)"),
-    ES("es","数电专票（纸质）","全电纸质发票(增值税专用发票)"),
-    EC("ec","数电普票（纸质）","全电纸质发票(普通发票)")
-    ;
-    private String line;//EI_INVOICELINE
-    private String name;
-    private String kind;//EI_INVOICEKIND
-
-    private ElecInVoicekind(String line,String name, String kind){
-        this.line = line;
-        this.name = name;
-        this.kind = kind;
-    }
-
-    public String getLine() {
-        return line;
-    }
-
-    public void setLine(String line) {
-        this.line = line;
-    }
-
-    public String getName() {
-        return name;
-    }
-
-    public void setName(String name) {
-        this.name = name;
-    }
-
-    public String getKind() {
-        return kind;
-    }
-
-    public void setKind(String kind) {
-        this.kind = kind;
-    }
-
-    public static String getKind(String line) {
-        for (ElecInVoicekind sf : values()) {
-            if (sf.getLine() == line) {
-                return sf.getKind();
-            }
-        }
-        return String.valueOf(line);
-    }
-}

src/main/java/com/uas/eis/core/enums/KingdeeFormId.java

@@ -1,23 +0,0 @@
-package com.uas.eis.core.enums;
-
-/**
- * @author: zhouy
- * @date: 2021/9/26 15:14
- * @desc: 金蝶业务类型
- */
-public enum KingdeeFormId {
-
-    SALOUTSTOCK("SAL_OUTSTOCK"), //销售出库单
-    PRDPICKMTRL("PRD_PickMtrl"), //生产领料单
-    SUBPICKMTRL("SUB_PickMtrl")//委外领料单
-    ;
-    private String formId;
-    private KingdeeFormId(String formId){
-        this.formId = formId;
-    }
-
-    public String getFormId(){
-        return formId;
-    }
-
-}

src/main/java/com/uas/eis/core/support/LoginInterceptor.java

@@ -1,85 +0,0 @@
-package com.uas.eis.core.support;
-
-import java.util.Date;
-
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
-
-import com.uas.eis.entity.ErrorMsg;
-import com.uas.eis.exception.SystemException;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.web.servlet.HandlerInterceptor;
-import org.springframework.web.servlet.ModelAndView;
-
-import com.uas.eis.service.QueryService;
-import io.jsonwebtoken.Claims;
-
-public class LoginInterceptor implements HandlerInterceptor{
-
-	@Autowired
-	private QueryService userService;
-	
-	public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
-		String token = request.getParameter("token");
-		Claims claims = parseToken(token); // 验证并解析token
-		String username = (String) claims.get("username");
-		String password = (String) claims.get("password");
-		checkUser(username, password); // 验证用户是否合法
-		String actionUrl = request.getRequestURI();
-		checkActionAccess(username, actionUrl); // 验证请求权限
-		return true;
-	}
-	
-	public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
-			ModelAndView modelAndView) throws Exception {
-	}
-	
-	public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler,
-			Exception ex) throws Exception {
-	}
-	
-	private Claims parseToken(String token) {
-		if(token == null || token.isEmpty()) {
-			throw new SystemException(ErrorMsg.NULL_TOKEN);
-		}
-		Claims claims = TokenHandler.parseToken(token);
-		if(claims == null) {
-			throw new SystemException(ErrorMsg.INVALID_TOKEN);
-		}
-		Date now = new Date();
-		Date start = claims.getNotBefore();
-		Date end = claims.getExpiration();
-		
-		if (now.after(start) && now.before(end)) {
-			return claims;
-		}else {
-			throw new SystemException(ErrorMsg.EXPIRED_TOKEN);
-		}
-	}
-	
-	private boolean checkUser(String username, String password) {
-		boolean enable = false;
-		if(username != null && password != null) {
-			if(username.equals("uas") && password.equals("123")) {
-				enable = true;
-			}else {
-				enable = userService.checkUser(username, password);
-			}
-		}
-		if(!enable) {
-			throw new SystemException(ErrorMsg.INVALID_USER);
-		}
-		return enable;
-	}
-	
-	private boolean checkActionAccess(String username, String action) {
-		if(username.equals("uas")) {
-			return true;
-		}
-		boolean enable = userService.checkAction(username, action);
-		if(!enable) {
-			throw new SystemException(ErrorMsg.PERMISSION_DENIED_REQUEST);
-		}
-		return enable;
-	}
-}

src/main/java/com/uas/eis/dao/BaseNuoNuoQResp.java

@@ -1,9 +0,0 @@
-package com.uas.eis.dao;
-
-import lombok.Data;
-
-@Data
-public class BaseNuoNuoQResp {
-    private String code;
-    private String describe;
-}

src/main/java/com/uas/eis/dao/BaseNuoNuoResp.java

@@ -1,23 +0,0 @@
-package com.uas.eis.dao;
-
-
-public class BaseNuoNuoResp {
-    private String status;
-    private String message;
-
-    public String getStatus() {
-        return status;
-    }
-
-    public void setStatus(String status) {
-        this.status = status;
-    }
-
-    public String getMessage() {
-        return message;
-    }
-
-    public void setMessage(String message) {
-        this.message = message;
-    }
-}

src/main/java/com/uas/eis/dao/BaseResp.java

@@ -1,22 +0,0 @@
-package com.uas.eis.dao;
-
-public class BaseResp {
-    private Integer code;
-    private String message;
-
-    public Integer getCode() {
-        return code;
-    }
-
-    public void setCode(Integer code) {
-        this.code = code;
-    }
-
-    public String getMessage() {
-        return message;
-    }
-
-    public void setMessage(String message) {
-        this.message = message;
-    }
-}

src/main/java/com/uas/eis/dao/FindOrderStateData.java

@@ -1,19 +0,0 @@
-package com.uas.eis.dao;
-
-public class FindOrderStateData{
-    private String invoiceStatus;//订单状态(0:待处理 1:处理中 2:已处理 4:提交失败 6:部分待处理 7:无需开票)
-    private String errorMsg;//提交失败原因
-    public void setInvoiceStatus(String invoiceStatus) {
-        this.invoiceStatus = invoiceStatus;
-    }
-    public String getInvoiceStatus() {
-        return invoiceStatus;
-    }
-
-    public void setErrorMsg(String errorMsg) {
-        this.errorMsg = errorMsg;
-    }
-    public String getErrorMsg() {
-        return errorMsg;
-    }
-}

src/main/java/com/uas/eis/dao/FindOrderStateResp.java

@@ -1,13 +0,0 @@
-package com.uas.eis.dao;
-
-public class FindOrderStateResp extends BaseResp {
-    private FindOrderStateData data;
-
-    public FindOrderStateData getData() {
-        return data;
-    }
-
-    public void setData(FindOrderStateData data) {
-        this.data = data;
-    }
-}

src/main/java/com/uas/eis/dao/InvoiceGoodsTransportsDTO.java

@@ -1,12 +0,0 @@
-package com.uas.eis.dao;
-
-import lombok.Data;
-
-@Data
-public class InvoiceGoodsTransportsDTO {
-    String transportTool;//	运输工具种类：1 铁路运输、2 公路运输、3 水路运输、4 航空运输、5 管道运输、6 其他运输工具
-    String transportToolNum;//运输工具牌号
-    String origin;//起运地
-    String destination;//到达地
-    String goodsName;//运输货物名称
-}

src/main/java/com/uas/eis/dao/InvoiceOrderDTO.java

@@ -1,16 +0,0 @@
-package com.uas.eis.dao;
-
-import lombok.Data;
-
-import java.util.List;
-
-@Data
-public class InvoiceOrderDTO {
-    String orderType;//订单类型：1销售单，2退货单 不能为空
-    String autoInvoiceFlag;//是否自动开票（false：订单只入库； true：订单入库后自动完成开票全流程 ；只能传false或true，不传默认false）
-    String repeatCall;//订单号重复时的处理方式（0：报错 1：覆盖原订单，仅订单状态为待处理时可以覆盖；不传默认0）
-    OrderDTO orderInfo;//订单基础信息
-    List<OrderDetDTO> orderOriginalDetails;//商品列表
-    List<InvoiceGoodsTransportsDTO> invoiceGoodsTransports;//货物运输信息列表，specificFactor为4且为销售单时，以下字段必传
-
-}

src/main/java/com/uas/eis/dao/OrderDTO.java

@@ -1,48 +0,0 @@
-package com.uas.eis.dao;
-
-import lombok.Data;
-
-@Data
-public class OrderDTO {
-    String originalOrderNo;//订单编号：支持字母、数字、英文符号 不能为空
-    String addDate;//下单时间（年月日时分秒 格式yyyy-MM-dd HH:mm:ss）若无下单时间自动添加当前时间
-    String invoiceLine;//发票种类(只能传 p：普通发票（电票） c：普通发票（纸票） s：专用发票（纸票） b：专用发票（电子） e：收购发票（电票） f：收购发票（纸质） r：普通发票（卷式） bs：数电专票（电子） pc：数电普票（电子） es：数电专票（纸质） ec：数电普票（纸质）中的 一种)
-    String specificFactor;//0普通发票（默认）、1 成品油、4 货物运输、35 矿产品
-    String saleTaxNum;//销方税号（字母+数字 6-20字符），与companyCode不能同时为空
-    String saleAddress;//销方地址，不传时去开票默认取系统内开票信息中配置的
-    String salePhone;//销方电话，不传时去开票默认取系统内开票信息中配置的
-    String saleAccount;//销方开户行及账号，不传时去开票默认取系统内开票信息中配置的
-    String buyerName;//客户名称
-    String naturalPersonFlag;//购买方（客户）自然人标记，1是、0否，为空默认0，仅票种为pc时支持传入
-    String taxNum;//购方税号或个人证件号码
-    String account;//开户行及账号
-    String address;//客户地址
-    String telephone;//客户电话
-    String phone;//交付手机，退货单开专票和数电发票时，固定取原蓝票的，可不传
-    String email;//交付邮箱，退货单开专票和数电发票时，固定取原蓝票的，可不传
-    String ccPhone;//抄送手机，多个时用英文逗号隔开，最多支持5个，必须在phone字段有值时，才支持传入
-    String ccEmail;//抄送邮箱，多个时用英文逗号隔开，最多支持5个，必须在email字段有值时，才支持传入
-    String orderRemark;//订单备注
-    String remark;//发票备注，票种为数电票时为200字符
-    String relateSaleOrderNo;//原销售订单编号（退货单选填，销售单不生效）
-    String salesperson;//销售员
-    String issuanceDate;//发货日期（年月日 yyyy-MM-dd）
-    String clerk;//开票员
-    String payee;//收款人
-    String checker;//复核人
-    String callbackUrl;//回调通知地址
-    String yfpdm;//原发票代码，退货单自动开票时，原发票代码不能为空
-    String yfphm;//原发票号码，退货单自动开票时，原发票号码不能为空
-    String deptId;//订单所属部门id，传诺诺网的部门id
-    String clerkId;//订单所属票员id，传诺诺网开票员id
-    String bField1;//自定义字段1，需开通自定义字段功能
-    String bField2;//自定义字段2
-    String bField3;//自定义字段3
-    String extensionNumber;//分机号（当autoInvoiceFlag为true时根据分机号，机器编号，终端号查找开票设备）
-    String machineCode;//机器编号（当autoInvoiceFlag为true时根据分机号，机器编号，终端号查找开票设备
-    String terminalNumber;//终端号（当autoInvoiceFlag为true时根据分机号，机器编号，终端号查找开票设备
-    String companyCode;//组织编码，saleTaxNum不传时，根据该字段匹配在诺税通工作台基础模块维护的组织编码，获得对应的销方税号；二者都传时，取saleTaxNum；有值时，topSaleTaxNum必传
-    String deptCode;//部门编码，根据该字段匹配在诺税通工作台基础模块维护的部门编码，获取订单对应的所属部门；优先取deptId
-    String userCode;//用户编码，根据该字段匹配在诺税通工作台基础模块维护的用户编码，获取订单对应的所属用户；优先取userId
-    String topSaleTaxNum;//顶级公司税号，saleTaxNum不传，且companyCode有值时，必传
-}

src/main/java/com/uas/eis/dao/OrderDetDTO.java

@@ -1,27 +0,0 @@
-package com.uas.eis.dao;
-
-import lombok.Data;
-
-@Data
-public class OrderDetDTO {
-    String rowNo;//行编号（非序号，可与自身业务系统内唯一编号对应，订单内唯一）
-    String goodsName;//	商品名称 不能为空
-    String spec;//规格型号
-    String unit;//单位（当成品油标志为1时，需为升或吨）
-    String num;//数量，销售单传入正数，退货单传入负数 2、包含小数点最长不超过16位，超出自动截取。数量、单价必须都不填，或者都必填。当数量、单价都不填时，金额必填
-    String price;//单价，包含小数点最长不超过16位，超出自动截取。数量、单价必须都不填，或者都必填。当数量、单价都不填时，金额必填
-    String taxRate;//税率
-    String tax;//税额，若自行传入时，折扣zke有值，请传未扣除折扣前的税额，折扣减掉的税额系统自动根据税率计算
-    String taxAmount;//金额 1、不能为0 2、销售订单传入正数，退货单传入负数 3、当数量、单价都不填时，金额必填
-    String hsbz;//含税标志：(0：否，1：是) 不能为空
-    String spbm;//税收分类编码（没传，会根据商品名称和规格型号，去商品库匹配，若商品库未匹配成功，则会去税收分类编码表匹配）
-    String yhzcbs;//是否享受优惠政策：(0：否，1：是)
-    String zzstsgl;//优惠政策类型，当是否享受优惠政策为是时，优惠政策类型必填
-    String zke;//折扣金额（当该商品开折扣发票时传入；退货单时传入负数，且会用金额-折扣，跟税率重算税额后入库，建议退货单时不传，自行减掉折扣后传入）
-    String lslbs;//零税率标识1-免税 ,2-不征税, 3-其他优惠政策（普通0税率）； 1、当税率为：0%，且增值税特殊管理：为“免税”， 零税率标识：需传“1” 2、当税率为：0%，且增值税特殊管理：为"不征税" 零税率标识：需传“2” 3、当税率为：0%，且增值税特殊管理：为空 零税率标识：需传“3”
-    String dField1;//商品明细自定义字段1
-    String dField2;//商品明细自定义字段2
-    String dField3;//商品明细自定义字段3
-    String dField4;//商品明细自定义字段4
-    String dField5;//商品明细自定义字段5
-}

src/main/java/com/uas/eis/dao/RedInvoiceReq.java

@@ -1,30 +0,0 @@
-package com.uas.eis.dao;
-
-import lombok.Data;
-
-@Data
-public class RedInvoiceReq {
-    String billId;//非必填	32	红字确认单申请号，需要保持唯一，不传的话系统自动生成一个
-    String blueInvoiceLine;//必填	pc	2	对应蓝票发票种类: bs:电子发票(增值税专用发票)， pc:电子发票(普通发票)，es:全电纸质发票(增值税专用发票)， ec:全电纸质发票(普通发票)，p:普通发票（电票），c:普通发票（纸票），s:专用发票，b:增值税电子专用发票
-    String applySource;//必填	0	2	申请方（录入方）身份： 0 销方 1 购方
-    String blueInvoiceNumber;//非必填	20230508287375668802	20	对应蓝字发票号码（蓝票是增值税发票时必传，长度为8位数字，若传20位数字则视为是蓝字数电票号码）
-    String blueInvoiceCode;//非必填	 12	对应蓝字发票代码（蓝票是增值税发票时必传）
-    String blueElecInvoiceNumber;//非必填	 20	对应蓝字数电票号码（数电普票、数电专票、数纸普票、数纸专票都需要传，蓝票是增值税发票时不传）
-    String billTime;//非必填 	填开时间（时间戳格式），默认为当前时间
-    String sellerTaxNo;//必填	91440101MA5APD8X8J	20	销方税号
-    String sellerName;//必填	广东航天信息爱信诺科技有限公司	100	销方名称，申请说明为销方申请时可为空
-    String departmentId;//非必填		-	32	部门门店id（诺诺网系统中的id）
-    String clerkId;//非必填		-	32	开票员id（诺诺网系统中的id）
-    String buyerTaxNo;//非必填	91330106MA2AYNWD8M	20	购方税号
-    String buyerName;//	必填	浙江诺诺网络科技有限公司	100	购方名称
-    String vatUsage;//非必填		-	2	蓝字发票增值税用途（预留字段可为空）: 1 勾选抵扣 2 出口退税 3 代办出口退税 4 不抵扣
-    String saleTaxUsage;//非必填		-	2	蓝字发票消费税用途（预留字段可为空）
-    String accountStatus;//非必填	-	2	发票入账状态（预留字段可为空）： 0 未入账 1 已入账
-    String redReason;//必填	2	冲红原因： 1销货退回 2开票有误 3服务中止 4销售折让
-    String extensionNumber;//非必填	9998	5	分机号
-    String autoInvoice;//非必填	0	2	是否自动开票，0否（不传默认0）1是；传1时，所申请的确认单变为购销双方已确认或无需确认状态时，而自动开具红票。目前该字段不生效，电票都自动开，纸票都不自动
-    String orderNo;//非必填20	若有值，则在无需确认或购销双方已确认后去自动开红票，发票的开票单号用该值
-    String phone;//非必填	20	交付手机，红票优先取该值，不传默认取原蓝票
-    String email;//非必填50	交付邮箱，红票优先取该值，不传默认取原蓝票
-    String callbackUrl;//非必填225	确认单回传地址，回调内容可联系服务人员；自动开票时，会透传到开票接口
-}

src/main/java/com/uas/eis/dao/RoleDao.java

@@ -1,37 +0,0 @@
-package com.uas.eis.dao;
-
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.jdbc.core.support.JdbcDaoSupport;
-import org.springframework.stereotype.Component;
-
-import com.uas.eis.core.support.TokenHandler;
-
-public class RoleDao extends JdbcDaoSupport{
-	
-	@Autowired
-	private BaseDao baseDao;
-	
-	public String login(String username, String password) {
-		return TokenHandler.createToken(username, password);
-	}
-	
-	public boolean getEnable(String username) {
-		int enable = baseDao.queryForObject("select er_enable from EIS_ROLE where er_name = '" + username + "'", Integer.class);
-		return enable == -1;
-	}
-	
-	public boolean checkActionAccess(String username, String action) {
-		String role = baseDao.queryForObject("select eu_role from EIS_USER; where eu_name = '" + username + "'", String.class);
-		String roles = baseDao.queryForObject("select ei_roles from EIS_INTERFACE where ei_path = '" + action + "'", String.class);
-		String[] allRoles = roles.split(",");
-		boolean flag = false;
-		
-		for(String r: allRoles){
-	        if(r.equals(role)) {
-	        	flag = true;
-	        	break;
-	        }
-	    }
-		return flag;
-	}
-}

src/main/java/com/uas/eis/dto/FindOrderRelationInvoiceDTO.java

@@ -1,124 +0,0 @@
-package com.uas.eis.dto;
-
-import com.uas.eis.utils.NumberUtil;
-import com.uas.eis.utils.StringUtil;
-import lombok.Data;
-
-import java.util.ArrayList;
-import java.util.List;
-
-@Data
-public class FindOrderRelationInvoiceDTO extends QSqlDTO{
-    private String sid;//发票流水号，返回合并冲销的开票单为空
-    private String orderNo;//开票单号
-    private String createtime;//开票单的创建时间
-    private Number invoiceType;//发票类型，合并冲销时为空；1：蓝票 2：红票
-    private String invoiceLine;//发票种类，合并冲销时为空 p：普通发票（电票） c：普通发票（纸票） s：专用发票（纸票） b：专用发票（电子） e：收购发票（电票） f：收购发票（纸质） r：普通发票（卷式） bs：数电专票（电子） pc：数电普票（电子） es：数电专票（纸质） ec：数电普票（纸质）
-    private String specificFactor;//1 成品油、35 矿产品；普通发票为空
-    private Number invoiceState;//开票状态，合并冲销时为空 1：开票成功 2：开票失败
-    private String exceptionMessage;//开票异常信息，开票失败状态时返回
-    private String invoiceCode;//发票代码，仅开票成功会返回，发票种类为bs和pc时为空
-    private String invoiceNumber;//发票号码，仅开票成功会返回，发票种类为bs和pc时为空
-    private String allElectronicInvoiceNumber;//数电发票号码，仅数电发票开票成功会返回
-    private String oldInvoiceCode;//原发票代码（红字发票开票成功后若有值回传），发票种类为bs和pc时为空
-    private String oldInvoiceNumber;//原发票号码（红字发票开票成功后若有值回传），发票种类为bs和pc时为空
-    private String oldAllElectronicInvoiceNu;//原数电发票号码（数电发票开票成功后若有值回传）
-    private String invoiceTime;//开票日期，仅开票成功会返回
-    private String invalidTime;//作废日期，暂时未用到
-    private String rushRedState;//发票冲红状态（0 未冲红，1 全部冲红，2 部分冲红)
-    private String pdfUrl;//发票pdf地址，仅开票成功时返回
-    private String ofdUrl;//发票ofd地址，仅开票成功时返回
-    private String imageUrl;//发票jpg地址，仅开票成功时返回
-    private Number calcExcludingTaxAmount;//不含税金额，开票失败时不返回，含税金额和不含税金额任一数值返回为0，即为合并冲销
-    private Number calcTaxAmount;//税额，开票失败时不返回
-    private Number caleOrderAmount;//含税金额，开票失败时不返回，含税金额和不含税金额任一数值返回为0，即为合并冲销
-    private String sellerTaxNo;//销方税号
-    private String sellerName;//销方名称，仅开票成功会返回
-    private String taxNo;//购方税号，仅开票成功会返回
-    private String buyerName;//购方名称，仅开票成功会返回
-    private String remark;//发票备注
-    private String clerker;//开票员
-    private String payee;//收款人
-    private String checker;//复核人
-    private String clerkId;//所属开票员id
-    private String deptId;//所属部门id
-    private String bField1;//主表自定义字段1
-    private String bField2;//主表自定义字段2
-    private String bField3;//主表自定义字段3
-    private List<OrderDetailCallBackVOSDTO> orderDetailCallBackVOS;//发票来源的订单明细list
-    private List<RelateRedInvoiceDTO> relateRedInvoiceList;//发票来源的订单明细list
-
-    public List<String> toMergeSql(int ioid,int detno){
-        List<String> sqls = new ArrayList<>();
-        String sql = "merge into (" +
-                "    select ei_id,ei_indate,ei_updatedate,ei_detno,ei_ioid,ei_iocode,ei_biid,ei_bicode " +
-                "        ,ei_refno,ei_sid,ei_orderno,ei_createtime,ei_invoicetype,ei_invoiceline,ei_specificfactor,ei_invoicestate,ei_exceptionmessage,ei_invoicecode,ei_invoicenumber " +
-                "        ,ei_allelectronicinvoicenumber,ei_oldinvoicecode,ei_oldinvoicenumber,ei_oldallelectronicinvoicenu,ei_invoicetime,ei_invalidtime,ei_rushredstate,ei_pdfurl,ei_ofdurl " +
-                "        ,ei_imageurl,ei_calcexcludingtaxamount,ei_calctaxamount,ei_caleorderamount,ei_sellertaxno,ei_sellername,ei_taxno,ei_buyername,ei_remark,ei_clerker " +
-                "        ,ei_payee,ei_checker,ei_bfield1,ei_bfield2,ei_bfield3,ei_pdfattach " +
-                "    from elecinvoice where ei_ioid = " +ioid+
-                " ) a USING ( " +
-                "    select io_id,io_code,io_biid,io_bicode, "+detno+" eiDetno " +
-                "        ,"+getRefno()+" eiRefno,"+stringField(getSid())+" eiSid,"+stringField(getOrderNo())+" eiOrderno,"+timeField(getCreatetime())+" eiCreatetime,"+numberField(getInvoiceType())+" eiInvoicetype,"+stringField(getInvoiceLine())+" eiinvoiceline,"+stringField(getSpecificFactor())+" eiSpecificfactor,"+numberField(getInvoiceState())+" eiInvoicestate" +
-                "        ,"+stringField(getExceptionMessage())+" eiExceptionmessage,"+stringField(getInvoiceCode())+" eiInvoicecode,"+stringField(getInvoiceNumber())+" eiInvoicenumber " +
-                "        ,"+stringField(getAllElectronicInvoiceNumber())+" eiAllelectronicinvoicenumber,"+stringField(getOldInvoiceCode())+" eiOldinvoicecode,"+stringField(getOldInvoiceNumber())+" eiOldinvoicenumber,"+stringField(getOldAllElectronicInvoiceNu())+" eiOldallelectronicinvoicenu " +
-                "        ,"+timeField(getInvoiceTime())+" eiInvoicetime,"+timeField(getInvalidTime())+" eiInvalidtime,"+(getRushRedState())+" eiRushredstate " +
-                "        ,"+stringField(getPdfUrl())+" eiPdfurl,"+stringField(getOfdUrl())+" eiOfdurl,"+stringField(getImageUrl())+" eiImageurl,"+numberField(getCalcExcludingTaxAmount())+" eiCalcexcludingtaxamount,"+numberField(getCalcTaxAmount())+" eiCalctaxamount,"+numberField(getCaleOrderAmount())+" eiCaleorderamount" +
-                "        ,"+stringField(getSellerTaxNo())+" eiSellertaxno,"+stringField(getSellerName())+" eiSellername,"+stringField(getTaxNo())+" eiTaxno " +
-                "        ,"+stringField(getBuyerName())+" eiBuyername,"+stringField(getRemark())+" eiRemark,"+stringField(getClerker())+" eiClerker,"+stringField(getPayee())+" eiPayee,"+stringField(getChecker())+" eiChecker" +
-                "        ,"+stringField(getBField1())+" eiBfield1,"+stringField(getBField2())+" eiBfield2,"+stringField(getBField3())+" eiBfield3 " +
-                "    from dual,(select io_id,io_code,io_biid,io_bicode from invoiceorder where io_id = "+ioid+") " +
-                ") b on (nvl(a.ei_orderno,' ') = b.eiorderno) " +
-                "when matched then update set ei_updatedate=sysdate " +
-                "    ,ei_detno = eidetno,ei_refno = eiRefno,ei_sid = eisid,ei_createtime = eicreatetime,ei_invoicetype = eiinvoicetype,ei_invoiceline = eiinvoiceline,ei_specificfactor = eispecificfactor " +
-                "    ,ei_invoicestate = eiinvoicestate,ei_exceptionmessage = eiexceptionmessage,ei_invoicecode = eiinvoicecode,ei_invoicenumber = eiinvoicenumber " +
-                "    ,ei_allelectronicinvoicenumber = eiallelectronicinvoicenumber,ei_oldinvoicecode = eioldinvoicecode,ei_oldinvoicenumber = eioldinvoicenumber,ei_oldallelectronicinvoicenu = eioldallelectronicinvoicenu " +
-                "    ,ei_invoicetime = eiinvoicetime,ei_invalidtime = eiinvalidtime,ei_rushredstate = eirushredstate " +
-                "    ,ei_pdfurl = eipdfurl,ei_ofdurl = eiofdurl,ei_imageurl = eiimageurl,ei_calcexcludingtaxamount = eicalcexcludingtaxamount,ei_calctaxamount = eicalctaxamount,ei_caleorderamount = eicaleorderamount " +
-                "    ,ei_sellertaxno = eisellertaxno,ei_sellername = eisellername,ei_taxno = eitaxno " +
-                "    ,ei_buyername = eibuyername,ei_remark = eiremark,ei_clerker = eiclerker,ei_payee = eipayee,ei_checker = eichecker,ei_bfield1 = eibfield1,ei_bfield2 = eibfield2,ei_bfield3 = eibfield3" +
-                "    ,ei_pdfattach=null " +//抓取后重新抓取附件
-                "when NOT MATCHED THEN insert (ei_id,ei_indate,ei_detno,ei_ioid,ei_iocode,ei_biid,ei_bicode " +
-                "    ,ei_refno,ei_sid,ei_orderno,ei_createtime,ei_invoicetype,ei_invoiceline,ei_specificfactor,ei_invoicestate,ei_exceptionmessage,ei_invoicecode,ei_invoicenumber " +
-                "    ,ei_allelectronicinvoicenumber,ei_oldinvoicecode,ei_oldinvoicenumber,ei_oldallelectronicinvoicenu,ei_invoicetime,ei_invalidtime,ei_rushredstate,ei_pdfurl,ei_ofdurl " +
-                "    ,ei_imageurl,ei_calcexcludingtaxamount,ei_calctaxamount,ei_caleorderamount,ei_sellertaxno,ei_sellername,ei_taxno,ei_buyername,ei_remark,ei_clerker " +
-                "    ,ei_payee,ei_checker,ei_bfield1,ei_bfield2,ei_bfield3) " +
-                "values(elecinvoice_seq.nextval,sysdate,eidetno,io_id,io_code,io_biid,io_bicode " +
-                "    ,eiRefno,eisid,eiorderno,eicreatetime,eiinvoicetype,eiinvoiceline,eispecificfactor,eiinvoicestate,eiexceptionmessage,eiinvoicecode,eiinvoicenumber " +
-                "    ,eiallelectronicinvoicenumber,eioldinvoicecode,eioldinvoicenumber,eioldallelectronicinvoicenu,eiinvoicetime,eiinvalidtime,eirushredstate,eipdfurl,eiofdurl " +
-                "    ,eiimageurl,eicalcexcludingtaxamount,eicalctaxamount,eicaleorderamount,eisellertaxno,eisellername,eitaxno,eibuyername,eiremark,eiclerker " +
-                "    ,eipayee,eichecker,eibfield1,eibfield2,eibfield3)";
-        sqls.add(sql);
-        if(relateRedInvoiceList !=null && relateRedInvoiceList.size()>0){//红冲数据更新
-            StringBuffer orderNos = new StringBuffer(); //红票开票单号 //  EI_redORDERNO
-            StringBuffer sids = new StringBuffer(); //红票流水号 EI_redSID
-            StringBuffer refnoS = new StringBuffer(); // 红字发票号 EI_RELATIVEREFNO
-            Double excludingTaxAmount = 0.0;//红票不含税金额 EI_TAXEXCLUDEDAMOUNT
-            Double taxAmount = 0.0;//红票税额  EI_TAXAMOUNT
-            // rushRedState 1 全冲  EI_RELATIVEREFNO	VARCHAR2(50 BYTE)	Yes		46	红字发票号
-            for (RelateRedInvoiceDTO rroDto : relateRedInvoiceList) {
-                orderNos.append(rroDto.getOrderNo()).append(",");
-                sids.append(rroDto.getSid()).append(",");
-                refnoS.append(StringUtil.nvl(rroDto.getAllElectronicInvoiceNumber(),rroDto.getInvoiceNumber())).append(",");
-                excludingTaxAmount = NumberUtil.add(excludingTaxAmount,rroDto.getExcludingTaxAmount());
-                taxAmount = NumberUtil.add(taxAmount,rroDto.getTaxAmount());
-            }
-            if(orderNos.length()>0){
-                sql = "update elecinvoice set " +
-                        "ei_redorderno='"+orderNos.substring(0,orderNos.length()-1)+"', " +
-                        "EI_redSID='"+sids.substring(0,sids.length()-1)+"', " +
-                        "ei_relativerefno='"+refnoS.substring(0,refnoS.length()-1)+"', " +
-                        "EI_TAXEXCLUDEDAMOUNT='"+excludingTaxAmount+"', " +
-                        "EI_TAXAMOUNT='"+taxAmount+"' " +
-                        ",ei_redpdfurl=null,ei_redpdfattach=null " +//抓取后重新抓取附件
-                        "where ei_ioid = "+ioid+" and ei_refno = "+getRefno();
-                sqls.add(sql);
-            }
-        }
-        return sqls;
-    }
-    private String getRefno(){
-        //ei_refno = (case when ei_invoiceLine in ('bs','pc','es','ec') then ei_allElectronicInvoiceNumber else ei_invoiceNumber end)
-        return stringField(StringUtil.nvl(getAllElectronicInvoiceNumber(),getInvoiceNumber()));
-    }
-}

src/main/java/com/uas/eis/dto/FindOrderRelationInvoiceReq.java

@@ -1,15 +0,0 @@
-package com.uas.eis.dto;
-
-import com.uas.eis.dao.InvoiceGoodsTransportsDTO;
-import com.uas.eis.dao.OrderDTO;
-import com.uas.eis.dao.OrderDetDTO;
-import lombok.Data;
-
-import java.util.List;
-
-@Data
-public class FindOrderRelationInvoiceReq {
-    String originalOrderNo;//订单编号
-    String saleTaxNum;//销方税号
-    String needInvoiceSourceDetail;//是否需要发票所来源的订单明细，1-是, 0-否(不填默认 0) 当为0时，将不回传orderDetailCallBackVOS
-}

src/main/java/com/uas/eis/dto/FindOrderRelationInvoiceResp.java

@@ -1,11 +0,0 @@
-package com.uas.eis.dto;
-
-import com.uas.eis.dao.BaseNuoNuoResp;
-import lombok.Data;
-
-import java.util.List;
-
-@Data
-public class FindOrderRelationInvoiceResp extends BaseNuoNuoResp {
-    private List<FindOrderRelationInvoiceDTO> data;
-}

src/main/java/com/uas/eis/dto/OrderDetailCallBackVOSDTO.java

@@ -1,24 +0,0 @@
-package com.uas.eis.dto;
-
-import lombok.Data;
-
-@Data
-public class OrderDetailCallBackVOSDTO {
-    private String RowNo;//行编号
-    private String goodsName;//商品名称
-    private String spbm;//商品税收分类编码
-    private String spec;//规格型号
-    private Number num;//本次开票所提交的数量
-    private Number price;//单价，读取含税标志
-    private String unit;//单位
-    private Number taxAmount;//本次开票所提交的金额，读取含税标志
-    private String hsbz;//含税标志 0：不含税 1：含税
-    private String tax;//本次开票所提交的税额
-    private Number zke;//本次开票所提交的折扣额，读取含税标志
-    private Number taxRate;//税率
-    private String dField1;//自定义字段1
-    private String dField2;//自定义字段2
-    private String dField3;//自定义字段3
-    private String dField4;//自定义字段4
-    private String dField5;//自定义字段5
-}

src/main/java/com/uas/eis/dto/QSqlDTO.java

@@ -1,13 +0,0 @@
-package com.uas.eis.dto;
-
-public class QSqlDTO {
-    public String numberField(Object v){
-        return (v == null ? "null" : v.toString());
-    }
-    public String stringField(String v){
-        return ((v == null || "".equals(v) || "NULL".equals(v.toUpperCase())) ? "null" : "'"+v+"'");
-    }
-    public String timeField(String v){
-        return (v == null ? "null" : "(to_date('1970-01-0100:00:00','yyyy-mm-dd hh24:mi:ss') + "+v+"/1000/24/60/60)");
-    }
-}

src/main/java/com/uas/eis/dto/QueryInvoiceRedConfirmDTO.java

@@ -1,33 +0,0 @@
-package com.uas.eis.dto;
-
-import lombok.Data;
-
-import java.util.List;
-
-@Data
-public class QueryInvoiceRedConfirmDTO{
-    private String billNo;//描述：红字确认单编号 示例值：1403011906000990
-    private String billUuid;//描述：红字确认单uuid 示例值：1d7f08b6ddb64cb19b095b0360f074d7
-    private String billId;//描述：红字确认单申请号 示例值：1119316085226510000
-    private String billStatus;//描述：红字确认单状态： 01 无需确认 02 销方录入待购方确认 03 购方录入待销方确认 04 购销双方已确认 05 作废（销方录入购方否认） 06 作废（购方录入销方否认） 07 作废（超72小时未确认） 08 作废（发起方已撤销） 09 作废（确认后撤销） 15 申请中 16 申请失败 示例值：1
-    private String billMessage;//描述：描述 示例值：
-    private String invoiceSerialNum;//描述：红票流水号，若红字确认单已开红票（或已自动开红票）才会返回该值 示例值：
-    private String orderNo;//描述：红票订单号（开票单号），若红字确认单已开红票（或已自动开红票）才会返回该值 示例值：
-    private String requestStatus;//描述：操作状态：（根据操作方返回对应状态，可能为空） 01 撤销中 02撤销失败 03 确认中 04 确认失败 示例值：操作状态：（根据操作方返回对应状态，可能为空） 01 撤销中 02撤销失败 03 确认中 04 确认失败
-    private String openStatus;//描述：已开具红字发票标记： 1：已开具 0：未开具 示例值：0
-    private String applySource;//描述：录入方身份： 0 销方 1 购方 示例值：0
-    private String blueInvoiceLine;//描述：蓝字发票票种： bs：电子发票(增值税专用发票)， pc：电子发票(普通发票)，es:全电纸质发票(增值税专用发票)， ec:全电纸质发票(普通发票) 示例值：bs
-    private String blueInvoiceNumber;//描述：对应蓝票号码 示例值：对应蓝票号码
-    private String blueInvoiceTime;//描述：蓝字发票开票日期 示例值：
-    private String billTime;//描述：申请日期 示例值：43916.7806481481
-    private String confirmTime;//描述：确认日期 示例值：43917.7806481481
-    private String sellerTaxNo;//描述：销方税号 示例值：150301199811285000
-    private String sellerName;//描述：销方名称 示例值：测试税号326
-    private String buyerTaxNo;//描述：购方税号 示例值：150301199811285000
-    private String buyerName;//描述：购方名称 示例值：测试税号326
-    private String taxExcludedAmount;//描述：冲红合计金额(不含税) 示例值：-0.94
-    private String taxAmount;//描述：冲红合计税额 示例值：-0.06
-    private String redReason;//描述：冲红原因： 1销货退回 2开票有误 3服务中止 4销售折让 示例值：
-    private String pdfUrl;//描述：申请表pdf地址（暂不支持） 示例值：
-    private List<QueryInvoiceRedConfirmDetDTO> detail; //红字确认单明细信息列表
-}

src/main/java/com/uas/eis/dto/QueryInvoiceRedConfirmDetDTO.java

@@ -1,21 +0,0 @@
-package com.uas.eis.dto;
-
-import lombok.Data;
-
-import java.util.List;
-
-@Data
-public class QueryInvoiceRedConfirmDetDTO {
-    private String blueDetailIndex;//描述：对应蓝票明细行序号 示例值：1
-    private String goodsName;//描述：商品名称 示例值：苹果
-    private String unit;//描述：单位 示例值：袋
-    private String specType;//描述：规格型号 示例值：规格型号
-    private String num;//描述：数量 示例值：-1
-    private String taxExcludedPrice;//描述：单价(不含税) 示例值：0.94
-    private String taxExcludedAmount;//描述：商品金额(不含税) 示例值：-0.94
-    private String taxAmount;//描述：商品税额 示例值：-0.06
-    private String taxRate;//描述：税率 示例值：0.06
-    private String goodsCode;//描述：商品编码 示例值：4020000000000000000
-    private String favouredPolicyFlag;//描述：01：简易征收 02：稀土产品 03：免税 04：不征税 05：先征后退 06：100%先征后退 07：50%先征后退 08：按3%简易征收 09：按5%简易征收 10：按5%简易征收减按1.5%计征 11：即征即退30% 12：即征即退50% 13：即征即退70% 14：即征即退100% 15：超税负3%即征即退 16：超税负8%即征即退 17：超税负12%即征即退 18：超税负6%即征即退 示例值：0
-    private String price;//描述：单价 示例值：0
-}

src/main/java/com/uas/eis/dto/QueryInvoiceRedConfirmReq.java

@@ -1,16 +0,0 @@
-package com.uas.eis.dto;
-
-import lombok.Data;
-
-@Data
-public class QueryInvoiceRedConfirmReq {
-    private String identity;//必填：是 说明：操作方身份： 0销方 1购方
-    private String billStatus;//必填：否 说明：红字确认单状态（不传则查全部状态）： 01 无需确认 02 销方录入待购方确认 03 购方录入待销方确认 04 购销双方已确认 05 作废（销方录入购方否认） 06 作废（购方录入销方否认） 07 作废（超72小时未确认） 08 作废（发起方已撤销） 09 作废（确认后撤销） 15 申请中 16 申请失败
-    private String billId;//必填：否 说明：红字确认单申请号
-    private String billNo;//必填：否 说明：红字确认单编号
-    private String billUuid;//必填：否 说明：红字确认单uuid
-    private String billTimeStart;//必填：否 说明：填开起始时间，确认单申请号/编号/uuid有值时，可为空，允许最大查询范围为90天
-    private String billTimeEnd;//必填：否 说明：填开结束时间，确认单申请号/编号/uuid有值时，可为空，允许最大查询范围为90天
-    private String pageSize;//必填：否 说明：每页数量（默认10，最大50）
-    private String pageNo;//必填：否 说明：当前页码（默认1）
-}

src/main/java/com/uas/eis/dto/QueryInvoiceRedConfirmResp.java

@@ -1,9 +0,0 @@
-package com.uas.eis.dto;
-
-import com.uas.eis.dao.BaseNuoNuoQResp;
-import lombok.Data;
-
-@Data
-public class QueryInvoiceRedConfirmResp extends BaseNuoNuoQResp {
-    private QueryInvoiceRedConfirmRespDTO result;
-}

src/main/java/com/uas/eis/dto/QueryInvoiceRedConfirmRespDTO.java

@@ -1,12 +0,0 @@
-package com.uas.eis.dto;
-
-import com.uas.eis.dao.BaseNuoNuoQResp;
-import lombok.Data;
-
-import java.util.List;
-
-@Data
-public class QueryInvoiceRedConfirmRespDTO {
-    private int total;
-    private List<QueryInvoiceRedConfirmDTO> list;
-}

src/main/java/com/uas/eis/dto/QueryInvoiceResultDTO.java

@@ -1,93 +0,0 @@
-package com.uas.eis.dto;
-
-//import com.uas.eis.core.enums.ElecISpecificFactor;
-import com.uas.eis.core.enums.ElecInVoiceSpecificFactor;
-import com.uas.eis.utils.StringUtil;
-import lombok.Data;
-
-import java.util.List;
-
-@Data
-public class QueryInvoiceResultDTO extends QSqlDTO {
-    private String serialNo;//描述：发票请求流水号 示例值：19010211130401000000
-    private String orderNo;//描述：订单编号 示例值：1001000011161
-    private String status;//描述：发票状态： 2 :开票完成（ 最终状 态），其他状态分别为: 20:开票中; 21:开票成功签章中;22:开票失败;24: 开票成功签章失败;3:发票已作废 31: 发票作废中 备注：22、24状态时，无需再查询，请确认开票失败原因以及签章失败原因； 注：请以该状态码区分发票状态 示例值：2
-    private String statusMsg;//描述：发票状态描述 示例值：开票完成（最终状态）
-    private String failCause;//描述：失败原因 示例值：
-    private String pdfUrl;//描述：发票pdf地址（若同时返回了ofdUrl与pdfUrl，则pdf文件不能做为原始凭证，请用ofd文件做为原始凭证） 示例值：https://invtest.jss.com.cn/group1/M00/0D/A4/wKjScVwsK6CAFzLgAABsVO-OKaE630.pdf
-    private String pictureUrl;//描述：发票图片地址 示例值：nnfpkf.jss.com.cn/ArQ6dFE3-9o5x4B
-    private String invoiceTime;//描述：开票时间 示例值：1546398919000
-    private String invoiceCode;//描述：发票代码（数电电票时为空，数电纸票时有值） 示例值：131880930199
-    private String invoiceNo;//描述：发票号码（数电电票时返回原来的20位数电票号码，数电纸票时为8位的纸票号码） 示例值：19902643
-    private String allElectronicInvoiceNumber;//描述：allElectronicInvoiceNumber 数电票号码（数电电票、数电纸票时均返回20位数电票号码） 示例值：22310000000000000000
-    private String exTaxAmount;//描述：不含税金额 示例值：0.38
-    private String taxAmount;//描述：合计税额 示例值：0.02
-    private String orderAmount;//描述：价税合计 示例值：0.4
-    private String payerName;//描述：购方名称（付款方名称） 示例值：个人2
-    private String payerTaxNo;//描述：购方税号（付款方税号） 示例值：110101TRDX8RQU1
-    private String address;//描述：购方地址 示例值：杭州西湖区
-    private String telephone;//描述：购方电话 示例值：13000000000
-    private String bankAccount;//描述：购方开户行及账号 示例值：中国工商银行000001
-    private String invoiceKind;//描述：发票种类，包含：增值税电子普通发票、增值税普通发票、专用发票(电子)、增值税专用发票、收购发票(电子)、收购发票(纸质)、增值税普通发票(卷式)、机动车销售统一发票、二手车销售统一发票、电子发票(增值税专用发票)、电子发票(普通发票)、全电纸质发票(增值税专用发票)、全电纸质发票(普通发票)； 备注：电子发票(增值税专用发票)即 数电专票(电子)，电子发票(普通发票)即 数电普票(电子) 示例值：增值税电子普通发票
-    private String checkCode;//描述：校验码（数电票时为空） 示例值：7.29697198825231E+19
-    private String qrCode;//描述：二维码 示例值：
-    private String machineCode;//描述：税控设备号（机器编码）；数电票时为空 示例值：
-    private String cipherText;//描述：发票密文（数电票时为空） 示例值：
-    private String paperPdfUrl;//描述：含底图纸票pdf地址 示例值：http://invtest.nntest.cn/group1/M00/01/8B/wKjScV6-P0aAKKPHAAH965KBApQ812.pdf
-    private String ofdUrl;//描述：发票ofd地址（公共服务平台签章及数电电票时返回） 示例值：
-    private String xmlUrl;//描述：发票xml地址（数电电票且企业配置成支持获取xml时返回） 示例值：
-    private String clerk;//描述：开票员 示例值：张三
-    private String payee;//描述：收款人 示例值：李四
-    private String checker;//描述：复核人 示例值：王五
-    private String salerAccount;//描述：销方银行账号 示例值：2000098287777
-    private String salerTel;//描述：销方电话 示例值：0937-9384
-    private String salerAddress;//描述：销方地址 示例值：杭州西湖
-    private String salerTaxNum;//描述：销方税号 示例值：150301199811285000
-    private String saleName;//描述：销方名称 示例值：浙江诺诺网
-    private String remark;//描述：备注 示例值：备注mlk
-    private String productOilFlag;//描述：成品油标志：0非成品油，1成品油 示例值：0
-    private String imgUrls;//描述：图片地址（多个图片以逗号隔开） 示例值：http://invtest.nntest.cn/group1/M00/01/8B/wKjScV6-P0WAHjKkAAC17-oX9RE037.jpg
-    private String extensionNumber;//描述：分机号 示例值：1
-    private String terminalNumber;//描述：终端号 示例值：
-    private String deptId;//描述：部门门店id（诺诺系统中的id） 示例值：1
-    private String clerkId;//描述：开票员id（诺诺系统中的id） 示例值：1
-    private String oldInvoiceCode;//描述：对应蓝票发票代码，红票时有值（蓝票为数电电票时为空，数电纸票时有值） 示例值：
-    private String oldInvoiceNo;//描述：对应蓝票发票号码，红票时有值（蓝票为数电电票时返回原来的20位数电票号码，数电纸票时为8位的纸票号码） 示例值：
-    private String oldEleInvoiceNumber;//描述：对应蓝票数电票号码，红票时有值（蓝票为数电票（电子+纸质）时 20位） 示例值：
-    private String listFlag;//描述：清单标志:0,非清单;1,清单票 示例值：0
-    private String listName;//描述：清单项目名称:打印清单时对应发票票面项目名称，注意：税总要求清单项目名称为（详见销货清单） 示例值：
-    private String phone;//描述：购方手机(开票成功会短信提醒购方) 示例值：
-    private String notifyEmail;//描述：购方邮箱推送邮箱(开票成功会邮件提醒购方) 示例值：
-    private String vehicleFlag;//描述：是否机动车类专票 0-否 1-是 示例值：0
-    private String createTime;//描述：数据创建时间（回传其他信息时返回） 示例值：
-    private String updateTime;//描述：数据更新时间（回传其他信息时返回） 示例值：
-    private String stateUpdateTime;//描述：发票状态更新时间（回传其他信息时返回；涉及状态：开票中、开票失败、开票成功签章中、开票成功签章失败、开票完成、发票作废中、发票已作废） 示例值：
-    private String proxyInvoiceFlag;//描述：代开标志 0-非代开 1-代开（回传其他信息时返回） 示例值：
-    private String invoiceDate;//描述：用于开票的订单的时间（回传其他信息时返回） 示例值：
-    private String invoiceType;//描述：开票类型 1-蓝票 2-红票（回传其他信息时返回） 示例值：1
-    private String redReason;//描述：冲红原因 1:销货退回;2:开票有误;3:服务中止;4:发生销售折让（红票且票种为p、c、e、f、r（成品油发票除外）且回传其他信息时返回） 示例值：1
-    private String invalidTime;//描述：作废时间（已作废状态下的发票，且回传其他信息时返回） 示例值：1625475746
-    private String invalidSource;//描述：作废来源 1-诺诺工作台 2-API接口 3-开票软件 4-验签失败作废 5-其他（已作废状态下的发票，且回传其他信息时返回） 示例值：1
-    private String invalidReason;//描述：数电纸票作废原因 1:销货退回;2:开票有误;3:服务中止;4:其他（已作废状态下的发票，且票为数电纸票且回传其他信息时返回） 示例值：
-    private String specificReason;//描述：其他作废原因详情（作废原因为4 且回传其他信息时返回） 示例值：
-    private Integer specificFactor;//描述：发票特定要素：（后续枚举值会有扩展，回传其他信息时返回）0-普通 1-成品油发票 3-建筑服务 4-货物运输服务 6-不动产经营租赁服务 9-旅客运输服务 16-农产品收购 31-建安发票 32-房地产销售发票 33-二手车发票反向开具 34-电子烟 35-矿产品 示例值：0
-    private String emailNotifyStatus;//描述：邮箱交付状态（0-未交付，1-交付成功，2-交付失败，3-交付中，4-不会交付；注：回传其他信息时返回） 示例值：
-    private String phoneNotifyStatus;//描述：手机交付状态（0-未交付，1-交付成功，2-交付失败，3-交付中，4-不会交付；注：回传其他信息时返回） 示例值：
-    private String buyerManagerName;//描述：购买方经办人姓名（数电票特有字段） 示例值：张三
-    private String managerCardType;//描述：经办人证件类型：101-组织机构代码证, 102-营业执照, 103-税务登记证, 199-其他单位证件, 201-居民身份证, 202-军官证, 203-武警警官证, 204-士兵证, 205-军队离退休干部证, 206-残疾人证, 207-残疾军人证（1-8级）, 208-外国护照, 210-港澳居民来往内地通行证, 212-中华人民共和国往来港澳通行证, 213-台湾居民来往大陆通行证, 214-大陆居民往来台湾通行证, 215-外国人居留证, 216-外交官证 299-其他个人证件(数电票特有) 示例值：201
-    private String managerCardNo;//描述：经办人证件号码（数电票特有字段） 示例值：
-    private String bField1;//描述：业务方自定义字段1 示例值：
-    private String bField2;//描述：业务方自定义字段2 示例值：
-    private String bField3;//描述：业务方自定义字段3 示例值：
-    private String naturalPersonFlag;//描述：购买方自然人标志：0-否，1-是（数电普票（电子）时才有可能返回，为1时，版式文件上在购方名称最后面会额外显示 （个人） ） 示例值：
-    public String updatePdfUrlSql(){//更新 红票PDFURL附件
-        String sql = "";
-        if(StringUtil.hasText(serialNo)){
-            sql= "update ElecInvoice set EI_REDPDFURL = "+stringField(pdfUrl)+ " where ei_allelectronicinvoicenumber = "+getBlueRefno()+" and ei_relativerefno = "+stringField(allElectronicInvoiceNumber);
-        }
-        return sql;
-    }
-    private String getBlueRefno(){
-        return stringField(StringUtil.nvl(oldEleInvoiceNumber,oldInvoiceNo));
-    }
-}

src/main/java/com/uas/eis/dto/QueryInvoiceResultReq.java

@@ -1,12 +0,0 @@
-package com.uas.eis.dto;
-
-import lombok.Data;
-
-import java.util.List;
-
-@Data
-public class QueryInvoiceResultReq {
-    private List<String> serialNos; //发票流水号，两字段二选一，同时存在以流水号为准（最多查50个订单号）
-    private List<String> orderNos;//订单编号（最多查50个订单号）
-    private String isOfferInvoiceDetail;//是否需要提供明细 1-是, 0-否(不填默认 0)
-}

src/main/java/com/uas/eis/dto/QueryInvoiceResultResp.java

@@ -1,11 +0,0 @@
-package com.uas.eis.dto;
-
-import com.uas.eis.dao.BaseNuoNuoQResp;
-import lombok.Data;
-
-import java.util.List;
-
-@Data
-public class QueryInvoiceResultResp extends BaseNuoNuoQResp {
-    private List<QueryInvoiceResultDTO> result;
-}

src/main/java/com/uas/eis/dto/RelateRedInvoiceDTO.java

@@ -1,16 +0,0 @@
-package com.uas.eis.dto;
-
-import lombok.Data;
-
-@Data
-public class RelateRedInvoiceDTO {
-    private String orderNo;//红票开票单号
-    private String sid;//红票流水号
-    private String invoiceCode;//红票发票代码
-    private String invoiceNumber;//红票发票号码
-    private String allElectronicInvoiceNumber;//allElectronicInvoiceNumber，红票数电票号码
-    private String invoiceTime;//红票开票日期
-    private Double orderAmount;//红票含税金额
-    private Double excludingTaxAmount;//红票不含税金额
-    private Double taxAmount;//红票税额
-}

src/main/java/com/uas/eis/entity/K3/AbstractAuditReq.java

@@ -1,30 +0,0 @@
-package com.uas.eis.entity.K3;
-
-import lombok.Data;
-
-import java.io.Serializable;
-
-/**
- * @author: zhouy
- * @date: 2021/9/26 11:19
- * @desc: 审核请求对象
- */
-@Data
-public abstract class AbstractAuditReq<T> implements Serializable {
-    /**
-     * CreateOrgId：创建者组织内码，字符串类型（非必录）
-     * Numbers：单据编码集合，数组类型，格式：[No1,No2,...]（使用编码时必录）
-     * Ids：单据内码集合，字符串类型，格式："Id1,Id2,..."（使用内码时必录）
-     * InterationFlags：交互标志集合，字符串类型，分号分隔，格式："flag1;flag2;..."（非必录） 例如（允许负库存标识：STK_InvCheckResult）
-     * NetworkCtrl：是否启用网控，布尔类型，默认false（非必录）
-     * IsVerifyProcInst：是否检验单据关联运行中的工作流实例，布尔类型，默认false（非必录）
-     * IgnoreInterationFlag：是否允许忽略交互，布尔类型，默认true（非必录）
-     * */
-    private String CreateOrgId;
-    private String[] Numbers;
-    private String Ids;
-    private String InterationFlags;
-    private boolean NetworkCtrl = false;
-    private boolean IsVerifyProcInst = false;
-    private boolean IgnoreInterationFlag = true;
-}

src/main/java/com/uas/eis/entity/K3/CommonSaveReq.java

@@ -1,42 +0,0 @@
-package com.uas.eis.entity.K3;
-
-import com.alibaba.fastjson.JSONPObject;
-import lombok.Builder;
-import lombok.Data;
-
-import java.io.Serializable;
-
-/**
- * @author: zhouy
- * @date: 2021/9/26 11:19
- * @desc: 保存请求对象
- */
-@Data
-public  class CommonSaveReq<T> implements Serializable{
-    /**
-     * NeedUpDateFields：需要更新的字段，数组类型，格式：[key1,key2,...] （非必录）注（更新单据体字段得加上单据体key）
-     * NeedReturnFields：需返回结果的字段集合，数组类型，格式：[key,entitykey.key,...]（非必录） 注（返回单据体字段格式：entitykey.key）
-     * IsDeleteEntry：是否删除已存在的分录，布尔类型，默认true（非必录）
-     * SubSystemId：表单所在的子系统内码，字符串类型（非必录）
-     * IsVerifyBaseDataField：是否验证所有的基础资料有效性，布尔类，默认false（非必录）
-     * IsEntryBatchFill：是否批量填充分录，默认true（非必录）
-     * ValidateFlag：是否验证标志，布尔类型，默认true（非必录）
-     * NumberSearch：是否用编码搜索基础资料，布尔类型，默认true（非必录）
-     * IsAutoAdjustField：是否自动调整JSON字段顺序，布尔类型，默认false（非必录）
-     * InterationFlags：交互标志集合，字符串类型，分号分隔，格式："flag1;flag2;..."（非必录） 例如（允许负库存标识：STK_InvCheckResult）
-     * IgnoreInterationFlag：是否允许忽略交互，布尔类型，默认true（非必录）
-     * Model：表单数据包，JSON类型（必录）
-     * */
-    private String[] NeedUpDateFields;
-    private String[] NeedReturnFields;
-    private boolean IsDeleteEntry = true;
-    private String SubSystemId;
-    private boolean IsVerifyBaseDataField = false;
-    private boolean IsEntryBatchFill= true;
-    private boolean ValidateFlag = true;
-    private boolean NumberSearch = true;
-    private boolean IsAutoAdjustField = false;
-    private String InterationFlags;
-    private boolean IgnoreInterationFlag;
-    private  T Model;
-}

src/main/java/com/uas/eis/entity/K3/FNumberE.java

@@ -1,13 +0,0 @@
-package com.uas.eis.entity.K3;
-
-/**
- * @author: zhouy
- * @date: 2021/9/26 18:48
- * @desc:
- */
-public class FNumberE {
-    private Object FNumber;
-    public FNumberE (Object FNumber) {
-        this.FNumber = FNumber;
-    }
-}

src/main/java/com/uas/eis/entity/K3/ProdInoutPickingF.java

@@ -1,13 +0,0 @@
-package com.uas.eis.entity.K3;
-
-import lombok.Data;
-
-import java.util.List;
-
-@Data
-public class ProdInoutPickingF{
-  private Integer FEntryID;
-  private FNumberE FParentMaterialId;
-  private String FMoBillNo;
-  List<ProdInoutPickingFSerialSub> FSerialSubEntity;
-}

src/main/java/com/uas/eis/entity/K3/ProdInoutPickingFSerialSub.java

@@ -1,10 +0,0 @@
-package com.uas.eis.entity.K3;
-
-import lombok.Data;
-
-@Data
- public class ProdInoutPickingFSerialSub {
-     private Integer FDetailID;
-     private String FSerialNo;
-     private String FSerialNote;
-  }

src/main/java/com/uas/eis/entity/K3/ProdInoutPickingSaveReqModel.java

@@ -1,25 +0,0 @@
-package com.uas.eis.entity.K3;
-
-import lombok.Builder;
-import lombok.Data;
-import net.sf.json.JSONObject;
-
-import java.util.List;
-import java.util.Map;
-
-/**
- * @author: zhouy
- * @date: 2021/9/26 16:08
- * @desc: 生产领料单对象
- */
-@Data
-@Builder
-public class ProdInoutPickingSaveReqModel{
-    private Integer FID;
-    private FNumberE FBillType;
-    private String FDate;
-    private FNumberE FStockOrgId;
-    private FNumberE FStockId0;
-    private List<ProdInoutPickingF> FEntity;
-}
-

src/main/java/com/uas/eis/entity/Make.java

@@ -1,243 +0,0 @@
-package com.uas.eis.entity;
-
-import com.alibaba.fastjson.annotation.JSONField;
-
-/**
- * @author koul
- * @email koul@usoftchina.com
- * @date 2021-12-07 13:55
- */
-public class Make {
-
-    @JSONField(name = "prodNo")
-    private String ma_code;
-    @JSONField(name = "itemNo")
-    private String ma_prodcode;
-    @JSONField(name = "prodQty")
-    private int ma_qty;
-    @JSONField(name = "custNo")
-    private String ma_custcode;
-    @JSONField(name = "unitNo")
-    private String pr_unit;
-    @JSONField(name = "itemName")
-    private String pr_detail;
-    @JSONField(name = "description")
-    private String pr_spec;
-    @JSONField(name = "custOrder")
-    private String ma_salecode;
-    @JSONField(name = "beginDate")
-    private String ma_planbegindate;
-    @JSONField(name = "endDate")
-    private String ma_planenddate;
-    @JSONField(name = "companyNo")
-    private String ma_cop;
-    @JSONField(name = "status")
-    private String status;
-    @JSONField(name = "createdDateTime")
-    private String ma_date;
-    @JSONField(name = "createdUser")
-    private String ma_recorder;
-    @JSONField(name = "version")
-    private String ma_version;
-    @JSONField(name = "finterid")
-    private int erpid;
-    @JSONField(name = "fWorkShop")
-    private String wc_id;
-    @JSONField(name = "fCostOBJID")
-    private String ma_kind;
-    @JSONField(name = "modifiedDateTime")
-    private String ma_modifydate;
-    @JSONField(name = "modifiedUser")
-    private String ma_modifier;
-    @JSONField(name = "mesUser")
-    private String mesUser;
-    @JSONField(name = "mesPwd")
-    private String mesPwd;
-    @JSONField(name = "flag")
-    private int flag;
-
-    public String getMa_kind() {
-        return ma_kind;
-    }
-
-    public void setMa_kind(String ma_kind) {
-        this.ma_kind = ma_kind;
-    }
-
-    public int getErpid() {
-        return erpid;
-    }
-
-    public void setErpid(int erpid) {
-        this.erpid = erpid;
-    }
-
-    public String getMesUser() {
-        return mesUser;
-    }
-
-    public void setMesUser(String mesUser) {
-        this.mesUser = mesUser;
-    }
-
-    public String getMesPwd() {
-        return mesPwd;
-    }
-
-    public void setMesPwd(String mesPwd) {
-        this.mesPwd = mesPwd;
-    }
-
-    public int getFlag() {
-        return flag;
-    }
-
-    public void setFlag(int flag) {
-        this.flag = flag;
-    }
-
-    public String getMa_code() {
-        return ma_code;
-    }
-
-    public void setMa_code(String ma_code) {
-        this.ma_code = ma_code;
-    }
-
-    public String getMa_prodcode() {
-        return ma_prodcode;
-    }
-
-    public void setMa_prodcode(String ma_prodcode) {
-        this.ma_prodcode = ma_prodcode;
-    }
-
-    public int getMa_qty() {
-        return ma_qty;
-    }
-
-    public void setMa_qty(int ma_qty) {
-        this.ma_qty = ma_qty;
-    }
-
-    public String getMa_custcode() {
-        return ma_custcode;
-    }
-
-    public void setMa_custcode(String ma_custcode) {
-        this.ma_custcode = ma_custcode;
-    }
-
-    public String getPr_unit() {
-        return pr_unit;
-    }
-
-    public void setPr_unit(String pr_unit) {
-        this.pr_unit = pr_unit;
-    }
-
-    public String getPr_detail() {
-        return pr_detail;
-    }
-
-    public void setPr_detail(String pr_detail) {
-        this.pr_detail = pr_detail;
-    }
-
-    public String getPr_spec() {
-        return pr_spec;
-    }
-
-    public void setPr_spec(String pr_spec) {
-        this.pr_spec = pr_spec;
-    }
-
-    public String getMa_salecode() {
-        return ma_salecode;
-    }
-
-    public void setMa_salecode(String ma_salecode) {
-        this.ma_salecode = ma_salecode;
-    }
-
-    public String getMa_planbegindate() {
-        return ma_planbegindate;
-    }
-
-    public void setMa_planbegindate(String ma_planbegindate) {
-        this.ma_planbegindate = ma_planbegindate;
-    }
-
-    public String getMa_planenddate() {
-        return ma_planenddate;
-    }
-
-    public void setMa_planenddate(String ma_planenddate) {
-        this.ma_planenddate = ma_planenddate;
-    }
-
-    public String getMa_cop() {
-        return ma_cop;
-    }
-
-    public void setMa_cop(String ma_cop) {
-        this.ma_cop = ma_cop;
-    }
-
-    public String getStatus() {
-        return status;
-    }
-
-    public void setStatus(String status) {
-        this.status = status;
-    }
-
-    public String getMa_date() {
-        return ma_date;
-    }
-
-    public void setMa_date(String ma_date) {
-        this.ma_date = ma_date;
-    }
-
-    public String getMa_recorder() {
-        return ma_recorder;
-    }
-
-    public void setMa_recorder(String ma_recorder) {
-        this.ma_recorder = ma_recorder;
-    }
-
-    public String getMa_version() {
-        return ma_version;
-    }
-
-    public void setMa_version(String ma_version) {
-        this.ma_version = ma_version;
-    }
-
-    public String getWc_id() {
-        return wc_id;
-    }
-
-    public void setWc_id(String wc_id) {
-        this.wc_id = wc_id;
-    }
-
-
-    public String getMa_modifydate() {
-        return ma_modifydate;
-    }
-
-    public void setMa_modifydate(String ma_modifydate) {
-        this.ma_modifydate = ma_modifydate;
-    }
-
-    public String getMa_modifier() {
-        return ma_modifier;
-    }
-
-    public void setMa_modifier(String ma_modifier) {
-        this.ma_modifier = ma_modifier;
-    }
-}

src/main/java/com/uas/eis/entity/MakeMaterial.java

@@ -1,251 +0,0 @@
-package com.uas.eis.entity;
-
-import com.alibaba.fastjson.annotation.JSONField;
-
-/**
- * @author koul
- * @email koul@usoftchina.com
- * @date 2021-12-07 14:32
- */
-public class MakeMaterial {
-
-    @JSONField(name = "prodNo")
-    private String mm_code;
-    @JSONField(name = "lineId")
-    private int erpid;
-    @JSONField(name = "itemNo")
-    private String mm_prodcode;
-    @JSONField(name = "itemName")
-    private String pr_detail;
-    @JSONField(name = "description")
-    private String pr_spec;
-    @JSONField(name = "unitNo")
-    private String pr_unit;
-    @JSONField(name = "qty")
-    private Float qty;
-    @JSONField(name = "totalQty")
-    private Float mm_qty;
-    @JSONField(name = "baseQty")
-    private Float mm_oneuseqty;
-    @JSONField(name = "type")
-    private String type;
-    @JSONField(name = "createdUser")
-    private String bo_recorder;
-    @JSONField(name = "createdDateTime")
-    private String bo_date;
-    @JSONField(name = "version")
-    private int bo_version;
-    @JSONField(name = "companyNo")
-    private String bo_cop;
-    @JSONField(name = "oriItemNo")
-    private String mm_repprodcode;
-    @JSONField(name = "scarpQty")
-    private Float mm_balance;
-    @JSONField(name = "custNo")
-    private String ma_custcode;
-    @JSONField(name = "modifiedDateTime")
-    private String mc_indate;
-    @JSONField(name = "modifiedUser")
-    private String mc_recorder;
-    @JSONField(name = "mesUser")
-    private String mesUser;
-    @JSONField(name = "mesPwd")
-    private String mesPwd;
-    @JSONField(name = "flag")
-    private int flag;
-    private int id;
-    @JSONField(name = "erptdid")
-    private int rpid;
-
-    public int getRpid() {
-        return rpid;
-    }
-
-    public void setRpid(int rpid) {
-        this.rpid = rpid;
-    }
-
-    public int getId() {
-        return id;
-    }
-
-    public void setId(int id) {
-        this.id = id;
-    }
-
-    public int getErpid() {
-        return erpid;
-    }
-
-    public void setErpid(int erpid) {
-        this.erpid = erpid;
-    }
-
-    public String getMesUser() {
-        return mesUser;
-    }
-
-    public void setMesUser(String mesUser) {
-        this.mesUser = mesUser;
-    }
-
-    public String getMesPwd() {
-        return mesPwd;
-    }
-
-    public void setMesPwd(String mesPwd) {
-        this.mesPwd = mesPwd;
-    }
-
-    public int getFlag() {
-        return flag;
-    }
-
-    public void setFlag(int flag) {
-        this.flag = flag;
-    }
-
-    public String getMm_code() {
-        return mm_code;
-    }
-
-    public void setMm_code(String mm_code) {
-        this.mm_code = mm_code;
-    }
-
-    public String getMm_prodcode() {
-        return mm_prodcode;
-    }
-
-    public void setMm_prodcode(String mm_prodcode) {
-        this.mm_prodcode = mm_prodcode;
-    }
-
-    public String getPr_detail() {
-        return pr_detail;
-    }
-
-    public void setPr_detail(String pr_detail) {
-        this.pr_detail = pr_detail;
-    }
-
-    public String getPr_spec() {
-        return pr_spec;
-    }
-
-    public void setPr_spec(String pr_spec) {
-        this.pr_spec = pr_spec;
-    }
-
-    public String getPr_unit() {
-        return pr_unit;
-    }
-
-    public void setPr_unit(String pr_unit) {
-        this.pr_unit = pr_unit;
-    }
-
-    public Float getQty() {
-        return qty;
-    }
-
-    public void setQty(Float qty) {
-        this.qty = qty;
-    }
-
-    public Float getMm_qty() {
-        return mm_qty;
-    }
-
-    public void setMm_qty(Float mm_qty) {
-        this.mm_qty = mm_qty;
-    }
-
-    public Float getMm_oneuseqty() {
-        return mm_oneuseqty;
-    }
-
-    public void setMm_oneuseqty(Float mm_oneuseqty) {
-        this.mm_oneuseqty = mm_oneuseqty;
-    }
-
-    public String getType() {
-        return type;
-    }
-
-    public void setType(String type) {
-        this.type = type;
-    }
-
-    public String getBo_recorder() {
-        return bo_recorder;
-    }
-
-    public void setBo_recorder(String bo_recorder) {
-        this.bo_recorder = bo_recorder;
-    }
-
-    public String getBo_date() {
-        return bo_date;
-    }
-
-    public void setBo_date(String bo_date) {
-        this.bo_date = bo_date;
-    }
-
-    public int getBo_version() {
-        return bo_version;
-    }
-
-    public void setBo_version(int bo_version) {
-        this.bo_version = bo_version;
-    }
-
-    public String getBo_cop() {
-        return bo_cop;
-    }
-
-    public void setBo_cop(String bo_cop) {
-        this.bo_cop = bo_cop;
-    }
-
-    public String getMm_repprodcode() {
-        return mm_repprodcode;
-    }
-
-    public void setMm_repprodcode(String mm_repprodcode) {
-        this.mm_repprodcode = mm_repprodcode;
-    }
-
-    public Float getMm_balance() {
-        return mm_balance;
-    }
-
-    public void setMm_balance(Float mm_balance) {
-        this.mm_balance = mm_balance;
-    }
-
-    public String getMa_custcode() {
-        return ma_custcode;
-    }
-
-    public void setMa_custcode(String ma_custcode) {
-        this.ma_custcode = ma_custcode;
-    }
-
-    public String getMc_indate() {
-        return mc_indate;
-    }
-
-    public void setMc_indate(String mc_indate) {
-        this.mc_indate = mc_indate;
-    }
-
-    public String getMc_recorder() {
-        return mc_recorder;
-    }
-
-    public void setMc_recorder(String mc_recorder) {
-        this.mc_recorder = mc_recorder;
-    }
-}

src/main/java/com/uas/eis/entity/PNSSendData.java

@@ -1,70 +0,0 @@
-package com.uas.eis.entity;
-
-import com.alibaba.fastjson.annotation.JSONField;
-import com.fasterxml.jackson.annotation.JsonFormat;
-import org.codehaus.jackson.annotate.JsonIgnore;
-import lombok.Data;
-import java.io.Serializable;
-import java.util.Date;
-@Data
-public class PNSSendData implements Serializable {
-    /**
-     * 序号
-     * */
-    private Integer row_number;
-    /**
-     * 期间
-     * */
-    private String ymonth;
-    /**
-     * 数据类型 INV：库存 SALES：销售
-     * */
-    private String data_type;
-    /**
-     * 部门code
-     * */
-    private String division_no;
-    /**
-     * 经销商id
-     * */
-    private String cust_id;
-    /**
-     * 经销商CODE
-     * */
-    private String cust_code;
-    /**
-     *  经销商名称
-     * */
-    private String cust_name;
-    /**
-     * 最终客户id
-     * */
-    private String final_buyer_cust;
-    private String final_buyer_isp;
-    /**
-     * 最终客户名称
-     * */
-    private String final_buyer_name;
-    /**
-     * 经销商内部型号
-     * */
-    private String model_no_cust;
-    /**
-     * 型号
-     * */
-    private String model_no_isp;
-    /**
-     *库存日期or销售日期
-     * */
-    @JSONField(format = "yyyy-MM-dd")
-    private Date confirm_date;
-    /**
-     * 数量
-     * */
-    private Float quantity;
-    /**
-     * 金额
-     * */
-    @JsonIgnore
-    private Float amount;
-}

src/main/java/com/uas/eis/entity/PNSSendResp.java

@@ -1,33 +0,0 @@
-package com.uas.eis.entity;
-
-import java.io.Serializable;
-
-public class PNSSendResp implements Serializable {
-    private String if_name;
-    private String if_batch_no;
-    private Boolean success;
-
-    public String getIf_name() {
-        return if_name;
-    }
-
-    public void setIf_name(String if_name) {
-        this.if_name = if_name;
-    }
-
-    public String getIf_batch_no() {
-        return if_batch_no;
-    }
-
-    public void setIf_batch_no(String if_batch_no) {
-        this.if_batch_no = if_batch_no;
-    }
-
-    public Boolean getSuccess() {
-        return success;
-    }
-
-    public void setSuccess(Boolean success) {
-        this.success = success;
-    }
-}

src/main/java/com/uas/eis/entity/ProdIODetail.java

@@ -1,15 +0,0 @@
-package com.uas.eis.entity;
-
-import lombok.Data;
-
-/**
- * @author: zhouy
- * @date: 2021/9/26 11:02
- * @desc: 出入库单明细表
- */
-@Data
-public class ProdIODetail {
-    private Integer pd_id;
-    private Integer pd_piid;
-    private String pd_prodcode;
-}

src/main/java/com/uas/eis/entity/ProdInOut.java

@@ -1,17 +0,0 @@
-package com.uas.eis.entity;
-
-import lombok.Data;
-
-import java.util.List;
-
-/**
- * @author: zhouy
- * @date: 2021/9/26 11:01
- * @desc: 出入库单主表
- */
-@Data
-public class ProdInOut {
-    private Integer pi_id;
-    private String pi_class;
-    List<ProdIODetail> detailList;
-}

src/main/java/com/uas/eis/entity/Product.java

@@ -1,205 +0,0 @@
-package com.uas.eis.entity;
-
-import com.alibaba.fastjson.annotation.JSONField;
-
-import java.io.Serializable;
-
-
-/**
- * @author koul
- * @email koul@usoftchina.com
- * @date 2021-11-25 8:47
- */
-public class Product implements Serializable {
-
-    @JSONField(name = "custNo")
-    private String pr_kh_user;
-    @JSONField(name = "itemNo")
-    private String pr_code;
-    @JSONField(name = "itemName")
-    private String pr_detail;
-    @JSONField(name = "description")
-    private String pr_spec;
-    @JSONField(name = "unitNo")
-    private String pr_unit;
-    @JSONField(name = "companyNo")
-    private String pr_cop;
-    @JSONField(name = "version")
-    private String pr_version;
-    @JSONField(name = "itemType")
-    private String pr_serial;
-    @JSONField(name = "invalidQty")
-    private int pr_validdays;
-    @JSONField(name = "msdLevel")
-    private String pr_msdlevel;
-    @JSONField(name = "memoryCode")
-    private String pr_kind3;
-    @JSONField(name = "packType")
-    private String pr_f_115;
-    @JSONField(name = "thickness")
-    private String pr_f_116;
-    @JSONField(name = "technology")
-    private String pr_f_102;
-    @JSONField(name = "itemCategory")
-    private String pr_kind;
-    @JSONField(name = "erpLoc")
-    private String pr_whcode;
-    @JSONField(name = "mesUser")
-    private String mesUser;
-    @JSONField(name = "mesPwd")
-    private String mesPwd;
-    @JSONField(name = "flag")
-    private int flag;
-
-    public String getPr_kind3() {
-        return pr_kind3;
-    }
-
-    public void setPr_kind3(String pr_kind3) {
-        this.pr_kind3 = pr_kind3;
-    }
-
-    public String getMesUser() {
-        return mesUser;
-    }
-
-    public void setMesUser(String mesUser) {
-        this.mesUser = mesUser;
-    }
-
-    public String getMesPwd() {
-        return mesPwd;
-    }
-
-    public void setMesPwd(String mesPwd) {
-        this.mesPwd = mesPwd;
-    }
-
-    public int getFlag() {
-        return flag;
-    }
-
-    public void setFlag(int flag) {
-        this.flag = flag;
-    }
-
-    public String getPr_kh_user() {
-        return pr_kh_user;
-    }
-
-    public void setPr_kh_user(String pr_kh_user) {
-        this.pr_kh_user = pr_kh_user;
-    }
-
-    public String getPr_code() {
-        return pr_code;
-    }
-
-    public void setPr_code(String pr_code) {
-        this.pr_code = pr_code;
-    }
-
-    public String getPr_detail() {
-        return pr_detail;
-    }
-
-    public void setPr_detail(String pr_detail) {
-        this.pr_detail = pr_detail;
-    }
-
-    public String getPr_spec() {
-        return pr_spec;
-    }
-
-    public void setPr_spec(String pr_spec) {
-        this.pr_spec = pr_spec;
-    }
-
-    public String getPr_unit() {
-        return pr_unit;
-    }
-
-    public void setPr_unit(String pr_unit) {
-        this.pr_unit = pr_unit;
-    }
-
-    public String getPr_cop() {
-        return pr_cop;
-    }
-
-    public void setPr_cop(String pr_cop) {
-        this.pr_cop = pr_cop;
-    }
-
-    public String getPr_version() {
-        return pr_version;
-    }
-
-    public void setPr_version(String pr_version) {
-        this.pr_version = pr_version;
-    }
-
-    public String getPr_serial() {
-        return pr_serial;
-    }
-
-    public void setPr_serial(String pr_serial) {
-        this.pr_serial = pr_serial;
-    }
-
-    public int getPr_validdays() {
-        return pr_validdays;
-    }
-
-    public void setPr_validdays(int pr_validdays) {
-        this.pr_validdays = pr_validdays;
-    }
-
-    public String getPr_msdlevel() {
-        return pr_msdlevel;
-    }
-
-    public void setPr_msdlevel(String pr_msdlevel) {
-        this.pr_msdlevel = pr_msdlevel;
-    }
-
-    public String getPr_f_115() {
-        return pr_f_115;
-    }
-
-    public void setPr_f_115(String pr_f_115) {
-        this.pr_f_115 = pr_f_115;
-    }
-
-    public String getPr_f_116() {
-        return pr_f_116;
-    }
-
-    public void setPr_f_116(String pr_f_116) {
-        this.pr_f_116 = pr_f_116;
-    }
-
-    public String getPr_f_102() {
-        return pr_f_102;
-    }
-
-    public void setPr_f_102(String pr_f_102) {
-        this.pr_f_102 = pr_f_102;
-    }
-
-    public String getPr_kind() {
-        return pr_kind;
-    }
-
-    public void setPr_kind(String pr_kind) {
-        this.pr_kind = pr_kind;
-    }
-
-    public String getPr_whcode() {
-        return pr_whcode;
-    }
-
-    public void setPr_whcode(String pr_whcode) {
-        this.pr_whcode = pr_whcode;
-    }
-}

src/main/java/com/uas/eis/entity/QueryArgs.java

@@ -1,48 +0,0 @@
-package com.uas.eis.entity;
-
-public class QueryArgs {
-
-	private Integer qa_id;
-	private String qa_qccode;
-	private String qa_param;
-	private String qa_paramtype;
-	private String qa_relation;
-	private Integer qa_detno;
-	public Integer getQa_id() {
-		return qa_id;
-	}
-	public void setQa_id(Integer qa_id) {
-		this.qa_id = qa_id;
-	}
-	public String getQa_qccode() {
-		return qa_qccode;
-	}
-	public void setQa_qccode(String qa_qccode) {
-		this.qa_qccode = qa_qccode;
-	}
-	public String getQa_param() {
-		return qa_param;
-	}
-	public void setQa_param(String qa_param) {
-		this.qa_param = qa_param;
-	}
-	public String getQa_paramtype() {
-		return qa_paramtype;
-	}
-	public void setQa_paramtype(String qa_paramtype) {
-		this.qa_paramtype = qa_paramtype;
-	}
-	public String getQa_relation() {
-		return qa_relation;
-	}
-	public void setQa_relation(String qa_relation) {
-		this.qa_relation = qa_relation;
-	}
-	public Integer getQa_detno() {
-		return qa_detno;
-	}
-	public void setQa_detno(Integer qa_detno) {
-		this.qa_detno = qa_detno;
-	}
-	
-}

src/main/java/com/uas/eis/entity/QueryConfig.java

@@ -1,95 +0,0 @@
-package com.uas.eis.entity;
-
-/**
- * 标准查询配置
- * @author chenw
- *
- */
-public class QueryConfig {
-
-	private Integer qc_id;
-	private String qc_code;
-	private String qc_table;
-	private String qc_condition;
-	private String qc_mapkey;
-	private String qc_beforesql;
-	private String qc_return;
-	private Integer qc_detno;
-	private String qc_orderby;
-	private Integer qc_isArray;
-	private String qc_relationCode;
-	private String qc_mainVar;
-	public String getQc_mainVar() {
-		return qc_mainVar;
-	}
-	public void setQc_mainVar(String qc_mainVar) {
-		this.qc_mainVar = qc_mainVar;
-	}
-	public String getQc_relationCode() {
-		return qc_relationCode;
-	}
-	public void setQc_relationCode(String qc_relationCode) {
-		this.qc_relationCode = qc_relationCode;
-	}
-	public Integer getQc_id() {
-		return qc_id;
-	}
-	public void setQc_id(Integer qc_id) {
-		this.qc_id = qc_id;
-	}
-	public String getQc_code() {
-		return qc_code;
-	}
-	public void setQc_code(String qc_code) {
-		this.qc_code = qc_code;
-	}
-	public String getQc_table() {
-		return qc_table;
-	}
-	public void setQc_table(String qc_table) {
-		this.qc_table = qc_table;
-	}
-	public String getQc_condition() {
-		return qc_condition;
-	}
-	public void setQc_condition(String qc_condition) {
-		this.qc_condition = qc_condition;
-	}
-	public String getQc_mapkey() {
-		return qc_mapkey;
-	}
-	public void setQc_mapkey(String qc_mapkey) {
-		this.qc_mapkey = qc_mapkey;
-	}
-	public String getQc_return() {
-		return qc_return;
-	}
-	public void setQc_return(String qc_return) {
-		this.qc_return = qc_return;
-	}
-	public Integer getQc_detno() {
-		return qc_detno;
-	}
-	public void setQc_detno(Integer qc_detno) {
-		this.qc_detno = qc_detno;
-	}
-	public String getQc_orderby() {
-		return qc_orderby;
-	}
-	public void setQc_orderby(String qc_orderby) {
-		this.qc_orderby = qc_orderby;
-	}
-	public String getQc_beforesql() {
-		return qc_beforesql;
-	}
-	public void setQc_beforesql(String qc_beforesql) {
-		this.qc_beforesql = qc_beforesql;
-	}
-	public Integer getQc_isArray() {
-		return qc_isArray;
-	}
-	public void setQc_isArray(Integer qc_isArray) {
-		this.qc_isArray = qc_isArray;
-	}
-	
-}

src/main/java/com/uas/eis/entity/QueryConfigDetail.java

@@ -1,34 +0,0 @@
-package com.uas.eis.entity;
-
-public class QueryConfigDetail {
-
-	private Integer qcd_id;
-	private Integer qcd_qcid;
-	private String qcd_field;
-	private String qcd_mappingkey;
-	public Integer getQcd_id() {
-		return qcd_id;
-	}
-	public void setQcd_id(Integer qcd_id) {
-		this.qcd_id = qcd_id;
-	}
-	public Integer getQcd_qcid() {
-		return qcd_qcid;
-	}
-	public void setQcd_qcid(Integer qcd_qcid) {
-		this.qcd_qcid = qcd_qcid;
-	}
-	public String getQcd_field() {
-		return qcd_field;
-	}
-	public void setQcd_field(String qcd_field) {
-		this.qcd_field = qcd_field;
-	}
-	public String getQcd_mappingkey() {
-		return qcd_mappingkey;
-	}
-	public void setQcd_mappingkey(String qcd_mappingkey) {
-		this.qcd_mappingkey = qcd_mappingkey;
-	}
-	
-}

src/main/java/com/uas/eis/entity/VerifyApply.java

@@ -1,384 +0,0 @@
-package com.uas.eis.entity;
-
-import com.alibaba.fastjson.annotation.JSONField;
-
-import java.util.List;
-
-/**
- * @author koul
- * @email koul@usoftchina.com
- * @date 2021-12-08 9:43
- */
-public class VerifyApply {
-
-    @JSONField(name = "fInterID")
-    private int va_id;
-    @JSONField(name = "mesCode")
-    private String va_mescode;
-    @JSONField(name = "journalNo")
-    private String va_code;
-    @JSONField(name = "createdDateTime")
-    private String va_date;
-    @JSONField(name = "vendNo")
-    private String va_vendcode;
-    @JSONField(name = "vendName")
-    private String va_vendname;
-    @JSONField(name = "currency")
-    private String va_currency;
-    @JSONField(name = "rate")
-    private Float va_rate;
-    @JSONField(name = "paymentsCode")
-    private String va_paymentscode;
-    @JSONField(name = "payments")
-    private String va_payments;
-    @JSONField(name = "transport")
-    private String va_transport;
-    @JSONField(name = "sendCode")
-    private String va_sendcode;
-    @JSONField(name = "sellerCode")
-    private String va_emcode;
-    @JSONField(name = "sellerName")
-    private String va_emname;
-    @JSONField(name = "whNo")
-    private String va_whcode;
-    @JSONField(name = "whName")
-    private String va_whname;
-    @JSONField(name = "erpFDeptID")
-    private String va_departmentcode;
-    @JSONField(name = "erpFDept")
-    private String va_department;
-    @JSONField(name = "createdUser")
-    private String va_recorder;
-    @JSONField(name = "companyNo")
-    private String va_cop;
-    @JSONField(name = "remark")
-    private String va_remark;
-    @JSONField(name = "anCode")
-    private String va_ancode;
-    @JSONField(name = "SHFactory")
-    private String va_factory;
-    @JSONField(name = "version")
-    private String version;
-    @JSONField(name = "custNo")
-    private String va_custcode;
-    @JSONField(name = "custName")
-    private String va_custname;
-    @JSONField(name = "recType")
-    private String va_type;
-    @JSONField(name = "devNo")
-    private String va_pucode;
-    @JSONField(name = "fSourceInterId")
-    private int pu_id;
-    @JSONField(name = "fPOStyle")
-    private String va_status;
-    @JSONField(name = "posted")
-    private int posted;
-    @JSONField(name = "postedDateTime")
-    private String va_auditdate;
-    @JSONField(name = "postedBy")
-    private String va_auditman;
-    @JSONField(name = "mesUser")
-    private String mesUser;
-    @JSONField(name = "mesPwd")
-    private String mesPwd;
-    @JSONField(name = "flag")
-    private int flag;
-    @JSONField(name = "detail")
-    private List<VerifyApplyDetail> detail;
-
-    public String getMesUser() {
-        return mesUser;
-    }
-
-    public void setMesUser(String mesUser) {
-        this.mesUser = mesUser;
-    }
-
-    public String getMesPwd() {
-        return mesPwd;
-    }
-
-    public void setMesPwd(String mesPwd) {
-        this.mesPwd = mesPwd;
-    }
-
-    public String getVa_type() {
-        return va_type;
-    }
-
-    public void setVa_type(String va_type) {
-        this.va_type = va_type;
-    }
-
-    public String getVa_status() {
-        return va_status;
-    }
-
-    public void setVa_status(String va_status) {
-        this.va_status = va_status;
-    }
-
-    public int getPosted() {
-        return posted;
-    }
-
-    public void setPosted(int posted) {
-        this.posted = posted;
-    }
-
-    public String getVa_auditdate() {
-        return va_auditdate;
-    }
-
-    public void setVa_auditdate(String va_auditdate) {
-        this.va_auditdate = va_auditdate;
-    }
-
-    public String getVa_auditman() {
-        return va_auditman;
-    }
-
-    public void setVa_auditman(String va_auditman) {
-        this.va_auditman = va_auditman;
-    }
-
-    public int getFlag() {
-        return flag;
-    }
-
-    public void setFlag(int flag) {
-        this.flag = flag;
-    }
-
-    public String getVersion() {
-        return version;
-    }
-
-    public void setVersion(String version) {
-        this.version = version;
-    }
-
-    public String getVa_custcode() {
-        return va_custcode;
-    }
-
-    public void setVa_custcode(String va_custcode) {
-        this.va_custcode = va_custcode;
-    }
-
-    public String getVa_custname() {
-        return va_custname;
-    }
-
-    public void setVa_custname(String va_custname) {
-        this.va_custname = va_custname;
-    }
-
-    public String getVa_pucode() {
-        return va_pucode;
-    }
-
-    public void setVa_pucode(String va_pucode) {
-        this.va_pucode = va_pucode;
-    }
-
-    public int getPu_id() {
-        return pu_id;
-    }
-
-    public void setPu_id(int pu_id) {
-        this.pu_id = pu_id;
-    }
-
-    public int getVa_id() {
-        return va_id;
-    }
-
-    public void setVa_id(int va_id) {
-        this.va_id = va_id;
-    }
-
-    public String getVa_mescode() {
-        return va_mescode;
-    }
-
-    public void setVa_mescode(String va_mescode) {
-        this.va_mescode = va_mescode;
-    }
-
-    public String getVa_code() {
-        return va_code;
-    }
-
-    public void setVa_code(String va_code) {
-        this.va_code = va_code;
-    }
-
-    public String getVa_date() {
-        return va_date;
-    }
-
-    public void setVa_date(String va_date) {
-        this.va_date = va_date;
-    }
-
-    public String getVa_vendcode() {
-        return va_vendcode;
-    }
-
-    public void setVa_vendcode(String va_vendcode) {
-        this.va_vendcode = va_vendcode;
-    }
-
-    public String getVa_vendname() {
-        return va_vendname;
-    }
-
-    public void setVa_vendname(String va_vendname) {
-        this.va_vendname = va_vendname;
-    }
-
-    public String getVa_currency() {
-        return va_currency;
-    }
-
-    public void setVa_currency(String va_currency) {
-        this.va_currency = va_currency;
-    }
-
-    public Float getVa_rate() {
-        return va_rate;
-    }
-
-    public void setVa_rate(Float va_rate) {
-        this.va_rate = va_rate;
-    }
-
-    public String getVa_paymentscode() {
-        return va_paymentscode;
-    }
-
-    public void setVa_paymentscode(String va_paymentscode) {
-        this.va_paymentscode = va_paymentscode;
-    }
-
-    public String getVa_payments() {
-        return va_payments;
-    }
-
-    public void setVa_payments(String va_payments) {
-        this.va_payments = va_payments;
-    }
-
-    public String getVa_transport() {
-        return va_transport;
-    }
-
-    public void setVa_transport(String va_transport) {
-        this.va_transport = va_transport;
-    }
-
-    public String getVa_sendcode() {
-        return va_sendcode;
-    }
-
-    public void setVa_sendcode(String va_sendcode) {
-        this.va_sendcode = va_sendcode;
-    }
-
-    public String getVa_emcode() {
-        return va_emcode;
-    }
-
-    public void setVa_emcode(String va_emcode) {
-        this.va_emcode = va_emcode;
-    }
-
-    public String getVa_emname() {
-        return va_emname;
-    }
-
-    public void setVa_emname(String va_emname) {
-        this.va_emname = va_emname;
-    }
-
-    public String getVa_whcode() {
-        return va_whcode;
-    }
-
-    public void setVa_whcode(String va_whcode) {
-        this.va_whcode = va_whcode;
-    }
-
-    public String getVa_whname() {
-        return va_whname;
-    }
-
-    public void setVa_whname(String va_whname) {
-        this.va_whname = va_whname;
-    }
-
-    public String getVa_departmentcode() {
-        return va_departmentcode;
-    }
-
-    public void setVa_departmentcode(String va_departmentcode) {
-        this.va_departmentcode = va_departmentcode;
-    }
-
-    public String getVa_department() {
-        return va_department;
-    }
-
-    public void setVa_department(String va_department) {
-        this.va_department = va_department;
-    }
-
-    public String getVa_recorder() {
-        return va_recorder;
-    }
-
-    public void setVa_recorder(String va_recorder) {
-        this.va_recorder = va_recorder;
-    }
-
-    public String getVa_cop() {
-        return va_cop;
-    }
-
-    public void setVa_cop(String va_cop) {
-        this.va_cop = va_cop;
-    }
-
-    public String getVa_remark() {
-        return va_remark;
-    }
-
-    public void setVa_remark(String va_remark) {
-        this.va_remark = va_remark;
-    }
-
-    public String getVa_ancode() {
-        return va_ancode;
-    }
-
-    public void setVa_ancode(String va_ancode) {
-        this.va_ancode = va_ancode;
-    }
-
-    public String getVa_factory() {
-        return va_factory;
-    }
-
-    public void setVa_factory(String va_factory) {
-        this.va_factory = va_factory;
-    }
-
-    public List<VerifyApplyDetail> getDetail() {
-        return detail;
-    }
-
-    public void setDetail(List<VerifyApplyDetail> detail) {
-        this.detail = detail;
-    }
-}

src/main/java/com/uas/eis/entity/VerifyApplyDetail.java

@@ -1,132 +0,0 @@
-package com.uas.eis.entity;
-
-import com.alibaba.fastjson.annotation.JSONField;
-
-/**
- * @author koul
- * @email koul@usoftchina.com
- * @date 2021-12-08 9:54
- */
-public class VerifyApplyDetail {
-
-    @JSONField(name = "journalNo")
-    private String vad_code;
-    @JSONField(name = "itemNo")
-    private String vad_prodcode;
-    @JSONField(name = "itemName")
-    private String pr_detail;
-    @JSONField(name = "description")
-    private String pr_spec;
-    @JSONField(name = "unitNo")
-    private String pr_unit;
-    @JSONField(name = "qty")
-    private Float vad_qty;
-    @JSONField(name = "createdUser")
-    private String va_recorder;
-    @JSONField(name = "createdDateTime")
-    private String va_date;
-    @JSONField(name = "flag")
-    private int flag;
-    @JSONField(name = "custNo")
-    private String pr_kh_user;
-    @JSONField(name="custName")
-    private String cu_name;
-    @JSONField(name="purNo")
-    private String vad_salecode;
-
-    public String getVad_salecode() {
-        return vad_salecode;
-    }
-
-    public void setVad_salecode(String vad_salecode) {
-        this.vad_salecode = vad_salecode;
-    }
-
-    public String getVa_recorder() {
-        return va_recorder;
-    }
-
-    public void setVa_recorder(String va_recorder) {
-        this.va_recorder = va_recorder;
-    }
-
-    public String getVa_date() {
-        return va_date;
-    }
-
-    public void setVa_date(String va_date) {
-        this.va_date = va_date;
-    }
-
-    public int getFlag() {
-        return flag;
-    }
-
-    public void setFlag(int flag) {
-        this.flag = flag;
-    }
-
-    public String getPr_kh_user() {
-        return pr_kh_user;
-    }
-
-    public void setPr_kh_user(String pr_kh_user) {
-        this.pr_kh_user = pr_kh_user;
-    }
-
-    public String getCu_name() {
-        return cu_name;
-    }
-
-    public void setCu_name(String cu_name) {
-        this.cu_name = cu_name;
-    }
-
-    public String getVad_code() {
-        return vad_code;
-    }
-
-    public void setVad_code(String vad_code) {
-        this.vad_code = vad_code;
-    }
-
-    public String getVad_prodcode() {
-        return vad_prodcode;
-    }
-
-    public void setVad_prodcode(String vad_prodcode) {
-        this.vad_prodcode = vad_prodcode;
-    }
-
-    public String getPr_detail() {
-        return pr_detail;
-    }
-
-    public void setPr_detail(String pr_detail) {
-        this.pr_detail = pr_detail;
-    }
-
-    public String getPr_spec() {
-        return pr_spec;
-    }
-
-    public void setPr_spec(String pr_spec) {
-        this.pr_spec = pr_spec;
-    }
-
-    public String getPr_unit() {
-        return pr_unit;
-    }
-
-    public void setPr_unit(String pr_unit) {
-        this.pr_unit = pr_unit;
-    }
-
-    public Float getVad_qty() {
-        return vad_qty;
-    }
-
-    public void setVad_qty(Float vad_qty) {
-        this.vad_qty = vad_qty;
-    }
-}

src/main/java/com/uas/eis/listener/UasProdInOutListener.java

@@ -1,245 +0,0 @@
-package com.uas.eis.listener;
-
-import com.uas.eis.aspect.UasEventListener;
-import com.uas.eis.config.KingdeeConfig;
-import com.uas.eis.dto.UasEvent;
-import com.uas.eis.entity.ProdInOut;
-import com.uas.eis.service.ProdInOutService;;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Component;
-
-import javax.annotation.Resource;
-
-/**
- * @author: zhouy
- * @date: 2021/9/26 10:47
- * @desc: 出入库单事件处理
- */
-@Component
-public class UasProdInOutListener {
-
-    @Resource
-    private KingdeeConfig kingdeeConfig;
-
-    @Autowired
-    private ProdInOutService prodInOutService;
-    /**
-     * 生产领料单过账->推送金蝶生成对应单据
-     */
-//    @UasEventListener(caller = "ProdInOut!Picking", operation = "POST")
-    public void onProdInOutPost_picking(UasEvent event) {
-//        ProdInOut prodInout = prodInOutService.findById(Integer.parseInt(event.getKey().toString()));
-        /**封装请求数据*/
-       /* K3CloudApiClient client = new K3CloudApiClient(kingdeeConfig.getUrl());
-        try {
-            Boolean result = client.login(kingdeeConfig.getDbId(), kingdeeConfig.getUid(), kingdeeConfig.getPwd(), kingdeeConfig.getLang().intValue());
-          *//*  String content = "{\"NeedUpDateFields\": []," +
-                    "    \"NeedReturnFields\": []," +
-                    "    \"IsDeleteEntry\": \"true\"," +
-                    "    \"SubSystemId\": \"\"," +
-                    "    \"IsVerifyBaseDataField\": \"false\"," +
-                    "    \"IsEntryBatchFill\": \"true\"," +
-                    "    \"ValidateFlag\": \"true\"," +
-                    "    \"NumberSearch\": \"true\"," +
-                    "    \"IsAutoAdjustField\": \"false\"," +
-                    "    \"InterationFlags\": \"\"," +
-                    "    \"IgnoreInterationFlag\": \"\"," +
-                    "    \"Model\": {" +
-                    "        \"FID\": 0," +
-                    "        \"FBillType\": {" +
-                    "            \"FNUMBER\": \"\"" +
-                    "        }," +
-                    "        \"FDate\": \"1900-01-01\"," +
-                    "        \"FStockOrgId\": {" +
-                    "            \"FNumber\": \"\"" +
-                    "        }," +
-                    "        \"FStockId0\": {" +
-                    "            \"FNumber\": \"\"" +
-                    "        }," +
-                    "        \"FPrdOrgId\": {" +
-                    "            \"FNumber\": \"\"" +
-                    "        }," +
-                    "        \"FWorkShopId\": {" +
-                    "            \"FNumber\": \"\"" +
-                    "        }," +
-                    "        \"FOwnerTypeId0\": \"\"," +
-                    "        \"FOwnerId0\": {" +
-                    "            \"FNumber\": \"\"" +
-                    "        }," +
-                    "        \"FPickerId\": {}," +
-                    "        \"FSTOCKERID\": {" +
-                    "            \"FNAME\": \"\"" +
-                    "        }," +
-                    "        \"FDescription\": \"\"," +
-                    "        \"FCurrId\": {" +
-                    "            \"FNumber\": \"\"" +
-                    "        }," +
-                    "        \"FIsCrossTrade\": \"false\"," +
-                    "        \"FVmiBusiness\": \"false\"," +
-                    "        \"FScanBox\": \"\"," +
-                    "        \"FSourceType\": \"\"," +
-                    "        \"FIsOwnerTInclOrg\": \"false\"," +
-                    "        \"F_EMD_Text\": \"\"," +
-                    "        \"F_EMD_Text1\": \"\"," +
-                    "        \"F_EMD_Text2\": \"\"," +
-                    "        \"F_EMD_PrintTimes\": 0," +
-                    "        \"F_EMD_Qty2\": 0," +
-                    "        \"F_EMD_Base\": {" +
-                    "            \"FNUMBER\": \"\"" +
-                    "        }," +
-                    "        \"FEntity\": [" +
-                    "            {" +
-                    "                \"FEntryID\": 0," +
-                    "                \"FParentMaterialId\": {" +
-                    "                    \"FNumber\": \"\"" +
-                    "                }," +
-                    "                \"FMoBillNo\": \"\"," +
-                    "                \"FBaseStockActualQty\": 0," +
-                    "                \"FFPMBillNo\": \"\"," +
-                    "                \"FConsome\": \"\"," +
-                    "                \"FOptQueue\": \"\"," +
-                    "                \"FReserveType\": \"\"," +
-                    "                \"FMaterialId\": {" +
-                    "                    \"FNumber\": \"\"" +
-                    "                }," +
-                    "                \"FUnitID\": {" +
-                    "                    \"FNumber\": \"\"" +
-                    "                }," +
-                    "                \"FAppQty\": 0," +
-                    "                \"FActualQty\": 0," +
-                    "                \"FEntryVmiBusiness\": \"false\"," +
-                    "                \"FStockId\": {" +
-                    "                    \"FNumber\": \"\"" +
-                    "                }," +
-                    "                \"FOptPlanBillNo\": \"\"," +
-                    "                \"FStockLocId\": {}," +
-                    "                \"FOptPlanBillId\": 0," +
-                    "                \"FWorkCenterId\": {" +
-                    "                    \"FNUMBER\": \"\"" +
-                    "                }," +
-                    "                \"FOptDetailId\": 0," +
-                    "                \"FLot\": {" +
-                    "                    \"FNumber\": \"\"" +
-                    "                }," +
-                    "                \"FProcessId\": {" +
-                    "                    \"FNumber\": \"\"" +
-                    "                }," +
-                    "                \"FCobyBomEntryID\": 0," +
-                    "                \"FBomId\": {" +
-                    "                    \"FNumber\": \"\"" +
-                    "                }," +
-                    "                \"FGroupRow\": \"\"," +
-                    "                \"FSrcPickEntryId\": 0," +
-                    "                \"FSrcBusinessType\": \"\"," +
-                    "                \"FStockStatusId\": {" +
-                    "                    \"FNumber\": \"\"" +
-                    "                }," +
-                    "                \"FQueryStockUpdate\": \"\"," +
-                    "                \"FProduceDate\": \"1900-01-01\"," +
-                    "                \"FSendRowId\": \"\"," +
-                    "                \"FEntrtyMemo\": \"\"," +
-                    "                \"FMtoNo\": \"\"," +
-                    "                \"FProjectNo\": \"\"," +
-                    "                \"FMoEntryId\": 0," +
-                    "                \"FPPBomEntryId\": 0," +
-                    "                \"FOperId\": 0," +
-                    "                \"FOwnerTypeId\": \"\"," +
-                    "                \"FStockUnitId\": {" +
-                    "                    \"FNumber\": \"\"" +
-                    "                }," +
-                    "                \"FStockAppQty\": 0," +
-                    "                \"FStockActualQty\": 0," +
-                    "                \"FStockAllowOverQty\": 0," +
-                    "                \"FSecUnitId\": {" +
-                    "                    \"FNumber\": \"\"" +
-                    "                }," +
-                    "                \"FSecActualQty\": 0," +
-                    "                \"FSecAllowOverQty\": 0," +
-                    "                \"FMoId\": 0," +
-                    "                \"FMoEntrySeq\": 0," +
-                    "                \"FAllowOverQty\": 0," +
-                    "                \"FPPBomBillNo\": \"\"," +
-                    "                \"FBaseUnitId\": {" +
-                    "                    \"FNumber\": \"\"" +
-                    "                }," +
-                    "                \"FBaseAppQty\": 0," +
-                    "                \"FBaseActualQty\": 0," +
-                    "                \"FBaseAllowOverQty\": 0," +
-                    "                \"FEntryWorkShopId\": {" +
-                    "                    \"FNumber\": \"\"" +
-                    "                }," +
-                    "                \"FKeeperTypeId\": \"\"," +
-                    "                \"FKeeperId\": {" +
-                    "                    \"FNumber\": \"\"" +
-                    "                }," +
-                    "                \"FOwnerId\": {" +
-                    "                    \"FNumber\": \"\"" +
-                    "                }," +
-                    "                \"FExpiryDate\": \"1900-01-01\"," +
-                    "                \"FSrcBillType\": \"\"," +
-                    "                \"FSrcBillNo\": \"\"," +
-                    "                \"FPrice\": 0," +
-                    "                \"FAmount\": 0," +
-                    "                \"FEntrySrcInterId\": 0," +
-                    "                \"FEntrySrcEnteryId\": 0," +
-                    "                \"FEntrySrcEntrySeq\": 0," +
-                    "                \"FParentOwnerTypeId\": \"\"," +
-                    "                \"FParentOwnerId\": {" +
-                    "                    \"FNumber\": \"\"" +
-                    "                }," +
-                    "                \"FSRCBIZBILLTYPE\": {" +
-                    "                    \"FNAME\": \"\"" +
-                    "                }," +
-                    "                \"FSRCBIZBILLNO\": \"\"," +
-                    "                \"FSRCBIZINTERID\": 0," +
-                    "                \"FSRCBIZENTRYID\": 0," +
-                    "                \"FSRCBIZENTRYSEQ\": 0," +
-                    "                \"FPickingStatus\": 0," +
-                    "                \"F_EMD_Qty\": 0," +
-                    "                \"F_EMD_Qty1\": 0," +
-                    "                \"F_EMD_Qty3\": 0," +
-                    "                \"F_EMD_Qty4\": 0," +
-                    "                \"F_EMD_Qty5\": 0," +
-                    "                \"FTransRetFormId\": \"\"," +
-                    "                \"FTransRetBillNo\": \"\"," +
-                    "                \"FTransRetId\": 0," +
-                    "                \"FTransRetEntryId\": 0," +
-                    "                \"FTransRetEntrySeq\": 0," +
-                    "                \"FAuxPropId\": {}," +
-                    "                \"FSerialSubEntity\": [" +
-                    "                    {" +
-                    "                        \"FDetailID\": 0," +
-                    "                        \"FSerialNo\": \"\"," +
-                    "                        \"FSerialId\": {" +
-                    "                            \"FNumber\": \"\"" +
-                    "                        }," +
-                    "                        \"FSerialNote\": \"\"" +
-                    "                    }" +
-                    "                ]" +
-                    "            }" +
-                    "        ]" +
-                    "    }";*//*
-
-            System.out.println("start----"+KingdeeFormId.SUBPICKMTRL.name());
-            List<ProdInoutPickingF> fList = new ArrayList<ProdInoutPickingF>();
-            ProdInoutPickingF  prodInoutPickingF= null;
-            for(int i = 1; i< 10 ; i++) {
-                prodInoutPickingF =  new ProdInoutPickingF();
-                prodInoutPickingF.setFEntryID(i);
-                fList.add(prodInoutPickingF);
-            }
-            ProdInoutPickingSaveReqModel reqModel = ProdInoutPickingSaveReqModel.builder().FBillType(
-                   new FNumberE(" ")
-            ).FDate("2021-08-09").FStockOrgId(new FNumberE("0")).FStockId0(new FNumberE("0")).FEntity(fList).
-                    build();
-            CommonSaveReq commonSaveReq = new CommonSaveReq<ProdInoutPickingSaveReqModel>();
-            commonSaveReq.setModel(reqModel);
-            System.out.println(JSONObject.fromObject(commonSaveReq).toString());
-            String Result = client.save(KingdeeFormId.SUBPICKMTRL.getFormId(), JSONObject.fromObject(commonSaveReq).toString());
-            System.out.println(" success:" + Result);
-        } catch (Exception e) {
-            e.printStackTrace();
-        }*/
-
-    }
-}

src/main/java/com/uas/eis/service/CommonService.java

@@ -1,20 +0,0 @@
-package com.uas.eis.service;
-
-
-import java.util.Map;
-
-/**
- * @author wuyx
- * @email wuyx@usoftchina.com
- * @date 2023-07-27
- */
-public interface CommonService {
-    //记录成功日志
-    void logSRecord(String code_,int keyvalue_);
-    void logSRecordBycon(String code_,String keyvalue_field,String logTab, String con);
-    //记录失败日志
-    void logFRecord(String code_,String err_,int keyvalue_);
-    void logFRecordBycon(String code_,String keyvalue_field,String logTab, String con, String err_);
-
-    int saveFilePath(String path, int size, String fileName, String emName);
-}

src/main/java/com/uas/eis/service/Impl/CommonServiceImpl.java

@@ -1,50 +0,0 @@
-package com.uas.eis.service.Impl;
-
-import com.uas.eis.dao.*;
-import com.uas.eis.entity.Employee;
-import com.uas.eis.service.CommonService;
-import com.uas.eis.utils.Constant;
-import com.uas.eis.utils.DateUtil;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Service;
-
-import java.util.Date;
-
-@Service
-public class CommonServiceImpl implements CommonService {
-    @Autowired
-    private BaseDao baseDao;
-
-    @Override
-    public void logSRecord(String code_, int keyvalue_) {
-        baseDao.execute("insert into invoicedockLog(id_,code_,date_,result_,keyvalue_) values (invoicedockLog_seq.nextval,?,sysdate,'SUCCEED',?)",code_,keyvalue_);
-    }
-    @Override
-    public void logSRecordBycon(String code_,String keyvalue_field,String logTab, String con) {
-        baseDao.execute("insert into invoicedockLog(id_,code_,date_,result_,keyvalue_) " +
-                "select invoicedockLog_seq.nextval,'"+code_+"',sysdate,'SUCCEED',id_ from ( select min("+keyvalue_field+") id_ from "+logTab+" where "+con+")");
-    }
-    @Override
-    public void logFRecord(String code_, String err_, int keyvalue_) {
-        baseDao.execute("insert into invoicedockLog(id_,code_,date_,result_,err_,keyvalue_) values (invoicedockLog_seq.nextval,?,sysdate,'FAILED',?,?)",code_,err_,keyvalue_);
-    }
-    @Override
-    public void logFRecordBycon(String code_,String keyvalue_field,String logTab, String con, String err_) {
-        baseDao.execute("insert into invoicedockLog(id_,code_,date_,result_,err_,keyvalue_) " +
-                "select invoicedockLog_seq.nextval,'"+code_+"',sysdate,'FAILED','"+err_+"',id_ from ( select min("+keyvalue_field+") id_ from "+logTab+" where "+con+")");
-    }
-    @Override
-    public int saveFilePath(String path, int size, String fileName, String emName) {
-        int id = baseDao.getSeqId("EMAILFILEPATH");
-        if (path.contains("\\")) {//上传到本地返回路径修改
-            path = path.replace("\\", "/");
-        }
-        /**
-         * 文件名含单引号无法下载*/
-        fileName=fileName.replaceAll(",", "，");
-        baseDao.execute("INSERT INTO filepath(fp_id,fp_path,fp_size,fp_man,fp_date,fp_name) values(" + id + ",'" + path + "'," + size
-                + ",'"+emName+"'," + DateUtil.parseDateToOracleString(Constant.YMD_HMS, new Date()) + ",'" + fileName
-                + "')");
-        return id;
-    }
-}

src/main/java/com/uas/eis/service/Impl/MESServiceImpl.java

@@ -1,3251 +0,0 @@
-package com.uas.eis.service.Impl;
-
-import com.alibaba.fastjson.JSON;
-import com.alibaba.fastjson.JSONArray;
-import com.alibaba.fastjson.JSONObject;
-import com.alibaba.fastjson.serializer.SerializerFeature;
-import com.uas.eis.dao.BaseDao;
-import com.uas.eis.dao.SqlRowList;
-import com.uas.eis.dto.Key;
-import com.uas.eis.entity.*;
-import com.uas.eis.sdk.entity.ApiResult;
-import com.uas.eis.sdk.resp.ApiResponse;
-import com.uas.eis.service.MESService;
-import com.uas.eis.utils.*;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.jdbc.core.BeanPropertyRowMapper;
-import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Transactional;
-
-import javax.servlet.http.HttpServletRequest;
-import java.io.IOException;
-import java.util.*;
-
-/**
- * @author koul
- * @email koul@usoftchina.com
- * @date 2021-12-08 9:32
- */
-@Service
-public class MESServiceImpl implements MESService {
-    private final Logger logger = LoggerFactory.getLogger(this.getClass());
-
-    @Autowired
-    private BaseDao baseDao;
-
-    @Autowired
-    private TransferRepository transferRepository;
-
-    @Override
-    public ApiResult<String> checkVerifyApply(HttpServletRequest request) {
-        JSONObject jsonData = getJsonData(request);
-        String mesCode = StringUtil.nvl(jsonData.get("mesCode"), "");
-        if ("".equals(mesCode)){
-            return ApiResponse.failRsp("10011",request.getHeader("RequestId"),"MES编号不能为空！");
-        }
-        VerifyApply verifyApply = baseDao.getJdbcTemplate().queryForObject("select va_id,va_mescode,va_code,to_char(va_date,'yyyy-MM-dd HH24:mi:ss') va_date,va_vendcode,va_vendname,va_currency,va_rate,va_paymentscode,va_payments,va_transport,va_sendcode,va_emcode,va_emname,va_departmentcode,va_department,va_recorder,case when nvl(va_cop,' ')=' ' then 'BYT' else va_cop end va_cop,va_remark,va_ancode,va_factory,0 version,va_type,va_pucode,case when nvl(va_pucode,' ')=' ' then 0 else (select pu_id from purchase where pu_code=va_pucode) end pu_id,va_status,1 posted,to_char(va_auditdate,'yyyy-MM-dd HH24:mi:ss') va_auditdate,va_auditman,va_custcode,va_custname from VerifyApply where va_statuscode='AUDITED' and va_mescode=?",
-                new BeanPropertyRowMapper<VerifyApply>(VerifyApply.class), mesCode);
-
-        if (verifyApply==null) {
-            return ApiResponse.failRsp("10012",request.getHeader("RequestId"),"单据未审核或不存在，请确认！");
-        }
-        SqlRowList rs = baseDao.queryForRowSet("select case when va_custcode='AR214' or nvl(va_custcode,' ')=' ' then 'BYT' else nvl(cu_mescode,cu_code) end cu_code,cu_name from verifyapply left join customer on va_custcode=cu_code where va_statuscode='AUDITED' and va_mescode='"+mesCode+"'");
-        if (rs.next()){
-            verifyApply.setVa_custcode(rs.getString("cu_code"));
-        }
-        List<VerifyApplyDetail> verifyApplyDetails = baseDao.query("select vad_code,vad_prodcode,pr_detail,replace(PR_SPEC,'''','''''') pr_spec,pr_unit,va_recorder,va_date,pr_kh_user,cu_name,sum(nvl(vad_qty,0)) vad_qty,vad_salecode from ( select vad_code,vad_prodcode,pr_detail,pr_spec,pr_unit,vad_qty,va_recorder,to_char(va_date,'yyyy-MM-dd HH24:mi:ss') va_date,case when pr_kh_user='柏英特' or nvl(pr_kh_user,' ')=' ' then 'BYT' else nvl(cu_mescode,cu_code) end pr_kh_user,cu_name,vad_salecode from verifyapplydetail left join VerifyApply on va_id=vad_vaid left join product on vad_prodcode=pr_code left join customer on cu_shortname=pr_kh_user where nvl(vad_qty,0)>0 and vad_vaid="+verifyApply.getVa_id()+") group by vad_code,vad_prodcode,pr_detail,pr_spec,pr_unit,va_recorder,va_date,pr_kh_user,cu_name,vad_salecode", VerifyApplyDetail.class);
-        verifyApply.setDetail(verifyApplyDetails);
-        String s = JSON.toJSONString(verifyApply, SerializerFeature.WriteMapNullValue);
-        return ApiResponse.successRsp("0","获取成功！",request.getHeader("RequestId"),s);
-    }
-
-    @Override
-    public ApiResult<String> purcCheckin(HttpServletRequest request) {
-        Map<String, JSONArray> data = getData(request);
-        JSONArray jsonArray = data.get("main");
-        Object vaid=0;
-        String caller="VerifyApply!ToOtherIn";
-        String type="其它入库单";
-        String djcaller="ProdInOut!OtherIn";
-        String sellerName="";
-        String whcode="";
-        for (int i = 0; i <jsonArray.size() ; i++) {
-            JSONObject jsonObject = JSON.parseObject(StringUtil.nvl(jsonArray.get(i), ""));
-            String mesCode = StringUtil.nvl(jsonObject.get("mesCode"),"");
-            whcode= StringUtil.nvl(jsonObject.get("whNo"), "");
-            if ("".equals(mesCode)){
-                return ApiResponse.failRsp("10011",request.getHeader("RequestId"),"ERP单据编号不能为空！");
-            }
-            int count = baseDao.getCountByCondition("verifyApply", "va_statuscode='AUDITED' and va_mescode='" + mesCode + "'");
-            if (count<1){
-                return ApiResponse.failRsp("10012",request.getHeader("RequestId"),"单据未审核或不存在，请确认！");
-            }
-            vaid = baseDao.getFieldDataByCondition("verifyApply", "va_id", "va_statuscode='AUDITED' and va_mescode='" + mesCode + "'");
-            String vaClass = StringUtil.nvl(baseDao.getFieldDataByCondition("VerifyApply", "va_class", "va_id=" + vaid), "");
-            if ("委外收料单".equals(vaClass)) {
-                caller = "VerifyApply!ToOutsideCheckIn";
-                type = "委外验收单";
-                djcaller = "ProdInOut!OutsideCheckIn";
-            }else if("采购收料单".equals(vaClass)){
-                int count1 = baseDao.getCount("select count(1) from VerifyApplyDetail where nvl(vad_pucode,' ')<>' ' and vad_vaid=" + vaid);
-                if (count1 > 0) {
-                    caller = "VerifyApply!ToPurcIn";
-                    type = "采购验收单";
-                    djcaller = "ProdInOut!PurcCheckin";
-                }
-            }
-            //判断已转数
-            Object chekQty = baseDao.getJdbcTemplate().queryForObject("select wmsys.wm_concat('收料单：'||vad_code||'序号：'||vad_detno)  from VerifyApplyDetail where vad_qty < vad_yqty and nvl(vad_qty,0)>0 and nvl(vad_prodcode,' ')<>' ' and vad_vaid = "+vaid, String.class);
-            if(chekQty !=null){
-                return ApiResponse.failRsp("10013",request.getHeader("RequestId"),"检测到" + chekQty + "，本次数量超出可转数量！");
-            }
-            if ("VerifyApply!ToPurcIn".equals(caller)) {
-                // 判断该收料单是否已经转入过采购验收单
-                Object code = baseDao.getFieldDataByCondition("VerifyApply", "va_code", "va_id=" + vaid);
-                code = baseDao.getFieldDataByCondition("ProdInOut", "pi_inoutno", "pi_sourcecode='" + code + "' and " + "PI_REFNO='采购收料单' and pi_class='采购验收单'");
-                if (code != null && !code.equals("")) {
-                    return ApiResponse.failRsp("10014", request.getHeader("RequestId"), "该收料单已转入过采购验收单,验收单号[" + code + "]");
-                }
-            }
-            if ("VerifyApply!ToOtherIn".equals(caller)) {
-                // 判断该收料单是否已经转入过其它入库单
-                Object code = baseDao.getFieldDataByCondition("VerifyApply", "va_code", "va_id=" + vaid);
-                code = baseDao.getFieldDataByCondition("ProdInOut", "pi_inoutno", "pi_sourcecode='" + code + "' and PI_REFNO='采购收料单' and pi_class='其它入库单'");
-                if (code != null && !code.equals("")) {
-                    return ApiResponse.failRsp("10014", request.getHeader("RequestId"), "该收料单已转入过其它入库单,单号[" + code + "]");
-                }
-            }
-            if ("VerifyApply!ToOutsideCheckIn".equals(caller)) {
-                // 判断该收料单是否已经转入过委外验收单
-                Object code = baseDao.getFieldDataByCondition("VerifyApply", "va_code", "va_id=" + vaid);
-                code = baseDao.getFieldDataByCondition("ProdInOut", "pi_inoutno", "pi_sourcecode='" + code + "' and PI_REFNO='采购收料单' and pi_class='委外验收单'");
-                if (code != null && !code.equals("")) {
-                    return ApiResponse.failRsp("10014", request.getHeader("RequestId"), "该收料单已转入过委外验收单,单号[" + code + "]");
-                }
-            }
-            sellerName = StringUtil.nvl(jsonObject.get("sellerName"), "mes");
-        }
-        JSONArray array = data.get("detail");
-        for (int i = 0; i <array.size() ; i++) {
-            JSONObject json = JSON.parseObject(StringUtil.nvl(array.get(i), ""));
-            String itemNo = StringUtil.nvl(json.get("itemNo"), "");
-            Double qty = Double.parseDouble(StringUtil.nvl(json.get("qty"), "0"));
-            Double vadQty = baseDao.getSummaryByField("verifyapplydetail", "vad_qty", "vad_prodcode='" + itemNo + "' and vad_vaid=" + vaid);
-            int compare = qty.compareTo(vadQty);
-            if (compare>0){
-                return ApiResponse.failRsp("10017",request.getHeader("RequestId"), "物料："+itemNo+"，收料数量："+qty+"超出ERP收料单数量："+vadQty+ "，不允许入库！");
-            }
-            if (compare<0){
-                return ApiResponse.failRsp("10018",request.getHeader("RequestId"),"物料："+itemNo+"，收料数量："+qty+"少于ERP收料单数量："+vadQty+"，不允许入库！");
-            }
-        }
-        if ("".equals(whcode)){
-            return ApiResponse.failRsp("10015",request.getHeader("RequestId"),"MES仓库编号不能为空！");
-        }
-        int coun = baseDao.getCount("select count(1) from customtabledetail left join customtable on cd_ctid=ct_id where ct_statuscode='AUDITED' and ct_caller='MESWarehouse' and cd_varchar50_1='" + whcode + "'");
-        if (coun<=0){
-            return ApiResponse.failRsp("10016",request.getHeader("RequestId"),"MES仓库编号在ERP没有对应关系，请联系管理员新增！");
-        }
-        Object[] warehouses = baseDao.getFieldsDataByCondition("customtabledetail left join customtable on cd_ctid=ct_id left join Warehouse on cd_varchar50_3=wh_code", "cd_varchar50_3,wh_description", "ct_statuscode='AUDITED' and ct_caller='MESWarehouse' and cd_varchar50_1='" + whcode + "'");
-
-        int piid =0;
-        Employee employee = baseDao.getJdbcTemplate().queryForObject("select * from employee where em_name=?",
-                new BeanPropertyRowMapper<Employee>(Employee.class), sellerName);
-        // 转采购验收单
-        Key key = transferRepository.transfer(caller, vaid,employee);
-        piid = key.getId();
-        // 转入明细
-        transferRepository.transferDetail(caller, vaid, key,employee);
-        if (piid != 0) {
-            baseDao.execute("delete from prodiodetail where nvl(pd_inqty,0)<=0 and pd_piid="+piid);
-            baseDao.updateByCondition("prodiodetail", "pd_whcode='"+warehouses[0]+"',pd_whname='"+warehouses[1]+"'", "pd_piid=" + piid);
-            baseDao.updateByCondition("prodinout", "pi_whcode='"+warehouses[0]+"',pi_whname='"+warehouses[1]+"'", "pi_id=" + piid);
-            baseDao.execute("update prodiodetail set pd_prodid=(select pr_id from product where pd_prodcode=pr_code) where pd_piid=" + piid
-                    + " and nvl(pd_prodcode,' ')<>' '");
-            baseDao.execute("update prodiodetail set pd_whid=(select wh_id from warehouse where wh_code=pd_whcode) where pd_piid=" + piid
-                    + " and nvl(pd_whcode,' ')<>' '");
-            baseDao.updateByCondition("ProdInOut",
-                    "pi_total=(SELECT round(sum(nvl(pd_orderprice,0)*(nvl(pd_inqty,0)+nvl(pd_outqty,0))),2) FROM ProdIODetail WHERE pd_piid="
-                            + piid + ")", "pi_id=" + piid);
-            baseDao.updateByCondition("ProdInOut", "pi_totalupper=L2U(nvl(pi_total,0))", "pi_id=" + piid);
-            if ("VerifyApply!ToPurcIn".equals(caller)) {
-                baseDao.execute("Insert into ProdChargeDetail(pd_id,pd_piid,pd_detno,pd_type,pd_amount,pd_currency,pd_rate) "
-                        + "select ProdChargeDetail_seq.nextval, " + piid + ", pd_detno, pd_type,pd_amount,pd_currency,pd_rate "
-                        + "from ProdChargeDetailAN where PD_ANID=" + vaid);
-                SqlRowList rs = baseDao.queryForRowSet("select vad_pucode,vad_pudetno,vad_qty from VerifyApplyDetail where vad_vaid=" + vaid);
-                String pCode = null;
-                int pDetno = 0;
-                double yq = 0;
-                Set<String> pCodes = new HashSet<String>();
-                while (rs.next()) {
-                    pCode = rs.getString("vad_pucode");
-                    if (!pCodes.contains(pCode)) {
-                        pCodes.add(pCode);
-                    }
-                    pDetno = rs.getInt("vad_pudetno");
-                    yq = rs.getDouble("vad_qty");
-                    baseDao.updateByCondition("PurchaseDetail", "pd_status='PART2IN'", "pd_code='" + pCode + "' and pd_detno=" + pDetno);
-                    baseDao.updateByCondition("PurchaseDetail", "pd_status='TURNIN'", "pd_code='" + pCode + "' and pd_detno=" + pDetno
-                            + " and pd_qty=" + yq);
-                }
-                Iterator<String> iter = pCodes.iterator();
-                while (iter.hasNext()) {
-                    pCode = iter.next();
-                    int total = baseDao.getCountByCondition("PurchaseDetail", "pd_code='" + pCode + "'");
-                    int aud = baseDao.getCountByCondition("PurchaseDetail", "pd_code='" + pCode + "' AND nvl(pd_acceptqty,0)=0");
-                    int turn = baseDao.getCountByCondition("PurchaseDetail", "pd_code='" + pCode
-                            + "' AND nvl(pd_acceptqty,0)=nvl(pd_qty,0)");
-                    String statuscode = aud == total ? "" : (turn == total ? "TURNIN" : "PART2IN");
-                    String status = aud == total ? "" : (turn == total ? "已入库" : "部分入库");
-                    baseDao.updateByCondition("Purchase",
-                            "pu_turnstatuscode='" + statuscode + "',pu_turnstatus='" + status + "'", "pu_code='" + pCode + "'");
-                }
-            }
-            // 修改收料状态
-            baseDao.updateByCondition("VerifyApplyDetail", "vad_yqty=vad_qty", "vad_vaid=" + vaid);
-            baseDao.updateByCondition("VerifyApply", "va_turnstatuscode='TURNIN',va_turnstatus='已入库'", "va_id=" + vaid);
-            String s = postProdInOut(piid, djcaller, employee);
-            logger.info("收料单入库=="+s);
-            if (s!=null){
-                return ApiResponse.successRsp("0",request.getHeader("RequestId"),type+"："+key.getCode()+"，过账失败，请在ERP重新过账！");
-            }
-            return ApiResponse.successRsp("0",request.getHeader("RequestId"),type+"："+key.getCode()+"，请在ERP查看！");
-        }
-        return ApiResponse.failRsp("10019",request.getHeader("RequestId"),"ERP生成单据失败！");
-    }
-
-    @Override
-    public ApiResult<String> prodInOutMakeIn(HttpServletRequest request) {
-        Map<String, JSONArray> data = getData(request);
-        JSONArray jsonArray = data.get("main");
-        String ma_tasktype="";
-        int piid=0;
-        String picode="";
-        String piclass="完工入库单";
-        String picaller="ProdInOut!Make!In";
-        int ma_id=0;
-        List<String> sqls = new ArrayList<>();
-        Employee employee = baseDao.getJdbcTemplate().queryForObject("select * from employee where em_code=?",
-                new BeanPropertyRowMapper<Employee>(Employee.class), "mes");
-        JSONArray array = data.get("detail");
-        if(array!=null&&array.size()>0){
-            String macode = StringUtil.valueOf(JSON.parseObject(StringUtil.nvl(array.get(0), "{}")).get("FICMOBillNo"));
-            Object[] data1 = baseDao.getFieldsDataByCondition("Make", "ma_tasktype,ma_id", "ma_code in ('" + macode + "')");
-            if (data1!=null&&data1.length>0) {
-                ma_tasktype = StringUtil.nvl(data1[0], "");
-                ma_id = Integer.parseInt(StringUtil.nvl(data1[1], "0"));
-            }else {
-                return ApiResponse.failRsp("10077", request.getHeader("RequestId"), "工单在ERP不存在，请核对！");
-            }
-        }
-        for (int i = 0; i <jsonArray.size() ; i++) {
-            Object obj = jsonArray.get(i);
-            JSONObject jsonObject2 = JSON.parseObject(StringUtil.nvl(obj, ""));
-            Map<Object, Object> map4 = JSONUtil.toMap(StringUtil.valueOf(jsonObject2.get("FDCStockID")));
-            Map<Object, Object> map5 = JSONUtil.toMap(StringUtil.valueOf(jsonObject2.get("FDeptID")));
-            Map<Object, Object> map6 = JSONUtil.toMap(StringUtil.valueOf(jsonObject2.get("FFManagerID")));
-            Map<Object, Object> map7 = JSONUtil.toMap(StringUtil.valueOf(jsonObject2.get("FSManagerID")));
-            Map<Object, Object> map8 = JSONUtil.toMap(StringUtil.valueOf(jsonObject2.get("FBillerID")));
-            String whcode = StringUtil.nvl(map4.get("FNumber"), "");
-            if ("".equals(whcode)) {
-                return ApiResponse.failRsp("10073", request.getHeader("RequestId"), "MES仓库编号不能为空！");
-            }
-            int count = baseDao.getCount("select count(1) from customtabledetail left join customtable on cd_ctid=ct_id where ct_statuscode='AUDITED' and ct_caller='MESWarehouse' and cd_varchar50_1='" + whcode + "'");
-            if (count <= 0) {
-                return ApiResponse.failRsp("10074", request.getHeader("RequestId"), "MES仓库编号在ERP没有对应关系，请联系管理员新增！");
-            }
-            Object[] warehouses = baseDao.getFieldsDataByCondition("customtabledetail left join customtable on cd_ctid=ct_id left join Warehouse on cd_varchar50_3=wh_code", "cd_varchar50_3,wh_description", "ct_statuscode='AUDITED' and ct_caller='MESWarehouse' and cd_varchar50_1='" + whcode + "'");
-            if ("OS".equals(ma_tasktype)) {
-                picaller="ProdInOut!OutsideCheckIn";
-                piclass="委外验收单";
-                // 转入委外验收单主记录
-                piid = baseDao.getSeqId("PRODINOUT_SEQ");
-                picode = baseDao.sGetMaxNumber(picaller, 2);
-                sqls.add("insert into prodinout (pi_id,pi_inoutno,pi_class,pi_date,pi_statuscode,pi_status,pi_whcode,pi_whname,pi_departmentcode,pi_departmentname,pi_emcode,pi_emname,pi_invostatuscode,pi_invostatus,pi_recordman,pi_recorddate,pi_printstatuscode,pi_printstatus) " +
-                        "values (" + piid + ",'" + picode + "','"+piclass+"',to_date('" + jsonObject2.get("Fdate") + "','yyyy-MM-dd HH24:mi:ss'),'UNPOST'," + "'未过账','" + warehouses[0] + "','" + warehouses[1] + "','" + map5.get("FNumber") + "','" + map5.get("FName") + "','" + map6.get("FNumber") + "','" + map7.get("FName") + "','ENTERING','在录入','" + map8.get("FName") + "',to_date('" + jsonObject2.get("Fdate") + "','yyyy-MM-dd HH24:mi:ss'),'UNPRINT','未打印')");
-                sqls.add("update prodinout set (pi_cardcode,pi_title,pi_currency,pi_rate,pi_receivecode," +
-                        "pi_receivename,pi_cardid,pi_paymentcode,pi_payment,pi_cop,pi_belongs," +
-                        "pi_sourcecode,pi_sellercode)=(select ma_vendcode,ma_vendname,ma_currency,ma_rate,ve_apvendcode," +
-                        "ve_apvendname,ve_id,ma_paymentscode,ma_payments,ma_cop,ve_buyername,ma_code,em_code from make left " +
-                        "join Vendor on ma_vendcode=ve_code left join employee on ve_buyerid=em_id where ma_id="+ma_id+") where pi_class='"+piclass+"' and pi_id="+piid);
-                sqls.add("update ProdinOut set pi_sellername=pi_belongs where pi_class='"+piclass+"' and pi_id=" + piid);
-                sqls.add("update ProdinOut set pi_rate=(select CR_RATE from Currencys where pi_currency=cr_name) where pi_class='"+piclass+"' and pi_id=" + piid + " and nvl(pi_rate,0)=0");
-            } else {
-                piid = baseDao.getSeqId("PRODINOUT_SEQ");
-                picode = baseDao.sGetMaxNumber(picaller, 2);
-                sqls.add("insert into prodinout (pi_id,pi_inoutno,pi_class,pi_date,pi_statuscode,pi_status,pi_whcode," +
-                        "pi_whname,pi_departmentcode,pi_departmentname,pi_emcode,pi_emname,pi_invostatuscode," +
-                        "pi_invostatus,pi_recordman,pi_recorddate,pi_printstatuscode,pi_printstatus) values (" + piid + ",'" + picode + "','"+piclass+"',to_date('" + jsonObject2.get("Fdate") + "','yyyy-MM-dd HH24:mi:ss'),'UNPOST'," + "'未过账','" + warehouses[0] + "','" + warehouses[1] + "','" + map5.get("FNumber") + "','" + map5.get("FName") + "','" + map6.get("FNumber") + "','" + map7.get("FName") + "','ENTERING','在录入','" + map8.get("FName") + "',to_date('" + jsonObject2.get("Fdate") + "','yyyy-MM-dd HH24:mi:ss'),'UNPRINT','未打印')");
-            }
-        }
-        int detno=1;
-        for (int i = 0; i <array.size(); i++) {
-            Object obj = array.get(i);
-            JSONObject jsonObject3 = JSON.parseObject(StringUtil.nvl(obj, ""));
-            Map<Object, Object> map11 = JSONUtil.toMap(StringUtil.valueOf(jsonObject3.get("FItemID")));
-            Map<Object, Object> map12 = JSONUtil.toMap(StringUtil.valueOf(jsonObject3.get("FDCStockID1")));
-            String whcode = StringUtil.nvl(map12.get("FNumber"), "");
-            if ("".equals(whcode)){
-                return ApiResponse.failRsp("10075",request.getHeader("RequestId"),"MES仓库编号不能为空！");
-            }
-            int count = baseDao.getCount("select count(1) from customtabledetail left join customtable on cd_ctid=ct_id where ct_statuscode='AUDITED' and ct_caller='MESWarehouse' and cd_varchar50_1='" + whcode + "'");
-            if (count<=0){
-                return ApiResponse.failRsp("10076",request.getHeader("RequestId"),"MES仓库编号在ERP没有对应关系，请联系管理员新增！");
-            }
-            Object[] warehouses = baseDao.getFieldsDataByCondition("customtabledetail left join customtable on cd_ctid=ct_id left join Warehouse on cd_varchar50_3=wh_code", "cd_varchar50_3,wh_description", "ct_statuscode='AUDITED' and ct_caller='MESWarehouse' and cd_varchar50_1='" + whcode + "'");
-            String fBatchNo = StringUtil.nvl(jsonObject3.get("FBatchNo"), "");
-            float fauxqty = jsonObject3.get("Fauxqty") == null ? 0 : Float.parseFloat(jsonObject3.get("Fauxqty").toString());
-            String fSecUnitID = StringUtil.nvl(jsonObject3.get("FSecUnitID"), "");
-            float fSecCoefficient = jsonObject3.get("FSecCoefficient") == null ? 0 : Float.parseFloat(jsonObject3.get("FSecCoefficient").toString());
-            float fSecQty = jsonObject3.get("FSecQty") == null ? 0 : Float.parseFloat(jsonObject3.get("FSecQty").toString());
-            float fAuxPlanPrice = jsonObject3.get("FAuxPlanPrice") == null ? 0 : Float.parseFloat(jsonObject3.get("FAuxPlanPrice").toString());
-            float fPlanAmount = jsonObject3.get("FPlanAmount") == null ? 0 : Float.parseFloat(jsonObject3.get("FPlanAmount").toString());
-            float fauxprice = jsonObject3.get("Fauxprice") == null ? 0 : Float.parseFloat(jsonObject3.get("Fauxprice").toString());
-            float famount = jsonObject3.get("Famount") == null ? 0 : Float.parseFloat(jsonObject3.get("Famount").toString());
-            String fnote = StringUtil.nvl(jsonObject3.get("Fnote"), "");
-            String fKFDate = StringUtil.nvl(jsonObject3.get("FKFDate"), "");
-            String fPeriodDate = StringUtil.nvl(jsonObject3.get("FPeriodDate"), "");
-            int fDCSPID = jsonObject3.get("FDCSPID") == null ? 0 : Integer.parseInt(jsonObject3.get("FDCSPID").toString());
-            Object location="";
-            if (fDCSPID>0){
-                location = baseDao.getFieldDataByCondition("ProductLocation", "pl_name", "pl_id=" + fDCSPID);
-            }
-            String fSourceBillNo = StringUtil.nvl(jsonObject3.get("FSourceBillNo"), "");
-            String fICMOBillNo = StringUtil.nvl(jsonObject3.get("FICMOBillNo"), "");
-            String fEntrySelfA0248 = StringUtil.nvl(jsonObject3.get("FEntrySelfA0248"), "");
-            String fEntrySelfA0245 = StringUtil.nvl(jsonObject3.get("FEntrySelfA0245"), "");
-            String fEntrySelfA0246 = StringUtil.nvl(jsonObject3.get("FEntrySelfA0246"), "");
-            String fEntrySelfA0247 = StringUtil.nvl(jsonObject3.get("FEntrySelfA0247"), "0");
-            String fEntrySelfA0242 = StringUtil.nvl(jsonObject3.get("FEntrySelfA0242"), "0");
-            if ("OS".equals(ma_tasktype)) {
-                sqls.add("insert into prodiodetail (pd_id,pd_piid,pd_inoutno,pd_piclass,pd_pdno,pd_ordercode,pd_prodcode," +
-                        "pd_batchcode,pd_inqty,pd_nxlh,pd_purcrate,pd_notinqty,pd_orderprice,pd_ordertotal,pd_price," +
-                        "pd_total,pd_whcode,pd_whname,pd_remark,pd_prodmadedate,pd_replydate,pd_location,pd_macode,pd_xb," +
-                        "pd_bz,pd_dbds,pd_zds,pd_status) values (PRODIODETAIL_SEQ.nextval," + piid + ",'" + picode + "','"+piclass+
-                        "'," + detno + ",'" + fSourceBillNo +
-                        "','" + map11.get("FNumber") + "','" + fBatchNo + "'," + fauxqty + ",'" + fSecUnitID + "'," + fSecCoefficient + "," + fSecQty + "," + fAuxPlanPrice + "," + fPlanAmount + "," + fauxprice + "," +
-                        "" + famount + ",'" + warehouses[0] + "','" + warehouses[1] + "','" + fnote + "',to_date('" + fEntrySelfA0248 + "'," +
-                        "'yyyy-MM-dd HH24:mi:ss'),to_date('" + fPeriodDate + "','yyyy-MM-dd HH24:mi:ss'),'" + location + "','" + fICMOBillNo + "','" + fEntrySelfA0246 + "','" + fEntrySelfA0245 + "'," + fEntrySelfA0247 + "," + fEntrySelfA0242 + ",0)");
-                detno++;
-            }else {
-                sqls.add("insert into prodiodetail (pd_id,pd_piid,pd_inoutno,pd_piclass,pd_pdno,pd_ordercode,pd_prodcode," +
-                        "pd_batchcode,pd_inqty,pd_nxlh,pd_purcrate,pd_notinqty,pd_orderprice,pd_ordertotal,pd_price," +
-                        "pd_total,pd_whcode,pd_whname,pd_remark,pd_prodmadedate,pd_replydate,pd_location,pd_macode,pd_xb," +
-                        "pd_bz,pd_dbds,pd_zds,pd_status) values (PRODIODETAIL_SEQ.nextval," + piid + ",'" + picode + "','"+piclass+
-                        "'," + detno + ",'" + fSourceBillNo +
-                        "','" + map11.get("FNumber") + "','" + fBatchNo + "'," + fauxqty + ",'" + fSecUnitID + "'," + fSecCoefficient + "," + fSecQty + "," + fAuxPlanPrice + "," + fPlanAmount + "," + fauxprice + "," +
-                        "" + famount + ",'" + warehouses[0] + "','" + warehouses[1] + "','" + fnote + "',to_date('" + fEntrySelfA0248 + "'," +
-                        "'yyyy-MM-dd HH24:mi:ss'),to_date('" + fPeriodDate + "','yyyy-MM-dd HH24:mi:ss'),'" + location + "','" + fICMOBillNo + "','" + fEntrySelfA0246 + "','" + fEntrySelfA0245 + "'," + fEntrySelfA0247 + "," + fEntrySelfA0242 + ",0)");
-                detno++;
-            }
-        }
-        if ("OS".equals(ma_tasktype)) {
-            sqls.add("update prodiodetail set (pd_location,pd_orderprice,pd_taxrate,pd_prodid,pd_orderid,pd_wccode)=" +
-                    "(select pr_location,ma_price,ma_taxrate,pr_id,ma_id,ma_wccode from make left join Product on " +
-                    "ma_prodcode=pr_code where ma_id="+ma_id+") where pd_piid="+piid);
-            sqls.add("update Prodiodetail set pd_whname=(select wh_description from warehouse where pd_whcode=wh_code) where pd_piid="
-                    + piid);
-            sqls.add("update Prodiodetail set pd_total=round(pd_inqty*pd_orderprice,2) where pd_piid=" + piid);
-        }
-        //更新已转完工数
-        sqls.add("update make set ma_tomadeqty=nvl((select sum(pd_inqty)-sum(case when pd_status=99 then pd_outqty else 0 end) from prodiodetail where pd_ordercode=ma_code and pd_piclass in('完工入库单','委外验收单','委外验退单')),0) where ma_id=" + ma_id);
-        sqls.add("update make set ma_tomadeqty=ma_madeqty where ma_id=" + ma_id + " and nvl(ma_madeqty,0)>nvl(ma_tomadeqty,0)");
-        //更新最大套料数
-        sqls.add("update make set ma_canmadeqty=nvl((select min(case when NVL(mm_havegetqty,0)-NVL(mm_scrapqty,0)>=mm_qty then ma_qty else floor((  nvl(mm_havegetqty, 0)-nvl(mm_scrapqty,0))*1.0/mm_oneuseqty )end) from makematerial where mm_maid=ma_id and nvl(mm_materialstatus,' ')=' ' and mm_oneuseqty>0 and mm_oneuseqty*ma_qty<=mm_qty+0.1 ),0)  where ma_id in (" + ma_id + ") ");
-        sqls.add("update make set ma_canmadeqty=ma_qty where ma_id in (" + ma_id
-                + ") and ma_id not in (select ma_id from make left join makematerial on ma_id=mm_maid where ma_id in (" + ma_id
-                + ") and nvl(mm_materialstatus,' ')=' ' and mm_oneuseqty>0 and mm_oneuseqty*ma_qty<=mm_qty+0.1)");
-        sqls.add("update make set ma_canmadeqty=0 where ma_id in (" + ma_id + ") and NVL(ma_canmadeqty,0)<=0");
-        baseDao.execute(sqls);
-        String s = postProdInOut(piid, picaller, employee);
-        logger.info("完工过账信息=="+s);
-        if (s!=null){
-            return ApiResponse.successRsp("0",request.getHeader("RequestId"),piclass+"："+picode+"，过账失败，请在ERP重新过账！");
-        }
-        return ApiResponse.successRsp("0",request.getHeader("RequestId"),piclass+"："+picode+"，请在ERP查看！");
-    }
-
-    @Override
-    public ApiResult<String> makeDeleteCheck(HttpServletRequest request) {
-        JSONObject jsonData = getJsonData(request);
-        Object maId = jsonData.get("finterid");
-        // 只能删除在录入的单据!
-        SqlRowList status =
-                baseDao.queryForRowSet("select ma_statuscode,ma_checkstatuscode from make where ma_code='"+maId+"'");
-        if (status.next()) {
-            if (!status.getString("ma_statuscode").equals("ENTERING") && (status.getString("ma_checkstatuscode").equals("APPROVE") || status.getString("ma_checkstatuscode").equals("COMMITED"))) {
-                return ApiResponse.failRsp("10015",request.getHeader("RequestId"),"只能删除在录入且批准状态不等于已批准或已提交的工单");
-            }
-        }
-        // 启用工厂模式 有对应的作业单 制造单不能删除
-        if (baseDao.isDBSetting("sys","usingMakeCraft")) {
-            int count = baseDao.getCount("Select count(1) from makecraft left join make on mc_makecode=ma_code where ma_code='"+maId+"'");
-            if (count > 0) {
-                return ApiResponse.failRsp("10016",request.getHeader("RequestId"),"当前工单存在作业单，不能删除");
-            }
-        }
-        return ApiResponse.successRsp("0",request.getHeader("RequestId"),"校验通过！");
-    }
-
-    @Override
-    public ApiResult<String> initMakeScrap(HttpServletRequest request) {
-        Map<String, JSONArray> data = getData(request);
-        JSONArray jsonArray = data.get("main");
-        int id=0;
-        String code="";
-        List<String> sqls = new ArrayList<>();
-        for (int i = 0; i <jsonArray.size() ; i++) {
-            JSONObject jsonObject = JSON.parseObject(StringUtil.nvl(jsonArray.get(i), ""));
-            id = baseDao.getSeqId("MAKESCRAP_SEQ");
-            code = baseDao.sGetMaxNumber("MakeScrap", 2);
-            String fdateTime = StringUtil.nvl(jsonObject.get("FdateTime"), DateUtil.format(new Date(), "yyyy-MM-dd HH:mm:ss"));
-            String fwcCode = StringUtil.nvl(jsonObject.get("FwcCode"), "");
-            if ("".equals(fwcCode)) {
-                return ApiResponse.failRsp("10021", request.getHeader("RequestId"), "工作中心不能为空！");
-            }
-            String createdUser = StringUtil.nvl(jsonObject.get("createdUser"), "mes");
-            String createdDateTime = StringUtil.nvl(jsonObject.get("createdDateTime"), DateUtil.format(new Date(), "yyyy-MM-dd HH:mm:ss"));
-            String companyNo = StringUtil.nvl(jsonObject.get("companyNo"), "BYT");
-            String fremark = StringUtil.nvl(jsonObject.get("Fremark"), "");
-            sqls.add("insert into MakeScrap (ms_id,ms_code,ms_class,ms_statuscode,ms_status,ms_printstatuscode,ms_printstatus," +
-                    "ms_date,ms_wccode,ms_recordman,ms_indate,ms_cop,ms_remark) values (" + id + ",'" + code + "','生产报废单','ENTERING'," +
-                    "'在录入','UNPRINT','未打印',to_date('" + fdateTime + "','yyyy-MM-dd HH24:mi:ss'),'" + fwcCode + "','" + createdUser +
-                    "',to_date('" + createdDateTime + "','yyyy-MM-dd HH24:mi:ss'),'" + companyNo + "','" + fremark + "')");
-        }
-        JSONArray array = data.get("detail");
-        int detno=1;
-        for (int i = 0; i <array.size(); i++) {
-            JSONObject object = JSON.parseObject(StringUtil.nvl(array.get(i), "{}"));
-            String lineId = StringUtil.nvl(object.get("lineId"), "");
-            if ("".equals(lineId)){
-                return ApiResponse.failRsp("10022",request.getHeader("RequestId"),"工单明细ID不能为空！");
-            }
-            Object mmdetno = baseDao.getFieldDataByCondition("MakeMaterial", "mm_detno", "mm_id in (" + lineId+")");
-            String prodNo = StringUtil.nvl(object.get("prodNo"), "");
-            if ("".equals(prodNo)){
-                return ApiResponse.failRsp("10023",request.getHeader("RequestId"),"工单单号不能为空！");
-            }
-            String prodDetno = StringUtil.nvl(object.get("prodDetno"), "");
-            if ("".equals(prodDetno)){
-                return ApiResponse.failRsp("10024",request.getHeader("RequestId"),"工单行号不能为空！");
-            }
-            String itemNo = StringUtil.nvl(object.get("itemNo"), "");
-            if ("".equals(itemNo)){
-                return ApiResponse.failRsp("10024",request.getHeader("RequestId"),"物料不能为空！");
-            }
-            String qty = StringUtil.nvl(object.get("qty"), "");
-            if ("".equals(qty)){
-                return ApiResponse.failRsp("10025",request.getHeader("RequestId"),"报废数量不能为空！");
-            }
-            String reason = StringUtil.nvl(object.get("reason"), "");
-            if ("".equals(reason)){
-                return ApiResponse.failRsp("10026",request.getHeader("RequestId"),"报废原因不能为空！");
-            }
-            String fDeptID = StringUtil.nvl(object.get("FDeptID"), "");
-            if ("".equals(fDeptID)){
-                return ApiResponse.failRsp("10027",request.getHeader("RequestId"),"责任部门编号不能为空！");
-            }
-            String fDept = StringUtil.nvl(object.get("FDept"), "");
-            if ("".equals(fDept)){
-                return ApiResponse.failRsp("10028",request.getHeader("RequestId"),"责任部门不能为空！");
-            }
-
-            String allScrapQty = StringUtil.nvl(object.get("AllScrapQty"), "0");
-            String remark = StringUtil.nvl(object.get("remark"), "");
-            sqls.add("insert into MakeScrapdetail (md_id,md_msid,md_detno,md_mmid,md_mmcode,md_mmdetno,md_prodcode," +
-                    "md_qty,md_reason,md_department,md_departmentname,md_allscrapqty,md_remark) values " +
-                    "(MAKESCRAPDETAIL_SEQ.nextval,"+id+","+detno+","+lineId+",'"+prodNo+"',"+mmdetno+",'"+itemNo+
-                    "',"+qty+",'"+reason+"','"+fDeptID+"','"+fDept+"',"+allScrapQty+",'"+remark+"')");
-            detno++;
-        }
-        baseDao.execute(sqls);
-        return ApiResponse.successRsp("0",request.getHeader("RequestId"),"生产报废单："+code+"，请在ERP查看！");
-    }
-
-    @Override
-    public ApiResult<String> prodInOutOtherOut(HttpServletRequest request) {
-        Map<String, JSONArray> data = getData(request);
-        JSONArray jsonArray = data.get("main");
-        int id=0;
-        String code="";
-        List<String> sqls = new ArrayList<>();
-        for (int i = 0; i <jsonArray.size() ; i++) {
-            JSONObject jsonObject2 = JSON.parseObject(StringUtil.nvl(jsonArray.get(i), ""));
-            Map<Object, Object> map1 = JSONUtil.toMap(StringUtil.valueOf(jsonObject2.get("FDeptID")));
-            Map<Object, Object> map2 = JSONUtil.toMap(StringUtil.valueOf(jsonObject2.get("FBillTypeID")));
-            Map<Object, Object> map3 = JSONUtil.toMap(StringUtil.valueOf(jsonObject2.get("FFManagerID")));
-            Map<Object, Object> map4 = JSONUtil.toMap(StringUtil.valueOf(jsonObject2.get("FSManagerID")));
-            Map<Object, Object> map5 = JSONUtil.toMap(StringUtil.valueOf(jsonObject2.get("FBillerID")));
-            id = baseDao.getSeqId("PRODINOUT_SEQ");
-            code = baseDao.sGetMaxNumber("ProdInOut!OtherOut", 2);
-            sqls.add("insert into prodinout (pi_id,pi_inoutno,pi_class,pi_date,pi_statuscode,pi_status,pi_departmentcode,pi_departmentname,pi_emcode,pi_emname,pi_invostatuscode,pi_invostatus,pi_recordman,pi_recorddate,pi_printstatuscode,pi_printstatus,pi_type) " +
-                    "values ("+id+",'"+code+"','其它出库单',to_date('"+jsonObject2.get("Fdate")+"','yyyy-MM-dd HH24:mi:ss'),'UNPOST','未过账','"+map1.get("FNumber")+"','"+map1.get("FName")+"','"+map3.get("FNumber")+"','"+map3.get("FName")+"','ENTERING','在录入','"+map5.get("FName")+"',to_date('"+jsonObject2.get("Fdate")+"','yyyy-MM-dd HH24:mi:ss'),'UNPRINT','未打印','"+map2.get("FName")+"')");
-        }
-        JSONArray array = data.get("detail");
-        int detno=1;
-        for (int i = 0; i <array.size(); i++) {
-            JSONObject object = JSON.parseObject(StringUtil.nvl(array.get(i), "{}"));
-            Map<Object, Object> map = JSONUtil.toMap(StringUtil.valueOf(object.get("FItemID")));
-            String itemNo = StringUtil.nvl(map.get("FNumber"), "");
-            if ("".equals(itemNo)){
-                return ApiResponse.failRsp("10031",request.getHeader("RequestId"),"物料不能为空！");
-            }
-            String qty = StringUtil.nvl(object.get("FAuxQtyMust"), "");
-            if ("".equals(qty)){
-                return ApiResponse.failRsp("10032",request.getHeader("RequestId"),"实出数量不能为空！");
-            }
-            String fnote = StringUtil.nvl(object.get("Fnote"), "");
-            Map<Object, Object> map1 = JSONUtil.toMap(StringUtil.valueOf(object.get("FDCStockID1")));
-            String whcode = StringUtil.nvl(map1.get("FNumber"), "");
-            String whname = StringUtil.nvl(map1.get("FName"), "");
-            if ("".equals(whcode)){
-                return ApiResponse.failRsp("10034",request.getHeader("RequestId"),"MES仓库编号不能为空！");
-            }
-            int count = baseDao.getCount("select count(1) from customtabledetail left join customtable on cd_ctid=ct_id where ct_statuscode='AUDITED' and ct_caller='MESWarehouse' and cd_varchar50_1='" + whcode + "'");
-            if (count<=0){
-                return ApiResponse.failRsp("10035",request.getHeader("RequestId"),"MES仓库编号在ERP没有对应关系，请联系管理员新增！");
-            }
-            Object[] warehouses = baseDao.getFieldsDataByCondition("customtabledetail left join customtable on cd_ctid=ct_id left join Warehouse on cd_varchar50_3=wh_code", "cd_varchar50_3,wh_description", "ct_statuscode='AUDITED' and ct_caller='MESWarehouse' and cd_varchar50_1='" + whcode + "'");
-            sqls.add("insert into prodiodetail (pd_id,pd_piid,pd_inoutno,pd_piclass,pd_pdno,pd_prodcode," +
-                    "pd_outqty,pd_whcode,pd_whname,pd_remark) " +
-                    "values (PRODIODETAIL_SEQ.nextval,"+id+",'"+code+"','其它出库单',"+detno+",'"+itemNo+ "',"+qty+",'"+warehouses[0]+"','"+warehouses[1]+"','"+fnote+"')");
-            detno++;
-        }
-        baseDao.execute(sqls);
-        return ApiResponse.successRsp("0",request.getHeader("RequestId"),"其它出库单："+code+"，请在ERP查看！");
-    }
-
-    @Override
-    public ApiResult<String> prodInOutPicking(HttpServletRequest request) {
-        Map<String, JSONArray> data = getData(request);
-        JSONArray jsonArray = data.get("main");
-        String bccode = null;
-        int bcpiid = 0;
-        String llcode = null;
-        int llpiid=0;
-        String ma_tasktype=null;
-        int maid=0;
-        String llpiclass = "生产领料单", llcaller = "ProdInOut!Picking", bcpiclass = "拨出单", bccaller = "ProdInOut!AppropriationOut";
-        // 是否生成调拨单，勾选不生成，不勾选默认生成
-        Boolean notCreateAppropriation = baseDao.isDBSetting("MultiMakeSendLS", "notCreateAppropriation");
-        List<String> sqls = new ArrayList<>();
-        JSONArray array = data.get("detail");
-        if(array!=null&&array.size()>0){
-            String macode = StringUtil.valueOf(JSON.parseObject(StringUtil.nvl(array.get(0), "{}")).get("FICMOBillNo"));
-            Object[] data1 = baseDao.getFieldsDataByCondition("Make", "ma_tasktype,ma_id", "ma_code in ('" + macode + "')");
-            if (data1!=null&&data1.length>0) {
-                ma_tasktype = StringUtil.nvl(data1[0], "");
-                maid = Integer.parseInt(StringUtil.nvl(data1[1], "0"));
-            }else {
-                return ApiResponse.failRsp("10046", request.getHeader("RequestId"), "工单在ERP不存在，请核对！");
-            }
-        }
-        for (int i = 0; i <jsonArray.size() ; i++) {
-            JSONObject jsonObject2 = JSON.parseObject(StringUtil.nvl(jsonArray.get(i), ""));
-            Map<Object, Object> map1 = JSONUtil.toMap(StringUtil.valueOf(jsonObject2.get("FDeptID")));
-            Map<Object, Object> map2 = JSONUtil.toMap(StringUtil.valueOf(jsonObject2.get("FPurposeID")));
-            Map<Object, Object> map3 = JSONUtil.toMap(StringUtil.valueOf(jsonObject2.get("FFManagerID")));
-            Map<Object, Object> map4 = JSONUtil.toMap(StringUtil.valueOf(jsonObject2.get("FSManagerID")));
-            Map<Object, Object> map5 = JSONUtil.toMap(StringUtil.valueOf(jsonObject2.get("FBillerID")));
-            if ("OS".equals(ma_tasktype)) {
-                llpiclass = "委外领料单";
-                llcaller = "ProdInOut!OutsidePicking";
-            }
-            if(!notCreateAppropriation){
-                //生成拨出单
-                bcpiid = baseDao.getSeqId("PRODINOUT_SEQ");
-                bccode = baseDao.sGetMaxNumber(bccaller, 2);
-                sqls.add("insert into prodinout (pi_id,pi_inoutno,pi_class,pi_date,pi_statuscode,pi_status," +
-                        "pi_departmentcode,pi_departmentname,pi_emcode,pi_emname,pi_invostatuscode,pi_invostatus," +
-                        "pi_recordman,pi_recorddate,pi_printstatuscode,pi_printstatus,pi_type) " +
-                        "values ("+bcpiid+",'"+bccode+"','"+bcpiclass+"',to_date('"+jsonObject2.get("Fdate")+"','yyyy-MM-dd " +
-                        "HH24:mi:ss'),'UNPOST','未过账','"+map1.get("FNumber")+"','"+map1.get("FName")+"','"+map4.get("FNumber")+"','"+map4.get("FName")+"','ENTERING','在录入','"+map5.get("FName")+"',to_date('"+jsonObject2.get("Fdate")+"','yyyy-MM-dd HH24:mi:ss'),'UNPRINT','未打印','库存转移')");
-            }
-            //生成领料单
-            llpiid = baseDao.getSeqId("PRODINOUT_SEQ");
-            llcode = baseDao.sGetMaxNumber(llcaller, 2);
-            sqls.add("insert into prodinout (pi_id,pi_inoutno,pi_class,pi_date,pi_statuscode,pi_status," +
-                    "pi_departmentcode,pi_departmentname,pi_emcode,pi_emname,pi_invostatuscode,pi_invostatus," +
-                    "pi_recordman,pi_recorddate,pi_printstatuscode,pi_printstatus,pi_type) " +
-                    "values ("+llpiid+",'"+llcode+"','"+llpiclass+"',to_date('"+jsonObject2.get("Fdate")+"','yyyy-MM-dd " +
-                    "HH24:mi:ss'),'UNPOST','未过账','"+map1.get("FNumber")+"','"+map1.get("FName")+"','"+map4.get(
-                            "FNumber")+"','"+map4.get("FName")+"','ENTERING','在录入','"+map5.get("FName")+"',to_date('"+jsonObject2.get("Fdate")+"','yyyy-MM-dd HH24:mi:ss'),'UNPRINT','未打印','"+map2.get("FName")+"')");
-            // 标示领料单的拨出单号
-            sqls.add("update ProdInOut set pi_fromcode='" + bccode + "' where pi_id=" + llpiid);
-        }
-        Object[] warehouses=null;
-        Object[] warehouses2=null;
-        int detno=1;
-        int det=1;
-        for (int i = 0; i <array.size(); i++) {
-            JSONObject object = JSON.parseObject(StringUtil.nvl(array.get(i), "{}"));
-            Map<Object, Object> map = JSONUtil.toMap(StringUtil.valueOf(object.get("FItemID")));
-            String itemNo = StringUtil.nvl(map.get("FNumber"), "");
-            if ("".equals(itemNo)){
-                return ApiResponse.failRsp("10041",request.getHeader("RequestId"),"物料不能为空！");
-            }
-            String fAuxQty = StringUtil.nvl(object.get("FAuxQty"), "0");
-            if ("0".equals(fAuxQty)){
-                return ApiResponse.failRsp("10042",request.getHeader("RequestId"),"实发数量不能为空！");
-            }
-            Double qty = Double.parseDouble(fAuxQty);
-            Map<Object, Object> map1 = JSONUtil.toMap(StringUtil.valueOf(object.get("FSCStockID1")));
-            String whcode = StringUtil.nvl(map1.get("FNumber"), "");
-            if ("".equals(whcode)){
-                return ApiResponse.failRsp("10043",request.getHeader("RequestId"),"发料仓库不能为空！");
-            }
-            int count = baseDao.getCount("select count(1) from customtabledetail left join customtable on cd_ctid=ct_id where ct_statuscode='AUDITED' and ct_caller='MESWarehouse' and cd_varchar50_1='" + whcode + "'");
-            if (count<=0){
-                return ApiResponse.failRsp("10044",request.getHeader("RequestId"),"MES仓库编号在ERP没有对应关系，请联系管理员新增！");
-            }
-            warehouses = baseDao.getFieldsDataByCondition("customtabledetail left join customtable on cd_ctid=ct_id left join Warehouse on cd_varchar50_3=wh_code", "cd_varchar50_3,wh_description", "ct_statuscode='AUDITED' and ct_caller='MESWarehouse' and cd_varchar50_1='" + whcode + "'");
-            String fSourceInterId = StringUtil.nvl(object.get("FSourceInterId"), "");
-            String ficmoBillNo = StringUtil.nvl(object.get("FICMOBillNo"), "");
-            Map<Object, Object> map2 = JSONUtil.toMap(StringUtil.nvl(object.get("FSCStockID2"), "{}"));
-            String whcode2 = StringUtil.nvl(map2.get("FNumber"), "");
-            if ("".equals(whcode2)){
-                return ApiResponse.failRsp("10043",request.getHeader("RequestId"),"物料所在仓库不能为空！");
-            }
-            int count2 = baseDao.getCount("select count(1) from customtabledetail left join customtable on cd_ctid=ct_id where ct_statuscode='AUDITED' and ct_caller='MESWarehouse' and cd_varchar50_1='" + whcode2 + "'");
-            if (count2<=0){
-                return ApiResponse.failRsp("10044",request.getHeader("RequestId"),"MES仓库编号在ERP没有对应关系，请联系管理员新增！");
-            }
-            warehouses2 = baseDao.getFieldsDataByCondition("customtabledetail left join customtable on cd_ctid=ct_id left join Warehouse on cd_varchar50_3=wh_code", "cd_varchar50_3,wh_description", "ct_statuscode='AUDITED' and ct_caller='MESWarehouse' and cd_varchar50_1='" + whcode2 + "'");
-
-            int lineId = Integer.parseInt(StringUtil.nvl(object.get("lineId"), "0"));
-            int count4 = baseDao.getCount("select count(1) from MakeMaterial where mm_id in (" + lineId + ")");
-            if (count4<=0){
-                return ApiResponse.failRsp("10046",request.getHeader("RequestId"),"工单BOM在ERP没有不存在，明细ID："+lineId+"，请联系管理员！");
-            }
-            Object[] data1 = baseDao.getFieldsDataByCondition("MakeMaterial", "mm_detno,mm_maid","mm_id in (" + lineId + ")");
-            maid = Integer.parseInt(StringUtil.nvl(data1[1], "0"));
-            if(bccode!=null) {
-                sqls.add("insert into prodiodetail (pd_id,pd_piid,pd_inoutno,pd_piclass,pd_pdno,pd_prodcode,pd_outqty,pd_whcode,pd_whname,pd_inwhcode,pd_inwhname,pd_macode,pd_madetno) values (PRODIODETAIL_SEQ.nextval," + bcpiid + ",'" + bccode + "','"+bcpiclass+"'," + detno + ",'" + itemNo + "'," + qty + ",'" + warehouses2[0] + "','" + warehouses2[1] + "','" + warehouses[0] + "','" + warehouses[1] + "','"+ficmoBillNo+"',"+data1[0]+")");
-                detno++;
-            }
-            int count1 = baseDao.getCount("select count(1) from MakeMaterial where mm_prodcode='" + itemNo + "' and mm_id in (" + lineId + ")");
-            if (count1>0) {
-                SqlRowList sqlRowList = baseDao.queryForRowSet("select sum(round((mm_qty-nvl(mm_canuserepqty,0)-(nvl(mm_havegetqty,0)-nvl(mm_haverepqty,0)+(nvl(mm_returnmqty,0)-nvl(mm_repreturnmqty,0))-(nvl(mm_addqty,0)-NVL(mm_repaddqty,0)))-nvl(mm_totaluseqty,0)+NVL(mm_repqty,0))-NVL(mm_stepinqty,0),7)) mmqty from MakeMaterial where mm_prodcode='" + itemNo + "' and mm_id in (" + lineId + ")");
-                if (sqlRowList.next()) {
-                    Double mmqty = sqlRowList.getGeneralDouble("mmqty");
-                    qty = qty.compareTo(mmqty) > 0 ? mmqty : qty;
-                }
-            }else {
-                int count3 = baseDao.getCount("select count(1) from MakeMaterialreplace where mp_prodcode='" + itemNo + "' and  mp_mmid in (" + lineId + ")");
-                if (count3>0){
-                    SqlRowList sqlRowList1 = baseDao.queryForRowSet("select sum(nvl(mp_canuseqty,0)-(nvl(mp_haverepqty,0)-NVL(mp_addqty,0)+NVL(mp_returnmqty,0))-nvl(mp_repqty,0)) mpqty from MakeMaterialreplace where mp_prodcode='" + itemNo + "' and  mp_mmid in (" + lineId + ")");
-                    if (sqlRowList1.next()){
-                        Double mpqty = sqlRowList1.getGeneralDouble("mpqty");
-                        qty = qty.compareTo(mpqty) > 0 ? mpqty : qty;
-                    }
-                }
-            }
-            if (qty>0) {
-                sqls.add("insert into prodiodetail (pd_id,pd_piid,pd_inoutno,pd_piclass,pd_pdno,pd_prodcode,pd_outqty,pd_whcode,pd_whname,pd_ordercode,pd_orderdetno,pd_macode,pd_madetno,pd_status) values (PRODIODETAIL_SEQ.nextval," + llpiid + ",'" + llcode + "','" + llpiclass + "'," + det + ",'" + itemNo + "'," + qty + ",'" + warehouses[0] + "','" + warehouses[1] + "','" + ficmoBillNo + "'," + data1[0] + ",'" + ficmoBillNo + "'," + data1[0] + ",0)");
-                det++;
-            }
-        }
-        if ("OS".equals(ma_tasktype)) {
-            sqls.add("update prodinout set(pi_cardcode,pi_title,pi_receivecode,pi_receivename) = (select max(ma_vendcode),max(ma_vendname),max(nvl(ma_apvendcode,ma_vendcode)),max(nvl(ma_apvendname,ma_vendname)) from make where ma_id in (" + maid + ")) where pi_id=" + llpiid);
-        }
-        if (warehouses2!=null){
-            sqls.add("update prodinout set pi_whcode='"+warehouses2[0]+"',pi_whname='"+warehouses2[1]+"' where " + "pi_id="+bcpiid);
-        }
-        if (warehouses!=null){
-            sqls.add("update prodinout set pi_purpose='"+warehouses[0]+"',pi_purposename='"+warehouses[1]+"' where pi_id="+bcpiid);
-        }
-        baseDao.execute(sqls);
-        refreshTurnQty(maid,0);
-        setBackQty(String.valueOf(maid),0);
-        int count = baseDao.getCount("select count(1) from prodiodetail where pd_piid=" + llpiid);
-        if (count<=0){
-            baseDao.deleteById("prodinout","pi_id",llpiid);
-        }
-        Employee employee = baseDao.getJdbcTemplate().queryForObject("select * from employee where em_code=?",
-                new BeanPropertyRowMapper<Employee>(Employee.class), "mes");
-        String s = postProdInOut(bcpiid, bccaller, employee);
-        logger.info("S=="+s);
-        if (s!=null){
-            return ApiResponse.successRsp("0",request.getHeader("RequestId"),bcpiclass+"："+bccode+"，过账失败，请在ERP重新过账！");
-        }else {
-            if (count>0) {
-                String s1 = postProdInOut(llpiid, llcaller, employee);
-                logger.info("S1==" + s1);
-                refreshTurnQty(maid,0);
-                setBackQty(String.valueOf(maid),0);
-                if (s1 != null) {
-                    return ApiResponse.successRsp("0", request.getHeader("RequestId"), llpiclass+"：" + llcode + "，过账失败，请在ERP重新过账！");
-                }
-            }
-        }
-        return ApiResponse.successRsp("0",request.getHeader("RequestId"),llpiclass+"："+llcode+"，"+bcpiclass+"："+bccode+ "，请在ERP查看！");
-    }
-
-    @Override
-    public ApiResult<String> prodInOutMakeReturn(HttpServletRequest request) {
-        Map<String, JSONArray> data = getData(request);
-        JSONArray jsonArray = data.get("main");
-        int id=0;
-        String code="";
-        int tlid=0;
-        String tlcode = "";
-        String macode="";
-        String ma_tasktype=null;
-        int maid=0;
-        String tlpiclass = "生产退料单", tlcaller = "ProdInOut!Make!Return", bcpiclass = "拨出单", bccaller = "ProdInOut!AppropriationOut";
-        List<String> sqls = new ArrayList<>();
-        int frob=99;
-        JSONArray array = data.get("detail");
-        if(array!=null&&array.size()>0){
-            macode = StringUtil.valueOf(JSON.parseObject(StringUtil.nvl(array.get(0), "")).get("FICMOBillNo"));
-            Object[] data1 = baseDao.getFieldsDataByCondition("Make", "ma_tasktype,ma_id", "ma_code in ('" + macode + "')");
-            if (data1!=null&&data1.length>0) {
-                ma_tasktype = StringUtil.nvl(data1[0], "");
-                maid = Integer.parseInt(StringUtil.nvl(data1[1], "0"));
-            }else {
-                return ApiResponse.failRsp("10057", request.getHeader("RequestId"), "工单在ERP不存在，请核对！");
-            }
-        }
-        for (int i = 0; i <jsonArray.size() ; i++) {
-            Object obj = jsonArray.get(i);
-            JSONObject jsonObject2 = JSON.parseObject(StringUtil.nvl(obj, ""));
-            Map<Object, Object> map1 = JSONUtil.toMap(StringUtil.nvl(jsonObject2.get("FDeptID"),"{}"));
-            Map<Object, Object> map2 = JSONUtil.toMap(StringUtil.nvl(jsonObject2.get("FPurposeID"),"{}"));
-            Map<Object, Object> map3 = JSONUtil.toMap(StringUtil.nvl(jsonObject2.get("FFManagerID"),"{}"));
-            Map<Object, Object> map4 = JSONUtil.toMap(StringUtil.nvl(jsonObject2.get("FSManagerID"),"{}"));
-            Map<Object, Object> map5 = JSONUtil.toMap(StringUtil.nvl(jsonObject2.get("FBillerID"),"{}"));
-            frob = Integer.parseInt(StringUtil.nvl(jsonObject2.get("FROB"), "99"));
-            if ("OS".equals(ma_tasktype)) {
-                tlpiclass = "委外退料单";
-                tlcaller = "ProdInOut!OutsideReturn";
-            }
-            if (frob==0){
-                tlid = baseDao.getSeqId("PRODINOUT_SEQ");
-                tlcode = baseDao.sGetMaxNumber(tlcaller, 2);
-                sqls.add("INSERT INTO ProdInOut(pi_id, pi_inoutno, pi_date, pi_class,pi_invostatus,pi_invostatuscode,pi_recordman, pi_recorddate, pi_statuscode,pi_status,pi_updatedate,pi_updateman,pi_printstatuscode,pi_printstatus,pi_departmentcode,pi_departmentname,pi_emcode,pi_emname) VALUES ("+tlid+",'"+tlcode+"',to_date('"+jsonObject2.get("Fdate")+"','yyyy-MM-dd HH24:mi:ss'),'"+tlpiclass+"','在录入','ENTERING','"+map5.get("FName")+"',to_date('"+jsonObject2.get("Fdate")+"','yyyy-MM-dd HH24:mi:ss'),'UNPOST','未过账',sysdate,'"+map5.get("FName")+"','UNPRINT','未打印','"+map1.get("FNumber")+"','"+map1.get("FName")+"','"+map4.get("FNumber")+"','"+map4.get("FName")+"')");
-            }
-            id = baseDao.getSeqId("PRODINOUT_SEQ");
-            code = baseDao.sGetMaxNumber(bccaller, 2);
-            sqls.add("insert into prodinout (pi_id,pi_inoutno,pi_class,pi_date,pi_statuscode,pi_status,pi_departmentcode,pi_departmentname,pi_emcode,pi_emname,pi_invostatuscode,pi_invostatus,pi_recordman,pi_recorddate,pi_printstatuscode,pi_printstatus,pi_inoutman,pi_type) values ("+id+",'"+code+"','"+bcpiclass+"',to_date('"+jsonObject2.get("Fdate")+"','yyyy-MM-dd HH24:mi:ss'),'UNPOST','未过账','"+map1.get("FNumber")+"','"+map1.get("FName")+"','"+map4.get("FNumber")+"','"+map4.get("FName")+"','ENTERING','在录入','"+map5.get("FName")+"',to_date('"+jsonObject2.get("Fdate")+"','yyyy-MM-dd HH24:mi:ss'),'UNPRINT','未打印','"+map3.get("FName")+"','库存转移')");
-        }
-        Object[] warehouses=null;
-        Object[] warehouses2=null;
-        int detno=1;
-        int det=1;
-        for (int i = 0; i <array.size(); i++) {
-            JSONObject object = JSON.parseObject(StringUtil.nvl(array.get(i), "{}"));
-            Map<Object, Object> map = JSONUtil.toMap(StringUtil.valueOf(object.get("FItemID")));
-            String itemNo = StringUtil.nvl(map.get("FNumber"), "");
-            if ("".equals(itemNo)){
-                return ApiResponse.failRsp("10051",request.getHeader("RequestId"),"物料不能为空！");
-            }
-            Double qty =Double.parseDouble(StringUtil.nvl(object.get("FAuxQty"), ""));
-            if ("".equals(qty)){
-                return ApiResponse.failRsp("10052",request.getHeader("RequestId"),"实发数量不能为空！");
-            }
-            String fnote = StringUtil.nvl(object.get("Fnote"), "");
-            Map<Object, Object> map1 = JSONUtil.toMap(StringUtil.valueOf(object.get("FSCStockID1")));
-            String whcode = StringUtil.nvl(map1.get("FNumber"), "");
-            String whname = StringUtil.nvl(map1.get("FName"), "");
-            if ("".equals(whcode)){
-                return ApiResponse.failRsp("10053",request.getHeader("RequestId"),"仓库编号不能为空！");
-            }
-            int count = baseDao.getCount("select count(1) from customtabledetail left join customtable on cd_ctid=ct_id where ct_statuscode='AUDITED' and ct_caller='MESWarehouse' and cd_varchar50_1='" + whcode + "'");
-            if (count<=0){
-                return ApiResponse.failRsp("10054",request.getHeader("RequestId"),"MES仓库编号在ERP没有对应关系，请联系管理员新增！");
-            }
-            warehouses = baseDao.getFieldsDataByCondition("customtabledetail left join customtable on cd_ctid=ct_id left join Warehouse on cd_varchar50_3=wh_code", "cd_varchar50_3,wh_description", "ct_statuscode='AUDITED' and ct_caller='MESWarehouse' and cd_varchar50_1='" + whcode + "'");
-            Map<Object, Object> map2 = JSONUtil.toMap(StringUtil.nvl(object.get("FSCStockID2"), "{}"));
-            String whcode2 = StringUtil.nvl(map2.get("FNumber"), "");
-            String whname2 = StringUtil.nvl(map2.get("FName"), "");
-            if ("".equals(whcode2)){
-                return ApiResponse.failRsp("10055",request.getHeader("RequestId"),"物料退回仓库不能为空！");
-            }
-            int count2 = baseDao.getCount("select count(1) from customtabledetail left join customtable on cd_ctid=ct_id where ct_statuscode='AUDITED' and ct_caller='MESWarehouse' and cd_varchar50_1='" + whcode2 + "'");
-            if (count2<=0){
-                return ApiResponse.failRsp("10056",request.getHeader("RequestId"),"MES仓库编号在ERP没有对应关系，请联系管理员新增！");
-            }
-            warehouses2 = baseDao.getFieldsDataByCondition("customtabledetail left join customtable on cd_ctid=ct_id left join Warehouse on cd_varchar50_3=wh_code", "cd_varchar50_3,wh_description", "ct_statuscode='AUDITED' and ct_caller='MESWarehouse' and cd_varchar50_1='" + whcode2 + "'");
-
-            String ficmoBillNo = StringUtil.nvl(object.get("FICMOBillNo"), "");
-            String fBatchNo = StringUtil.nvl(object.get("FBatchNo"), "");
-            Object lineId = object.get("lineId");
-            int count1 = baseDao.getCount("select count(1) from MakeMaterial where mm_id in (" + lineId + ")");
-            if (count1<=0){
-                return ApiResponse.failRsp("10075",request.getHeader("RequestId"),"工单BOM不存在或ID不一致，请联系管理员处理！");
-            }
-            Object[] objs = baseDao.getFieldsDataByCondition("Make left join MakeMaterial on ma_id=mm_maid", new String[] { "mm_id", "mm_code","mm_detno", "mm_mdcode", "mm_prodcode", "mm_wccode"}, "mm_id in (" + lineId+")");
-            sqls.add("insert into prodiodetail (pd_id,pd_piid,pd_inoutno,pd_piclass,pd_pdno,pd_prodcode,pd_outqty,pd_whcode,pd_whname,pd_inwhcode,pd_inwhname,pd_macode,pd_madetno) values (PRODIODETAIL_SEQ.nextval,"+id+",'"+code+"','"+bcpiclass+"',"+detno+",'"+itemNo+"',"+qty+",'"+warehouses[0]+"','"+warehouses[1]+"','"+warehouses2[0]+"','"+warehouses2[1]+"','"+ficmoBillNo+"',"+objs[2]+")");
-            if (frob==0) {
-                Object prid = baseDao.getFieldDataByCondition("Product", "pr_id", "pr_code='" + itemNo + "'");
-                Double remain = baseDao.getSummaryByField("batch", "ba_remain", "ba_prodcode='" + itemNo + "' and ba_macode='" + macode + "' and ba_whcode='" + warehouses[0] + "'");
-                /*Object[] data1 = baseDao.getFieldsDataByCondition("MakeMaterial left join Make on ma_id=mm_maid",
-                        "mm_totaluseqty,mm_havegetqty,ma_tomadeqty,mm_oneuseqty,ma_qty", "mm_id=" + objs[0]);*/
-                if (qty.compareTo(remain) > 0){
-                    double sub = DoubleUtils.sub(qty, remain);
-                    sqls.add("INSERT INTO ProdIODetail(pd_id, pd_piid, pd_inoutno, pd_piclass, pd_pdno, pd_status,pd_auditstatuscode,pd_auditstatus,pd_prodcode,pd_ordercode, pd_orderdetno,pd_macode,pd_madetno,pd_plancode, pd_wccode, pd_orderid, pd_prodid,pd_whcode,pd_whname,pd_inqty,pd_description) VALUES (PRODIODETAIL_SEQ.nextval,"+tlid+",'"+tlcode+"','"+tlpiclass+"',"+det+ ",0,'ENTERING','在录入','"+itemNo+"','"+ficmoBillNo+"',"+objs[2]+",'"+ficmoBillNo+"',"+objs[2]+ ",'"+objs[3]+"','"+objs[5]+"',"+lineId+","+prid+",'"+warehouses[0]+"','"+warehouses[1]+"',"+sub+ ",'良品退仓')");
-                    det++;
-                }
-            }
-            detno++;
-        }
-        if (frob==0){
-            sqls.add("update prodiodetail set (pd_mcid,pd_jobcode)=(select mc_id,mm_mdcode from MakeMaterial,makecraft where pd_orderdetno=mm_detno and pd_ordercode=mm_code and mm_mdcode=mc_code) where pd_piid="
-                    + tlid);
-            sqls.add("update prodiodetail set pd_purcinqty=Round(Pd_Inqty/nvl((Select case when nvl(Pr_Purcrate,0)=0 then 1 else Pr_Purcrate end From Product Where Pd_Prodcode=Pr_Code),1),8) where pd_piid="
-                    + tlid);
-        }
-        if ("OS".equals(ma_tasktype)) {
-            sqls.add("update prodinout set(pi_cardcode,pi_title,pi_receivecode,pi_receivename) = (select max(ma_vendcode),max(ma_vendname),max(nvl(ma_apvendcode,ma_vendcode)),max(nvl(ma_apvendname,ma_vendname)) from make where ma_id in (" + maid + ")) where pi_id=" + tlid);
-        }
-        if (warehouses!=null){
-            sqls.add("update prodinout set pi_whcode='"+warehouses[0]+"',pi_whname='"+warehouses[1]+"' where pi_id="+id);
-        }
-        if (warehouses2!=null){
-            sqls.add("update prodinout set pi_purpose='"+warehouses2[0]+"',pi_purposename='"+warehouses2[1]+"' where pi_id="+id);
-        }
-        baseDao.execute(sqls);
-        baseDao.execute("delete from prodiodetail where pd_inqty=0 and pd_piclass='"+tlpiclass+"' and pd_piid="+tlid);
-        int count = baseDao.getCount("select count(1) from prodiodetail where pd_piid=" + tlid);
-        if (count<=0){
-            baseDao.deleteById("prodinout","pi_id",tlid);
-        }
-        Employee employee = baseDao.getJdbcTemplate().queryForObject("select * from employee where em_code=?", new BeanPropertyRowMapper<Employee>(Employee.class), "mes");
-        if (count>0) {
-            String s1 = postProdInOut(tlid, tlcaller, employee);
-            logger.info("S1==" + s1);
-            if (s1 != null) {
-                return ApiResponse.successRsp("0", request.getHeader("RequestId"), tlpiclass+"：" + tlcode + "，过账失败，请在ERP重新过账！");
-            }
-        }
-        String s = postProdInOut(id, bccaller, employee);
-        logger.info("S=="+s);
-        if (s!=null){
-            return ApiResponse.successRsp("0",request.getHeader("RequestId"),bcpiclass+"："+code+"，过账失败，请在ERP重新过账！");
-        }
-        return ApiResponse.successRsp("0",request.getHeader("RequestId"),tlpiclass+"："+tlcode+"，"+bcpiclass+"："+code+"，请在ERP查看！");
-    }
-
-    @Override
-    public ApiResult<String> prodInOutAppropriationOut(HttpServletRequest request) {
-        Map<String, JSONArray> data = getData(request);
-        JSONArray jsonArray = data.get("main");
-        int id=0;
-        String code="";
-        List<String> sqls = new ArrayList<>();
-        for (int i = 0; i <jsonArray.size() ; i++) {
-            JSONObject jsonObject2 = JSON.parseObject(StringUtil.nvl(jsonArray.get(i), ""));
-            Map<Object, Object> map1 = JSONUtil.toMap(StringUtil.valueOf(jsonObject2.get("FDeptID")));
-            Map<Object, Object> map2 = JSONUtil.toMap(StringUtil.valueOf(jsonObject2.get("FRefType")));
-            Map<Object, Object> map3 = JSONUtil.toMap(StringUtil.valueOf(jsonObject2.get("FFManagerID")));
-            Map<Object, Object> map4 = JSONUtil.toMap(StringUtil.valueOf(jsonObject2.get("FSManagerID")));
-            Map<Object, Object> map5 = JSONUtil.toMap(StringUtil.valueOf(jsonObject2.get("FBillerID")));
-            id = baseDao.getSeqId("PRODINOUT_SEQ");
-            code = baseDao.sGetMaxNumber("ProdInOut!AppropriationOut", 2);
-            sqls.add("insert into prodinout (pi_id,pi_inoutno,pi_class,pi_date,pi_statuscode,pi_status,pi_departmentcode,pi_departmentname,pi_emcode,pi_emname,pi_invostatuscode,pi_invostatus,pi_recordman,pi_recorddate,pi_printstatuscode,pi_printstatus,pi_type,pi_inoutman) values ("+id+",'"+code+"','拨出单',to_date('"+jsonObject2.get("Fdate")+"','yyyy-MM-dd HH24:mi:ss'),'UNPOST','未过账','"+map1.get("FNumber")+"','"+map1.get("FName")+"','"+map4.get("FNumber")+"','"+map4.get("FName")+"','ENTERING','在录入','"+map5.get("FName")+"',to_date('"+jsonObject2.get("Fdate")+"','yyyy-MM-dd HH24:mi:ss'),'UNPRINT','未打印','"+map2.get("FName")+"','"+map3.get("FName")+"')");
-        }
-        JSONArray array = data.get("detail");
-        Object[] warehouses=null;
-        Object[] warehouses2=null;
-        int detno=1;
-        for (int i = 0; i <array.size(); i++) {
-            JSONObject object = JSON.parseObject(StringUtil.nvl(array.get(i), "{}"));
-            Map<Object, Object> map = JSONUtil.toMap(StringUtil.valueOf(object.get("FItemID")));
-            String itemNo = StringUtil.nvl(map.get("FNumber"), "");
-            if ("".equals(itemNo)){
-                return ApiResponse.failRsp("10061",request.getHeader("RequestId"),"物料不能为空！");
-            }
-            String qty = StringUtil.nvl(object.get("Fauxqty"), "");
-            if ("".equals(qty)){
-                return ApiResponse.failRsp("10062",request.getHeader("RequestId"),"实转数量不能为空！");
-            }
-            Map<Object, Object> map1 = JSONUtil.toMap(StringUtil.valueOf(object.get("FSCStockID1")));
-            String whcode = StringUtil.nvl(map1.get("FNumber"), "");
-            String whname = StringUtil.nvl(map1.get("FName"), "");
-            if ("".equals(whcode)){
-                return ApiResponse.failRsp("10063",request.getHeader("RequestId"),"发货仓库不能为空！");
-            }
-            int count = baseDao.getCount("select count(1) from customtabledetail left join customtable on cd_ctid=ct_id where ct_statuscode='AUDITED' and ct_caller='MESWarehouse' and cd_varchar50_1='" + whcode + "'");
-            if (count<=0){
-                return ApiResponse.failRsp("10064",request.getHeader("RequestId"),"MES仓库编号在ERP没有对应关系，请联系管理员新增！");
-            }
-            warehouses = baseDao.getFieldsDataByCondition("customtabledetail left join customtable on cd_ctid=ct_id left join Warehouse on cd_varchar50_3=wh_code", "cd_varchar50_3,wh_description", "ct_statuscode='AUDITED' and ct_caller='MESWarehouse' and cd_varchar50_1='" + whcode + "'");
-            Map<Object, Object> map2 = JSONUtil.toMap(StringUtil.valueOf(object.get("FDCStockID1")));
-            String whcode2 = StringUtil.nvl(map2.get("FNumber"), "");
-            String whname2 = StringUtil.nvl(map2.get("FName"), "");
-            if ("".equals(whcode2)){
-                return ApiResponse.failRsp("10065",request.getHeader("RequestId"),"收货仓库不能为空！");
-            }
-            int count2 = baseDao.getCount("select count(1) from customtabledetail left join customtable on cd_ctid=ct_id where ct_statuscode='AUDITED' and ct_caller='MESWarehouse' and cd_varchar50_1='" + whcode2 + "'");
-            if (count2<=0){
-                return ApiResponse.failRsp("10066",request.getHeader("RequestId"),"MES仓库编号在ERP没有对应关系，请联系管理员新增！");
-            }
-            warehouses2 = baseDao.getFieldsDataByCondition("customtabledetail left join customtable on cd_ctid=ct_id left join Warehouse on cd_varchar50_3=wh_code", "cd_varchar50_3,wh_description", "ct_statuscode='AUDITED' and ct_caller='MESWarehouse' and cd_varchar50_1='" + whcode2 + "'");
-            sqls.add("insert into prodiodetail (pd_id,pd_piid,pd_inoutno,pd_piclass,pd_pdno,pd_prodcode,pd_outqty,pd_whcode,pd_whname,pd_inwhcode,pd_inwhname) values (PRODIODETAIL_SEQ.nextval,"+id+",'"+code+"','拨出单',"+detno+",'"+itemNo+"',"+qty+",'"+warehouses[0]+"','"+warehouses[1]+"','"+warehouses2[0]+"','"+warehouses2[1]+"')");
-            detno++;
-        }
-        if (warehouses!=null){
-            sqls.add("update prodinout set pi_whcode='"+warehouses[0]+"',pi_whname='"+warehouses[1]+"' where " + "pi_id="+id);
-        }
-        if (warehouses2!=null){
-            sqls.add("update prodinout set pi_purpose='"+warehouses2[0]+"',pi_purposename='"+warehouses2[1]+"' where pi_id="+id);
-        }
-        baseDao.execute(sqls);
-        return ApiResponse.successRsp("0",request.getHeader("RequestId"),"拨出单："+code+"，请在ERP查看！");
-    }
-
-    @Override
-    public ApiResult<String> makeCheckOutStock(HttpServletRequest request) {
-        try {
-            String data = PSHttpUtils.readRaw(request.getInputStream());
-            JSONArray jsonArray = JSON.parseArray(data);
-            for (int i = 0; i <jsonArray.size() ; i++) {
-                JSONObject jsonObject = jsonArray.getJSONObject(i);
-                String whcode = StringUtil.nvl(jsonObject.getString("outwhcode"), "");
-                if ("".equals(whcode)){
-                    return ApiResponse.failRsp("10081",request.getHeader("RequestId"),"拨出仓库不能为空！");
-                }
-                int count = baseDao.getCount("select count(1) from customtabledetail left join customtable on cd_ctid=ct_id where ct_statuscode='AUDITED' and ct_caller='MESWarehouse' and cd_varchar50_1='" + whcode + "'");
-                if (count<=0){
-                    return ApiResponse.failRsp("10082",request.getHeader("RequestId"),"MES仓库编号在ERP没有对应关系，请联系管理员新增！");
-                }
-                Object outwhcode = baseDao.getFieldDataByCondition("customtabledetail left join customtable on cd_ctid=ct_id", "cd_varchar50_3", "ct_statuscode='AUDITED' and ct_caller='MESWarehouse' and cd_varchar50_1='" + whcode + "'");
-                jsonObject.put("outwhcode",outwhcode);
-                String whcode1 = StringUtil.nvl(jsonObject.getString("inwhcode"), "");
-                if ("".equals(whcode1)){
-                    return ApiResponse.failRsp("10083",request.getHeader("RequestId"),"拨入仓库不能为空！");
-                }
-                int count1 = baseDao.getCount("select count(1) from customtabledetail left join customtable on cd_ctid=ct_id where ct_statuscode='AUDITED' and ct_caller='MESWarehouse' and cd_varchar50_1='" + whcode1 + "'");
-                if (count1<=0){
-                    return ApiResponse.failRsp("10084",request.getHeader("RequestId"),"MES仓库编号在ERP没有对应关系，请联系管理员新增！");
-                }
-                Object inwhcode = baseDao.getFieldDataByCondition("customtabledetail left join customtable on cd_ctid=ct_id", "cd_varchar50_3", "ct_statuscode='AUDITED' and ct_caller='MESWarehouse' and cd_varchar50_1='" + whcode1 + "'");
-                jsonObject.put("inwhcode",inwhcode);
-            }
-            String msg = baseDao.callProcedure("USER_CHECKOUTSTOCK", new Object[] {null,JSON.toJSONString(jsonArray)});
-            if (msg != null && !msg.trim().equals("")){
-                return ApiResponse.failRsp("10085",request.getHeader("RequestId"),msg);
-            }
-            return ApiResponse.successRsp("0",request.getHeader("RequestId"),"校验通过！");
-        } catch (IOException e) {
-            return ApiResponse.failRsp("10086",request.getHeader("RequestId"),e.getMessage());
-        }
-
-    }
-
-    @Override
-    public ApiResult<String> makeECNCheck(HttpServletRequest request) {
-        JSONObject jsonData = getJsonData(request);
-        if (jsonData!=null){
-            String makeCode = StringUtil.nvl(jsonData.get("MakeCode"), "");
-            Object mcCode = baseDao.getFieldDataByCondition("makematerialchange", "wm_concat(mc_code)",
-                    "mc_id in (select md_mcid from makematerialchangedet where md_makecode='"+makeCode+"' and nvl(md_didstatus,' ')<>'执行成功')");
-            if (mcCode!=null){
-                return ApiResponse.failRsp("10091",request.getHeader("RequestId"),"ERP有未执行的制造单ECN："+mcCode);
-            }
-            Object ecnCode = baseDao.getFieldDataByCondition("ecn", "wm_concat(ecn_code)",
-                    "nvl(ecn_didstatus,' ')<>'已执行' and ecn_id in (select ed_ecnid from ecndetail left join make on ed_boid=ma_bomid where ma_code='"+makeCode+"')");
-            if (ecnCode!=null){
-                return ApiResponse.failRsp("10092",request.getHeader("RequestId"),"ERP有未执行的ECN："+ecnCode);
-            }
-            return ApiResponse.successRsp("0",request.getHeader("RequestId"),"校验通过！");
-        }else {
-            return ApiResponse.failRsp("10093",request.getHeader("RequestId"),"参数异常！");
-        }
-
-    }
-
-    private Map<String, JSONArray> getData(HttpServletRequest request){
-        Map<String, JSONArray> map = new HashMap<>();
-        try {
-            String data = PSHttpUtils.readRaw(request.getInputStream());
-            JSONObject jsonObject = JSON.parseObject(data);
-            Object data1 = jsonObject.get("Data");
-            JSONObject jsonObject1 = JSON.parseObject(StringUtil.nvl(data1,""));
-            Object page1 = jsonObject1.get("Page1");
-            Object page2 = jsonObject1.get("Page2");
-            JSONArray jsonArray = JSON.parseArray(StringUtil.nvl(page1, ""));
-            map.put("main",jsonArray);
-            JSONArray jsonArray1 = JSON.parseArray(StringUtil.nvl(page2, ""));
-            map.put("detail",jsonArray1);
-        } catch (IOException e) {
-            logger.info("参数解析异常信息："+e.getMessage());
-            e.printStackTrace();
-        }
-        return map;
-    }
-
-    private JSONObject getJsonData(HttpServletRequest request){
-        JSONObject jsonObject=null;
-        try {
-            String data = PSHttpUtils.readRaw(request.getInputStream());
-            jsonObject = JSON.parseObject(data);
-        } catch (IOException e) {
-            logger.info("参数解析异常信息："+e.getMessage());
-            e.printStackTrace();
-        }
-        return jsonObject;
-    }
-
-    private synchronized String postProdInOut(int pi_id, String caller,Employee employee) {
-    // 增加系统参数 出入库日期小于等于当前日期才允许过账 maz 2018020006
-		if (baseDao.isDBSetting("sys", "limitPostAfter")) {
-        Object pi_date = baseDao.getFieldDataByCondition("ProdInOut", "pi_date", "pi_id=" + pi_id);
-        String sysdate = DateUtil.getCurrentDate();
-        int sign = 0;
-        sign = DateUtil.compare(pi_date.toString(), sysdate);
-        if (sign == 1) {
-            return "单据日期大于当前日期，不能过账";
-        }
-    }
-    // 只能对状态为[未过账]的单据进行过账操作!
-    Object[] status = baseDao.getFieldsDataByCondition("ProdInOut", new String[] { "pi_statuscode", "pi_invostatuscode", "pi_date", "pi_class", "pi_recordman", "pi_inoutno" }, "pi_id=" + pi_id);
-		if (status[0].equals("POSTED")) {
-            return "只能对未过账的" + status[3] + "[" + status[5] + "]进行过账操作！";
-    }
-    // 2018030244 maz 送货单号不一致不允许提交
-		if ("ProdInOut!PurcCheckin".equals(caller) || "ProdInOut!DefectIn".equals(caller)) {
-        if (baseDao.isDBSetting("VerifyApplyDetail!Deal", "turnByDeliver")) {
-            SqlRowList rs = baseDao
-                    .queryForRowSet("select pd_pdno from prodinout left join prodiodetail on pi_id=pd_piid left join VerifyApply on va_code=pd_vacode where pi_id="
-                            + pi_id + " and nvl(pi_sendcode,' ')<>nvl(va_sendcode,' ')");
-            if (rs.next()) {
-                return "行号:" + rs.getInt("pd_pdno") + "送货单号不一致，不允许操作";
-            }
-        }
-    }
-    // 明细中如果有属于物料等级属于库存不可用的，就提示这些物料当前等级库存不可用
-    SqlRowList rowList = baseDao
-            .queryForRowSet(
-                    "select wm_concat(pd_prodcode)  prodcode from (select distinct pd_prodcode from prodiodetail "
-                            + "left join product on pd_prodcode=pr_code left join productlevel on pr_level=pl_levcode where pd_piid=? and pl_id>0 "
-                            + "and pl_isuseable=0 ) where rownum<=20", pi_id);
-		if (rowList.next()) {
-        if (rowList.getString("prodcode") != null) {
-            return "这些物料当前等级库存不可用,物料编号：" + rowList.getString("prodcode");
-        }
-    }
-		baseDao.execute("update prodinout set (pi_whcode,pi_whname)=(select pd_whcode,pd_whname from prodiodetail where pd_piid=pi_id and nvl(pd_whcode,' ')<>' ' and rownum<2) where pi_id="
-                + pi_id + " and nvl(pi_whcode,' ')= ' '");
-    // 判断已审核才允许过账
-		if (baseDao.isDBSetting(caller, "postNeedAudit")) {
-        if (!status[1].equals("AUDITED")) {
-            return status[3] + "[" + status[5] + "]未审核，不允许过账！";
-        }
-    }
-    String dets = baseDao
-            .getJdbcTemplate()
-            .queryForObject(
-                    "select wm_concat(distinct pi_class||'['||pi_inoutno||']') from prodinout left join prodiodetail a on pi_id=pd_piid where exists (select 1 from prodiodetail B WHERE B.PD_IOID=A.PD_ID AND B.PD_PIID=?) AND Pi_STATUSCODE='UNPOST'",
-                    String.class, pi_id);
-		if (dets != null) {
-            return "来源的" + dets + "未过账，本单据不允许过账！";
-    }
-    // 无来源订单不能直接过账
-		if (baseDao.isDBSetting(caller, "isWuPO")) {
-        int count = baseDao
-                .getCount("select count(*) from ProdIODetail where (pd_ordercode is null or pd_orderdetno is null) and  pd_piid="
-                        + pi_id);
-        if (!status[1].equals("AUDITED") && count != 0) {
-            return "无来源订单审核后才能过账";
-        }
-    }
-		boolean isProdIn=baseDao.isProdIn(caller);
-        if (isProdIn) {
-        // 检测入库单明细生产日期是否大于系统时间
-            if (baseDao.isDBSetting("sys","inOverNow")) {
-                dets = baseDao
-                        .getJdbcTemplate()
-                        .queryForObject(
-                                "select wm_concat(PD_PDNO) from ProdIODetail left join ProdInOut on pd_piid=pi_id where pi_id=? and pd_prodmadedate is not null and to_char(pd_prodmadedate,'yyyy-mm') > to_char(sysdate,'yyyy-mm') ",
-                                String.class, pi_id);
-                if (dets != null) {
-                    return "行：" + dets + "，明细生产日期不能大于系统日期所在年月！";
-                }
-            }
-        SqlRowList rs = null;
-        // 入库类单据:如果pd_location为空，默认等于物料资料里的仓位pr_location
-        baseDao.execute(
-                "update prodiodetail set pd_location=(select pr_location from product where pr_code=pd_prodcode) where pd_piid=? and nvl(pd_location,' ')=' '",
-                pi_id);
-
-        rs = baseDao.queryForRowSet("SELECT pd_id FROM ProdioDetail where pd_piid=? and nvl(pd_batchcode,' ')=' '", pi_id);
-        while (rs.next()) {
-            baseDao.execute("update prodiodetail set pd_batchcode=? where pd_id=?", baseDao.getBatchcode(caller), rs.getInt("pd_id"));
-        }
-
-        // 入库单有生成条码但条码对应的物料或数量或批次号与明细行不一致则不允许过账
-        rs = baseDao.queryForRowSet(
-                        "select wm_concat(pd_pdno)no,count(1)cn from prodiodetail left join (select sum(bi_inqty)inqty,bi_pdno,max(bi_prodcode)bi_prodcode,max(bi_batchcode)bi_batchcode from barcodeio"
-                                + " where bi_piid=? group by bi_pdno) on bi_pdno=pd_pdno where pd_piid=? and pd_inqty>0 and inqty>0 "
-                                + " and (nvl(inqty,0)<>pd_inqty or bi_prodcode<>pd_prodcode or bi_batchcode<>pd_batchcode) and rownum<30",
-                        pi_id, pi_id);
-        if (rs.next() && rs.getInt("cn") > 0) {
-            return "条码与明细行中的物料或数量或批次号不一致，不允许过账，请先清除不一致条码!行号：" + rs.getString("no");
-        }
-    } else {
-        SqlRowList rs = null;
-        rs = baseDao
-                .queryForRowSet(
-                        "SELECT pd_id,ba_purcrate FROM ProdioDetail,batch where pd_batchid=ba_id and pd_piid=? and nvl(pd_batchid,0)<>0 and nvl(pd_outqty,0)>0",
-                        pi_id);
-        while (rs.next()) {
-            if (rs.getGeneralDouble("ba_purcrate") != 0) {
-                baseDao.execute("update prodiodetail set pd_purcoutqty=round(nvl(pd_outqty,0)/" + rs.getGeneralDouble("ba_purcrate")
-                        + ",8) where pd_id=" + rs.getObject("pd_id"));
-            } else {
-                baseDao.execute("update prodiodetail set pd_purcoutqty=nvl(pd_outqty,0) where pd_id=" + rs.getObject("pd_id"));
-            }
-        }
-
-    }
-    useDefaultTax(caller, pi_id);
-        String s = allowZeroTax(caller, pi_id);
-        if (s!=null){
-            return s;
-        }
-        String s1 = checkFreezeMonth(caller, status[2]);
-        if (s1!=null){
-            return s1;
-        }
-        String s2 = checkCloseMonth(status[2]);
-        if (s2!=null){
-            return s2;
-        }
-        String s3 = checkFirstMonth(caller, status[2]);
-        if (s3!=null){
-            return s3;
-        }
-        String s4 = checkCommit(caller, pi_id);
-        if (s4!=null){
-            return s4;
-        }
-        String s5 = checkBatch(caller, pi_id);
-        if (s5!=null){
-            return s5;
-        }
-        String copcheck = copcheck(pi_id, caller);
-        if (copcheck!=null){
-            return copcheck;
-        }
-        String factorycheck = factorycheck(pi_id, caller);
-        if (factorycheck!=null){
-            return factorycheck;
-        }
-        // 制造工单加工类型
-		if ("ProdInOut!Make!In".equals(caller) || "ProdInOut!OutsideCheckIn".equals(caller)) {
-            String s6 = checkMakeKindType(caller, pi_id);
-            if (s6!=null){
-                return s6;
-            }
-        }
-    // 暂时不启用平台 销售仓模式checkWhIsB2C(caller, pi_id);
-    /**
-     * 委外验收单,委外验退单 过账限制，判断明细行中的应付供应商或币别与主表是否一致，不一致则不允许过账;
-     */
-		if ("ProdInOut!OutsideCheckIn".equals(caller) || "ProdInOut!OutesideCheckReturn".equals(caller)) {
-        SqlRowList rs = baseDao
-                .queryForRowSet(
-                        "select wm_concat(pd_pdno) c from (select nvl(nvl(ma_apvendcode,ve_apvendcode),ve_code) apvendcode, pi_receivecode,pd_pdno "
-                                + "from prodiodetail left join prodinout on pd_piid=pi_id left join make on ma_code=pd_ordercode left join vendor "
-                                + "on ma_vendcode=ve_code where pi_id=?) t where t.apvendcode <> t.pi_receivecode and rownum<30", pi_id);
-        if (rs.next()) {
-            if (rs.getObject("c") != null) {
-                return "明细行中委外加工单的应付供应商与主表中的应付供应商不一致!";
-            }
-        }
-        SqlRowList rs2 = baseDao.queryForRowSet("select wm_concat(pd_pdno) x from (select ma_currency,pi_currency,pd_pdno"
-                + " from prodiodetail left join prodinout on pd_piid=pi_id left join make on ma_code=pd_ordercode"
-                + " where pi_id=?) t where t.ma_currency <> t.pi_currency and rownum<30", pi_id);
-        if (rs2.next()) {
-            if (rs2.getObject("x") != null) {
-                return "明细行中委外加工单的币别与主表中的币别不一致!";
-            }
-        }
-    }
-    // 完工入库，委外验收限制，入库数量不允许大于到当前pi_date的月份为止的（制造单生产的总数数量-已入库总数）
-		if ("ProdInOut!Make!In".equals(caller) || "ProdInOut!OutsideCheckIn".equals(caller)) {
-        // 存在pi_date 年月之后的 出入库单
-        int ym = DateUtil.getYearmonth(status[2].toString());
-        SqlRowList rs = baseDao
-                .queryForRowSet(
-                        "select A.pd_ordercode pd_ordercode,sum(A.pd_inqty)inqty from prodiodetail A left join make on ma_code=A.pd_ordercode left join makekind ON mk_name=ma_Kind"
-                                + " where A.pd_piid=? AND NVL(mk_finishunget, 0) = 0 and exists (select 1 from prodiodetail B left join prodinout on pi_id=B.pd_piid "
-                                + " where A.pd_ordercode=B.pd_ordercode and  to_char(pi_date,'yyyyMM')>? and "
-                                + " pi_class in('生产领料单','生产退料单','生产补料单','委外补料单','委外领料单','委外退料单') and B.pd_status=99) group by A.pd_ordercode",
-                        pi_id, ym);
-        while (rs.next()) {
-            Object[] obs = baseDao
-                    .getFieldsDataByCondition(
-                            "make left join makematerial on mm_maid=ma_id",
-                            new String[] {
-                                    " nvl(min(case when mm_oneuseqty*ma_qty>mm_qty+0.1 then ma_qty else ceil((nvl(mm_havegetqty, 0)-(select sum(nvl(pd_outqty,0)-nvl(pd_inqty,0)) from prodinout left join prodiodetail on pd_piid=pi_id "
-                                            + " where to_char(pi_date,'yyyyMM')>'"
-                                            + ym
-                                            + "' and pd_ordercode=ma_code and pd_orderdetno=mm_detno  and pi_class in('生产领料单','生产退料单','生产补料单','委外补料单','委外领料单','委外退料单'))"
-                                            + " -nvl(mm_scrapqty,0))*1.0/mm_oneuseqty)end),0) as canmadeqty",
-                                    "nvl(max(ma_madeqty),0) -"
-                                            + "nvl(max((select SUM(NVL(pd_inqty,0)-NVL(pd_outqty,0)) from prodinout LEFT JOIN prodiodetail ON pd_piid=pi_id "
-                                            + " WHERE TO_CHAR(pi_date,'yyyyMM')>'" + ym + "' and pd_ordercode='"
-                                            + rs.getString("pd_ordercode")
-                                            + "' and pi_class in('完工入库单','委外验收单','委外验退单'))),0) as madeqty" },
-                            " mm_code='" + rs.getString("pd_ordercode") + "' and nvl(mm_materialstatus,' ')=' ' and mm_oneuseqty>0");
-            if (obs != null) {// 比较
-                if (rs.getDouble("inqty") > (Double.valueOf(obs[0].toString()).doubleValue() - Double.valueOf(obs[1].toString())
-                        .doubleValue())) {
-                    return "工单[" + rs.getString("pd_ordercode") + "]当前月份领料套数(" + obs[0] + ")不足完工数";
-                }
-            }
-        }
-    }
-
-    /**
-     * 采购验收单、委外验收单 从表单位pr_unit与采购单位pr_purcunit不一致的时候，
-     * 数量pd_inqty与采购单位入库数量pd_purcinqty不能一致，否则无法提交、过账
-     */
-		if (baseDao.isDBSetting("sys","usePurcUnit") && ("ProdInOut!PurcCheckin".equals(caller) || ("ProdInOut" +
-                "!OutsideCheckIn").equals(caller))) {
-        String dets1 = baseDao.getJdbcTemplate().queryForObject(
-                "select wm_concat(pd_pdno)  from ProdIODetail left join Product on pd_prodcode=pr_code  where pd_piid=?  "
-                        + "and PR_UNIT is not null  and pr_purcunit is not null "
-                        + "and (nvl(pd_inqty,0)>0) and (nvl(pd_purcinqty,0)>0)  "
-                        + "and nvl(PR_UNIT,'')<>nvl(pr_purcunit,'') and nvl(pd_inqty,0)=nvl(pd_purcinqty,0)", String.class, pi_id);
-        if (dets1 != null) {
-            return "行" + dets1 + "，明细入库数量和采购单位入库数量需不一致，否则无法过账！";
-        }
-    }
-    /**
-     * 新增生产退料和委外退料判断，替代料退料数量不能大于替代料已领数量，禁用物料判断mm_updatetype='R',
-     *
-     * @date 2016年10月17日 下午12:30:58
-     */
-		if (("ProdInOut!Make!Return").equals(caller) || ("ProdInOut!OutsideReturn").equals(caller)) {
-        checkRepQty(pi_id);
-        /**
-         * 生产退料单，委外退料单  校验退料数量不能大于截止到单据日期月份 已过账的领料-退料-报废+补料-完工数*单位用量
-         */
-        checkMmBackOver(caller,pi_id);
-    }
-    /**
-     * 新增限制,拆件类型制造单不允许走完工入库单
-     *
-     * @author XiaoST 2016年12月9日 下午4:26:34
-     */
-		if ("ProdInOut!Make!In".equals(caller) || "ProdInOut!OutsideCheckIn".equals(caller)) {
-        dets = baseDao
-                .getJdbcTemplate()
-                .queryForObject(
-                        "select wm_concat('行号：'||pd_pdno||'工单：'||pd_ordercode) from ProdIODetail left join make on ma_code=pd_ordercode left join makekind ON mk_name=ma_kind where pd_piid=? and  mk_type='D' and rownum<20",
-                        String.class, pi_id);
-        if (dets != null) {
-            return "拆件工单必须走拆件入库单！" + dets;
-        }
-    }
-		baseDao.getEndDate(caller, pi_id);
-        String res = null;
-        // 平台生成的销售订单转出货单过账必须等于销售订单明细序号和数量
-		if ("ProdInOut!Sale".equals(caller)) {
-        SqlRowList rs = baseDao
-                .queryForRowSet(
-                        "select distinct sa_code,sum(pd_outqty) out_qty,pd_orderdetno from prodiodetail left join sale on sa_code=pd_ordercode where sa_ordertype='B2C' and nvl(sa_b2ccode,' ')<>' ' and pd_piid=? group by sa_code,pd_orderdetno",
-                        pi_id);
-        while (rs.next()) {
-            rs = baseDao
-                    .queryForRowSet(
-                            "select distinct pd_ordercode pd_ordercode from prodiodetail where pd_piid=? and (pd_orderdetno not in (select sd_detno from saledetail where sd_code=?))"
-                                    + " OR "
-                                    + rs.getDouble("out_qty")
-                                    + " <>(select sd_qty from saledetail where sd_code=? and sd_detno=?) and  pd_ordercode =?", pi_id,
-                            rs.getString("sa_code"), rs.getString("sa_code"), rs.getString("pd_orderdetno"), rs.getString("sa_code"));
-            if (rs.next()) {
-                return "通过优软商城平台生成的发货单必须一次性发货，销售单号[" + rs.getString("pd_ordercode") + "]";
-            }
-            // 维护物流公司和物流单号
-            Object[] obs = baseDao.getFieldsDataByCondition("prodinout", new String[] { "pi_logisticscompany", "pi_logisticscode" },
-                    "pi_id=" + pi_id);
-            if (obs[0] == null || obs[1] == null) {
-                return "请维护出货单的物流公司和物料单号信息!";
-            }
-        }
-    }
-    // 委外领、退、补单过账前
-		if ("ProdInOut!OutsidePicking".equals(caller) || "ProdInOut!OutsideReturn".equals(caller) || "ProdInOut!OSMake!Give".equals(caller)) {
-        // 更新：如果主表的应付供应商空，则取第一个工单的应付供应商ma_apvendcode，空则取工单供应商ma_vendcode
-        baseDao.execute("update prodinout  set (pi_receivecode,pi_receivename)=(select code,ve_name from "
-                + "(select nvl(ma_apvendcode,ma_vendcode)code,ve_name from prodiodetail left join make on "
-                + "pd_ordercode=ma_code left join  vendor on nvl(ma_apvendcode,ma_vendcode)=ve_code "
-                + "where pd_piid=? order by pd_pdno) where rownum=1 )" + "where nvl(pi_receivecode,' ')=' ' and pi_id=?", pi_id, pi_id);
-        // 判断主表应付供应商与从表工单应付供应商是否一致
-        SqlRowList pdnos = baseDao
-                .queryForRowSet(
-                        "select wm_concat(pd_pdno) c from (select nvl(nvl(ma_apvendcode,ve_apvendcode),ve_code) apvendcode, pi_receivecode,pd_pdno "
-                                + "from prodiodetail left join prodinout on pd_piid=pi_id left join make on ma_code=pd_ordercode left join vendor "
-                                + "on ma_vendcode=ve_code where pi_id=?) t where t.apvendcode <> t.pi_receivecode and rownum<30", pi_id);
-        if (pdnos.next()) {
-            if (pdnos.getObject("c") != null) {
-                return "行" + pdnos.getObject("c") + "工单应付供应商与主表应付供应商不一致，不能过账";
-            }
-        }
-    }
-    // @add20171103
-		if ("ProdInOut!PurcCheckin".equals(caller)) {// 采购验收单根据采购单号、序号，更新入库销售单号、序号
-        baseDao.execute(
-                "update prodiodetail set (pd_salecode,pd_saledetno,pd_topmothercode)=(select d.pd_salecode,d.pd_saledetno,d.pd_topmothercode from purchase left join purchasedetail d on pu_id=pd_puid where "
-                        + " pd_ordercode=pu_code and pd_orderdetno=pd_detno) where pd_piid=?", pi_id);
-    }
-    // 生产退料单、委外退料单、拆件入库单、完工入库单、委外验收单,根据工单的订单号、订单序号能匹配到销售单号和序号（如果是预测单则不锁批记录）则更新到入库单明细的销售单号、序号
-		if ("ProdInOut!OutsideReturn".equals(caller) || "ProdInOut!OutsideCheckIn".equals(caller) || "ProdInOut!Make!In".equals(caller)
-				|| "ProdInOut!PartitionStockIn".equals(caller) || "ProdInOut!Make!Return".equals(caller)) {
-        baseDao.execute(
-                "update prodiodetail set (pd_salecode,pd_saledetno,pd_topmothercode)=(select ma_salecode,ma_saledetno,nvl(ma_topmothercode,ma_prodcode)topmothercode from make where pd_ordercode=ma_code)"
-                        + " where pd_piid=? and exists (select 1 from make left join sale on sa_code=ma_salecode left join saledetail on sd_said=sa_id and sd_detno=ma_saledetno where pd_ordercode=ma_code and sd_detno>0)",
-                pi_id);
-
-    }
-    // 销售退货明细客户为空时=主表客户
-		if ("ProdInOut!SaleReturn".equals(caller)) {
-        baseDao.execute(
-                "update prodiodetail set (pd_custcode,pd_custname)=(select pi_cardcode,pi_title from prodinout where pd_piid=pi_id)"
-                        + " where pd_piid=? and nvl(pd_custcode,' ')=' '", pi_id);
-
-    }
-    /*
-     * 退料数量不能大于维护的可退数量 String SQLStr_s = ""; SqlRowList rs_s; SQLStr_s=
-     * "select * from ProdIODetail left join make on ma_code=pd_ordercode"
-     * +" left join IO_MAKEMATERIAL_DETNO_VIEW on pd_orderdetno = mm_detno"
-     * +" where ma_id=mm_maid and pd_piid= '"+pi_id+"'"; rs_s =
-     * baseDao.queryForRowSet(SQLStr_s); if(rs_s.next()){ if
-     * (rs_s.getInt("pd_inqty")>rs_s.getInt("mm_havegetqty")) {
-     * BaseUtil.showError("工单序号[" + rs_s.getString("pd_orderdetno") +
-     * "]的退料数量不能大于维护的可退数量!'"); } }
-     */
-    // 过账前的其它逻辑
-    getTotal(pi_id, caller);// 调用过账存储过程前后都掉用一次gettotal方法，解决出入库单税率与发票不一致
-    getQtyTotal(pi_id, caller);
-    // 执行过账操作
-    Object[] objs = baseDao.getFieldsDataByCondition("ProdInOut", new String[] { "pi_class", "pi_inoutno" }, "pi_id=" + pi_id);
-		if ("ProdInOut!CostChange".equals(caller)) {
-        res = baseDao.callProcedure("SP_PRODUCTCOSTADJUST", new Object[] { objs[0].toString(), objs[1].toString(), "" });
-        if (res != null && !res.trim().equals("")) {
-            return res;
-        }
-    } else {
-        baseDao.procedure("SP_GetCostPrice", new Object[] { objs[0].toString(), objs[1].toString() });
-        if (baseDao.isDBSetting("sys","SplitprodoutByseller")) {// 出单过账前取批号按照业务员pi_sellercode获取
-            res = baseDao.callProcedure("Sp_Splitprodout_Byseller",
-                    new Object[] { objs[0].toString(), objs[1].toString(),employee.getEm_name()});
-        } else {
-            res = baseDao.callProcedure("Sp_SplitProdOut",
-                    new Object[] { objs[0].toString(), objs[1].toString(),employee.getEm_name()});
-        }
-
-        if (res != null && !res.trim().equals("")) {
-            // 重新添加提示限制信息
-            return res + "  " + objs[0].toString() + objs[1].toString() + "，过账失败";
-            // BaseUtil.showError(res);
-        }
-        // @add 20170614 抓取批次号成功之后更新出库单据的备料状态
-        updatePdaStatus(caller, pi_id);
-        if (baseDao.isDBSetting(caller, "ifBatchCodeNotChange") && baseDao.isDBSetting(caller, "autoPostIn")) {
-            // 拨出单过账后产生的拨入单批号不变，同一物料同仓库不能同时入两次相同的批号
-            SqlRowList rs1 = baseDao
-                    .queryForRowSet("select  count(1)n, wm_concat(pd_pdno)detno from (select pd_batchcode,pd_inwhcode,pd_prodcode,min(pd_pdno)pd_pdno,count(1)c from  ProdIODetail where pd_piid="
-                            + pi_id + " and pd_batchcode<>' ' group by pd_batchcode,pd_inwhcode,pd_prodcode ) where c> 1");
-            if (rs1.next()) {
-                if (rs1.getInt("n") > 0) {
-                    return "拨出单过账后产生的拨入单批号不变，同一物料同拨入仓库批号不能相同！行号：" + rs1.getString("detno");
-                }
-            }
-        }
-            String s7 = checkBatchRemain(pi_id);
-            if (s7!=null){
-                return s7;
-            }
-            dets = baseDao
-                .getJdbcTemplate()
-                .queryForObject(
-                        "select wmsys.wm_concat(a2.pd_pdno) from prodinout a1 left join prodiodetail a2 on a1.pi_id=a2.pd_piid " +
-                                "left join prodiodetail b2 on a2.pd_batchcode=b2.pd_batchcode and a2.pd_prodcode=b2.pd_prodcode and a2.pd_whcode=b2.pd_whcode " +
-                                "left join prodinout b1 on b2.pd_piid=b1.pi_id where a2.pd_piid=? and nvl(b2.pd_inqty,0)>0 and nvl(a2.pd_outqty,0)>0 " +
-                                "and to_char(a1.pi_date,'yyyymm')<to_char(b1.pi_date,'yyyymm') and rownum<20",
-                        String.class, pi_id);
-        if (dets != null) {
-            return "出库单据日期所在期间小于批次入库日期所在期间,不能过账!行号：" + dets;
-        }
-        // 存储过程
-        res = baseDao.callProcedure("Sp_CommitProdInout",
-                new Object[] { objs[0].toString(), objs[1].toString(), employee.getEm_name()});
-        if (res != null && !res.trim().equals("")) {
-            return res;
-        }
-        if (baseDao.isDBSetting("sys","autoCreateApBill")) {
-            if ("采购验收单".equals(status[3]) || "采购验退单".equals(status[3]) || "委外验收单".equals(status[3]) || "委外验退单".equals(status[3])
-                    || "用品验收单".equals(status[3]) || "用品验退单".equals(status[3])) {
-                dets = baseDao.queryForObject("select wm_concat(ab_code) from apbill where ab_source=? and ab_statuscode<>'POSTED'",
-                        String.class, status[5]);
-                if (dets != null) {
-                    return "发票" + dets + "未过账成功，请手工过账！";
-                }
-            }
-        }
-        if (baseDao.isDBSetting("sys","autoCreateArBill")) {
-            if ("出货单".equals(status[3]) || "销售退货单".equals(status[3])) {
-                dets = baseDao.queryForObject(
-                        "select wm_concat(ab_code) from arbill where AB_SOURCECODE=? and ab_statuscode<>'POSTED'", String.class,
-                        status[5]);
-                if (dets != null) {
-                    return "发票" + dets + "未过账成功，请手工过账！";
-                }
-            }
-        }
-    }
-
-		getTotal(pi_id, caller);
-		getQtyTotal(pi_id, caller);
-		baseDao.updateByCondition("ProdInOut", "pi_statuscode='POSTED',pi_status='已过账',pi_inoutman='"+employee.getEm_name()+"'," + "pi_date1=sysdate,pi_sendstatus='待上传'", "pi_id=" + pi_id);
-		if (!baseDao.isIn(caller)) {// 出库类单据过账时，根据批号抓取batch.ba_vendorrate到prodiodetail.pd_vendorrate
-        baseDao.execute("update prodiodetail set pd_vendorrate=(select ba_vendorrate from batch where ba_code=pd_batchcode"
-                + " and ba_whcode =pd_whcode and ba_prodcode=pd_prodcode ) where pd_piid=" + pi_id + " and nvl(pd_vendorrate,0)=0");
-    }
-		if (baseDao.isDBSetting("sys","updateBusinessChance") && !"ProdInOut!GoodsIn".equals(caller)) {// 更新当前商机阶段
-        Object bsname = baseDao.getFieldDataByCondition("BusinessChanceStage", "bs_name", "bs_relativeitem='Shipment'");
-        Object date = baseDao.getFieldDataByCondition("ProdInOut", "to_char(pi_recorddate,'yyyy-MM-dd')", "pi_id=" + pi_id);
-
-        List<Object[]> data = baseDao.getFieldsDatasByCondition("prodiodetail  left join ProdInOut on pd_piid=pi_id", new String[] {
-                "pd_bcid", "pd_prodcode", "pd_pdno" }, "pd_piid=" + pi_id);
-        for (Object[] os : data) {
-            if (os[0] == null || os[0].equals("") || os[0].equals("0") || Integer.parseInt(os[0].toString()) == 0) {
-                String sql = "update Prodiodetail set pd_bcid=nvl((select sd_bcid from saledetail "
-                        + "where pd_ordercode=sd_code and pd_orderdetno=sd_detno),0) where pd_piid=" + pi_id + " and nvl(pd_bcid,0)=0";
-                baseDao.execute(sql);
-            }
-            Object pd_bcid = baseDao.getFieldDataByCondition("Prodiodetail", "pd_bcid", " pd_prodcode='" + os[1] + "' and pd_piid="
-                    + pi_id);
-            if (pd_bcid == null || pd_bcid.equals("") || pd_bcid.equals("0") || Integer.parseInt(pd_bcid.toString()) == 0) {
-                String sql = "update prodiodetail set pd_bcid=nvl((select max(bc_id) from prodinout,businesschance "
-                        + "where pi_id=pd_piid and pi_cardcode=bc_custcode and pd_prodcode=bc_model and bc_status<>'已结案'),0) where nvl(pd_bcid,0)=0 and pd_piid="
-                        + pi_id + " and nvl(pd_bcid,0)=0";
-                baseDao.execute(sql);
-            }
-            Object bc_id = baseDao.getFieldDataByCondition("Prodiodetail", "pd_bcid", " pd_prodcode='" + os[1] + "' and pd_piid="
-                    + pi_id);
-            Integer bs_detno = baseDao.getFieldValue("businesschancestage", "bs_detno", "bs_name='" + bsname + "'", Integer.class);
-            Integer bs_detno1 = baseDao.getFieldValue("businesschance left join businesschancestage on bs_name=bc_currentprocess",
-                    "nvl(bs_detno,0)", "bc_id=" + bc_id, Integer.class);
-            if (bs_detno != null && bs_detno1 != null) {
-                if (bs_detno >= bs_detno1) {
-                    baseDao.updateByCondition("BusinessChance", "bc_currentprocess='" + bsname + "',bc_desc" + bs_detno + "='" + bsname
-                            + "',bc_date" + bs_detno + "=to_date('" + date.toString() + "','yyyy-MM-dd')", "bc_id=" + bc_id);
-                    if (bsname != null && Integer.parseInt(pd_bcid.toString()) != 0) {
-                        Object bscode = baseDao.getFieldDataByCondition("BusinessChanceStage", "bs_code", "bs_name='" + bsname + "'");
-                        // 插入一条记录到商机动态表
-                        int bcd_id = baseDao.getSeqId("BusinessChanceData_seq");
-                        String link = "jsps/scm/reserve/prodInOut.jsp?whoami=ProdInOut!Sale&formCondition=pi_idIS" + pi_id
-                                + "&gridCondition=pd_piidIS" + pi_id;
-                        String contactSql = "insert into BusinessChanceData (bcd_id,bcd_bcid,bcd_code,bcd_bscode,bcd_bsname,bcd_date,bcd_man,bcd_statuscode,bcd_status,bcd_sourcecode,bcd_sourcelink) values ("
-                                + bcd_id
-                                + ","
-                                + bc_id
-                                + ",'"
-                                + baseDao.sGetMaxNumber("BusinessChanceData", 2)
-                                + "','"
-                                + bscode
-                                + "','"
-                                + bsname
-                                + "',"
-                                + "to_date('"
-                                + date.toString()
-                                + "','yyyy-MM-dd')"
-                                + ",'"
-                                + status[4]
-                                + "','"
-                                + "ENTERING" + "','在录入','" + status[5] + "','" + link + "')";
-                        baseDao.execute(contactSql);
-                    }
-                }
-            }
-
-        }
-
-    }
-    // 调用冲销
-		createSaleClash(pi_id, "ProdInOut",employee);
-		if ("ProdInOut!AppropriationOut".equals(caller) || "ProdInOut!SaleAppropriationOut".equals(caller)) {
-        dets = null;
-        if (baseDao.isDBSetting(caller, "autoPostIn")) {
-            // 过账销售拨入单
-            dets = turnProdIO(pi_id,employee);
-            // 过账失败提醒
-            boolean showTurnProdIOError = baseDao.checkIf("ProdInOut",
-                    "pi_class='拨入单' and pi_statuscode='UNPOST' and pi_inoutno=(select pi_relativeplace from ProdInOut where pi_class='拨出单' and pi_id="
-                            + pi_id + ")");
-            if (showTurnProdIOError) {
-                return "自动过账失败";
-            }
-        }
-        if (dets != null) {
-            return "拨入单明细行仓库对应的仓管员与当前过账人不一致，不允许进行当前操作!行号：" + dets;
-        }
-        if (baseDao.isDBSetting(caller, "autoPostMakeLSSend")) {// MakeSendLS
-            // 拉式发料
-            // 拨出单过账,拨入也过账时自动过账领料单
-            String SQLStr = "";
-            String Outpiclass = "";
-            SQLStr = "select pi_inoutno from prodinout where pi_id=" + pi_id + " and pi_statuscode='POSTED'";
-            SqlRowList rs0 = baseDao.queryForRowSet(SQLStr);
-            if (rs0.next()) {
-                SQLStr = "select pi_id,pi_class,pi_inoutno from prodinout where pi_fromcode='" + rs0.getString("pi_inoutno")
-                        + "' and pi_statuscode='UNPOST' ";
-                SqlRowList rs = baseDao.queryForRowSet(SQLStr);
-                if (rs.next()) {
-                    Outpiclass = rs.getObject("pi_class").toString();
-                    if (Outpiclass.equals("生产领料单")) {
-                        postProdInOut(rs.getInt("pi_id"), "ProdInOut!Picking",employee);
-                    } else if (Outpiclass.equals("委外领料单")) {
-                        postProdInOut(rs.getInt("pi_id"), "ProdInOut!OutsidePicking",employee);
-                    }
-                    SQLStr = "select pi_statuscode from prodinout where pi_id=" + rs.getInt("pi_id") + " and pi_statuscode='POSTED' ";
-                    rs0 = baseDao.queryForRowSet(SQLStr);
-                    if (rs0.next()) {
-                        return Outpiclass + "：" + rs.getString("pi_inoutno") + "过账成功!";
-                    } else {
-                        return Outpiclass + "：" + rs.getString("pi_inoutno") + "过账不成功!";
-                    }
-                }
-            }
-
-        }
-    }
-    // 委外验收，验退，完工入库单，过账更新完工状态
-		if ("ProdInOut!Make!In".equals(caller) || "ProdInOut!OutsideCheckIn".equals(caller)
-				|| "ProdInOut!OutesideCheckReturn".equals(caller)) {
-        SqlRowList rs = baseDao.queryForRowSet(
-                "select distinct ma_id from  prodiodetail left join make on ma_code=pd_ordercode where pd_piid=?", pi_id);
-        while (rs.next()) {// 更新完工状态
-            updateMakeFinishStatus(rs.getInt("ma_id"));
-        }
-    }
-		/*if ("ProdInOut!AppropriationOut".equals(caller)) {
-        SqlRowList rs3 = baseDao
-                .queryForRowSet(
-                        "select b.pi_id pi_id,a.pi_relativeplace pi_relativeplace from prodinout a left join prodinout  b on a.pi_relativeplace=b.pi_inoutno where a.pi_id=? and b.pi_class='拨入单'",
-                        pi_id);
-        if (rs3.next()) {
-            return "拨出单过账成功!系统产生的拨入单号 "+ rs3.getString("pi_relativeplace");
-        }
-    }*/
-
-		if ("ProdInOut!PurcCheckin".equals(caller)) {// 采购验收单过账根据采购单+采购单序号更新pd_vendorrate
-        // ba_vendorrate
-        SqlRowList pdRowList = baseDao
-                .queryForRowSet("select pd_id,nvl(pd_batchid,0) pd_batchid,nvl(pd_ordercode,' ') pd_ordercode,nvl(pd_orderdetno,0) pd_orderdetno from prodiodetail where pd_piid="
-                        + pi_id);
-        while (pdRowList.next()) {
-            baseDao.execute("update prodiodetail set pd_vendorrate=(select pd_vendorrate from purchasedetail where pd_code='"
-                    + pdRowList.getObject("pd_ordercode") + "' and pd_detno='" + pdRowList.getObject("pd_orderdetno")
-                    + "') where pd_id=" + pdRowList.getObject("pd_id"));
-            baseDao.execute("update batch set ba_vendorrate=(select pd_vendorrate from purchasedetail where pd_code='"
-                    + pdRowList.getObject("pd_ordercode") + "' and pd_detno='" + pdRowList.getObject("pd_orderdetno")
-                    + "') where ba_id=" + pdRowList.getObject("pd_batchid"));
-        }
-    }
-		if ("ProdInOut!Make!Give".equals(caller) || "ProdInOut!Make!Return".equals(caller) || "ProdInOut!Picking".equals(caller)
-				|| "ProdInOut!OSMake!Give".equals(caller) || "ProdInOut!OutsideReturn".equals(caller)
-				|| "ProdInOut!OutsidePicking".equals(caller)) {
-        changeMaStatus(pi_id);
-    }
-    // 2017-08-30 重新根据pdno更新批号仓库属性
-		if (isProdIn) {
-        baseDao.execute(
-                "update barcodeio set (bi_batchcode,bi_batchid,bi_whcode)=(select pd_batchcode,pd_batchid,pd_whcode from prodiodetail where bi_piid=pd_piid and pd_pdno=bi_pdno) where bi_piid=? and nvl(bi_status,0)=0",
-                pi_id);
-        baseDao.execute(
-                "update batch set ba_hasbarcode=-1 where ba_id in (select pd_batchid from prodiodetail "
-                        + " where pd_piid=?) and NVL(ba_hasbarcode,0)=0 and ba_id in (select bi_batchid from barcodeio where bi_inqty>0 and bi_status=0) ",
-                pi_id);
-    }
-    /**
-     * @author wsy
-     *         其它入库单：如果选择了采购单号、采购序号后，提交、审核的时候要判断采购单号+采购序号+物料编号是否一致，不一致限制提交
-     *         、审核
-     */
-		if ("ProdInOut!OtherIn".equals(caller)) {
-        baseDao.execute("update purchasedetail set pd_beipinacceptqty=(nvl((select sum(nvl(pd_purcinqty,0)) from prodiodetail where pd_piclass='其它入库单' and pd_ordercode=pd_code and pd_orderdetno=pd_detno and pd_status=99),0))where (pd_code,pd_detno) in (select pd_ordercode,pd_orderdetno from prodiodetail where pd_piid="
-                + pi_id + " and pd_piclass='其它入库单')");
-    }
-        prodinout_post_updatesourceqty(pi_id);
-		return null;
-}
-
-    /**
-     * 过账后扣除待检数量、收料数量 scm->prodinout->post->after
-     *
-     * @author madan
-     */
-    public void prodinout_post_updatesourceqty(Integer id) {
-        Object[] piclass = baseDao.getFieldsDataByCondition("ProdInOut", new String[] { "pi_class", "pi_type" }, "pi_id=" + id);
-        if (!(piclass[0].toString().equals("采购验收单") || piclass[0].toString().equals("委外验收单") || piclass[0].toString().equals("不良品入库单"))) {
-            return;
-        }
-        List<Object[]> objs = baseDao.getFieldsDatasByCondition("prodioDetail", new String[] { "pd_orderdetno", "pd_ordercode",
-                "sum(pd_inqty)", "pd_prodcode" }, "pd_piid=" + id + " and pd_qcid>0 group by pd_ordercode, pd_orderdetno, pd_prodcode");
-        for (Object[] obj : objs) {
-            if ("采购验收单".equals(piclass[0].toString())) {
-                baseDao.updateByCondition("PurchaseDetail", "pd_reconhand = nvl(pd_reconhand,0)-" + obj[2]
-                        + ",pd_totested=NVL(pd_totested,0)-" + obj[2], "pd_code='" + obj[1] + "' and pd_detno = " + obj[0]);
-            } else if ("委外验收单".equals(piclass[0].toString()) || "完工入库单".equals(piclass[0].toString())) {
-                baseDao.updateByCondition("Make", "ma_reconhand = nvl(ma_reconhand,0)-" + obj[2] + ",ma_totested=NVL(ma_totested,0)-"
-                        + obj[2], "ma_code='" + obj[1] + "'");
-            } else if ("不良品入库单".equals(piclass[0].toString())) {
-                if ("PURC".equals(piclass[1].toString()) || "采购不良品入库".equals(piclass[1].toString())) {
-                    baseDao.updateByCondition("PurchaseDetail", "pd_reconhand = nvl(pd_reconhand,0)-" + obj[2]
-                            + ",pd_totested=NVL(pd_totested,0)-" + obj[2], "pd_code='" + obj[1] + "' and pd_detno = " + obj[0]);
-                } else {
-                    baseDao.updateByCondition("Make", "ma_reconhand = nvl(ma_reconhand,0)-" + obj[2] + ",ma_totested=NVL(ma_totested,0)-"
-                            + obj[2], "ma_code='" + obj[1] + "'");
-                }
-            }
-            baseDao.updateByCondition("Product", "pr_reconhand = nvl(pr_reconhand,0)-" + obj[2] + ",pr_totested=NVL(pr_totested,0)-"
-                    + obj[2], "pr_code='" + obj[3] + "'");
-        }
-    }
-
-    // 税率强制等于币别表的默认税率
-    private void useDefaultTax(String caller, Object pi_id) {
-        if (baseDao.isDBSetting(caller, "useDefaultTax")) {
-            baseDao.execute("update ProdIODetail set pd_taxrate=(select cr_taxrate from currencys left join ProdInOut on pi_currency=cr_name and cr_statuscode='CANUSE' where pd_piid=pi_id)"
-                    + " where pd_piid=" + pi_id);
-        }
-        String defaultTax = baseDao.getDBSetting(caller, "defaultTax");
-        if (defaultTax != null) {
-            // 税率强制等于币别表的默认税率
-            if ("1".equals(defaultTax)) {
-                baseDao.execute("update ProdIODetail set pd_taxrate=(select cr_taxrate from currencys left join ProdInOut on pi_currency=cr_name and cr_statuscode='CANUSE' where pd_piid=pi_id)"
-                        + " where pd_piid=" + pi_id);
-            }
-            // 税率强制等于供应商资料的默认税率
-            if ("2".equals(defaultTax)) {
-                if ("ProdInOut!PurcCheckin".equals(caller) || "ProdInOut!PurcCheckout".equals(caller)
-                        || "ProdInOut!OutsideCheckIn".equals(caller) || "ProdInOut!OutesideCheckReturn".equals(caller)) {
-                    baseDao.execute("update ProdIODetail set pd_taxrate=(select nvl(ve_taxrate,0) from Vendor left join ProdInOut on pi_cardcode=ve_code and ve_auditstatuscode='AUDITED' where pi_id=pd_piid)"
-                            + " where pd_piid=" + pi_id);
-                }
-                if ("ProdInOut!SaleReturn".equals(caller) || "ProdInOut!Sale".equals(caller)) {
-                    baseDao.execute("update ProdIODetail set pd_taxrate=(select nvl(cu_taxrate,0) from Customer left join ProdInOut on pi_cardcode=cu_code and cu_auditstatuscode='AUDITED' where pi_id=pd_piid)"
-                            + " where pd_piid=" + pi_id);
-                }
-            }
-        }
-    }
-
-    // 本位币允许税率为0
-    private String allowZeroTax(String caller, Object pi_id) {
-        String currency = baseDao.getDBSetting("sys","defaultCurrency");
-        boolean allowZeroTax = baseDao.isDBSetting(caller, "allowZeroTax");
-        if ("ProdInOut!Sale".equals(caller) || "ProdInOut!SaleReturn".equals(caller)) {
-            allowZeroTax = baseDao.isDBSetting("Sale", "allowZeroTax");
-        }
-        if ("ProdInOut!PurcCheckin".equals(caller) || "ProdInOut!PurcCheckout".equals(caller)) {
-            allowZeroTax = baseDao.isDBSetting("Purchase", "allowZeroTax");
-        }
-        if ("ProdInOut!OutsideCheckIn".equals(caller) || "ProdInOut!OutesideCheckReturn".equals(caller)) {
-            allowZeroTax = baseDao.isDBSetting("Make", "allowZeroTax");
-        }
-        if (!allowZeroTax) {
-            String dets = baseDao.getJdbcTemplate().queryForObject(
-                    "select WM_CONCAT(pd_pdno) from ProdIODetail left join ProdInOut on pd_piid=pi_id where nvl(pd_taxrate,0)=0 and pi_currency='"
-                            + currency + "' and pi_id=?", String.class, pi_id);
-            if (dets != null) {
-                return "本位币税率为0，不允许进行当前操作!行号：" + dets;
-            }
-        }
-        return null;
-    }
-
-    String checkCloseMonth(Object pidate) {
-        boolean bool = baseDao.checkIf("PeriodsDetail", "pd_code='MONTH-P' and pd_status=99 and pd_detno=to_char(to_date('" + pidate
-                + "','yyyy-mm-dd hh24:mi:ss'), 'yyyymm')");
-        if (bool) {
-            return "单据日期所属期间已结账，不允许进行当前操作！";
-        }
-        return null;
-    }
-
-    String checkMakeKindType(String caller, Object pi_id) {
-        if (baseDao.isDBSetting(caller, "makeKindType")) {
-            String sql = "select count(1)cn from (select count(1) cn,  mk_type from make left join makekind on mk_name =ma_kind"
-                    + " left join prodiodetail on pd_ordercode = ma_code where pd_piid=? group by mk_type) ";
-            SqlRowList sqlRowList = baseDao.queryForRowSet(sql, pi_id);
-            if (sqlRowList.next()) {
-                if (sqlRowList.getInt("cn") > 1) {
-                    return "明细行制造单加工类型不同，不能使用同一张完工入库单";
-                }
-            }
-        }
-        return null;
-    }
-
-    String checkFreezeMonth(String caller, Object pidate) {
-        if (!"ProdInOut!CostChange".equals(caller)) {
-            String freeze = baseDao.getDBSetting("sys","freezeMonth");
-            if (freeze != null && !freeze.equals("")) {
-                if (Integer.parseInt(freeze) == DateUtil.getYearmonth(pidate.toString())) {
-                    return "单据日期所属期间已冻结，不允许进行当前操作！";
-                }
-            }
-        }
-        return null;
-    }
-
-    String checkFirstMonth(String caller, Object pidate) {
-        if ("ProdInOut!ReserveInitialize".equals(caller)) {
-            Object first = baseDao.getFieldDataByCondition("periods", "nvl(PE_FIRSTDAY,0)", "PE_CODE='MONTH-P'");
-            if ("0".equals(first.toString())) {
-                return "请前往【初始化期间设置】确认开账期间！";
-            } else {
-                if (Integer.parseInt(first.toString()) != DateUtil.getYearmonth(pidate.toString())) {
-                    return "库存初始化单据只能发生在库存模块的开账期间！当前库存模块开账期间为[" + first + "]，请前往【初始化期间设置】确认开账期间！";
-                }
-            }
-        }
-        return null;
-    }
-
-    /*
-     * 提交，审核，过账之前的限制
-     */
-    private String checkCommit(String caller, Object pi_id) {
-        checkIOMaPick(caller,pi_id);
-        if (!caller.equals("ProdInOut!AppropriationOut") && !caller.equals("ProdInOut!AppropriationIn")) {
-            baseDao.execute("update prodiodetail set pd_whcode=(select pi_whcode from prodinout where pd_piid=pi_id) where pd_piid="
-                    + pi_id + " and NVL(pd_whcode,' ')=' '");
-        }
-        if (caller.equals("ProdInOut!Make!Return") || caller.equals("ProdInOut!OutsideReturn")) {
-            baseDao.execute("update prodiodetail a set pd_prodmadedate=(select min(ba_date) from prodiodetail b left join batch on b.pd_batchid=ba_id where a.pd_ordercode=b.pd_ordercode and a.pd_prodcode=b.pd_prodcode and nvl(b.pd_batchcode,' ')<>' ' and ((b.pd_piclass ='生产领料单' and a.pd_piclass='生产退料单') or (b.pd_piclass ='委外领料单' and a.pd_piclass='委外退料单'))) where pd_piid="
-                    + pi_id + " and pd_prodmadedate is null");
-        }
-        baseDao.execute("update prodiodetail set pd_prodmadedate=(select pi_date from prodinout where pd_piid=pi_id) where pd_piid="
-                + pi_id + " and pd_prodmadedate is null");
-        if ("ProdInOut!CostChange".equals(caller)) {
-            baseDao.execute(
-                    "update prodiodetail set (pd_orderqty,pd_orderprice)=(select ba_remain,ba_price from batch where ba_code=pd_batchcode and pd_prodcode=ba_prodcode and ba_whcode=pd_whcode) where pd_piid=?",
-                    pi_id);
-            baseDao.execute(
-                    "update prodiodetail set pd_total=round(nvl(pd_orderqty,0)*(nvl(pd_price,0)-nvl(pd_orderprice,0)),2) where pd_piid=?",
-                    pi_id);
-        }
-        baseDao.execute("update prodiodetail set pd_qctype=(select ve_class from qua_verifyapplydetail left join qua_verifyapplydetaildet on ved_veid=ve_id where pd_qcid=ved_id) where pd_piid="
-                + pi_id + " and nvl(pd_qcid,0)<>0");
-        String dets = baseDao
-                .getJdbcTemplate()
-                .queryForObject(
-                        "select wm_concat(pd_piclass||'['||pd_inoutno||']行号['||pd_pdno||']') from ProdIODetail left  join product on pr_code=pd_prodcode  where pd_piid=? and NVL(pr_statuscode,' ')<>'AUDITED'",
-                        String.class, pi_id);
-        if (dets != null) {
-            return "明细行物料不存在或者状态不等于已审核，不允许进行当前操作！" + dets;
-        }
-        dets = baseDao
-                .getJdbcTemplate()
-                .queryForObject(
-                        "select wm_concat(pd_piclass||'['||pd_inoutno||']行号['||pd_pdno||']') from ProdIODetail where pd_piid=? and nvl(pd_whcode,' ')=' '",
-                        String.class, pi_id);
-        if (dets != null) {
-            return "明细行仓库为空，不允许进行当前操作！" + dets;
-        }
-        /**
-         * 限制当仓库编号不为空时，明细行仓库至少有一行与主记录一致;为空则不判断
-         */
-
-        /*
-         * 暂不启用该逻辑限制 int c = baseDao.getCountByCondition(
-         * "ProdInOut left join ProdIODetail on pi_id=pd_piid", "pi_id=" + pi_id
-         * +
-         * " and ((NVL(pd_whcode,' ')=nvl(pi_whcode,' ') AND pi_whcode IS NOT NULL) or pi_whcode is null )"
-         * ); if (c < 1) { BaseUtil.showError("无一明细仓库与主表仓库一致，不允许进行当前操作！"); }
-         */
-        if (!caller.equals("ProdInOut!StockProfit") && !caller.equals("ProdInOut!StockLoss")) {
-            dets = baseDao
-                    .getJdbcTemplate()
-                    .queryForObject(
-                            "select wm_concat(pd_pdno) from ProdIODetail inner join Prodinout on pd_piid=pi_id left join product on pr_code=pd_prodcode where "
-                                    + "pd_piid=? and round(pd_outqty+pd_inqty,0)<>pd_outqty+pd_inqty and pd_status=0 and NVL(pr_precision,0)=0  and NVL(pr_groupcode,' ')<>'用品' ",
-                            String.class, pi_id);
-            if (dets != null) {
-                return "计算精度是0的物料不能以小数出入库!行号：" + dets;
-            }
-        }
-        if (baseDao.isDBSetting("sys","warehouseCheck") || baseDao.isDBSetting(caller, "warehouseCheck")) {
-            // 出入库单主记录与明细行仓库必须一致
-            dets = baseDao
-                    .getJdbcTemplate()
-                    .queryForObject(
-                            "select wm_concat(pd_piclass||'['||pd_inoutno||']行号['||pd_pdno||']') from ProdIODetail left join ProdInOut on pd_piid=pi_id where pi_id=? and (nvl(pi_whcode,' ')<>nvl(pd_whcode,' ') or nvl(pi_purpose,' ')<>nvl(pd_inwhcode,' '))",
-                            String.class, pi_id);
-            if (dets != null) {
-                return "明细行仓库与当前单主表仓库不一致，不允许进行当前操作！" + dets;
-            }
-        }
-        dets = baseDao
-                .getJdbcTemplate()
-                .queryForObject(
-                        "select wmsys.wm_concat(pd_piclass||':'||pd_inoutno||',行:'||pd_pdno||',仓库:'||pd_whcode) from prodiodetail left join warehouse on wh_code=pd_whcode where pd_piid=? and nvl(pd_whcode,' ')<>' ' and nvl(wh_statuscode,' ')='DISABLE'",
-                        String.class, pi_id);
-        if (dets != null) {
-            return "仓库已禁用，不允许进行当前操作！" + dets;
-        }
-        dets = baseDao
-                .getJdbcTemplate()
-                .queryForObject(
-                        "select wmsys.wm_concat(pd_piclass||':'||pd_inoutno||',行:'||pd_pdno||',仓库:'||pd_whcode) from prodiodetail left join warehouse on wh_code=pd_whcode where pd_piid=? and nvl(pd_whcode,' ')<>' ' and pd_whcode not in (select wh_code from warehouse)",
-                        String.class, pi_id);
-        if (dets != null) {
-            return "仓库不存在，不允许进行当前操作！" + dets;
-        }
-        String maxprice = baseDao.getDBSetting(caller, "maxPrice");
-        if (maxprice != null) {
-            dets = baseDao
-                    .getJdbcTemplate()
-                    .queryForObject(
-                            "select wmsys.wm_concat(pd_piclass||':'||pd_inoutno||',行:'||pd_pdno||',单价:'||pd_price) from prodiodetail where pd_piid=? and nvl(pd_price,0)>?",
-                            String.class, pi_id, maxprice);
-            if (dets != null) {
-                return "单价超过设置上限，不允许进行当前操作！" + dets;
-            }
-        }
-        if ("ProdInOut!Picking".equals(caller) || "ProdInOut!Make!Give".equals(caller) || "ProdInOut!Make!Return".equals(caller)
-                || "ProdInOut!OutsidePicking".equals(caller) || "ProdInOut!OutsideReturn".equals(caller)
-                || "ProdInOut!OSMake!Give".equals(caller) || "ProdInOut!Make!In".equals(caller)
-                || "ProdInOut!PartitionStockIn".equals(caller) || "ProdInOut!OutsideCheckIn".equals(caller)
-                || "ProdInOut!OutesideCheckReturn".equals(caller)) {
-            dets = baseDao
-                    .getJdbcTemplate()
-                    .queryForObject(
-                            "select wm_concat(pd_pdno) from ProdIODetail where pd_piid=? and pd_piclass in ('生产领料单','生产补料单','生产退料单','委外领料单','委外退料单','委外补料单') and not exists (select 1 from make left join makematerial on ma_id=mm_maid where pd_ordercode=ma_code and pd_orderdetno=mm_detno)",
-                            String.class, pi_id);
-            if (dets != null) {
-                return "工单+序号不存在，不允许进行当前操作！行号：" + dets;
-            }
-            dets = baseDao
-                    .getJdbcTemplate()
-                    .queryForObject(
-                            "select wm_concat(pd_pdno) from ProdIODetail where pd_piid=? and pd_piclass in ('生产领料单','生产补料单','生产退料单','委外领料单','委外退料单','委外补料单') and not exists (select 1 from make left join makematerial on ma_id=mm_maid where pd_ordercode=ma_code and pd_orderdetno=mm_detno and pd_prodcode=mm_prodcode) and "
-                                    + " not exists(select 1 from make inner join makematerial on ma_id= mm_maid inner join makematerialreplace on mm_id = mp_mmid where pd_ordercode=ma_code and pd_orderdetno=mm_detno and pd_prodcode=mp_prodcode)",
-                            String.class, pi_id);
-            if (dets != null) {
-                return "工单+序号+物料编号不存在，不允许进行当前操作！行号：" + dets;
-            }
-            dets = baseDao
-                    .getJdbcTemplate()
-                    .queryForObject(
-                            "select wm_concat(pd_pdno) from ProdIODetail left join Prodinout on pd_piid=pi_id left join make on ma_code=pd_ordercode where "
-                                    + "pd_piid=? and nvl(pi_cardcode,' ')<>nvl(ma_vendcode,' ') and pd_piclass in ('委外退料单','委外验退单','委外领料单') "
-                                    + "and nvl(pd_ordercode,' ')<>' ' and not exists (select 1 from makecraft where mc_code=pd_jobcode and mc_tasktype='工序委外单')",
-                            String.class, pi_id);
-            if (dets != null) {
-                return "明细委外单委外商与单据委外商不一致，不允许进行当前操作!行号：" + dets;
-            }
-
-            dets = baseDao
-                    .getJdbcTemplate()
-                    .queryForObject(
-                            "select wm_concat(pd_pdno) from ProdIODetail where nvl(pd_jobcode,' ')<>' ' and not exists (select 1 from makecraft where pd_jobcode=mc_code "
-                                    + "and mc_tasktype='工序委外单') and pd_piclass in ('委外退料单','委外验退单','委外领料单') and pd_piid=?", String.class,
-                            pi_id);
-            if (dets != null) {
-                return "明细工序委外单不存在，不允许进行当前操作!行号：" + dets;
-            }
-
-            dets = baseDao
-                    .getJdbcTemplate()
-                    .queryForObject(
-                            "select wm_concat(pd_pdno) from ProdIODetail left join Prodinout on pd_piid=pi_id left join makecraft on mc_code=pd_jobcode where "
-                                    + "pd_piid=? and nvl(pi_cardcode,' ')<>nvl(mc_vendcode,' ') and pd_piclass in ('委外退料单','委外验退单','委外领料单') "
-                                    + "and nvl(pd_ordercode,' ')<>' ' and exists (select 1 from makecraft where mc_code=pd_jobcode and mc_tasktype='工序委外单') ",
-                            String.class, pi_id);
-            if (dets != null) {
-                return "委外商与工序委外单委外商不一致，不允许进行当前操作!行号：" + dets;
-            }
-            dets = baseDao
-                    .getJdbcTemplate()
-                    .queryForObject(
-                            "select wm_concat('工单：'||pd_ordercode||'序号:'||pd_orderdetno) from (select pd_ordercode,pd_orderdetno,sum(pd_inqty) pd_inqty,max(mm_yqty)mm_yqty,max(mm_gqty)mm_gqty from ProdIODetail left join make on ma_code=pd_ordercode left join makematerial on ma_id=mm_maid and mm_detno=pd_orderdetno where pd_piid=? and pd_piclass='拆件入库单'  group by pd_ordercode,pd_orderdetno)A where mm_yqty+pd_inqty>mm_gqty and mm_gqty>0 ",
-                            String.class, pi_id);
-            if (dets != null) {
-                return "拆件入库数不能大于工单允许可拆件入库数！" + dets;
-            }
-            dets = baseDao
-                    .getJdbcTemplate()
-                    .queryForObject(
-                            "select wm_concat('行号：'||pd_pdno||'工单：'||pd_ordercode) from ProdIODetail left join make on ma_code=pd_ordercode  left join makekind ON mk_name=ma_kind where pd_piid=? and pd_piclass='拆件入库单'  and  mk_type='S'",
-                            String.class, pi_id);
-            if (dets != null) {
-                return "拆件单明细中存在制造单的类型是标准！" + dets;
-            }
-            boolean allowBackAfterFinish = false;
-            if ("ProdInOut!Make!Return".equals(caller)) { // @add xst 20180830
-                // 反馈：2018080651
-                // ，制造单已结案允许退料
-                allowBackAfterFinish = baseDao.isDBSetting("Make!Base", "allowBackAfterFinish");
-            }
-            dets = baseDao
-                    .getJdbcTemplate()
-                    .queryForObject(
-                            "select wm_concat(pd_pdno) from prodinout left join  ProdIODetail  on pd_piid=pi_id  left join make on ma_code=pd_ordercode  where  pd_piid=? and (NVL(ma_statuscode,' ')<>'AUDITED' AND ('"
-                                    + allowBackAfterFinish
-                                    + "'='false' or (pd_piclass='生产退料单' and ma_statuscode<>'FINISH'))) and pi_statuscode='UNPOST' and pd_piclass in ('完工入库单','拆件入库单','委外验收单','生产领料单','生产补料单','生产退料单','委外领料单','委外退料单','委外补料单') and nvl(pd_ordercode,' ')<>' ' ",
-                            String.class, pi_id);
-            if (dets != null) {
-                return "工单不存在或者状态不等于已审核，不允许进行当前操作！行号：" + dets;
-            }
-
-            dets = baseDao
-                    .getJdbcTemplate()
-                    .queryForObject(
-                            "select wm_concat(pd_pdno) from ProdIODetail left join Prodinout on pd_piid=pi_id left join make on ma_code=pd_ordercode  left join MakeKind on mk_name=ma_kind "
-                                    + "where pd_piid=? and nvl(pd_whcode,' ')<>' ' and nvl(mk_whcodes,' ')<>' ' and pd_whcode not in (select column_value from table(parsestring(mk_whcodes,'#'))) "
-                                    + "and pd_piclass in ('完工入库单','委外验收单') and nvl(pd_ordercode,' ')<>' ' and nvl(ProdIODetail.pd_status,0)=0",
-                            String.class, pi_id);
-            if (dets != null) {
-                return "明细仓库与工单类型允许入库仓库不一致，不允许进行当前操作!行号：" + dets;
-            }
-        }
-        if ("ProdInOut!OutesideCheckReturn".equals(caller)) {
-            dets = baseDao
-                    .getJdbcTemplate()
-                    .queryForObject(
-                            "select wm_concat(pd_pdno) from ProdIODetail where pd_piid=? and pd_piclass in ('委外验退单') and not exists (select 1 from make where pd_ordercode=ma_code and pd_prodcode=ma_prodcode) "
-                                    + "and not exists (select 1 from makecraft where pd_jobcode=mc_code and mc_tasktype='工序委外单' and pd_prodcode=mc_prodcode)",
-                            String.class, pi_id);
-            if (dets != null) {
-                return "委外单+物料编号不存在，不允许进行当前操作！行号：" + dets;
-            }
-
-            dets = baseDao
-                    .getJdbcTemplate()
-                    .queryForObject(
-                            "select wm_concat(pd_pdno) from ProdIODetail left join Prodinout on pd_piid=pi_id left join Make on ma_code=pd_ordercode where pd_piid=? and nvl(pi_currency,' ')<>nvl(ma_currency,' ')"
-                                    + " and not exists (select 1 from makecraft where pd_jobcode=mc_code and mc_tasktype='工序委外单')"
-                                    + " and pd_piclass in ('委外验退单') and nvl(pd_ordercode,' ')<>' '", String.class, pi_id);
-            if (dets != null) {
-                return "明细委外单与单据币别不一致，不允许进行当前操作!行号：" + dets;
-            }
-
-            dets = baseDao.getJdbcTemplate().queryForObject(
-                    "select wm_concat(pd_pdno) from ProdIODetail left join Prodinout on pd_piid=pi_id left join MakeCraft on mc_makecode=pd_ordercode "
-                            + " and mc_code =pd_jobcode where pd_piid=? and nvl(pi_currency,' ')<>nvl(mc_currency,' ')"
-                            + " and exists (select 1 from makecraft where pd_jobcode=mc_code and mc_tasktype='工序委外单')"
-                            + " and pd_piclass in ('委外验退单') and nvl(pd_ordercode,' ')<>' '", String.class, pi_id);
-            if (dets != null) {
-                return "明细委外单与单据币别不一致，不允许进行当前操作!行号：" + dets;
-            }
-        }
-        if ("ProdInOut!PurcCheckin".equals(caller) || "ProdInOut!PurcCheckout".equals(caller) || "ProdInOut!DefectIn".equals(caller)
-                || "ProdInOut!DefectOut".equals(caller)) {
-            dets = baseDao
-                    .getJdbcTemplate()
-                    .queryForObject(
-                            "select wm_concat(pi_inoutno) from ProdInOut where pi_id=? and pi_class in ('采购验收单','采购验退单') and (pi_cardcode,pi_title) not in (select ve_code,ve_name from vendor)",
-                            String.class, pi_id);
-            if (dets != null) {
-                return "单据中供应商编号，供应商名称在供应商资料中不存在!";
-            }
-            dets = baseDao
-                    .getJdbcTemplate()
-                    .queryForObject(
-                            "select wm_concat(pi_inoutno) from ProdInOut where pi_id=? and pi_class in ('采购验收单','采购验退单') and (pi_receivecode,pi_receivename) not in (select ve_code,ve_name from vendor)",
-                            String.class, pi_id);
-            if (dets != null) {
-                return "单据中应付供应商编号，应付供应商名称在供应商资料中不存在!";
-            }
-            dets = baseDao
-                    .getJdbcTemplate()
-                    .queryForObject(
-                            "select wm_concat(pd_pdno) from ProdIODetail where pd_piid=?"
-                                    + " and pd_piclass in ('采购验收单','采购验退单') and nvl(pd_ordercode,' ')<>' ' and  not exists (select pd_code,pd_detno from purchasedetail where pd_code=ProdIODetail.pd_ordercode and pd_detno=ProdIODetail.pd_orderdetno)",
-                            String.class, pi_id);
-            if (dets != null) {
-                return "采购单号+采购序号不存在，不允许进行当前操作!行号：" + dets;
-            }
-            dets = baseDao
-                    .getJdbcTemplate()
-                    .queryForObject(
-                            "select wm_concat(pd_pdno) from ProdIODetail where pd_piid=?"
-                                    + " and  not exists(select pd_code,pd_detno from purchasedetail p  where p.pd_prodcode=ProdIODetail.pd_prodcode and p.pd_code=ProdIODetail.pd_ordercode and  p.pd_detno=ProdIODetail.pd_orderdetno ) and pd_piclass in ('采购验收单','采购验退单') and nvl(pd_ordercode,' ')<>' ' ",
-                            String.class, pi_id);
-            if (dets != null) {
-                Boolean bo = baseDao.isDBSetting("VerifyApply", "verifyApplyAllowPre"); // 允许收替代料
-                if (bo) {
-                    SqlRowList rsReq = baseDao
-                            .queryForRowSet(
-                                    "select pd_repprodcode,pd_detno,pd_code from purchasedetail A where exists(select 1 from prodiodetail B where B.pd_piid=? and A.pd_code=B.pd_ordercode and A.pd_detno=B.pd_orderdetno )",
-                                    pi_id);
-                    if (!rsReq.hasNext()) {
-                        return "采购单号+采购序号不存在!";
-                    }
-                    while (rsReq.next()) {
-                        if (rsReq.getString("pd_repprodcode") != null && !("").equals(rsReq.getString("pd_repprodcode"))) {
-                            StringBuffer codes = new StringBuffer();
-                            String[] arr = rsReq.getString("pd_repprodcode").split(",");
-                            codes.append("'");
-                            for (int i = 0; i < arr.length; i++) {
-                                if (i < arr.length - 1) {
-                                    codes.append(arr[i] + "','");
-                                } else {
-                                    codes.append(arr[i] + "'");
-                                }
-                            }
-                            dets = baseDao
-                                    .getJdbcTemplate()
-                                    .queryForObject(
-                                            " select wm_concat(pd_pdno) from ProdIODetail where pd_piid=? and pd_ordercode ='"
-                                                    + rsReq.getString("pd_code")
-                                                    + "' and pd_orderdetno="
-                                                    + rsReq.getInt("pd_detno")
-                                                    + " and  not exists(select pd_code,pd_detno from purchasedetail p  where  p.pd_code=ProdIODetail.pd_ordercode and  p.pd_detno=ProdIODetail.pd_orderdetno and (p.pd_prodcode=ProdIODetail.pd_prodcode or ProdIODetail.pd_prodcode in ("
-                                                    + codes + ")) ) and pd_piclass in ('采购验收单','采购验退单') and nvl(pd_ordercode,' ')<>' ' ",
-                                            String.class, pi_id);
-                            if (dets != null) {
-                                return "采购单号+采购序号+物料不存在，不允许进行当前操作!行号：" + dets;
-                            }
-                        }
-                    }
-                }
-                if (dets != null) {
-                    return "采购单号+采购序号+物料不存在，不允许进行当前操作!行号：" + dets;
-                }
-            }
-            dets = baseDao.getJdbcTemplate().queryForObject(
-                    "select wm_concat(pd_pdno) from ProdIODetail left join PurchaseDetail on pd_ordercode=pd_code and pd_orderdetno=pd_detno where "
-                            + "pd_piid=? and nvl(pd_mrpstatuscode,' ') in ('FREEZE','FINISH') and pd_piclass in ('采购验收单','采购验退单') "
-                            + "and nvl(pd_ordercode,' ')<>' '", String.class, pi_id);
-            if (dets != null) {
-                return "采购单明细已冻结或者已结案，不允许进行当前操作!行号：" + dets;
-            }
-            dets = baseDao.getJdbcTemplate().queryForObject(
-                    "select wm_concat(pd_pdno) from ProdIODetail left join PurchaseDetail on pd_ordercode=pd_code and pd_orderdetno=pd_detno where "
-                            + "pd_piid=? and nvl(pd_mrpstatuscode,' ') in ('FREEZE','FINISH') and pd_piclass in ('不良品入库单','不良品出库单') "
-                            + "and nvl(pd_ordercode,' ')<>' ' and nvl(pd_qctype,' ')='采购检验单'", String.class, pi_id);
-            if (dets != null) {
-                return "采购单明细已冻结或者已结案，不允许进行当前操作!行号：" + dets;
-            }
-            dets = baseDao.getJdbcTemplate().queryForObject(
-                    "select wm_concat(pd_pdno) from ProdIODetail left join Make on pd_ordercode=ma_code where "
-                            + "pd_piid=? and nvl(ma_statuscode,' ') in ('FREEZE','FINISH') and pd_piclass in ('不良品入库单','不良品出库单') "
-                            + "and nvl(pd_ordercode,' ')<>' ' and nvl(pd_qctype,' ')='委外检验单'", String.class, pi_id);
-            if (dets != null) {
-                return "明细行委外单已冻结或者已结案，不允许进行当前操作!行号：" + dets;
-            }
-            if (!baseDao.isDBSetting(caller, "noLimitVendor")) {
-                dets = baseDao.getJdbcTemplate().queryForObject(
-                        "select wm_concat(pd_pdno) from ProdIODetail left join Prodinout on pd_piid=pi_id left join Purchase on pu_code=pd_ordercode where "
-                                + "pd_piid=? and nvl(pi_cardcode,' ')<>nvl(pu_vendcode,' ') and pd_piclass in ('采购验收单','采购验退单') "
-                                + "and nvl(pd_ordercode,' ')<>' '", String.class, pi_id);
-                if (dets != null) {
-                    return "明细采购单与单据供应商不一致，不允许进行当前操作!行号：" + dets;
-                }
-            }
-            if (!baseDao.isDBSetting(caller, "allowARCust")) {
-                dets = baseDao
-                        .getJdbcTemplate()
-                        .queryForObject(
-                                "select wm_concat(pd_pdno) from ProdIODetail left join Prodinout on pd_piid=pi_id left join Purchase on pu_code=pd_ordercode where "
-                                        + "pd_piid=? and nvl(pi_receivecode,' ')<>nvl(pu_receivecode,' ') and pd_piclass in ('采购验收单','采购验退单') and nvl(pd_ordercode,' ')<>' '",
-                                String.class, pi_id);
-                if (dets != null) {
-                    return "明细采购单与单据应付供应商不一致，不允许进行当前操作!行号：" + dets;
-                }
-                dets = baseDao
-                        .getJdbcTemplate()
-                        .queryForObject(
-                                "select wm_concat(pd_pdno) from ProdIODetail left join Prodinout on pd_piid=pi_id left join Purchase on pu_code=pd_ordercode where pd_piid=? and nvl(pi_currency,' ')<>nvl(pu_currency,' ')"
-                                        + " and pd_piclass in ('采购验收单','采购验退单') and nvl(pd_ordercode,' ')<>' '", String.class, pi_id);
-                if (dets != null) {
-                    return "明细采购单与单据币别不一致，不允许进行当前操作!行号：" + dets;
-                }
-            }
-            dets = baseDao
-                    .getJdbcTemplate()
-                    .queryForObject(
-                            "select wm_concat('行号：'||pd_pdno||'收料合格数量：'||ved_okqty) from ProdIODetail left join QUA_VerifyApplyDetailDet on pd_qcid=ved_id where pd_piid=? and nvl(pd_qcid,0)<>0 and nvl(pd_inqty,0)>nvl(ved_okqty,0) and pd_piclass in ('采购验收单')",
-                            String.class, pi_id);
-            if (dets != null) {
-                return "明细行入库数量大于收料合格数量!" + dets;
-            }
-            dets = baseDao
-                    .getJdbcTemplate()
-                    .queryForObject(
-                            "select wm_concat('行号：'||pd_pdno||'收料不合格数量：'||ved_ngqty) from ProdIODetail left join QUA_VerifyApplyDetailDet on pd_qcid=ved_id where pd_piid=? and nvl(pd_qcid,0)<>0 and nvl(pd_inqty,0)>nvl(ved_ngqty,0) and pd_piclass in ('不良品入库单')",
-                            String.class, pi_id);
-            if (dets != null) {
-                return "明细行入库数量大于收料不合格数量!" + dets;
-            }
-            dets = baseDao
-                    .getJdbcTemplate()
-                    .queryForObject(
-                            "select wm_concat(pd_pdno) from ProdIODetail left join Prodinout on pd_piid=pi_id left join Purchase on pu_code=pd_ordercode left join purchasekind on pk_name=pu_kind "
-                                    + "where pd_piid=? and nvl(pd_whcode,' ')<>' ' and nvl(pk_whcodes,' ')<>' ' and pd_whcode not in (select column_value from table(parsestring(pk_whcodes,'#'))) "
-                                    + "and pd_piclass in ('采购验收单') and nvl(pd_ordercode,' ')<>' '", String.class, pi_id);
-            if (dets != null) {
-                return "明细仓库与采购单类型允许入仓库不一致，不允许进行当前操作!行号：" + dets;
-            }
-            if ("ProdInOut!PurcCheckin".equals(caller)) {
-                dets = baseDao
-                        .getJdbcTemplate()
-                        .queryForObject(
-                                "select wm_concat(pd_pdno) from ProdIODetail left join PurchaseDetail on PurchaseDetail.pd_code=ProdIODetail.pd_ordercode and PurchaseDetail.pd_detno=ProdIODetail.pd_orderdetno "
-                                        + "where pd_piid=? and nvl(PurchaseDetail.pd_yqty,0)>nvl(PurchaseDetail.pd_qty,0)-nvl(PurchaseDetail.pd_frozenqty,0) "
-                                        + "and pd_piclass in ('采购验收单') and nvl(ProdIODetail.pd_ordercode,' ')<>' '", String.class, pi_id);
-                if (dets != null) {
-                    return "明细采购订单已转数大于采购订单数量-已冻结数量，不允许进行当前操作!行号：" + dets;
-                }
-            }
-        }
-        if ("ProdInOut!SaleBorrow".equals(caller) || "ProdInOut!OtherPurcIn".equals(caller)) {
-            dets = baseDao
-                    .getJdbcTemplate()
-                    .queryForObject(
-                            "select wm_concat(pd_piclass||'['||pd_inoutno||']行号['||pd_pdno||']') from ProdIODetail left join Prodinout on pd_piid=pi_id left join BorrowCargoType on bt_name=pi_outtype "
-                                    + "where pd_piid=? and nvl(pd_whcode,' ')<>' ' and nvl(bt_whcodes,' ')<>' ' and pd_whcode not in (select column_value from table(parsestring(bt_whcodes,'#'))) "
-                                    + "and pd_piclass in ('借货出货单','其它采购入库单')", String.class, pi_id);
-            if (dets != null) {
-                return "明细仓库与借货类型允许出入仓库不一致，不允许进行当前操作！" + dets;
-            }
-        }
-        if ("ProdInOut!Sale".equals(caller) || "ProdInOut!SaleReturn".equals(caller) || "ProdInOut!OtherOut".equals(caller)
-                || "ProdInOut!ExchangeOut".equals(caller) || "ProdInOut!SaleAppropriationOut".equals(caller)) {
-            if (baseDao.isDBSetting(caller, "allowDifProd")) {
-                dets = baseDao
-                        .getJdbcTemplate()
-                        .queryForObject(
-                                "select wm_concat(pd_pdno) from ProdIODetail where pd_piid=? and not exists(select sd_code,sd_detno from saledetail where sd_code=pd_ordercode and sd_detno=pd_orderdetno and sd_statuscode='AUDITED')"
-                                        + " and pd_piclass in ('出货单','销售退货单','其它出库单','换货出库单','销售拨出单') and nvl(pd_ordercode,' ')<>' ' and nvl(pd_ioid,0)=0",
-                                String.class, pi_id);
-                if (dets != null) {
-                    return "销售单号+销售序号不存在或者状态不等于已审核，不允许进行当前操作!行号：" + dets;
-                }
-            } else if (baseDao.isDBSetting(caller, "SaleWithProdRelation")) {
-                dets = baseDao
-                        .getJdbcTemplate()
-                        .queryForObject(
-                                "select wm_concat(pd_pdno) from ProdIODetail where pd_piid=? and "
-                                        + "not exists (select sd_code,sd_detno from saledetail left join ProdRelation on (sd_prodcode=prr_soncode or (nvl(prr_ifonewa,0)=0 and sd_prodcode=prr_repcode)) "
-                                        + "where sd_code=pd_ordercode and sd_detno=pd_orderdetno and (nvl(sd_prodcode,' ')=nvl(pd_prodcode,' ') or nvl(prr_repcode ,' ')=nvl(pd_prodcode,' ') or nvl(prr_soncode ,' ')=nvl(pd_prodcode,' ')))"
-                                        + "	and pd_piclass in ('出货单','销售退货单','其它出库单','换货出库单','销售拨出单') and nvl(pd_ordercode,' ')<>' ' and nvl(pd_ioid,0)=0",
-                                String.class, pi_id);
-                if (dets != null) {
-                    return "销售单号+销售序号+物料编号不存在或者状态不等于已审核，不允许进行当前操作!行号：" + dets;
-                }
-            } else {
-                dets = baseDao
-                        .getJdbcTemplate()
-                        .queryForObject(
-                                "select wm_concat(pd_pdno) from ProdIODetail where pd_piid=? and not exists(select sd_code,sd_detno from saledetail where sd_prodcode=pd_prodcode and sd_code=pd_ordercode and sd_detno=pd_orderdetno )"
-                                        + " and pd_piclass in ('出货单','销售退货单','其它出库单','换货出库单','销售拨出单') and nvl(pd_ordercode,' ')<>' ' and nvl(pd_ioid,0)=0",
-                                String.class, pi_id);
-                if (dets != null) {
-                    return "销售单号+销售序号+物料编号不存在，不允许进行当前操作!行号：" + dets;
-                }
-            }
-            if (baseDao.isDBSetting("sys","useMachineNo")) {
-                dets = baseDao
-                        .getJdbcTemplate()
-                        .queryForObject(
-                                "select wm_concat('物料'||pd_prodcode||'总数量'||qty||'已采集数'||yqty) from (SELECT pd_piid, pd_prodcode, pd_inoutno, nvl(sum(nvl(pd_inqty,0)+nvl(pd_outqty,0)),0) qty from prodiodetail where pd_piid=? group by pd_piid,pd_inoutno,pd_prodcode) left join (select pim_piid,pim_prodcode,count(1) yqty from prodiomac group by pim_piid,pim_prodcode) on pim_piid=pd_piid and pim_prodcode=pd_prodcode where nvl(qty,0)<>nvl(yqty,0) and nvl(yqty,0)<>0",
-                                String.class, pi_id);
-                if (dets != null) {
-                    return "单据+物料数量跟机器号数量不一致，不允许进行当前操作!行号：" + dets;
-                }
-            }
-            if (!(baseDao.isDBSetting("ProdInOut!Sale", "custatus"))) {
-                if (baseDao.isDBSetting("Sale", "zeroOutWhenHung")) {// 客户挂起时，订单单价为0不限制出货
-                    dets = baseDao
-                            .getJdbcTemplate()
-                            .queryForObject(
-                                    "select wm_concat(pi_cardcode) from ProdInOut left join customer on pi_cardcode=cu_code where pi_id = ? and pi_class in ('出货单') "
-                                            + "and cu_status='挂起' and not exists (select 1 from prodiodetail left join saledetail on pd_ordercode=sd_code and pd_orderdetno=sd_detno"
-                                            + " where pd_piid=pi_id and nvl(pd_ordercode,' ')<>' ' and nvl(sd_price,0)=0)", String.class,
-                                    pi_id);
-                    if (dets != null) {
-                        return "客户资料状态为挂起，且订单单价不为0，不允许进行当前操作!客户号：" + dets;
-                    }
-                } else {
-                    dets = baseDao
-                            .getJdbcTemplate()
-                            .queryForObject(
-                                    "select wm_concat(pi_cardcode) from ProdInOut left join customer on pi_cardcode=cu_code where pi_id = ? and pi_class in ('出货单','其它出库单','换货出库单','销售拨出单') and cu_status='挂起'",
-                                    String.class, pi_id);
-                    if (dets != null) {
-                        return "客户资料状态为挂起，不允许进行当前操作!客户号：" + dets;
-                    }
-                }
-
-            }
-            if (!baseDao.isDBSetting(caller, "allowARCust")) {
-                dets = baseDao
-                        .getJdbcTemplate()
-                        .queryForObject(
-                                "select wm_concat(pd_pdno) from ProdIODetail left join Prodinout on pd_piid=pi_id left join Sale on sa_code=pd_ordercode where pd_piid=? and nvl(pi_cardcode,' ')<>nvl(sa_custcode,' ')"
-                                        + " and pd_piclass in ('出货单','销售退货单','其它出库单','换货出库单','销售拨出单') and nvl(pd_ordercode,' ')<>' ' and nvl(pd_ioid,0)=0",
-                                String.class, pi_id);
-                if (dets != null) {
-                    return "明细销售单与单据客户不一致，不允许进行当前操作!行号：" + dets;
-                }
-                dets = baseDao
-                        .getJdbcTemplate()
-                        .queryForObject(
-                                "select wm_concat(pd_pdno) from ProdIODetail left join Prodinout on pd_piid=pi_id left join Sale on sa_code=pd_ordercode where pd_piid=? and nvl(pi_arcode,' ')<>nvl(sa_apcustcode,' ')"
-                                        + " and pd_piclass in ('出货单','销售退货单') and nvl(pd_ordercode,' ')<>' '", String.class, pi_id);
-                if (dets != null) {
-                    return "明细销售单与单据应收客户不一致，不允许进行当前操作!行号：" + dets;
-                }
-                dets = baseDao
-                        .getJdbcTemplate()
-                        .queryForObject(
-                                "select wm_concat(pd_pdno) from ProdIODetail left join Prodinout on pd_piid=pi_id left join Sale on sa_code=pd_ordercode where pd_piid=? and nvl(pi_currency,' ')<>nvl(sa_currency,' ')"
-                                        + " and pd_piclass in ('出货单','销售退货单') and nvl(pd_ordercode,' ')<>' '", String.class, pi_id);
-                if (dets != null) {
-                    return "明细销售单与单据币别不一致，不允许进行当前操作!行号：" + dets;
-                }
-            }
-            dets = baseDao
-                    .getJdbcTemplate()
-                    .queryForObject(
-                            "select wm_concat(pi_inoutno) from ProdInOut where pi_id=? and pi_class in ('出货单','销售退货单') and (pi_cardcode,pi_title) not in (select cu_code,cu_name from customer)",
-                            String.class, pi_id);
-            if (dets != null) {
-                return "单据中客户编号，客户名称在客户资料中不存在!";
-            }
-            dets = baseDao
-                    .getJdbcTemplate()
-                    .queryForObject(
-                            "select wm_concat(pi_inoutno) from ProdInOut where pi_id=? and pi_class in ('出货单','销售退货单') and (pi_arcode,pi_arname) not in (select cu_code,cu_name from customer)",
-                            String.class, pi_id);
-            if (dets != null) {
-                return "单据中应收客户编号，应收客户名称在客户资料中不存在!";
-            }
-            // 销售退货单：退货数量，如退货数量+其它未过账的退货单数量大于销售订单出货数
-            /**
-             * 需考虑状态
-             */
-            dets = baseDao
-                    .getJdbcTemplate()
-                    .queryForObject(
-                            "select wm_concat(pd_pdno) from ProdIODetail b left join SaleDetail on sd_code=pd_ordercode and sd_detno=pd_orderdetno where pd_piid=? and pd_status<99 and pd_piclass='销售退货单' and nvl(pd_ordercode,' ')<>' ' and nvl(pd_inqty,0) + (select nvl(sum(nvl(a.pd_inqty,0)),0) from ProdIODetail a where a.pd_piclass='销售退货单' and a.pd_status<99 and a.pd_ordercode=b.pd_ordercode and a.pd_orderdetno=b.pd_orderdetno and a.pd_id <> b.pd_id) > nvl(sd_sendqty,0)",
-                            String.class, pi_id);
-            if (dets != null) {
-                return "本次退货数+其它退货数合计大于订单的已发货数量，不允许进行当前操作！行号：" + dets;
-            }
-            if ("ProdInOut!SaleAppropriationOut".equals(caller) || "ProdInOut!OtherOut".equals(caller)) {
-                dets = baseDao
-                        .getJdbcTemplate()
-                        .queryForObject(
-                                "select wm_concat(pd_piclass||'['||pd_inoutno||']行号['||pd_pdno||']') from ProdIODetail where pd_piid=? and (pd_plancode,pd_forecastdetno) not in (select sd_code, sd_detno from saleforecastdetail,saleforecast where sf_id=sd_sfid and sf_code=pd_plancode and sd_detno=pd_forecastdetno and sd_statuscode='AUDITED') and nvl(pd_plancode,' ')<>' '",
-                                String.class, pi_id);
-                if (dets != null) {
-                    return "明细行预测单号+预测序号不存在或者状态不等于已审核，不允许进行当前操作!！" + dets;
-                }
-                dets = baseDao
-                        .getJdbcTemplate()
-                        .queryForObject(
-                                "select wm_concat(pd_piclass||'['||pd_inoutno||']行号['||pd_pdno||']') from ProdIODetail where pd_piid=? and (pd_plancode,pd_forecastdetno) in (select sd_code, sd_detno from saleforecastdetail where nvl(sd_qty,0)=0) and nvl(pd_plancode,' ')<>' '",
-                                String.class, pi_id);
-                if (dets != null) {
-                    return "明细行预测单号+预测序号预测数量等于0，不允许进行当前操作！" + dets;
-                }
-                dets = baseDao
-                        .getJdbcTemplate()
-                        .queryForObject(
-                                "select wm_concat(pd_piclass||'['||pd_inoutno||']行号['||pd_pdno||']') from ProdIODetail left join SaleDetail on pd_ordercode=sd_code and pd_orderdetno=sd_detno where pd_piid=? and pd_piclass in ('销售拨出单','其它出库单') and nvl(pd_outqty+pd_inqty,0)>nvl(sd_qty,0)-nvl(sd_yqty,0) and nvl(pd_ordercode,' ')<>' ' and nvl(pd_ioid,0)=0 and nvl(pd_snid,0)=0",
-                                String.class, pi_id);
-                if (dets != null) {
-                    return "明细行销售单号+销售序号数量大于订单未发货数，不允许进行当前操作！" + dets;
-                }
-                dets = baseDao
-                        .getJdbcTemplate()
-                        .queryForObject(
-                                "select wm_concat(pd_piclass||'['||pd_inoutno||']行号['||pd_pdno||']') from ProdIODetail where pd_piid=? and pd_piclass='销售拨出单' and pd_plancode not in (select a.sf_code from saleforecast a left join saleforecastkind b on (a.sf_kind=b.sf_name or a.sf_kind=b.sf_code) where a.sf_code=pd_plancode and sf_clashoption in ('SEND','发货冲销')) and nvl(pd_plancode,' ')<>' '",
-                                String.class, pi_id);
-                if (dets != null) {
-                    return "预测单录入错误，该预测类型不属于发货冲销！" + dets;
-                }
-            }
-        }
-//		if ("ProdInOut!AppropriationOut".equals(caller) || "ProdInOut!AppropriationIn".equals(caller)
-//				|| "ProdInOut!SaleAppropriationOut".equals(caller) || "ProdInOut!SaleAppropriationIn".equals(caller)) {
-//			dets = baseDao
-//					.getJdbcTemplate()
-//					.queryForObject(
-//							"select wm_concat(pd_pdno) from ProdIODetail,warehouse w1,warehouse w2 where pd_piid=? and pd_whcode=w1.wh_code and pd_inwhcode=w2.wh_code and nvl(w1.wh_nocost,0)<>nvl(w2.wh_nocost,0)",
-//							String.class, pi_id);
-//			if (dets != null) {
-//				return "有值和无值仓之间不能相互调拨!行号：" + dets);
-//			}
-//		}
-        SqlRowList rs = baseDao.queryForRowSet("select * from prodiodetail where pd_piid=?", pi_id);
-        StringBuffer sb = new StringBuffer();
-        while (rs.next()) {
-            int pdid = rs.getInt("pd_id");
-            int ioid = rs.getGeneralInt("pd_ioid");
-            double tqty = rs.getGeneralDouble("pd_inqty") + rs.getGeneralDouble("pd_outqty");
-            double yqty = 0.0;
-            if (ioid > 0) {
-                yqty = baseDao.getSummaryByField("Prodiodetail", "nvl(pd_outqty,0) + nvl(pd_inqty,0)", "pd_ioid=" + ioid + " and pd_id<>"
-                        + pdid);
-                Object[] source = baseDao.getFieldsDataByCondition("Prodiodetail", new String[] { "nvl(pd_outqty,0)", "nvl(pd_inqty,0)",
-                        "pd_piclass", "pd_inoutno" }, "pd_id=" + ioid);
-                if (source != null) {
-                    if (yqty + tqty > Double.parseDouble(source[0].toString()) + Double.parseDouble(source[1].toString())) {
-                        sb.append("行号:" + rs.getInt("pd_pdno") + ",数量:" + tqty + ",无法转出." + source[2] + "[" + source[3] + "]已转数量:" + yqty
-                                + ",本次数量:" + tqty + "<hr/>");
-                    }
-                }
-            }
-        }
-        if (sb.length() > 0) {
-            return sb.toString();
-        }
-        // 保税信息判断
-        if (baseDao.isDBSetting("sys","ioWHBondedCheck")) {
-            if ("ProdInOut!PurcCheckin".equals(caller) || "ProdInOut!PurcCheckout".equals(caller)) {
-                dets = baseDao
-                        .getJdbcTemplate()
-                        .queryForObject(
-                                "select wm_concat(pd_pdno) from ProdIODetail left join Prodinout on pd_piid=pi_id left join PurchaseDetail on pd_code=pd_ordercode and pd_detno=pd_orderdetno left join warehouse on ProdIODetail.pd_whcode=wh_code where pd_piid=? and nvl(PurchaseDetail.pd_bonded,0)<>nvl(wh_bonded,0)"
-                                        + " and pd_piclass in ('采购验收单','采购验退单') and nvl(pd_ordercode,' ')<>' '", String.class, pi_id);
-                if (dets != null) {
-                    return "采购单的保税属性与仓库的保税属性不一致，不允许进行当前操作!行号：" + dets;
-                }
-            }
-            if ("ProdInOut!OutesideCheckReturn".equals(caller) || "ProdInOut!OutsideCheckIn".equals(caller)) {
-                dets = baseDao
-                        .getJdbcTemplate()
-                        .queryForObject(
-                                "select wm_concat(pd_pdno) from ProdIODetail left join Prodinout on pd_piid=pi_id left join Make on ma_code=pd_ordercode left join warehouse on pd_whcode=wh_code where pd_piid=? and nvl(ma_bonded,0)<>nvl(wh_bonded,0)"
-                                        + " and pd_piclass in ('委外验退单','委外验收单') and nvl(pd_ordercode,' ')<>' '", String.class, pi_id);
-                if (dets != null) {
-                    return "委外单的保税属性与仓库的保税属性不一致，不允许进行当前操作!行号：" + dets;
-                }
-            }
-            if ("ProdInOut!Make!In".equals(caller) || "ProdInOut!PartitionStockIn".equals(caller)) {
-                dets = baseDao
-                        .getJdbcTemplate()
-                        .queryForObject(
-                                "select wm_concat(pd_pdno) from ProdIODetail left join Prodinout on pd_piid=pi_id left join Make on ma_code=pd_ordercode left join warehouse on pd_whcode=wh_code where pd_piid=? and nvl(ma_bonded,0)<>nvl(wh_bonded,0)"
-                                        + " and pd_piclass in ('完工入库单','拆件入库单') and nvl(pd_ordercode,' ')<>' '", String.class, pi_id);
-                if (dets != null) {
-                    return "工单的保税属性与仓库的保税属性不一致，不允许进行当前操作!行号：" + dets;
-                }
-            }
-            if ("ProdInOut!Make!Give".equals(caller) || "ProdInOut!Make!Return".equals(caller) || "ProdInOut!Picking".equals(caller)
-                    || "ProdInOut!OSMake!Give".equals(caller) || "ProdInOut!OutsideReturn".equals(caller)
-                    || "ProdInOut!OutsidePicking".equals(caller)) {
-                dets = baseDao
-                        .getJdbcTemplate()
-                        .queryForObject(
-                                "select wm_concat(pd_piclass||'['||pd_inoutno||']行号['||pd_pdno||']') from ProdIODetail left join Prodinout on pd_piid=pi_id left join Make on ma_code=pd_ordercode left join warehouse on pd_whcode=wh_code where pd_piid=? and nvl(ma_bonded,0)=0 and nvl(wh_bonded,0)<>0"
-                                        + " and pd_piclass in ('委外补料单','委外退料单','委外领料单') and nvl(pd_ordercode,' ')<>' '", String.class,
-                                pi_id);
-                if (dets != null) {
-                    return "委外单保税属性是非保税，不能发生仓库保税属性是保税的单据！" + dets;
-                }
-                dets = baseDao
-                        .getJdbcTemplate()
-                        .queryForObject(
-                                "select wm_concat(pd_piclass||'['||pd_inoutno||']行号['||pd_pdno||']') from ProdIODetail left join Prodinout on pd_piid=pi_id left join Make on ma_code=pd_ordercode left join warehouse on pd_whcode=wh_code where pd_piid=? and nvl(ma_bonded,0)=0 and nvl(wh_bonded,0)<>0"
-                                        + " and pd_piclass in ('生产补料单','生产退料单','生产领料单') and nvl(pd_ordercode,' ')<>' '", String.class,
-                                pi_id);
-                if (dets != null) {
-                    return "工单保税属性是非保税，不能发生仓库保税属性是保税的单据！" + dets;
-                }
-            }
-            if ("ProdInOut!SaleAppropriationOut".equals(caller) || "ProdInOut!AppropriationOut".equals(caller)) {
-                dets = baseDao
-                        .getJdbcTemplate()
-                        .queryForObject(
-                                "select wm_concat(pd_piclass||'['||pd_inoutno||']行号['||pd_pdno||']') from ProdIODetail left join Prodinout on pd_piid=pi_id left join warehouse a on a.wh_code=pd_whcode left join warehouse b on b.wh_code=pd_inwhcode where pd_piid=? and nvl(a.wh_bonded,0)<>nvl(b.wh_bonded,0)"
-                                        + " and pd_piclass in ('拨出单','销售拨出单') and nvl(pd_whcode,' ')<>' ' and nvl(pd_inwhcode,' ')<>' '",
-                                String.class, pi_id);
-                if (dets != null) {
-                    return "拨出仓库与拨入仓库仓库的保税属性不一致，不能进行当前操作！" + dets;
-                }
-            }
-        }
-
-        // @add20180605 Q:2018050126 最后一张完工入库单或者委外验收单，提交、审核、过账之前限制，不允许存在未过账
-        // 领、退、补单据,未审核的报废单，未过账的委外验退单
-        if (("ProdInOut!OutsideCheckIn".equals(caller) || "ProdInOut!Make!In".equals(caller))
-                && baseDao.isDBSetting(caller, "checkRelBillsStatus")) {
-            // 判断哪些工单是最后一张完工入库单
-            rs = baseDao
-                    .queryForRowSet(
-                            "select pd_ordercode,pd_pdno from (select pd_ordercode,sum(pd_inqty)inqty,wm_concat(pd_pdno)pd_pdno from prodiodetail  where "
-                                    + "pd_piid=? and pd_piclass in('完工入库单','委外验收单') group by pd_ordercode) A left join make on ma_code=A.pd_ordercode "
-                                    + "where nvl(ma_madeqty,0)+inqty>=ma_qty", pi_id);
-            String errors = null;
-            while (rs.next()) {
-                dets = baseDao
-                        .getJdbcTemplate()
-                        .queryForObject(
-                                "select wm_concat(pi_class||':'||pi_inoutno) from prodiodetail,ProdInOut WHERE pd_piid=pi_id AND pi_id<>? and pd_ordercode = ? AND pi_statuscode = 'UNPOST' AND pd_status=0 AND (pd_piclass LIKE '生产%' OR pd_piclass LIKE '委外%' OR pd_piclass LIKE '完工%') and rownum<15",
-                                String.class, pi_id, rs.getString("pd_ordercode"));
-                if (dets != null) {
-                    errors = "行号：" + rs.getString("pd_pdno") + ",工单:" + rs.getString("pd_ordercode") + "存在关联未过账单据!" + dets;
-                }
-                dets = baseDao
-                        .getJdbcTemplate()
-                        .queryForObject(
-                                "SELECT wm_concat(ms_code) FROM MakeScrapdetail,MakeScrap WHERE md_msid=ms_id AND md_mmcode=? AND ms_statuscode in ('ENTERING','COMMITED') AND nvl(md_status,0)=0",
-                                String.class, rs.getString("pd_ordercode"));
-                if (dets != null) {
-                    if (errors != null) {
-                        errors += "<br>未审核的报废单：" + dets;
-                    } else {
-                        errors = "行号：" + rs.getString("pd_pdno") + ",工单:" + rs.getString("pd_ordercode") + "存在关联未审核的报废单：" + dets;
-                    }
-                }
-                if (errors != null && !"".equals(errors)) {
-                    return errors;
-                }
-            }
-        }
-        if (baseDao.isOut(caller)) {
-            dets = baseDao
-                    .getJdbcTemplate()
-                    .queryForObject(
-                            "select wm_concat(pd_pdno) from (select pd_pdno from ProdIODetail where pd_piid=? and nvl(pd_outqty,0)>0 and nvl(pd_prodcode,' ')<>' ' and nvl(pd_whcode,' ')<>' ' and nvl(pd_batchcode,' ')<>' '"
-                                    + "and not exists(select 1 from batch where pd_prodcode=ba_prodcode and pd_whcode=ba_whcode and pd_batchcode=ba_code) order by pd_pdno)",
-                            String.class, pi_id);
-            if (dets != null) {
-                return "物料编号+仓库编号+批号不存在，不允许进行当前操作！行号：" + dets;
-            }
-        }
-        return null;
-    }
-
-    /**
-     * 校验批次是否重复
-     *
-     * @param caller
-     * @param pi_id
-     */
-    private String checkBatch(String caller, Object pi_id) {
-        if (baseDao.isIn(caller)) {
-            // 入库单据，同一物料同仓库不能同时入两次相同的批号
-            SqlRowList rs = baseDao
-                    .queryForRowSet("select  count(1)n, wm_concat(pd_piclass||'['||pd_inoutno||']行号['||pd_pdno||']')detno from (select pd_batchcode,pd_whcode,pd_prodcode,min(pd_pdno)pd_pdno,min(pd_inoutno)pd_inoutno,min(pd_piclass)pd_piclass,count(1)c from  ProdIODetail where pd_piid="
-                            + pi_id + " and pd_batchcode<>' ' group by pd_batchcode,pd_whcode,pd_prodcode ) where c> 1");
-            if (rs.next()) {
-                if (rs.getInt("n") > 0) {
-                    return "同一物料同仓库不能同时入两次相同的批号！" + rs.getString("detno");
-                }
-            }
-            rs = baseDao
-                    .queryForRowSet("select count(1) n,wm_concat(pd_piclass||'['||pd_inoutno||']行号['||pd_pdno||']')detno "
-                            + "from (select pd_piclass,pd_inoutno,pd_pdno from ProdIODetail where pd_piid="
-                            + pi_id
-                            + " and pd_batchcode is not null and exists (select 1 from batch where ba_code=pd_batchcode and ba_prodcode=pd_prodcode "
-                            + "and ba_whcode=pd_whcode and (nvl(ba_remain,0)<>0 or nvl(ba_inqty,0)<>0))) where rownum<30");
-            if (rs.next()) {
-                if (rs.getInt("n") > 0) {
-                    return "批号已存在，不能重复入库！" + rs.getString("detno");
-                }
-            }
-        }
-        return null;
-    }
-
-    private String copcheck(int pi_id, String caller) {
-        if (baseDao.isDBSetting("sys","CopCheck")) {
-            // 出入库单：明细行采购单所属公司与当前单所属公司必须一致，可在提交、打印、审核、过账等操作前配置
-            String dets = baseDao
-                    .getJdbcTemplate()
-                    .queryForObject(
-                            "select wm_concat(pd_pdno) from ProdIODetail left join ProdInOut on pd_piid=pi_id left join Purchase on pd_ordercode=pu_code where pi_id=? and nvl(pu_cop,' ')<>nvl(pi_cop,' ') and nvl(pd_ordercode,' ')<>' ' "
-                                    + " and pd_piclass in ('采购验收单','采购验退单')", String.class, pi_id);
-            if (dets != null) {
-                return "明细行采购单所属公司与当前单所属公司不一致，不允许进行当前操作!行号：" + dets;
-            }
-            // 出入库单：明细行销售单所属公司与当前单所属公司必须一致，可在提交、打印、审核、过账等操作前配置
-            dets = baseDao
-                    .getJdbcTemplate()
-                    .queryForObject(
-                            "select wm_concat(pd_pdno) from ProdIODetail left join ProdInOut on pd_piid=pi_id left join Sale on pd_ordercode=sa_code where pi_id=? and nvl(sa_cop,' ')<>nvl(pi_cop,' ') and nvl(pd_ordercode,' ')<>' ' "
-                                    + "and pd_piclass in ('出货单','销售退货单','销售拨出单','销售拨入单')", String.class, pi_id);
-            if (dets != null) {
-                return "明细行销售单所属公司与当前单所属公司不一致，不允许进行当前操作!行号：" + dets;
-            }
-            // 出货单：来源单所属公司与当前单所属公司不一致，不允许进行当前操作
-            dets = baseDao
-                    .getJdbcTemplate()
-                    .queryForObject(
-                            "select wm_concat(pd_pdno) from ProdIODetail left join ProdInOut on pd_piid=pi_id left join Sendnotify on pd_snid=sn_id where pi_id=? and nvl(sn_cop,' ')<>nvl(pi_cop,' ') and nvl(pd_snid,0)<>0 ",
-                            String.class, pi_id);
-            if (dets != null) {
-                return "明细来源通知单所属公司与当前单所属公司不一致，不允许进行当前操作!行号：" + dets;
-            }
-            // 出入库单：明细行制造单所属公司与当前单所属公司必须一致，可在提交、打印、审核、过账等操作前配置
-            dets = baseDao
-                    .getJdbcTemplate()
-                    .queryForObject(
-                            "select wm_concat(pd_pdno) from ProdIODetail left join ProdInOut on pd_piid=pi_id left join Make on pd_ordercode=ma_code where pi_id=? and nvl(ma_cop,' ')<>nvl(pi_cop,' ') and nvl(pd_ordercode,' ')<>' ' "
-                                    + "and pd_piclass in  ('生产领料单','生产退料单','生产补料单','完工入库单','拆件入库单')", String.class, pi_id);
-            if (dets != null) {
-                return "明细行制造单所属公司与当前单所属公司不一致，不允许进行当前操作!行号：" + dets;
-            }
-            // 出入库单：明细行委外单所属公司与当前单所属公司必须一致，可在提交、打印、审核、过账等操作前配置
-            dets = baseDao
-                    .getJdbcTemplate()
-                    .queryForObject(
-                            "select wm_concat(pd_pdno) from ProdIODetail left join ProdInOut on pd_piid=pi_id left join Make on pd_ordercode=ma_code where pi_id=? and nvl(ma_cop,' ')<>nvl(pi_cop,' ') and nvl(pd_ordercode,' ')<>' ' "
-                                    + "and pd_piclass in ('委外验收单','委外验退单','委外领料单','委外退料单','委外补料单')", String.class, pi_id);
-            if (dets != null) {
-                return "明细行委外单所属公司与当前单所属公司不一致，不允许进行当前操作!行号：" + dets;
-            }
-            if ("ProdInOut!SaleAppropriationOut".equals(caller) || "ProdInOut!OtherOut".equals(caller)
-                    || "ProdInOut!AppropriationOut".equals(caller)) {
-                dets = baseDao
-                        .getJdbcTemplate()
-                        .queryForObject(
-                                "select wm_concat(pd_pdno) from ProdIODetail left join ProdInOut on pd_piid=pi_id left join SaleForecast on pd_plancode=sf_code where pi_id=? and nvl(sf_cop,' ')<>nvl(pi_cop,' ') and nvl(pd_plancode,' ')<>' ' "
-                                        + "and pd_piclass in  ('销售拨出单','其它出库单')", String.class, pi_id);
-                if (dets != null) {
-                    return "明细行销售预测单所属公司与当前单所属公司不一致，不允许进行当前操作!行号：" + dets;
-                }
-                dets = baseDao
-                        .getJdbcTemplate()
-                        .queryForObject(
-                                "select wm_concat(pd_pdno) from ProdIODetail left join prodinout on pd_piid=pi_id left join Warehouse on pd_inwhcode=wh_code where pi_id=? and pi_class in ('销售拨出单','拨出单') and nvl(pi_cop,' ')<>nvl(wh_cop,' ')",
-                                String.class, pi_id);
-                if (dets != null) {
-                    return "单据所属公司和明细行拨入仓库的所属公司不一致，不允许进行当前操作!行号：" + dets;
-                }
-            }
-            // 出入库单限制界面的所属公司和仓库的所属公司必须一致，可在提交、打印、审核、过账等操作前配置
-            dets = baseDao
-                    .getJdbcTemplate()
-                    .queryForObject(
-                            "select wm_concat(pd_pdno) from ProdIODetail left join prodinout on pd_piid=pi_id left join Warehouse on pd_whcode=wh_code where nvl(pi_cop,' ')<>nvl(wh_cop,' ') and pi_id=? and pi_class not in ('成本调整单')",
-                            String.class, pi_id);
-            if (dets != null) {
-                return "单据所属公司和明细行仓库的所属公司不一致，不允许进行当前操作!行号：" + dets;
-            }
-        }
-        return null;
-    }
-
-    private String factorycheck(int pi_id, String caller) {
-        if (baseDao.isDBSetting("MpsDesk", "mrpSeparateFactory")) {
-            // 采购验收单、采购验退单：明细行采购单所属工厂与仓库的所属工厂不一致，，不允许进行当前操作
-            String dets = baseDao
-                    .getJdbcTemplate()
-                    .queryForObject(
-                            "select wm_concat(pd_pdno) from ProdIODetail left join PurchaseDetail on ProdIODetail.pd_ordercode=PurchaseDetail.pd_code and ProdIODetail.pd_orderdetno=PurchaseDetail.pd_detno left join Warehouse on ProdIODetail.pd_whcode=wh_code left join product on ProdIODetail.pd_prodcode=pr_code where pd_piid=? and nvl(PR_ISGROUPPURC,0)=0 and nvl(PurchaseDetail.pd_factory,' ')<>nvl(wh_factory,' ') and nvl(ProdIODetail.pd_ordercode,' ')<>' ' "
-                                    + " and  PurchaseDetail.pd_factory is not null and pd_piclass in ('采购验收单','采购验退单')", String.class,
-                            pi_id);
-            if (dets != null) {
-                return "明细行采购单所属工厂与仓库的所属工厂不一致，不允许进行当前操作!行号：" + dets;
-            }
-            // 生产领料单、退料单、补料单：明细行制造单所属工厂与仓库的所属工厂不一致，不允许进行当前操作
-            dets = baseDao
-                    .getJdbcTemplate()
-                    .queryForObject(
-                            "select wm_concat(pd_pdno) from ProdIODetail left join Make on pd_ordercode=ma_code left join Warehouse on pd_whcode=wh_code left join product on ProdIODetail.pd_prodcode=pr_code where pd_piid=? and nvl(PR_ISGROUPPURC,0)=0 and nvl(ma_factory,' ')<>nvl(wh_factory,' ') and nvl(pd_ordercode,' ')<>' ' "
-                                    + "and pd_piclass in  ('生产领料单','生产退料单','生产补料单')", String.class, pi_id);
-            if (dets != null) {
-                return "明细行制造单所属工厂与仓库的所属工厂不一致，不允许进行当前操作!行号：" + dets;
-            }
-            // 委外领料单、退料单、补料单：明细行委外单所属工厂与仓库的所属工厂不一致，不允许进行当前操作
-            dets = baseDao
-                    .getJdbcTemplate()
-                    .queryForObject(
-                            "select wm_concat(pd_pdno) from ProdIODetail left join Make on pd_ordercode=ma_code left join Warehouse on pd_whcode=wh_code left join product on ProdIODetail.pd_prodcode=pr_code where pd_piid=? and nvl(PR_ISGROUPPURC,0)=0 and nvl(ma_factory,' ')<>nvl(wh_factory,' ') and nvl(pd_ordercode,' ')<>' ' "
-                                    + "and pd_piclass in ('委外领料单','委外退料单','委外补料单')", String.class, pi_id);
-            if (dets != null) {
-                return "明细行委外单所属工厂与仓库的所属工厂不一致，不允许进行当前操作!行号：" + dets;
-            }
-        }
-        return null;
-    }
-
-    private String checkIOMaPick(String caller, Object pi_id) {
-        String[] checkCallers={"ProdInOut!AppropriationOut","ProdInOut!Picking", "ProdInOut!OutsidePicking","ProdInOut!Make!Give","ProdInOut!OSMake!Give"
-                ,"ProdInOut!OtherOut","ProdInOut!SaleBorrow"};
-        if(Arrays.asList(checkCallers).contains(caller)){
-            String gridStore = "[]";
-            String formStore = null;
-            SqlRowList fromP = baseDao.queryForRowSet("select pi_id,pi_class,TO_CHAR(pi_date,'YYYYMM') pi_date from prodinout where pi_id = "+pi_id+" ");
-            if(fromP.next()){
-                formStore = BaseUtil.parseMap2Str(baseDao.changeKeyToLowerCase(fromP.getCurrentMap()));
-                SqlRowList checkDetail = baseDao.queryForRowSet("select pd_ordercode macode, pd_prodcode prodcode,pd_outqty outqty,pd_whcode outwhcode,pd_inwhcode inwhcode" +
-                        " from prodiodetail where pd_piid = "+pi_id+" order by pd_pdno");
-                if(checkDetail.hasNext()){
-                    gridStore = BaseUtil.parseGridStore2Str(baseDao.changeKeyToLowerCase(checkDetail.getResultList()));
-                }
-                String res = baseDao.callProcedure("USER_CHECKOUTSTOCK", new Object[] {formStore,gridStore});
-                if (res != null && res.length() > 0) {
-                    return res;
-                }
-            }
-        }
-        return null;
-    }
-
-    /**
-     * 新增生产退料和委外退料判断，替代料退料数量不能大于替代料已领数量,主料退料不能大于主料已领数,工单外退料的情况不限制
-     *
-     * @date 2016年10月17日 下午12:30:58
-     * @param pi_id
-     *            单据id
-     */
-    private String checkRepQty(int pi_id) {
-        SqlRowList rs = baseDao
-                .queryForRowSet(
-                        "select wm_concat(T.pdno) no from (select nvl(sum(pd_inqty),0) inqty,pd_ordercode,pd_orderdetno,pd_prodcode,max(pd_pdno)pdno "
-                                + " from prodiodetail where pd_piid=? group by pd_ordercode,pd_orderdetno,pd_prodcode )T "
-                                + " left join makematerial on mm_code=T.pd_ordercode and mm_detno=T.pd_orderdetno "
-                                + " where T.pd_prodcode=mm_prodcode and mm_havegetqty-nvl(mm_haverepqty,0)<T.inqty and (nvl(mm_qty,0)>0 or (nvl(mm_qty,0)=0 and nvl(mm_updatetype,' ')<>'R')) and rownum<25",
-                        pi_id);
-        if (rs.next() && rs.getObject("no") != null) {
-            return "主料退料数不允许大于主料已领数，行号：" + rs.getString(1);
-        }
-        rs = baseDao
-                .queryForRowSet(
-                        "select wm_concat(T.pdno) no from (select nvl(sum(pd_inqty),0) inqty,pd_ordercode,pd_orderdetno,pd_prodcode,max(pd_pdno)pdno "
-                                + " from prodiodetail where pd_piid=? group by pd_ordercode,pd_orderdetno,pd_prodcode )T "
-                                + " left join MakeMaterialreplace on mp_mmcode=T.pd_ordercode and mp_mmdetno=T.pd_orderdetno left join makematerial on mm_code=mp_mmcode and mm_detno=mp_mmdetno"
-                                + " where T.pd_prodcode=mp_prodcode and T.inqty>nvl(mp_haverepqty,0) and (nvl(mm_qty,0)>0 or (nvl(mm_qty,0)=0 and nvl(mm_updatetype,' ')<>'R')) and rownum<25",
-                        pi_id);
-        if (rs.next() && rs.getObject("no") != null) {
-            return "替代料退料数不允许大于替代已领数，行号：" + rs.getString(1);
-        }
-        return null;
-    }
-
-    private String checkMmBackOver(String caller, int pi_id) {
-        //截止到退料单单据日期月份的 本单的退料不允许大于 已过账的 领料出库-退料数+补料数-（完工-验退数）*单位用量
-        String data = baseDao.getJdbcTemplate().queryForObject("select wm_concat('工单：'||pd_ordercode||',序号：'||pd_orderdetno ||'<br>') " +
-                " from (select pd_ordercode,pd_orderdetno,sum(pd_inqty)inqty,to_char(max(pi_date),'yyyymm')pidate from prodinout left join prodiodetail on pd_piid=pi_id where pd_piid=? group by pd_ordercode,pd_orderdetno)a LEFT JOIN MAKE ON MA_CODE=PD_ORDERCODE " +
-                " LEFT JOIN MAKEMATERIAL ON MM_MAID=MA_ID and pd_orderdetno=mm_detno where " +
-                " inqty > nvl((select sum(nvl(pd_outqty,0)-nvl(pd_inqty,0)) from prodiodetail b left join prodinout on pd_piid=pi_id where pd_status=99 and pidate>= to_char(pi_date,'yyyymm') and " +
-                " a.pd_ordercode=b.pd_ordercode and a.pd_orderdetno=b.pd_orderdetno and pi_class in('生产领料单','委外领料单','生产退料单','委外退料单','生产补料单','委外补料单')),0) " +
-                " - NVL((select SUM(MD_QTY) from makescrap left join makescrapdetail on md_msid=ms_id WHERE ms_statuscode='AUDITED' AND pidate>=to_char(MS_AUDITDATE,'yyyymm') AND MD_mmcode = pd_ordercode AND MD_mmdetno = pd_orderdetno),0) " +
-                " -NVL((SELECT sum(nvl(pd_inqty,0)-nvl(pd_outqty,0)) FROM prodiodetail b left join prodinout on pd_piid=pi_id where pd_status=99 and pidate>=to_char(pi_date,'yyyymm') and " +
-                " a.pd_ordercode=b.pd_ordercode AND pi_class in('完工入库单','委外验退单','委外验收单')),0)*nvl(mm_oneuseqty,0) and rownum<10",String.class,pi_id);
-        if(data != null){
-            return "退料数大于截止到单据月份剩余的结存数，"+data;
-        }
-        return null;
-
-    }
-
-    /**
-     * 计算pi_total
-     */
-    private void getTotal(Object pi_id, String caller) {
-        baseDao.execute("update prodiodetail set pd_purcinqty=nvl(pd_inqty,0) where pd_piid=" + pi_id
-                + " and exists (select 1 from product where pd_prodcode=pr_code and nvl(pr_purcunit,pr_unit)=pr_unit) ");
-        baseDao.execute("update prodiodetail set pd_purcoutqty=nvl(pd_outqty,0) where pd_piid=" + pi_id
-                + " and exists (select 1 from product where pd_prodcode=pr_code and nvl(pr_purcunit,pr_unit)=pr_unit)");
-
-        baseDao.execute("update prodiodetail set pd_purcinqty=pd_inqty/(select case when nvl(pr_purcrate,0)<>0 then pr_purcrate else 1 end from product where pr_code=pd_prodcode) where pd_piid="
-                + pi_id + " and nvl(pd_purcinqty,0)=0");
-
-        if ("ProdInOut!PurcCheckin".equals(caller) || "ProdInOut!PurcCheckout".equals(caller) || "ProdInOut!OutsideCheckIn".equals(caller)
-                || "ProdInOut!OutesideCheckReturn".equals(caller)) {
-            if ("ProdInOut!OutsideCheckIn".equals(caller) || "ProdInOut!OutesideCheckReturn".equals(caller)) {// 委外
-                baseDao.updateByCondition("ProdIODetail", "pd_orderprice=(select ma_price from make where ma_code=pd_ordercode)",
-                        "pd_piid=" + pi_id + " and nvl(pd_orderprice,0)=0");
-                // 强制取委外单主表中的税率
-                baseDao.execute(
-                        "update ProdIODetail set pd_taxrate=(select nvl(ma_taxrate,0) from make where ma_code=pd_ordercode) where pd_ordercode is not null and pd_piid=?",
-                        pi_id);
-            } else {// 采购
-                baseDao.updateByCondition("ProdIODetail",
-                        "pd_orderprice=nvl((select pd_price from PurchaseDetail where pd_code=pd_ordercode and pd_detno=pd_orderdetno),0)",
-                        "pd_piid=" + pi_id + " and nvl(pd_orderprice,0)=0 and nvl(pd_status,0)<>99");
-                // 强制取采购单明细表中的对应的税率
-                baseDao.execute(
-                        "update ProdIODetail set pd_taxrate=(select nvl(pd_rate,0) from PurchaseDetail where pd_code=pd_ordercode and pd_detno=pd_orderdetno) where  pd_ordercode is not null  and nvl(pd_status,0)<>99 and pd_piid=?",
-                        pi_id);
-
-            }
-            baseDao.execute("update ProdIODetail set pd_ordertotal=round(pd_orderprice*(case when nvl(pd_purcinqty,0)+nvl(pd_purcoutqty,0)=0 then nvl(pd_inqty,0)+nvl(pd_outqty,0) else nvl(pd_purcinqty,0)+nvl(pd_purcoutqty,0) end),2) where pd_piid="
-                    + pi_id);
-            baseDao.execute("update ProdIODetail set pd_taxtotal=round(pd_orderprice*(case when nvl(pd_purcinqty,0)+nvl(pd_purcoutqty,0)=0 then nvl(pd_inqty,0)+nvl(pd_outqty,0) else nvl(pd_purcinqty,0)+nvl(pd_purcoutqty,0) end)*nvl(pd_taxrate,0)/(100+nvl(pd_taxrate,0)),2),pd_nettotal=round(pd_orderprice*(case when nvl(pd_purcinqty,0)+nvl(pd_purcoutqty,0)=0 then nvl(pd_inqty,0)+nvl(pd_outqty,0) else nvl(pd_purcinqty,0)+nvl(pd_purcoutqty,0) end)/(1+nvl(pd_taxrate,0)/100),2) where pd_piid="
-                    + pi_id);
-            baseDao.updateByCondition("ProdIODetail", " pd_total=round(nvl(pd_price,0)*(nvl(pd_inqty,0)+nvl(pd_outqty,0)),2)", "pd_piid="
-                    + pi_id);
-            baseDao.updateByCondition("ProdInOut",
-                    "pi_total = round(nvl((SELECT sum(round(pd_ordertotal,2)) FROM ProdIODetail WHERE pd_piid=pi_id),0),2)", "pi_id="
-                            + pi_id);
-            baseDao.updateByCondition(
-                    "ProdIODetail",
-                    "pd_netprice=round(pd_orderprice/(1+pd_taxrate/100),8),pd_nettotal=round(pd_orderprice*(case when nvl(pd_purcinqty,0)+nvl(pd_purcoutqty,0)=0 then nvl(pd_inqty,0)+nvl(pd_outqty,0) else nvl(pd_purcinqty,0)+nvl(pd_purcoutqty,0) end)/(1+nvl(pd_taxrate,0)/100),2)",
-                    "pd_piid=" + pi_id);
-            baseDao.updateByCondition("ProdInOut", "pi_totalupper=L2U(nvl(pi_total,0))", "pi_id=" + pi_id);
-        } else if ("ProdInOut!Sale".equals(caller) || "ProdInOut!SaleReturn".equals(caller)) {
-            baseDao.updateByCondition(
-                    "ProdIODetail",
-                    "pd_ordertotal=round(nvl(pd_sendprice,0)*(case when nvl(pd_purcinqty,0)+nvl(pd_purcoutqty,0)=0 then nvl(pd_inqty,0)+nvl(pd_outqty,0) else nvl(pd_purcinqty,0)+nvl(pd_purcoutqty,0) end),2),pd_total=round(nvl(pd_price,0)*(nvl(pd_inqty,0)+nvl(pd_outqty,0)),2)",
-                    "pd_piid=" + pi_id);
-            baseDao.updateByCondition(
-                    "ProdIODetail",
-                    "pd_netprice=round(pd_sendprice/(1+pd_taxrate/100),8),pd_nettotal=round(pd_sendprice*(case when nvl(pd_purcinqty,0)+nvl(pd_purcoutqty,0)=0 then nvl(pd_inqty,0)+nvl(pd_outqty,0) else nvl(pd_purcinqty,0)+nvl(pd_purcoutqty,0) end)/(1+nvl(pd_taxrate,0)/100),2)",
-                    "pd_piid=" + pi_id);
-            baseDao.updateByCondition("ProdInOut",
-                    "pi_total=round(nvl((SELECT sum(round(pd_ordertotal,2)) FROM ProdIODetail WHERE pd_piid=pi_id),0),2)", "pi_id=" + pi_id);
-            baseDao.execute("update prodiodetail set pd_customprice=pd_sendprice, pd_taxamount=pd_ordertotal "
-                    + "where pd_piclass in ('出货单','销售退货单') and pd_piid=? and nvl(pd_customprice,0)=0", pi_id);
-            baseDao.updateByCondition("ProdInOut", "pi_totalupper=L2U(nvl(pi_total,0))", "pi_id=" + pi_id);
-            // 成品标准成本，用于报价毛利润统计
-            baseDao.execute("UPDATE product set pr_cost=nvl((select price from ( select qd_prodcode,round(qd_factprice*qu_rate,2) price,"
-                    + "     row_number() over(partition by qd_prodcode order by qu_auditdate desc) rn from  quotation,quotationdetail  "
-                    + "where qu_id=qd_quid and qu_statuscode='AUDITED') t1 where rn=1 and qd_prodcode=pr_code),0) "
-                    + "where nvl(pr_cost,0)=0 and pr_code in (select pd_prodcode from prodiodetail where pd_piid=?)", pi_id);
-            baseDao.execute("UPDATE prodiodetail SET pd_showprice=nvl((select pr_cost from product where pd_prodcode=pr_code),0)"
-                    + "WHERE  pd_piid=?", pi_id);
-        } else {
-            baseDao.updateByCondition("ProdIODetail", "pd_total=round(nvl(pd_price,0)*(nvl(pd_inqty,0)+nvl(pd_outqty,0)),2)", "pd_piid="
-                    + pi_id);
-            baseDao.updateByCondition(
-                    "ProdInOut",
-                    "pi_total=(SELECT sum(round(nvl(pd_price,0)*(nvl(pd_inqty,0)+nvl(pd_outqty,0)),2)) FROM ProdIODetail WHERE pd_piid=pi_id)",
-                    "pi_id=" + pi_id);
-            baseDao.updateByCondition("ProdInOut", "pi_totalupper=L2U(nvl(pi_total,0))", "pi_id=" + pi_id);
-        }
-        if ("ProdInOut!Sale".equals(caller) || "ProdInOut!SaleReturn".equals(caller) || "ProdInOut!AppropriationOut".equals(caller)
-                || "ProdInOut!OtherOut".equals(caller) || "ProdInOut!ExchangeOut".equals(caller)) {
-            Object cardcode = baseDao.getFieldDataByCondition("ProdInOut", "pi_cardcode", "pi_id=" + pi_id);
-            baseDao.execute("update prodiodetail set (PD_CUSTPRODCODE,PD_CUSTPRODSPEC,pd_custproddetail)=(select max(pc_custprodcode),max(pc_custprodspec),max(pc_custproddetail) from ProductCustomer left join Product on pc_prodid=pr_id left join customer on pc_custid=cu_id where cu_code='"
-                    + cardcode
-                    + "' and pd_prodcode=pr_code) where pd_piid="
-                    + pi_id
-                    + " and nvl(pd_custprodcode,' ')=' ' and nvl(pd_custprodspec,' ')=' ' and pd_piclass in ('销售退货单', '出货单', '其它出库单', '拨出单', '换货出库单')");
-            baseDao.execute("update ProdIODetail set pd_taxtotal=round(pd_sendprice*(case when nvl(pd_purcinqty,0)+nvl(pd_purcoutqty,0)=0 then nvl(pd_inqty,0)+nvl(pd_outqty,0) else nvl(pd_purcinqty,0)+nvl(pd_purcoutqty,0) end)*nvl(pd_taxrate,0)/(100+nvl(pd_taxrate,0)),2) where pd_piid="
-                    + pi_id);
-        }
-
-        if ("ProdInOut!CostChange".equals(caller)) {
-            baseDao.execute(
-                    "update prodiodetail set pd_total=round((nvl(pd_price,0)-nvl(pd_orderprice,0))*nvl(pd_orderqty,0),2) where pd_piclass ='成本调整单' and pd_piid=?",
-                    pi_id);
-        }
-        // 入库类单据:如果pd_location为空，默认等于物料资料里的仓位pr_location
-        if (baseDao.isIn(caller)) {
-            baseDao.execute(
-                    "update prodiodetail set pd_location=(select pr_location from product where pr_code=pd_prodcode) where pd_piid=? and nvl(pd_location,' ')=' '",
-                    pi_id);
-        }
-        baseDao.updateByCondition("ProdInOut",
-                "pi_total = round(nvl((SELECT sum(round(nvl(pd_ordertotal,0),2)) FROM ProdIODetail WHERE pd_piid=pi_id),0),2)", "pi_id="
-                        + pi_id);
-        baseDao.updateByCondition("ProdInOut",
-                "pi_nettotal = round(nvl((SELECT sum(round(nvl(pd_nettotal,0),2)) FROM ProdIODetail WHERE pd_piid=pi_id),0),2)", "pi_id="
-                        + pi_id);
-    }
-
-    /**
-     * 计算pi_qtytotal
-     */
-    private void getQtyTotal(Object pi_id, String caller) {
-        if ("ProdInOut!Sale".equals(caller) || "ProdInOut!PurcCheckin".equals(caller) || "ProdInOut!OtherOut".equals(caller)) {
-            baseDao.execute("update ProdInOut set pi_qtytotal=nvl((select sum(nvl(pd_outqty,0)+nvl(pd_inqty,0))  from ProdIODetail where  "
-                    + "ProdIODetail.pd_piid = ProdInOut.pi_id),0) where pi_id=" + pi_id);
-        }
-    }
-
-    // @add 20170524 出库类型的单据，保存，更新，获取批号之后更新备料状态
-    private void updatePdaStatus(String caller, Object pi_id) {
-        Boolean bo = baseDao.isDBSetting("BarCodeSetting", "BarRelevancyBatch");
-        Boolean AutoPickBarcode = baseDao.isDBSetting("BarCodeSetting", "autoPickBarcode");
-        if (!AutoPickBarcode) {
-            if (!bo) {
-                if (baseDao.isOut(caller)) { // 出库类型
-                    // 如果所有的明细都没有条码则更新为空
-                    SqlRowList rs = baseDao.queryForRowSet(
-                            "select count(1)cn from prodiodetail where pd_piid=? and nvl(pd_batchcode,' ')<>' '", pi_id);
-                    if (rs.next() && rs.getInt("cn") == 0) {
-                        baseDao.execute("update prodinout set pi_pdastatus='' where pi_id=? and nvl(pi_pdastatus,' ')<>' '", pi_id);
-                    } else {
-                        rs = baseDao.queryForRowSet("select count(1)cn from barcodeio where bi_piid=? and bi_outqty>0", pi_id);
-                        if (rs.next() && rs.getInt("cn") > 0) { // 有一行以上备料记录则是备料中
-                            baseDao.execute("update prodinout set pi_pdastatus ='备料中' where pi_id=?", pi_id);
-                            rs = baseDao
-                                    .queryForRowSet(
-                                            "select count(1) cn from (select pd_prodcode,pd_whcode,sum(pd_outqty)qty from prodiodetail left join batch on pd_batchid=ba_id "
-                                                    + " where pd_piid=? and ba_hasbarcode<>0 group by pd_prodcode,pd_whcode)A left join (select bi_prodcode,bi_whcode,sum(bi_outqty)qty "
-                                                    + " from barcodeio where bi_piid=? group by bi_prodcode,bi_whcode)B on (pd_prodcode=bi_prodcode and pd_whcode=bi_whcode) where A.qty>NVL(B.qty,0)",
-                                            pi_id, pi_id);
-                            if (rs.next() && rs.getInt("cn") == 0) {
-                                baseDao.execute("update prodinout set pi_pdastatus ='已备料' where pi_id=?", pi_id);
-                            }
-                        } else {
-                            // --存在有条码的批号则更新成未备料
-                            baseDao.execute(
-                                    "update prodinout set pi_pdastatus ='未备料' where pi_id=?  and exists(select 1 from prodiodetail,batch where pd_piid=? and pd_batchid=ba_id and ba_hasbarcode<>0)",
-                                    pi_id, pi_id);
-                            // --所有批号都无条码则更新成无条码
-                            baseDao.execute(
-                                    "update prodinout set pi_pdastatus ='无条码' where pi_id=? and not exists(select 1 from prodiodetail left join batch on ba_id=pd_batchid where pd_piid=?  and ba_hasbarcode=-1)",
-                                    pi_id, pi_id);
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    /**
-     * 检查批号是否存在，批号数量是否足够
-     */
-    private String checkBatchRemain(Object pi_id) {
-        int count = baseDao.getCount("select count(1) from documentsetup where ds_name=(select pi_class from prodinout " + "where pi_id="
-                + pi_id + ") and (ds_inorout = '-IN' or ds_inorout = 'OUT')");
-        if (count > 0) {
-            String pdnos1 = baseDao.getJdbcTemplate().queryForObject(
-                    "select WMSYS.WM_CONCAT(pd_pdno) from (select pd_pdno  from prodiodetail left join batch on"
-                            + " pd_batchcode=ba_code and ba_whcode = pd_whcode and ba_prodcode = pd_prodcode "
-                            + "where pd_piid=? and ba_code is null order by pd_pdno) where rownum<20", String.class, pi_id);
-            String pdnos2 = baseDao
-                    .getJdbcTemplate()
-                    .queryForObject(
-                            "select WMSYS.WM_CONCAT(pd_pdno) from (select WMSYS.WM_CONCAT(pd_pdno) pd_pdno,max(pd_batchcode),"
-                                    + "sum(pd_outqty),max(ba_remain),max(ba_code) from prodiodetail left join batch on pd_batchcode=ba_code and "
-                                    + "ba_whcode = pd_whcode and ba_prodcode = pd_prodcode where pd_piid=? group by pd_batchcode,pd_prodcode,pd_whcode"
-                                    + "  having sum(pd_outqty)>max(ba_remain) ) where rownum<20", String.class, pi_id);
-            if (pdnos1 != null || pdnos2 != null) {
-                String error1 = pdnos1 == null ? "" : "找不到您所指的批号，请修改批号或点击【重置批号】再过账！行号是：" + pdnos1 + "<br>";
-                String error2 = pdnos2 == null ? "" : "批号的库存数小于出库数量，请修改批号或点击【重置批号】再过账!行号是:" + pdnos2 + "<br>";
-                return error1 + error2;
-            }
-        }
-        return null;
-    }
-
-    /**
-     * 产生冲销单并审核 发货单过账/销售单审核 scm->prodinout->post->after scm->sale->audit->after
-     *
-     * @author ZhongYL
-     */
-    @Transactional
-    public void createSaleClash(Integer fromid, String fromcaller,Employee employee) {
-        String SqlStr = "", clashcode = "", canclash = "", othercondition = "";
-        double thisqty = 0, needclashqty = 0, clashedqty = 0;
-        int csid = 0, detno = 0;
-        String prodcode = "", ordercode = "", fromcode = "", fromwhere = "";
-        String clashoption = "", saleclashkind = "";
-        SqlRowList rs0;
-        if (fromcaller.equalsIgnoreCase("ProdInOut")) {
-            fromwhere = baseDao.getFieldDataByCondition("ProdInOut", "pi_class", "pi_id=" + fromid).toString();
-        } else if (fromcaller.equalsIgnoreCase("Sale") || fromcaller.equals("销售单")) {
-            fromwhere = "销售单";
-        } else {
-            return;
-        }
-        // 先更新呆冲销的明细已冲销数为0
-        SqlStr = "update saleforecastDetail set sd_stepqty=0 where sd_id in (select sd_id from saleforecastDetail ,saleforecast   where sd_sfid=sf_id and sf_statuscode='AUDITED' and NVL(sd_statuscode,' ')<>'FINISH' and sd_qty>0)  ";
-        baseDao.execute(SqlStr);
-        // 获取冲销来源单据
-        if (fromwhere.equals("出货单")) {
-            SqlStr = "select pd_id as sourcedetid,pd_inoutno as fromcode,pd_outqty+nvl(pd_beipinoutqty,0) as qty,pd_prodcode as prodcode,pd_ordercode as ordercode,pd_pdno as pdno,sd_forecastcode as sfcode,sd_forecastdetno as sfdetno from Prodiodetail left join saledetail on sd_code=pd_ordercode and sd_detno=pd_orderdetno where pd_piid='"
-                    + fromid + "' ";
-        } else if (fromwhere.equals("销售单")) {
-            SqlStr = "select sd_id as sourcedetid,sd_code as fromcode,sd_qty as qty,sd_prodcode as prodcode,sa_code as ordercode,sd_detno as pdno,sd_forecastcode as sfcode,sd_forecastdetno as sfdetno,sa_custcode,sa_sellercode from saledetail,sale where sa_id=sd_said and sd_said='"
-                    + fromid + "' ";
-        } else if (fromwhere.equals("完工入库单") || fromwhere.equals("委外验收单") || fromwhere.equals("委外验退单")) {
-            SqlStr = "select pd_id as sourcedetid,pd_inoutno as fromcode,NVL(pd_inqty,0)+NVL(pd_outqty,0) as qty,pd_prodcode as prodcode,pd_ordercode as ordercode,pd_pdno as pdno,ma_salecode,ma_saledetno from Prodiodetail,warehouse,make,makekind where pd_piid='"
-                    + fromid
-                    + "' and pd_whcode=wh_code and NVL(wh_ifclash,0)<>0  and ma_code=pd_ordercode and ma_kind=mk_name and NVL(mk_clashsale,0)<>0 ";
-            // 判断是否存在需要完工入库冲销的预测
-            rs0 = baseDao.queryForRowSet("select sf_code from saleforecastkind where sf_clashoption='完工冲销' or sf_clashoption='FINISH' ");
-            if (!rs0.hasNext()) {
-                // 不需要完工冲销
-                return;
-            }
-        } else if (fromwhere.equals("销售拨出单")) {
-            SqlStr = "select pd_id as sourcedetid,pd_inoutno as fromcode,pd_outqty+nvl(pd_beipinoutqty,0) as qty,pd_prodcode as prodcode,pd_plancode as ordercode,pd_pdno as pdno,pd_plancode as sfcode,pd_forecastdetno as sfdetno from Prodiodetail where  pd_piid='"
-                    + fromid + "' and  NVL(pd_plancode,' ')<>' ' and pd_forecastdetno>0 ";
-        } else if (fromwhere.equals("其它出库单")) {
-            SqlStr = "select pd_id as sourcedetid,pd_inoutno as fromcode,pd_outqty+nvl(pd_beipinoutqty,0) as qty,pd_prodcode as prodcode,pd_plancode as ordercode,pd_pdno as pdno,pd_plancode as sfcode,pd_forecastdetno as sfdetno from Prodiodetail where  pd_piid='"
-                    + fromid + "' and  NVL(pd_plancode,' ')<>' ' and pd_forecastdetno>0 ";
-        } else {
-            return;
-        }
-        detno = 1;
-        SqlRowList rs = baseDao.queryForRowSet(SqlStr);
-        while (rs.next()) {
-            fromcode = rs.getString("fromcode");
-            clashoption = "";
-            saleclashkind = "";
-            othercondition = "";
-            clashedqty = 0;
-            needclashqty = rs.getDouble("qty");
-            prodcode = rs.getString("prodcode");
-            ordercode = rs.getString("ordercode");
-            // 判断此行记录是否需要冲销
-            canclash = "N";
-            if (fromwhere.equals("销售单") || fromwhere.equals("出货单")) {
-                if(fromwhere.equals("出货单") && baseDao.isDBSetting("ProdInOut!Sale", "clashSaleForecastByProduct")){
-                    saleclashkind="PRODUCT";
-                    clashoption = "SEND";
-                }else{
-                    SqlStr = "SELECT * from sale left join salekind on (sa_kind=sk_name or sa_kind=sk_code) where sa_code='" + ordercode + "' ";
-                    SqlRowList rs2 = baseDao.queryForRowSet(SqlStr);
-                    if (rs2.next()) {
-                        saleclashkind = rs2.getString("sk_clashfor");
-                        clashoption = rs2.getString("sk_clashoption");
-                        othercondition = rs2.getString("sk_clashkind");
-                    } else {
-                        // 未设置类型，不冲销
-                        continue;
-                    }
-                }
-            } else if (fromwhere.equals("完工入库单") || fromwhere.equals("委外验收单") || fromwhere.equals("委外验退单")) {
-                saleclashkind = "PRODUCT";
-                clashoption = "FINISH";
-            } else if (fromwhere.equals("销售拨出单") || fromwhere.equals("其它出库单")) {
-                saleclashkind = "单号冲销";
-                clashoption = "SEND";
-            }
-            if (saleclashkind == null || clashoption == null) {
-                // 未设置类型，不冲销
-                continue;
-            }
-            if (fromwhere.equals("销售单")) {
-                if (clashoption.equals("订单冲销") || clashoption.equalsIgnoreCase("SALE")) {
-                    canclash = "Y";
-                }
-            } else if (fromwhere.equals("出货单")) {
-                if (clashoption.equals("发货冲销") || clashoption.equalsIgnoreCase("SEND")) {
-                    canclash = "Y";
-                }
-            }
-            if (fromwhere.equals("完工入库单") || fromwhere.equals("委外验收单") || fromwhere.equals("委外验退单") || fromwhere.equals("销售拨出单")
-                    || fromwhere.equals("其它出库单")) {
-                canclash = "Y";
-            }
-            if (canclash.equals("N")) {
-                // 不冲销
-                continue;
-            }
-            SqlStr = "";
-            if (saleclashkind.equalsIgnoreCase("sale") || saleclashkind.equals("单号冲销")) {
-                SqlStr = "SELECT saleforecastDetail.*,saleforecast.* from saleforecastDetail left join saleforecast on sd_sfid=sf_id left join saleforecastkind on (saleforecast.sf_kind=saleforecastkind.sf_name or saleforecast.sf_kind=saleforecastkind.sf_code) where saleforecast.sf_code='"
-                        + rs.getString("sfcode") + "' and sd_detno=" + rs.getInt("sfdetno");
-            } else if (saleclashkind.equalsIgnoreCase("product") || saleclashkind.equals("料号冲销")) {
-                // 按物料号冲销
-                SqlStr = "SELECT saleforecastDetail.*,saleforecast.* from saleforecastDetail left join saleforecast on sd_sfid=sf_id left join saleforecastkind on (saleforecast.sf_kind=saleforecastkind.sf_name or saleforecast.sf_kind=saleforecastkind.sf_code) where sd_prodcode='"
-                        + prodcode + "' ";
-                if (fromwhere.equals("完工入库单") || fromwhere.equals("委外验收单")) {
-                    SqlStr = "SELECT case when saleforecast.sf_code='"
-                            + rs.getString("ma_salecode")
-                            + "' and sd_detno="
-                            + rs.getInt("ma_saledetno")
-                            + " then 1 else 2 end sortid,saleforecastDetail.*,saleforecast.* from saleforecastDetail left join saleforecast on sd_sfid=sf_id left join saleforecastkind on (saleforecast.sf_kind=saleforecastkind.sf_name or saleforecast.sf_kind=saleforecastkind.sf_code) where sd_prodcode='"
-                            + prodcode + "' ";
-                }
-                if (fromwhere.equals("销售单") && othercondition != null && othercondition.equals("客户匹配")) {
-                    SqlStr = SqlStr + " and (case when NVL(saleforecastDetail.sd_custcode,' ')<>' ' then saleforecastDetail.sd_custcode else sf_custcode end)='" + rs.getString("sa_custcode") + "' ";
-                } else if (fromwhere.equals("销售单") && othercondition != null && othercondition.equals("业务员")){
-                    SqlStr = SqlStr + " and (case when nvl(saleforecastDetail.sd_sellercode,' ')<>' ' then saleforecastDetail.sd_sellercode else sf_sellercode end)='"+ rs.getString("sa_sellercode")+"' ";
-                }
-            } else {
-                // 不冲销
-                continue;
-            }
-            if (clashoption.equals("订单冲销") || clashoption.equalsIgnoreCase("SALE")) {
-                SqlStr = SqlStr + " and sf_clashoption in ('SALE','订单冲销') ";
-            } else if (clashoption.equals("发货冲销") || clashoption.equalsIgnoreCase("SEND")) {
-                SqlStr = SqlStr + " and sf_clashoption in ('SEND','发货冲销') ";
-            } else if (clashoption.equals("完工冲销") || clashoption.equalsIgnoreCase("FINISH")) {
-                SqlStr = SqlStr + " and sf_clashoption in ('FINISH','完工冲销') ";
-            }
-            if (saleclashkind.equalsIgnoreCase("product") || saleclashkind.equals("料号冲销")) {
-                SqlStr = SqlStr + " and trunc(sd_enddate)>=trunc(sysdate) ";// 只冲销有效的预测，@update 20170224 截止日期等于今日的也可冲销，与存储过程中的计算一致
-            }
-            if (fromwhere.equals("委外验退单")) {
-                SqlStr = " SELECT saleforecastDetail.*,saleforecast.*,scd_id,NVL(scd_clashqty,0)scd_clashqty,NVL(scd_cancelqty,0)scd_cancelqty,scd_id from saleclashdetail left join saleclash on scd_scid=sc_id left join saleforecast on scd_ordercode=sf_code left join saleforecastdetail on sd_sfid=sf_id  where sc_source='委外验收单' and scd_fromcode='"
-                        + rs.getString("ordercode")
-                        + "' and scd_clashqty>0 and scd_clashqty-NVL(scd_cancelqty,0)>0 and sc_statuscode='AUDITED' and sd_clashsaleqty>0 ";
-            }
-            if (fromwhere.equals("完工入库单") || fromwhere.equals("委外验收单")) {
-                if (baseDao.isDBSetting("SaleForecast", "mappingSaleForecast")) {
-                    SqlStr = SqlStr
-                            + " and saleforecast.sf_code='"
-                            + rs.getString("ma_salecode")
-                            + "' and saleforecastdetail.sd_detno="
-                            + rs.getInt("ma_saledetno")
-                            + " and saleforecast.sf_statuscode='AUDITED' and sd_qty-nvl(sd_stepqty,0)>0 order by sortid,sd_needdate asc,sd_detno asc";
-                } else {
-                    SqlStr = SqlStr
-                            + " and saleforecast.sf_statuscode='AUDITED' and sd_qty-nvl(sd_stepqty,0)>0 order by sortid,sd_needdate asc,sd_detno asc";
-                }
-            } else if (fromwhere.equals("委外验退单")) {
-                // 委外验退条件特殊，上面已加
-            } else {
-                SqlStr = SqlStr
-                        + " and saleforecast.sf_statuscode='AUDITED' and NVL(sd_statuscode,' ')<>'FINISH' and sd_qty-nvl(sd_stepqty,0)>0 order by sd_needdate asc,sd_detno asc";
-            }
-
-            if ("Y".equals(canclash) && !SqlStr.equals("")) {
-                SqlRowList rs2 = baseDao.queryForRowSet(SqlStr);
-                while (rs2.next() && clashedqty < needclashqty) {
-                    double remain = rs2.getDouble("sd_qty") - rs2.getDouble("sd_stepqty");
-                    int cancelsourceid = 0;
-                    if (fromwhere.equals("委外验退单")) {
-                        remain = (rs2.getDouble("scd_clashqty") - rs2.getDouble("scd_cancelqty"));// 拿冲销数反冲减预测
-                        cancelsourceid = rs2.getInt("scd_id");
-                        if (remain <= 0) {
-                            continue;
-                        }
-                    }
-                    thisqty = remain > needclashqty - clashedqty ? needclashqty - clashedqty : remain;
-                    if (clashcode == "") {
-                        clashcode = baseDao.sGetMaxNumber("SaleClash", 2);
-                        csid = baseDao.getSeqId("SALECLASH_SEQ");
-                        SqlStr = "insert into SaleClash(sc_id,sc_code,sc_date,sc_status,sc_statuscode,sc_recorder,sc_source,sc_sourceid,sc_sourcecode)values("
-                                + csid
-                                + ",'"
-                                + clashcode
-                                + "',sysdate,'已提交','COMMITED','"+employee.getEm_name()+"','" + fromwhere + "'," + fromid + ",'" + fromcode+ "') ";
-                        baseDao.execute(SqlStr);
-                    }
-                    SqlStr = "insert into SaleClashDetail(scd_id,scd_scid,scd_detno,scd_prodcode,scd_clashqty,scd_ordercode,scd_orderdetno,scd_sourcedetid,scd_fromcode,scd_cancelid)values("
-                            + "SALECLASHDETAIL_SEQ.NEXTVAL,"
-                            + csid
-                            + ",'"
-                            + detno
-                            + "','"
-                            + prodcode
-                            + "','"
-                            + thisqty
-                            + "','"
-                            + rs2.getString("sf_code")
-                            + "','"
-                            + rs2.getInt("sd_detno")
-                            + "',"
-                            + rs.getInt("sourcedetid")
-                            + ",'"
-                            + rs.getString("ordercode") + "'," + cancelsourceid + ")";
-                    baseDao.execute(SqlStr);
-                    if (fromwhere.equals("委外验退单")) {
-                        SqlStr = "UPDATE SaleClashDetail set scd_cancelqty=nvl(scd_cancelqty,0)+" + thisqty + " where scd_id="
-                                + rs2.getInt("scd_id") + " ";
-                        baseDao.execute(SqlStr);
-                    }
-                    SqlStr = "UPDATE saleforecastDetail set sd_stepqty=nvl(sd_stepqty,0)+(" + thisqty + ") where sd_id="
-                            + rs2.getInt("sd_id") + " ";
-                    baseDao.execute(SqlStr);
-                    detno = detno + 1;
-                    clashedqty = clashedqty + thisqty;
-                }
-            }
-        }
-        if (fromwhere.equals("委外验退单") && csid > 0) {
-            SqlStr = "UPDATE SaleClashDetail set scd_clashqty=0-scd_clashqty  where scd_scid=" + csid + " ";
-            baseDao.execute(SqlStr);
-        }
-        if (!"".equals(clashcode)) {
-            // 审核冲销单
-            auditSaleClash(csid, "SaleClash",employee);
-        }
-    }
-
-    public String auditSaleClash(int sc_id, String caller,Employee employee) {
-        // 只能对状态为[已提交]的订单进行审核操作!
-        Object status = baseDao.getFieldDataByCondition("SaleClash", "sc_statuscode", "sc_id=" + sc_id);
-        if (!"AUDITED".equals(StringUtil.nvl(status, ""))){
-            return "只能对已提交的单据进行审核！";
-        }
-        String dets = baseDao
-                .getJdbcTemplate()
-                .queryForObject(
-                        "select WM_CONCAT('预测单号:'||sf_code||',行号:'||sd_detno) from (select sf_code,sd_detno from SaleForecast left join SaleForecastDetail on sf_id=sd_sfid where  (nvl(sd_statuscode,' ')<>'AUDITED' and not(sd_statuscode='COMMITED' and sf_statuscode='AUDITED')) and (sf_code,sd_detno) in (select scd_ordercode,scd_orderdetno from SaleClashDetail where scd_scid=?))",
-                        String.class, sc_id);
-        if (dets != null) {
-            return "预测单号+预测行号状态不等于已审核，不允许已审核!" + dets;
-        }
-        // 执行审核操作
-        baseDao.audit("SaleClash", "sc_id=" + sc_id, "sc_status", "sc_statuscode", "sc_auditdate", "sc_auditman",employee);
-        Object source = baseDao.getFieldDataByCondition("SaleClash", "sc_source", "sc_id=" + sc_id);
-        // 冲销数量记录在预测单中
-        SqlRowList rs = baseDao
-                .queryForRowSet(
-                        "select scd_ordercode,scd_orderdetno,sum(scd_clashqty) scd_clashqty from SaleClashDetail where scd_scid=? group by scd_ordercode,scd_orderdetno",
-                        sc_id);
-        while (rs.next()) {
-            baseDao.updateByCondition("SaleForecastDetail", "sd_qty=sd_qty-(" + rs.getDouble("scd_clashqty")
-                    + "),sd_clashsaleqty=nvl(sd_clashsaleqty,0)+" + rs.getDouble("scd_clashqty"), "sd_detno=" + rs.getInt("scd_orderdetno")
-                    + " AND sd_sfid=(SELECT sf_id FROM SaleForecast WHERE sf_code='" + rs.getString("scd_ordercode") + "')");
-            if (source != null && source.equals("销售单") && rs.getGeneralDouble("scd_clashqty") > 0) {
-                baseDao.updateByCondition("SaleForecastDetail", "sd_yqty=(case when NVL(sd_yqty,0)-(" + rs.getDouble("scd_clashqty")
-                        + ")<0 then 0 else sd_yqty-(" + rs.getDouble("scd_clashqty") + ") end)", "sd_detno=" + rs.getInt("scd_orderdetno")
-                        + " AND sd_sfid=(SELECT sf_id FROM SaleForecast WHERE sf_code='" + rs.getString("scd_ordercode") + "')");
-            }
-        }
-        return null;
-    }
-
-    /*
-     * 拨出单过账后过账拨入单
-     */
-    public String turnProdIO(int id,Employee employee) {
-        String dets = null;
-        SqlRowList rs = baseDao.queryForRowSet("select pi_relativeplace,pi_class from prodinout where pi_id=?", id);
-        if (rs.next()) {
-            SqlRowList rs1 = baseDao.queryForRowSet(
-                    "select pi_id from prodinout where pi_inoutno=? and pi_class in ('拨入单','销售拨入单') and nvl(PI_UNAUTOPOSTIN,0)=0",
-                    rs.getString("pi_relativeplace"));
-            if (rs1.next()) {
-                if (baseDao.isDBSetting("sys","cgyCheck")) {
-                    /**
-                     * maz
-                     * 出入库单判断过账人是否在明细行仓库的仓管员资料表中存在,人员资料中查找管理员一样限制如果为非仓库员不允许过账
-                     * 虚拟账号不限制 2017080135
-                     */
-                    Object type = baseDao.getFieldDataByCondition("Employee", "em_code",
-                            "em_code='"+employee.getEm_code()+"'");
-                    if (type != null) {
-                        dets = baseDao.getJdbcTemplate()
-                                .queryForObject(
-                                        "select wm_concat(pd_pdno) from prodinout,prodiodetail where pi_id=pd_piid and pi_id=? and pd_id not in "
-                                                + "(select pd_id from prodinout,prodiodetail,warehouse,warehouseman where pi_id=pd_piid and pd_whcode=wh_code and wh_id=wm_whid "
-                                                + "and pi_id=? and wm_cgycode=?)", String.class, rs1.getInt("pi_id"),
-                                        rs1.getInt("pi_id"), employee.getEm_code());
-                    }
-                }
-                if (dets == null) {
-                    if ("拨出单".equals(rs.getString("pi_class"))) {
-                        postProdInOut(rs1.getInt("pi_id"), "ProdInOut!AppropriationIn",employee);
-                    } else if ("销售拨出单".equals(rs.getString("pi_class"))) {
-                        postProdInOut(rs1.getInt("pi_id"), "ProdInOut!SaleAppropriationIn",employee);
-                    }
-                }
-            }
-        }
-        return dets;
-    }
-
-    /**
-     * @author XiaoST 2016年8月25日 下午7:18:45 更新工单的完工状态，在完工入库，委外验收，验退过账，反过账时调用
-     */
-    public void updateMakeFinishStatus(Integer ma_id) {
-        baseDao.execute("update make set ma_madeqty=nvl((select sum(pd_inqty-pd_outqty) from prodiodetail where " +
-                "pd_ordercode=ma_code and pd_piclass in ('委外验收单','完工入库单','委外验退单') and pd_status>0),0) WHERE ma_id="
-                + ma_id);
-        baseDao.execute("update make set ma_finishstatuscode='COMPLETED',ma_finishstatus='已完工' where ma_id=" + ma_id + " and ma_madeqty>=ma_qty  ");
-        baseDao.execute("update make set ma_finishstatuscode='PARTFI',ma_finishstatus='部分完工' where ma_id="
-                + ma_id + " and ma_madeqty>0 and ma_madeqty<ma_qty  ");
-        baseDao.execute("update make set ma_finishstatuscode='UNCOMPLET',ma_finishstatus='未完工' where ma_id=" + ma_id + " and ma_madeqty=0  ");
-    }
-
-    private void changeMaStatus(int pi_id) {
-        String ids = baseDao
-                .getJdbcTemplate()
-                .queryForObject(
-                        "select wm_concat(ma_id) from (select distinct ma_id from ProdIODetail left join make on ma_code=pd_ordercode where pd_piid=?)",
-                        String.class, pi_id);
-        if (ids != null) {
-            updateMakeGetStatus(ids);
-        }
-    }
-
-    /**
-     * 修改工单领料状态
-     */
-    public void updateMakeGetStatus(String ids) {
-        baseDao.execute("update make set ma_turnstatuscode='UNGET',ma_turnstatus='未领料' where ma_id in ("
-                + ids + ") and not exists(select 1 from makematerial where mm_maid=ma_id and NVL(mm_havegetqty,0)+NVL(mm_totaluseqty,0)>0)");
-        baseDao.execute("update make set ma_turnstatuscode='PARTGET',ma_turnstatus='部分转领料' where ma_id in ("
-                + ids + ") and nvl(ma_turnstatuscode,' ')<>'PARTGET' and exists (select 1 from makematerial where mm_maid=ma_id "
-                + "and NVL(mm_havegetqty,0)+NVL(mm_totaluseqty,0)+NVL(mm_turnaddqty,0)>0 and NVL(mm_materialstatus,' ')=' ')");
-        baseDao.execute("update make set ma_turnstatuscode='TURNGET',ma_turnstatus='已转领料' where ma_id in ("
-                + ids + ") and nvl(ma_turnstatuscode,' ')<>'TURNGET' and not exists(select 1 from makematerial where mm_maid=ma_id "
-                + "and nvl(MM_QTY,0)-NVL(mm_havegetqty,0)-NVL(mm_totaluseqty,0)-NVL(mm_turnaddqty,0)>0 and NVL(mm_materialstatus,' ')=' ')");
-    }
-
-
-    private void refreshTurnQty(Integer ma_id, Integer mm_id) {
-        if (mm_id != null && mm_id > 0) {
-            // 已转领料数
-            baseDao.execute("update MakeMaterial set mm_totaluseqty=(select sum(nvl(pd_outqty,0)) from prodiodetail,prodinout where pd_piid=pi_id and pd_status=0 and pd_ordercode=mm_code and pd_orderdetno=mm_detno and pd_piclass in ('生产领料单', '委外领料单')) WHERE mm_maid="
-                    + ma_id + " and mm_id=" + mm_id);
-            // 转补料数
-            baseDao.execute("update MakeMaterial set mm_turnaddqty=(select sum(nvl(pd_outqty,0)) from prodiodetail,prodinout "
-                    + "where pd_piid=pi_id and pi_statuscode<>'DELETE' and pd_status=0 and pd_ordercode=mm_code and pd_orderdetno=mm_detno and pd_piclass in ('生产补料单', '委外补料单')) where mm_maid ="
-                    + ma_id + " and mm_id=" + mm_id);
-            // 更新替代已转数
-            baseDao.execute("update makematerialreplace set mp_repqty=(select NVL(sum(nvl(pd_outqty,0)),0) from prodiodetail,prodinout "
-                    + "where pd_piid=pi_id and pd_status=0  and pd_prodcode=mp_prodcode and pd_ordercode=mp_mmcode and "
-                    + "pd_orderdetno=mp_mmdetno  and pd_piclass in ('生产领料单', '委外领料单')) where mp_maid=" + ma_id + " and mp_mmid=" + mm_id);
-            baseDao.execute("update makematerialreplace set mp_repqty=0  where mp_maid=" + ma_id + " AND MP_REPQTY<0");
-            // 更新替代总已转数
-            baseDao.execute("update MakeMaterial set mm_repqty=NVL((select sum(NVL(mp_repqty,0)) from MakeMaterialreplace where mp_mmid=mm_id),0) where mm_maid="
-                    + ma_id + " and mm_id=" + mm_id);
-            // 更新替代总已领数
-            baseDao.execute("update MakeMaterial set mm_haverepqty=NVL((select sum(NVL(mp_haverepqty,0)) from MakeMaterialreplace where mp_mmid=mm_id),0) where mm_maid="
-                    + ma_id + " and mm_id=" + mm_id);
-        } else {
-            // 已转领料数
-            baseDao.execute("update MakeMaterial set mm_totaluseqty=(select sum(nvl(pd_outqty,0)) from prodiodetail,prodinout "
-                    + "where pd_piid=pi_id and pd_status=0 and pd_ordercode=mm_code and pd_orderdetno=mm_detno and pd_piclass in ('生产领料单', '委外领料单')) WHERE mm_maid="
-                    + ma_id);
-            // 转补料数
-            baseDao.execute("update MakeMaterial set mm_turnaddqty=(select sum(nvl(pd_outqty,0)) from prodiodetail,prodinout "
-                    + "where pd_piid=pi_id and pi_statuscode<>'DELETE' and pd_status=0 and pd_ordercode=mm_code and pd_orderdetno=mm_detno and pd_piclass in ('生产补料单', '委外补料单')) where mm_maid ="
-                    + ma_id);
-            // 更新替代已转数
-            baseDao.execute("update makematerialreplace set mp_repqty=(select NVL(sum(nvl(pd_outqty,0)),0) from prodiodetail,prodinout "
-                    + "where pd_piid=pi_id and pd_status=0  and pd_prodcode=mp_prodcode and pd_ordercode=mp_mmcode and "
-                    + "pd_orderdetno=mp_mmdetno  and pd_piclass in ('生产领料单', '委外领料单')) where mp_maid=" + ma_id);
-            baseDao.execute("update makematerialreplace set mp_repqty=0  where mp_maid=" + ma_id + " AND MP_REPQTY<0");
-            // 更新替代总已转数
-            baseDao.execute("update MakeMaterial set mm_repqty=NVL((select sum(NVL(mp_repqty,0)) from MakeMaterialreplace where mp_mmid=mm_id),0) where mm_maid="
-                    + ma_id);
-            // 更新替代总已领数
-            baseDao.execute("update MakeMaterial set mm_haverepqty=NVL((select sum(NVL(mp_haverepqty,0)) from MakeMaterialreplace where mp_mmid=mm_id),0) where mm_maid="
-                    + ma_id);
-        }
-
-    }
-
-    private void setBackQty(String maidstr, Integer mm_id) {
-        if (mm_id != null && mm_id > 0) {
-            baseDao.getJdbcTemplate()
-                    .execute(
-                            "update makematerial set mm_backqty=(select sum(pd_inqty) from prodiodetail where pd_piclass in ('生产退料单','委外退料单') and pd_ordercode=mm_code and pd_orderdetno=mm_detno and pd_status=0) WHERE mm_maid in ("
-                                    + maidstr + ") and mm_id=" + mm_id);
-            baseDao.getJdbcTemplate()
-                    .execute(
-                            "update MakeMaterialreplace set mp_backqty=(select sum(pd_inqty) from prodiodetail where pd_piclass in ('生产退料单','委外退料单') and pd_ordercode=mp_mmcode and pd_orderdetno=mp_mmdetno and pd_prodcode=mp_prodcode and pd_status=0) WHERE mp_maid in ("
-                                    + maidstr + ") and mp_mmid=" + mm_id);
-            baseDao.getJdbcTemplate()
-                    .execute(
-                            "update makematerial set mm_turnscrapqty=(select sum(md_qty) from makescrapdetail,makescrap where ms_id=md_msid and ms_statuscode<>'AUDITED' and md_mmcode=mm_code and md_mmdetno=mm_detno ) WHERE mm_maid in ("
-                                    + maidstr + ") and mm_id=" + mm_id);
-            baseDao.getJdbcTemplate()
-                    .execute(
-                            "update MakeMaterialreplace set mp_turnscrapqty=(select sum(md_qty) from makescrapdetail,makescrap where ms_id=md_msid and ms_statuscode<>'AUDITED' and md_mmcode=mp_mmcode and md_mmdetno=mp_mmdetno ) WHERE mp_maid in ("
-                                    + maidstr + ") and mp_mmid=" + mm_id);
-        } else {
-            baseDao.getJdbcTemplate()
-                    .execute(
-                            "update makematerial set mm_backqty=(select sum(pd_inqty) from prodiodetail where pd_piclass in ('生产退料单','委外退料单') and pd_ordercode=mm_code and pd_orderdetno=mm_detno and pd_status=0) WHERE mm_maid in ("
-                                    + maidstr + ")");
-            baseDao.getJdbcTemplate()
-                    .execute(
-                            "update MakeMaterialreplace set mp_backqty=(select sum(pd_inqty) from prodiodetail where pd_piclass in ('生产退料单','委外退料单') and pd_ordercode=mp_mmcode and pd_orderdetno=mp_mmdetno and pd_prodcode=mp_prodcode and pd_status=0) WHERE mp_maid in ("
-                                    + maidstr + ")");
-            baseDao.getJdbcTemplate()
-                    .execute(
-                            "update makematerial set mm_turnscrapqty=(select sum(md_qty) from makescrapdetail,makescrap where ms_id=md_msid and ms_statuscode<>'AUDITED' and md_mmcode=mm_code and md_mmdetno=mm_detno ) WHERE mm_maid in ("
-                                    + maidstr + ")");
-            baseDao.getJdbcTemplate()
-                    .execute(
-                            "update MakeMaterialreplace set mp_turnscrapqty=(select sum(md_qty) from makescrapdetail,makescrap where ms_id=md_msid and ms_statuscode<>'AUDITED' and md_mmcode=mp_mmcode and md_mmdetno=mp_mmdetno ) WHERE mp_maid in ("
-                                    + maidstr + ")");
-        }
-    }
-}

src/main/java/com/uas/eis/service/Impl/QueryServiceImpl.java

@@ -1,272 +0,0 @@
-package com.uas.eis.service.Impl;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
-
-import com.alibaba.fastjson.serializer.SerializerFeature;
-import com.uas.eis.entity.*;
-import com.uas.eis.exception.SystemException;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.cache.annotation.Cacheable;
-import org.springframework.stereotype.Service;
-import org.springframework.util.StringUtils;
-
-import com.alibaba.fastjson.JSON;
-import com.uas.eis.core.support.TokenHandler;
-import com.uas.eis.dao.BaseDao;
-import com.uas.eis.service.QueryService;
-import com.uas.eis.utils.BaseUtil;
-
-import net.sf.json.JSONObject;
-
-
-@Service
-public class QueryServiceImpl implements QueryService {
-
-	@Autowired
-	private BaseDao baseDao;
-	@Autowired
-	private ActionConfig actionConfig;
-	
-	@Override
-	public String login(String username, String password) {
-		if(checkUser(username, password)) {
-			return TokenHandler.createToken(username, password);
-		}else {
-			return null;
-		}
-	}
-	
-	@Override
-	@Cacheable(value="userEnableCache")
-	public boolean checkUser(String username, String password) {
-		return baseDao.checkIf("EIS_USER", "eu_enable=-1 and " + "eu_name='" + username + "' and eu_password='" + password + "'");
-	}
-
-	@Override
-	@Cacheable(value="userActionEnableCache")
-	public boolean checkAction(String username, String action) {
-		boolean flag = false;
-		
-		String roles = baseDao.queryForObject("select eu_role from eis_user where eu_name='" + username + "'", String.class);
-		if(roles == null) {
-			return false;
-		}
-		// 开放公共API的权限
-		String apiAction = actionConfig.getApiAction();
-		if(action.startsWith(apiAction)) {
-			return true;
-		}
-		// 判断是否在不需要权限控制的请求配置中
-		String[] publicActions = actionConfig.getPublicActions();
-		for(String publicAction : publicActions) {
-			if(publicAction.equals(action)) {
-				return true;
-			}
-		}
-		String[] fields = {"er_reg","er_action"};
-		List<JSONObject> res = baseDao.getFieldsJSONDatasByCondition("EIS_ROLE", fields, "er_id in (" + roles + ")");
-		for(int o = 0; o< res.size(); o++) {
-			JSONObject data = res.get(o);
-			String reg = data.containsKey("er_reg") ? data.getString("er_reg") : "(\\S)*";
-			String act = data.containsKey("er_action") ? data.getString("er_action") : "";
-			// 通过正则和预设接口校验请求权限
-			if(action.matches(reg) || act.indexOf(action) != -1) {
-				flag = true;
-				break;
-			}
-		}
-		return flag;
-	}
-	public String getUsers(){
-		String sql = "SELECT EM_NAME,EM_CODE,TO_CHAR(EM_INDATE,'yyyy-MM-dd hh24:mm:ss') EM_INDATE FROM EMPLOYEE WHERE EM_CODE = 'U0818'";
-		Map<String, Object> map = baseDao.getJdbcTemplate().queryForMap(sql);
-		List<Map<String,Object>> list = baseDao.queryForList("SELECT * FROM UPLOADDOCDETAIL WHERE UDD_UDID=284");
-		return BaseUtil.parseDataToJson(map,list);
-	}
-	
-	/**
-	 * 标准查询API
-	 * @param code		查询方案Code
-	 * @param param		参数
-	 * @return
-	 */
-	public Object query(String code, String param){
-		Map<String, Object> resultmap = new HashMap<String, Object>();
-		List<Map<String, Object>> resultList = new ArrayList<Map<String,Object>>();
-		com.alibaba.fastjson.JSONObject json = JSON.parseObject(param);
-		//查询参数配置表
-		String getInOutParamsSql = "select * from queryArgs where qa_qccode = ?";
-		List<QueryArgs> inOutParamList = baseDao.query(getInOutParamsSql,  QueryArgs.class, code);
-		Map<String, String> argsMap = new HashMap<String, String>();	//存参数名对应的参数值
-		Map<String, String> argsTypeMap = new HashMap<String, String>();		//存参数名对应的参数类型
-		for(QueryArgs args : inOutParamList){
-			argsMap.put(args.getQa_param(),json.getString(args.getQa_param()));
-			argsTypeMap.put(args.getQa_param(), args.getQa_paramtype());
-		}
-		//校验查询方案传入的参数是否正确
-		checkParam(code, param);
-		//code对应的查询方案
-		String getQueryConfigsql = "select * from queryconfig where qc_code=? order by qc_detno"; 
-		List<QueryConfig> queryConfigList = baseDao.query(getQueryConfigsql, QueryConfig.class, code);
-		if(queryConfigList != null){
-			List<String> valueList = new ArrayList<String>();
-			Object mainField = baseDao.getFieldDataByCondition("queryArgs", "qa_param", "qa_qccode='"+code+"' and qa_ismainfield=1");
-			if(mainField != null && "array".equals(argsTypeMap.get(mainField))){
-				String argValue = argsMap.get(mainField);
-				String[] valueArray = argValue.replace("[", "").replace("]", "").replaceAll("\"", "").split(",");
-				valueList = new ArrayList<String>(Arrays.asList(valueArray));
-			}else{
-				valueList.add(argsMap.get(mainField));
-			}
-			for(int i = 0; i < valueList.size(); i++){
-				Map<String, Object> map = new HashMap<String, Object>();
-				for(QueryConfig queryConfig : queryConfigList){
-					StringBuilder inParam = new StringBuilder();
-					StringBuilder outParam = new StringBuilder();
-					//查询方案明细表，得到要查询的字段
-					String getQueryFieldssql = "select * from queryConfigDetail where qcd_qcid = ?";
-					List<QueryConfigDetail> queryFieldsList = baseDao.query(getQueryFieldssql, QueryConfigDetail.class, queryConfig.getQc_id());
-					StringBuilder sb = new StringBuilder();
-					sb.append("select ");
-					for(QueryConfigDetail field : queryFieldsList){
-						sb.append(field.getQcd_field() + " \"" + field.getQcd_mappingkey() + "\",");
-					}
-					sb.deleteCharAt(sb.length()-1);			//去掉最后一个 ,
-					sb.append(" from " + queryConfig.getQc_table());
-					//拼接condition
-					String condition = queryConfig.getQc_condition();
-					Pattern pattern = Pattern.compile("@[\\w]+");		//通过正则替换@变量
-					Matcher m = pattern.matcher(condition);
-					List<String> matchList = new ArrayList<String>();
-					while(m.find()){
-						matchList.add(m.group());
-					}
-					for(String match : matchList){
-						/*if("array".equals(argsTypeMap.get(match.replace("@", "")))){
-							String value = argsMap.get(match.replace("@", ""));
-							value = value.replaceAll("\"", "'");
-							condition = condition.replaceAll(match, value);
-						}else{
-							condition = condition.replaceAll(match, "'"+argsMap.get(match.replace("@", ""))+"'");
-						}*/
-						if(match.equals("@"+mainField)){
-							condition = condition.replaceAll(match, "'"+valueList.get(i)+"'");
-							inParam.append(mainField+"="+valueList.get(i)+";");
-						}else{
-							condition = condition.replaceAll(match, "'"+argsMap.get(match.replace("@", ""))+"'");
-							inParam.append(match.replace("@","")+"="+argsMap.get(match.replace("@", ""))+";");
-						}
-					}
-					sb.append(" " + condition);		//append where条件
-					//append order by语句
-					if(!StringUtils.isEmpty(queryConfig.getQc_orderby())){
-						sb.append(" " + queryConfig.getQc_orderby());
-					}
-					if(queryFieldsList != null && queryFieldsList.size()>0){
-						if(queryConfig.getQc_isArray() != null && queryConfig.getQc_isArray() == 0){
-							map.put(queryConfig.getQc_mapkey(), baseDao.getJdbcTemplate().queryForMap(sb.toString()));
-						}else{
-							map.put(queryConfig.getQc_mapkey(), baseDao.queryForList(sb.toString()));
-						}
-					}
-					
-					//获取额外返回值
-					if(!StringUtils.isEmpty(queryConfig.getQc_return())){
-						String getReturnSql = "select " + queryConfig.getQc_return() + " from " + queryConfig.getQc_table() + " " + condition;
-						Map<String, Object> returnMap = baseDao.getJdbcTemplate().queryForMap(getReturnSql);
-						List<Object> list = baseDao.getFieldDatasByCondition("queryArgs", "qa_param", "qa_qccode='"+queryConfig.getQc_code()+"' and qa_relation="+queryConfig.getQc_id()+" order by qa_detno");
-						Iterator<Object> it = returnMap.values().iterator();
-						int j = 0;
-						while(it.hasNext()){
-							String value = String.valueOf(it.next());
-							argsMap.put(String.valueOf(list.get(j)), value);
-							outParam.append(String.valueOf(list.get(j))+"="+value+";");
-							j++;
-						}
-					}
-					//记录日志
-					String insertSql = "INSERT INTO QUERYLOG(QL_ID,QL_QCCODE,QL_PARAM,QL_RETURN,QL_DATE) VALUES(QUERYLOG_SEQ.NEXTVAL,'"+queryConfig.getQc_code()+"','"+inParam.toString()+"','"+outParam.toString()+"',SYSDATE)";
-					baseDao.execute(insertSql);
-				}
-				if(valueList.size() > 1){
-					resultList.add(map);
-				}else{
-					resultmap.putAll(map);
-				}
-			}
-			if(valueList.size() > 1)
-				return resultList;
-			else
-				return resultmap;
-		}else{
-			return resultmap;
-		}
-		
-	}
-	
-	public Object doAction() {
-		return null;
-	}
-	
-	/**
-	 * 传入参数的合法性校验
-	 * @param code
-	 * @param param
-	 */
-	private void checkParam(String code, String param){
-		com.alibaba.fastjson.JSONObject json = JSON.parseObject(param);
-		if(StringUtils.isEmpty(code)){
-			throw new SystemException(ErrorMsg.NULL_QUERY_CODE);
-		}
-		if(json == null){
-			throw new SystemException(ErrorMsg.PARAM_AMOUNT_ERROR);
-		}
-		String getInParamsSql = "select * from queryArgs where qa_qccode = ? and qa_relation is null";
-		List<QueryArgs> inParamList = baseDao.query(getInParamsSql,  QueryArgs.class, code);
-		if(inParamList.size() != json.size()){
-			throw new SystemException(ErrorMsg.PARAM_AMOUNT_ERROR);
-		}else{
-			 for(QueryArgs queryArgs : inParamList){
-				 if(json.getString(queryArgs.getQa_param()) == null){
-					 throw new SystemException(ErrorMsg.PARAM_NAME_ERROR);
-				 }else{
-					 if("array".equals(queryArgs.getQa_paramtype())){
-						 String stringArray = json.getString(queryArgs.getQa_param());
-						 if(!(stringArray.contains("[") && stringArray.contains("]"))){
-							 BaseUtil.showError(ErrorMsg.PARAM_FORMAT_ERROR,"传入的参数："+queryArgs.getQa_param()+"格式不正确");
-						 }
-					 }
-				 }
-			 }
-		}
-	}
-
-	@Override
-	public Object doAction(String code, String param) {
-		return null;
-	}
-
-	@Override
-	public String queryProduct(String data) {
-		Map<Object, Object> store = BaseUtil.parseFormStoreToMap(data);
-		int size = store.get("SIZE") == null ? 500 : Integer.parseInt(store.get("SIZE").toString());
-		size=size>500?500:size;
-		List<Product> products = baseDao.query("select * from (select pr_code ,pr_detail ,pr_spec ,nvl(pr_unit,'PCS')" +
-						" pr_unit,nvl(pr_cop,'BYT') pr_cop,nvl(pr_version,0) pr_version,pr_serial ," +
-						"nvl(pr_validdays,0) pr_validdays ,pr_msdlevel ,pr_fhelpcode ,pr_f_115 ,pr_f_116 ,pr_f_102 ," +
-						"pr_kind ," +
-						"pr_whcode from product where pr_sendstatus='待上传' and pr_statuscode='AUDITED' and nvl(pr_groupcode,' ')<>'用品' order by pr_auditdate,pr_id) where rownum<=" + size,
-				Product.class);
-		String s = JSON.toJSONString(products, SerializerFeature.WriteMapNullValue);
-		baseDao.execute("update product set pr_sendstatus='已上传' where pr_id in (select pr_id from (select pr_id from product where pr_sendstatus='待上传' and pr_statuscode='AUDITED' and nvl(pr_groupcode,' ')<>'用品' order by pr_auditdate,pr_id) where rownum<=" + size+")");
-		return s;
-	}
-}

src/main/java/com/uas/eis/service/LingxingService.java

@@ -1,16 +0,0 @@
-package com.uas.eis.service;
-
-/**
- * @author: zhouy
- * @date: 2021/9/16 16:39
- * @desc:
- * https://csbd.w.eolinker.com/#/share/index?shareCode=YMPaGu
- * 访问秘钥：nJ5QvgmVRPaCP1My
- *
- * https://csbd.w.eolinker.com/#/share/project/api/?groupID=-1&shareCode=4k6NYb&shareToken=$2y$10$gs1s62Vl.tZywl~2F9M.uaMeTc~2FJniR.lLSy4i2OW9vka0N~2FTvibCF2&shareID=215514
- */
-public interface LingxingService {
-
-    //获取订单信息
-    void getSellerOrders(String appId);
-}

src/main/java/com/uas/eis/service/MESService.java

@@ -1,85 +0,0 @@
-package com.uas.eis.service;
-
-import com.uas.eis.sdk.entity.ApiResult;
-
-import javax.servlet.http.HttpServletRequest;
-
-/**
- * @author koul
- * @email koul@usoftchina.com
- * @date 2021-12-07 15:38
- */
-public interface MESService {
-
-    /**
-     * 获取ERP收料单
-     * @param
-     * @return
-     */
-    ApiResult<String> checkVerifyApply(HttpServletRequest request);
-
-    /**
-     * 确认入库
-     * @param
-     * @return
-     */
-    ApiResult<String> purcCheckin(HttpServletRequest request);
-
-    /**
-     * 成品半成品入库
-     * @return
-     */
-    ApiResult<String> prodInOutMakeIn(HttpServletRequest request);
-
-    /**
-     * 工单删除校验接口
-     * @param
-     * @return
-     */
-    ApiResult<String> makeDeleteCheck(HttpServletRequest request);
-
-    /**
-     * 报废单
-     * @param
-     * @return
-     */
-    ApiResult<String> initMakeScrap(HttpServletRequest request);
-
-    /**
-     * 原材料出库
-     * @return
-     */
-    ApiResult<String> prodInOutOtherOut(HttpServletRequest request);
-
-    /**
-     * 生产领料
-     * @return
-     */
-    ApiResult<String> prodInOutPicking(HttpServletRequest request);
-
-    /**
-     * 生产退料
-     * @return
-     */
-    ApiResult<String> prodInOutMakeReturn(HttpServletRequest request);
-
-    /**
-     * 库存转移
-     * @return
-     */
-    ApiResult<String> prodInOutAppropriationOut(HttpServletRequest request);
-
-    /**
-     * 制造单发料校验
-     * @param request
-     * @return
-     */
-    ApiResult<String> makeCheckOutStock(HttpServletRequest request);
-
-    /**
-     * 制造单ECN和ECN变更校验
-     * @param request
-     * @return
-     */
-    ApiResult<String> makeECNCheck(HttpServletRequest request);
-}

src/main/java/com/uas/eis/service/ProdInOutService.java

@@ -1,38 +0,0 @@
-package com.uas.eis.service;
-
-import com.uas.eis.dao.BaseDao;
-import com.uas.eis.entity.ProdIODetail;
-import com.uas.eis.entity.ProdInOut;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.dao.EmptyResultDataAccessException;
-import org.springframework.jdbc.core.BeanPropertyRowMapper;
-import org.springframework.stereotype.Service;
-import java.util.List;
-
-/**
- * @author: zhouy
- * @date: 2021/9/26 10:58
- * @desc: 出入库单据业务
- */
-@Service
-public class ProdInOutService{
-
-    @Autowired
-    private BaseDao baseDao;
-
-    public ProdInOut findById(Integer id) {
-        try {
-            ProdInOut prodInOut = baseDao.getJdbcTemplate().queryForObject("SELECT * FROM PRODINOUT WHERE PI_ID=?", new BeanPropertyRowMapper<ProdInOut>(ProdInOut.class), id);
-            List<ProdIODetail> prodIODetails = baseDao.getJdbcTemplate().query("SELECT * FROM PRODIODETAIL WHERE PD_PIID=? ORDER BY PD_PDNO ASC ", new BeanPropertyRowMapper<ProdIODetail>(ProdIODetail.class), prodInOut.getPi_id());
-            prodInOut.setDetailList(prodIODetails);
-            return prodInOut;
-        } catch (EmptyResultDataAccessException e) {
-            e.printStackTrace();
-            return null;
-        } catch (Exception e) {
-            e.printStackTrace();
-            return null;
-        }
-    }
-
-}

src/main/java/com/uas/eis/service/QueryService.java

@@ -1,20 +0,0 @@
-package com.uas.eis.service;
-
-
-import com.alibaba.fastjson.JSONArray;
-
-public interface QueryService {
-
-	public abstract String login(String username, String password);
-	
-	public abstract boolean checkUser(String username, String password);
-	
-	public abstract boolean checkAction(String username, String action);
-	
-	public Object query(String code, String param);
-	
-	public Object doAction(String code, String param);
-
-	public String queryProduct(String data);
-
-}

src/main/java/com/uas/eis/utils/HttpUtil.java

@@ -255,21 +255,6 @@ public class HttpUtil {
         return Response.getResponse(response);
     }
 
-	public static Response doPost(String postUrl, String formData,String deipaaskeyauth,String deipaasjwt) throws Exception {
-		CloseableHttpClient httpClient = HttpClients.createDefault();
-		HttpPost post = new HttpPost(postUrl);
-		StringEntity postingString = new StringEntity(formData, HTTP.UTF_8);
-		post.setEntity(postingString);
-		// 设置 Authorization 头为 NoAuth
-		post.setHeader("Authorization", "NoAuth");
-		post.setHeader("deipaaskeyauth",deipaaskeyauth);
-		post.setHeader("Content-type", "application/json");
-		if(StringUtil.hasText(deipaasjwt)){
-			post.setHeader("deipaasjwt", deipaasjwt);
-		}
-		CloseableHttpResponse response = httpClient.execute(post);
-		return Response.getResponse(response);
-	}
 	public static Response doPost(String postUrl, String formData,  boolean sign, String signKey, int timeout) throws Exception {
 		URL url = new URL(postUrl);
 		HttpURLConnection urlConn = (HttpURLConnection) url.openConnection();