package com.steering.pss.sale.order;

import CoreFS.SA06.CoreReturnObject;
import CoreFS.SA08.CoreXmlSqlParsersFactory;
import CoreFS.SC01.CoreConstantData;
import CoreFS.Util.StringUtils;
import com.steering.comm.db.DBCommon;
import com.steering.comm.tools.EntityTool;
import com.steering.comm.tools.SqlBuilder;
import com.steering.pss.plan.order.model.SlmOrderHeadCopy;
import com.steering.pss.sale.order.model.CoreOrderStatus;
import com.steering.pss.sale.order.model.CrmSlmOrder;
import com.steering.pss.sale.order.model.SlmOrderLineNewEntity;
import com.steering.pss.sale.order.model.SlmOrderReviewItemListEntity;
import com.steering.pss.sale.order.orderchange.entity.ChgeSlmOrderLineEntity;
import com.steering.pss.sale.order.qualityDesign.QualityDesignMain;
import net.sf.json.JSONObject;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 合同信息维护 含状态判断
 * @author WHB 2015-6-9
 */
public class CoreOrderInfoUpdate extends DBCommon {

    @SuppressWarnings("serial")
    ArrayList<String> lineStatus = new ArrayList<String>() {
        {// 这些状态下合同行不允许新增，修改，删除。
            add("12020212"); // 交货期评审通过
            add("12020220"); // 待审批
            add("12020221"); // 主管审批退回
            add("12020222"); // 主管审批通过
            add("12020223"); // 经理审批退回
            add("12020224"); // 经理审批通过
            add("12020231"); // 价格评审失败
            add("12020232"); // 价格评审通过
            add("12020241"); // 法务评审失败
            add("12020242"); // 法务评审通过
            add("12020251"); // 评审通过
            add("12020301"); // 生效
        }
    };

    HashMap<String, String> map = null;

    /**
     * 是否可以修改合同头信息，true修改信息和状态。
     * @param con
     * @param ordPk
     * @return
     * @throws SQLException
     */

    public CoreReturnObject modifyHeadAndSatus(String ordPk,
            ArrayList<Object> parm, String name, String dept) {
        CoreReturnObject cro = new CoreReturnObject();
        Connection con = null;
        try {
            con = this.getDao(CoreConstantData.sysbeanstr).getConnection();
            con.setAutoCommit(false);
            if(parm.get(7).equals("120501")){
            	if(!"0".equals(getTgDeliveryCount(con,ordPk))){
            		cro.setResult("交货地点与制造商不对应，无法修改！");
                cro.setV_errCode(-1);
                return cro;
            	}
            }else if(parm.get(7).equals("120504")){
            	if(!"0".equals(getThDeliveryCount(con,ordPk))){
            		cro.setResult("交货地点与制造商不对应，无法修改！");
                cro.setV_errCode(-1);
                return cro;
            	}
            }
            CoreOrderStatus cos = getOrderStatus(con, ordPk);
            if (cos == null) {
                cro.setResult("该合同没有状态！");
                cro.setV_errCode(-1);
                return cro;
            }
            // 这些状态合同头都为录入，且可以修改，其他不管
            // 录入 待提报评审待技术评审 技术评审通过 技术评审失败 待交货期评审 交货期评审失败 交货期评审通过 38，39
            if (cos.getList().contains(cos.getOrderSts())
                    && !cos.getOrderSts().equals("12020211")) {
                // 可以修改
                parm.set(36, "12020101");
                parm.set(37, "录入");
                updateOrderHead(con, parm, ordPk);
                //同步修改crm表
//                doCrmEvent(con, ordPk,"","","1");

                con.commit();
                cro.setV_errCode(0);

            }
            else if (cos.getOrderSts().equals("12020211")) { // 交货期评审失败
                                                             // （2015-07-13新增逻辑）
                parm.set(36, "12020101");
                parm.set(37, "录入");
                updateOrderHead(con, parm, ordPk);
                // 评审明细记录 封锁价格 法务。若存在
                String reviewNo = getOrderReviewNo(con, ordPk);
                String obj = dept + "-" + name
                        + "在[合同信息维护]界面,合同状态为[交货期评审失败]时，点击修改合同头信息。";
                updateOrderReviewItem(con, reviewNo, "P", "L");
                CoreOrderStatusCommFun.updateOrderReviewItemList(con, reviewNo,
                        "P", "H", ordPk, obj);
                CoreOrderStatusCommFun.insertOrderReviewItemList(con, reviewNo,
                        "P", "H", ordPk, "L", name, dept, obj);

                updateOrderReviewItem(con, reviewNo, "F", "L");
                CoreOrderStatusCommFun.updateOrderReviewItemList(con, reviewNo,
                        "F", "H", ordPk, obj);
                CoreOrderStatusCommFun.insertOrderReviewItemList(con, reviewNo,
                        "F", "H", ordPk, "L", name, dept, obj);
                //同步修改crm表
//                doCrmEvent(con, ordPk,"","","1");
                con.commit();
                cro.setV_errCode(0);
            }
            // 待审批 不允许修改
            else if (cos.getOrderSts().equals("12020220")) {
                cro.setResult("该合同处于'待审批'状态，不允许修改！");
                cro.setV_errCode(-1);
            }
            else if (cos.getOrderSts().equals("12020221")) { // 审批退回（业务主管）
                parm.set(36, "12020101");
                parm.set(37, "录入");
                updateOrderHead(con, parm, ordPk);
                updateOrderLineStatus(con, ordPk, "12020212"); // 交货期评审通过
                updateOrderDeliveryLineStatus(con, ordPk, "12020212");
                //同步修改crm表
//                doCrmEvent(con, ordPk,"","","1");
                con.commit();
                cro.setV_errCode(0);
            }
            else if (cos.getOrderSts().equals("12020222")) { // 审批通过（业务主管）
                cro.setResult("该合同处于'主管审批通过'状态，不允许修改！");
                cro.setV_errCode(-1);
            }
            else if (cos.getOrderSts().equals("12020223")) { // 审批退回（主管经理）
                parm.set(36, "12020101");
                parm.set(37, "录入");
                updateOrderHead(con, parm, ordPk);
                updateOrderLineStatus(con, ordPk, "12020212"); // 交货期评审通过
                updateOrderDeliveryLineStatus(con, ordPk, "12020212");
                //同步修改crm表
//                doCrmEvent(con, ordPk,"","","1");
                con.commit();
                cro.setV_errCode(0);
            }
            else if (cos.getOrderSts().equals("12020224")) { // 审批通过（主管经理）
                cro.setResult("该合同处于'主管经理审批通过'状态，不允许修改！");
                cro.setV_errCode(-1);
            }
            else if (cos.getOrderSts().equals("12020231")) { // 价格评审失败
                parm.set(36, "12020101");
                parm.set(37, "录入");
                updateOrderHead(con, parm, ordPk);
                updateOrderLineStatus(con, ordPk, "12020212"); // 交货期评审通过
                updateOrderDeliveryLineStatus(con, ordPk, "12020212");
                // 评审明细表
                String reviewNo = getOrderReviewNo(con, ordPk);
                updateOrderReviewItem(con, reviewNo, "P", "L");
                // updateOrderReviewItemList(con, reviewNo, "P", "H", ordPk);
                String obj = dept + "-" + name
                        + "在[合同信息维护]界面,合同状态为[价格评审失败]时，点击修改合同头信息。";
                CoreOrderStatusCommFun.updateOrderReviewItemList(con, reviewNo,
                        "P", "H", ordPk, obj);
                // insertOrderReviewItemList(con, reviewNo, "P", "H", ordPk,
                // "L",
                // name, "");
                CoreOrderStatusCommFun.insertOrderReviewItemList(con, reviewNo,
                        "P", "H", ordPk, "L", name, dept, obj);
                // 2015-07-13 add 封锁后面的状态
                updateOrderReviewItem(con, reviewNo, "F", "L");
                CoreOrderStatusCommFun.updateOrderReviewItemList(con, reviewNo,
                        "F", "H", ordPk, obj);
                CoreOrderStatusCommFun.insertOrderReviewItemList(con, reviewNo,
                        "F", "H", ordPk, "L", name, dept, obj);
                //同步修改crm表
//                doCrmEvent(con, ordPk,"","","1");
                con.commit();
                cro.setV_errCode(0);
            }
            else if (cos.getOrderSts().equals("12020232")) { // 价格评审通过
                cro.setResult("该合同处于'价格评审通过'状态，不允许修改！");
                cro.setV_errCode(-1);
            }
            else if (cos.getOrderSts().equals("12020241")) { // 法务评审失败
                parm.set(36, "12020101");
                parm.set(37, "录入");
                updateOrderHead(con, parm, ordPk);
                updateOrderLineStatus(con, ordPk, "12020212"); // 交货期评审通过
                updateOrderDeliveryLineStatus(con, ordPk, "12020212");
                // 评审明细表
                String reviewNo = getOrderReviewNo(con, ordPk);
                String obj = dept + "-" + name
                        + "在[合同信息维护]界面,合同状态为[法务评审失败]时，点击修改合同头信息。";
                updateOrderReviewItem(con, reviewNo, "P", "L");
                // updateOrderReviewItemList(con, reviewNo, "P", "H", ordPk);
                CoreOrderStatusCommFun.updateOrderReviewItemList(con, reviewNo,
                        "P", "H", ordPk, obj);
                // insertOrderReviewItemList(con, reviewNo, "P", "H", ordPk,
                // "L",
                // name, "");
                CoreOrderStatusCommFun.insertOrderReviewItemList(con, reviewNo,
                        "P", "H", ordPk, "L", name, dept, obj);

                updateOrderReviewItem(con, reviewNo, "F", "L");
                // updateOrderReviewItemList(con, reviewNo, "F", "H", ordPk);
                CoreOrderStatusCommFun.updateOrderReviewItemList(con, reviewNo,
                        "F", "H", ordPk, obj);
                // insertOrderReviewItemList(con, reviewNo, "F", "H", ordPk,
                // "L",
                // name, "");
                CoreOrderStatusCommFun.insertOrderReviewItemList(con, reviewNo,
                        "F", "H", ordPk, "L", name, dept, obj);
                //同步修改crm表
//                doCrmEvent(con, ordPk,"","","1");
                con.commit();
                cro.setV_errCode(0);
            }
            else if (cos.getOrderSts().equals("12020242")) { // 法务评审通过
                cro.setResult("该合同处于'法务评审通过'状态，不允许修改！");
                cro.setV_errCode(-1);
            }
            else if (cos.getOrderSts().equals("12020251")) { // 评审通过
                cro.setResult("该合同处于'评审通过'状态，不允许修改！");
                cro.setV_errCode(-1);
            }
            else if (cos.getOrderSts().equals("12020301")) {// 生效
                cro.setResult("该合同已经生效，不允许修改！");
                cro.setV_errCode(-1);
            }
            else {
                cro.setResult("该合同已处于生效之后的状态，不允许修改！");
                cro.setV_errCode(-1);
            }
        }
        catch (Exception e) {
            try {
                con.rollback();
                cro.setV_errCode(-1);
                cro.setResult(e.getMessage());
            }
            catch (SQLException e1) {
                e1.printStackTrace();
            }

            try {
                con.close();
            }
            catch (SQLException e1) {
                e1.printStackTrace();
            }
        }
        finally {
            try {
                if (con != null && !con.isClosed()) {
                    con.close();
                }
            }
            catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return cro;
    }

    /**
     * 根据状态判断是否可以新增合同行。
     * @param ordPk
     * @param parm
     * @return
     * @throws SQLException
     */
    public CoreReturnObject addOrderLine(String ordPk, ArrayList<Object> parm,
            String name, String dept, String saleOrg) {
        CoreReturnObject cro = new CoreReturnObject();
        Connection con = null;
        try {
            con = this.getDao(CoreConstantData.sysbeanstr).getConnection();
            con.setAutoCommit(false);
            map = getOrderStatus(con);
            CoreOrderStatus cos = getOrderStatus(con, ordPk); // 合同状态
            if (cos.getOrderSts().equals("12020101")) { // 录入
                String reviewNo = getOrderReviewNo(con, ordPk);
                // addOrderLineAndStatus(con, parm);
                String ordLnPk = getAddLineOrdLnPk(con, ordPk);
                addOrderLineAndStatus(con, ordLnPk, parm);
                String ordType = CoreOrderStatusCommFun
                        .getOrderType(con, ordPk);
                if (!reviewNo.equals("") && !ordType.equals("120102")) { // 不是现货合同
                    String obj = dept + "-" + name
                            + "在[合同信息维护]界面，合同状态[录入]时，新增合同行。";
                    updateOrderReviewItem(con, reviewNo, "T", "L");
                    CoreOrderStatusCommFun.insertOrderReviewItemList(con,
                            reviewNo, "T", "L", ordLnPk, "L", name, dept, obj);
                }
                CoreOrderStatusCommFun.clearOrderPriceStatus(con, ordPk);

                cro.setV_errCode(0);
                // 添加crm
                doCrmEvent(con, "",ordLnPk,"","0");
                con.commit();
            }
            else if (cos.getOrderSts().equals("12020102")) { // 待提报评审
                String ordLnPk = getAddLineOrdLnPk(con, ordPk);
                updateOrderHeadStatus(con, ordPk, "12020102", "12020101", "录入");
                updateOrderLineStatus(con, ordPk, "12020102", "12020101");
                updateOrderDeliveryLineStatus(con, ordPk, "12020102",
                        "12020101");
                addOrderLineAndStatus(con, parm);
                CoreOrderStatusCommFun.clearOrderPriceStatus(con, ordPk);
                // 添加crm
                doCrmEvent(con, "",ordLnPk,"","0");
                con.commit();
                cro.setV_errCode(0);
            }
            else if (cos.getOrderSts().equals("12020201")) {// 待技术评审

                cro.setV_errCode(-1);
                cro.setResult("合同头处于‘技术评审中’状态，不能新增合同行！");
            }
            else if (cos.getOrderSts().equals("12020202")) { // 技术评审通过
                updateOrderHeadStatus(con, ordPk, "12020202", "12020101", "录入");
                // addOrderLineAndStatus(con, parm);
                // 评审明细
                String reviewNo = getOrderReviewNo(con, ordPk);
                String ordLnPk = getAddLineOrdLnPk(con, ordPk);
                addOrderLineAndStatus(con, ordLnPk, parm);
                String obj = dept + "-" + name
                        + "在[合同信息维护]界面，合同状态[技术评审通过]时，新增合同行。";
                updateOrderReviewItem(con, reviewNo, "T", "L");
                // insertOrderReviewItemList(con, reviewNo, "T", "L", ordLnPk,
                // "L", name, "");
                CoreOrderStatusCommFun.insertOrderReviewItemList(con, reviewNo,
                        "T", "L", ordLnPk, "L", name, dept, obj);
                CoreOrderStatusCommFun.clearOrderPriceStatus(con, ordPk);
                // 添加crm
                doCrmEvent(con, "",ordLnPk,"","0");
                con.commit();
                cro.setV_errCode(0);
            }
            else if (cos.getOrderSts().equals("12020203")) {// 技术评审失败
                updateOrderHeadStatus(con, ordPk, "12020203", "12020101", "录入");
                // addOrderLineAndStatus(con, parm);
                // 评审明细
                String reviewNo = getOrderReviewNo(con, ordPk);
                String ordLnPk = getAddLineOrdLnPk(con, ordPk); // 这个很有可能存在同步数据的BUG
                                                                // (需要更改客户端代码)
                addOrderLineAndStatus(con, ordLnPk, parm);
                String obj = dept + "-" + name
                        + "在[合同信息维护]界面，合同状态[技术评审失败]时，新增合同行。";
                // insertOrderReviewItemList(con, reviewNo, "T", "L", ordLnPk,
                // "L", name, "");
                CoreOrderStatusCommFun.insertOrderReviewItemList(con, reviewNo,
                        "T", "L", ordLnPk, "L", name, dept, obj);
                // updateOrderReviewItem(con, reviewNo, "T", "L");
                CoreOrderStatusCommFun.clearOrderPriceStatus(con, ordPk);
                // 添加crm
                doCrmEvent(con, "",ordLnPk,"","0");
                con.commit();
                cro.setV_errCode(0);

            }
            else if (cos.getOrderSts().equals("12020210")) { // 待交货期评审
                cro.setV_errCode(-1);
                cro.setResult("合同头处于‘待交货期评审’状态，不能新增合同行！");
            }
            else if (cos.getOrderSts().equals("12020211")) { // 交货期评审失败
                updateOrderHeadStatus(con, ordPk, "12020211", "12020101", "录入");
                updateOrderLineOnlyStatus(con, ordPk, "12020202");
                updateOrderDeliveryLineStatus(con, ordPk, "12020202",
                        "12020202");
                // 评审明细
                String reviewNo = getOrderReviewNo(con, ordPk);
                String ordLnPk = getAddLineOrdLnPk(con, ordPk);

                String obj = dept + "-" + name
                        + "在[合同信息维护]界面，合同状态[交货期评审失败]时，新增合同行。";
                // insertOrderReviewItemList(con, reviewNo, "T", "L", ordLnPk,
                // "L", name, "");
                CoreOrderStatusCommFun.insertOrderReviewItemList(con, reviewNo,
                        "T", "L", ordLnPk, "L", name, dept, obj);
                updateOrderReviewItem(con, reviewNo, "T", "L");
                // List<String> list = getOrderDeliveryLinePK(con, ordPk);
                // for (int i = 0; i < list.size(); i++) {
                // updateOrderReviewItemList(con, reviewNo, "D", "D",
                // list.get(i));

                // }
                CoreOrderStatusCommFun.updateOrderReviewItemList(con, reviewNo,
                        "D", "H", ordPk, obj);

                // for (int i = 0; i < list.size(); i++) {
                // insertOrderReviewItemList(con, reviewNo, "D", "D",
                // list.get(i), "L", name, "");
                // }
                CoreOrderStatusCommFun.insertOrderReviewItemList(con, reviewNo,
                        "D", "H", ordPk, "L", name, dept, obj);
                updateOrderReviewItem(con, reviewNo, "D", "L");
                addOrderLineAndStatus(con, ordLnPk, parm);

                // 2015-07-13 add 封锁后面的状态 07-24 国贸没有价格 法务
                if (!saleOrg.equals("100102")) {
                    updateOrderReviewItem(con, reviewNo, "P", "L");
                    CoreOrderStatusCommFun.updateOrderReviewItemList(con,
                            reviewNo, "P", "H", ordPk, obj);
                    CoreOrderStatusCommFun.insertOrderReviewItemList(con,
                            reviewNo, "P", "H", ordPk, "L", name, dept, obj);

                    updateOrderReviewItem(con, reviewNo, "F", "L");
                    CoreOrderStatusCommFun.updateOrderReviewItemList(con,
                            reviewNo, "F", "H", ordPk, obj);
                    CoreOrderStatusCommFun.insertOrderReviewItemList(con,
                            reviewNo, "F", "H", ordPk, "L", name, dept, obj);
                }
                CoreOrderStatusCommFun.clearOrderPriceStatus(con, ordPk);
                // 添加crm
                doCrmEvent(con, "",ordLnPk,"","0");
                con.commit();
                cro.setV_errCode(0);
                // addOrderLineAndStatus(con, parm);
            }
            else if (lineStatus.contains(cos.getOrderSts())) {
                cro.setV_errCode(-1);
                cro.setResult("当前合同处于‘" + map.get(cos.getOrderSts())
                        + "’状态,不允许新增合同行！");
            }
        }
        catch (Exception e) {
            try {
                con.rollback();
                cro.setV_errCode(-1);
                cro.setResult(e.getMessage());
            }
            catch (SQLException e1) {
                e1.printStackTrace();
            }
        }
        finally {
            try {
                if (con != null && !con.isClosed()) {
                    con.close();
                }
            }
            catch (SQLException e) {
                e.printStackTrace();
            }
        }

        return cro;
    }

    /**
     * 根据合同的状态判断是否可以修改合同行。
     * @param ordPk
     * @param ordLnPk
     * @param parm
     * @param flag 是否涉及到技术项的修改。
     * @param reviewMemo 用于技术评审失败时 输入提交评审的原因
     * @return
     * @throws SQLException
     */
    public CoreReturnObject modifyOrderLineAndStatus(String ordPk,
            String ordLnPk, ArrayList<Object> parm, Boolean flag, String name,
            String dept, String reviewMemo, String saleOrg, Boolean isClear) {
        CoreReturnObject cro = new CoreReturnObject();
        Connection con = null;
        try {
            con = this.getDao(CoreConstantData.sysbeanstr).getConnection();
            con.setAutoCommit(false);
            map = getOrderStatus(con);
            CoreOrderStatus cos = getOrderStatus(con, ordPk); // 合同头状态
            CoreOrderStatus cosLine = getOrderLineStatus(con, ordLnPk); // 合同行状态

            if (cosLine.getOrderLnStatus().equals("12020101")) { // 合同行 录入状态
                String reviewNo = getOrderReviewNo(con, ordPk);
                if (isClear) {
                    clearOrderLineCustAlpha(con, ordLnPk);
                }
                if (!reviewNo.equals("")) {
                    if (flag) { // 存在评审单号 同时修改了技术项
                        String obj = dept + "-" + name
                                + "在[合同信息维护]界面，合同状态[录入]时，修改合同行信息。";

                        CoreOrderStatusCommFun.updateOrderReviewItemList(con,
                                reviewNo, "T", "L", ordLnPk, obj);
                        updateOrderReviewItem(con, reviewNo, "T", "L");
                        CoreOrderStatusCommFun.insertOrderReviewItemList(con,
                                reviewNo, "T", "L", ordLnPk, "L", name, dept,
                                obj);
                        // 清除合同行的监制信息
                        String[] arr = CoreOrderStatusCommFun
                                .getOrderLinePrdcrNo(con, ordLnPk);
                        CoreOrderStatusCommFun.clearOrderLinePrdcrNo(con,
                                ordLnPk);
                        if (arr != null && arr.length > 0) {
                            CoreOrderStatusCommFun.deleteOrderLinePrdcrList(
                                    con, arr);
                        }
                    }
                }
                updateOrderLineInfo(con, parm);
                updateOneOrderLineStatus(con, ordLnPk, "12020101", "12020101");
                updateOrderDeliveryLineStatusWithOrdLnPk(con, ordLnPk,
                        "12020101", "12020101");
                //同步修改crm表
//                doCrmEvent(con, "",ordLnPk,"","1");

                con.commit();
                cro.setV_errCode(0);
            }
            else if (cosLine.getOrderLnStatus().equals("12020102")) { // 待提报评审
                updateOrderLineInfo(con, parm);
                updateOrderHeadStatus(con, ordPk, "12020102", "12020101", "录入");
                updateOneOrderLineStatus(con, ordLnPk, "12020102", "12020101");
                updateOrderDeliveryLineStatusWithOrdLnPk(con, ordLnPk,
                        "12020102", "12020101");
                //同步修改crm表
//                doCrmEvent(con, "",ordLnPk,"","1");
                con.commit();
                cro.setV_errCode(0);
            }
            else if (cosLine.getOrderLnStatus().equals("12020201")) { // 待技术评审

                cro.setV_errCode(-1);
                cro.setResult("合同行处于‘技术评审中’状态，不允许修改！");
            }
            else if (cosLine.getOrderLnStatus().equals("12020202")) { // 技术评审通过
                updateOrderLineInfo(con, parm);
                updateOrderHeadStatus(con, ordPk, "12020202", "12020101", "录入");
                updateOneOrderLineStatus(con, ordLnPk, "12020202", "12020101");
                updateOrderDeliveryLineStatusWithOrdLnPk(con, ordLnPk,
                        "12020202", "12020101");
                if (isClear) {
                    clearOrderLineCustAlpha(con, ordLnPk);
                }
                if (flag) { // 涉及到技术项的修改。
                    String reviewNo = getOrderReviewNo(con, ordPk);
                    String obj = dept + "-" + name
                            + "在[合同信息维护]界面，合同状态[技术评审通过]时，修改合同行信息。";
                    // updateOrderReviewItemList(con, reviewNo, "T", "L",
                    // ordLnPk);
                    CoreOrderStatusCommFun.updateOrderReviewItemList(con,
                            reviewNo, "T", "L", ordLnPk, obj);
                    updateOrderReviewItem(con, reviewNo, "T", "L");
                    // insertOrderReviewItemList(con, reviewNo, "T", "L",
                    // ordLnPk,
                    // "L", name, "");
                    CoreOrderStatusCommFun.insertOrderReviewItemList(con,
                            reviewNo, "T", "L", ordLnPk, "L", name, dept, obj);

                    // 清除合同行的监制信息
                    String[] arr = CoreOrderStatusCommFun.getOrderLinePrdcrNo(
                            con, ordLnPk);
                    CoreOrderStatusCommFun.clearOrderLinePrdcrNo(con, ordLnPk);
                    if (arr != null && arr.length > 0) {
                        CoreOrderStatusCommFun.deleteOrderLinePrdcrList(con,
                                arr);
                    }
                }
                //同步修改crm表
//                doCrmEvent(con, "",ordLnPk,"","1");
                con.commit();
                cro.setV_errCode(0);
            }
            else if (cosLine.getOrderLnStatus().equals("12020203")) { // 技术评审失败
                updateOrderLineInfo(con, parm);
                updateOrderHeadStatus(con, ordPk, "12020203", "12020101", "录入");
                updateOneOrderLineStatus(con, ordLnPk, "12020203", "12020101");
                updateOrderDeliveryLineStatusWithOrdLnPk(con, ordLnPk,
                        "12020203", "12020101");
                // 涉及到技术项的修改。
                String reviewNo = getOrderReviewNo(con, ordPk);
                String obj = dept + "-" + name
                        + "在[合同信息维护]界面，合同状态[技术评审失败]时，修改合同行信息。";
                CoreOrderStatusCommFun.updateOrderReviewItemList(con, reviewNo,
                        "T", "L", ordLnPk, obj);
                updateOrderReviewItem(con, reviewNo, "T", "L");
                CoreOrderStatusCommFun.updateOrderReviewItemList(con, reviewNo,
                        "T", "L", ordLnPk, obj);
                CoreOrderStatusCommFun.insertOrderReviewItemList(con, reviewNo,
                        "T", "L", ordLnPk, "L", name, dept, obj, reviewMemo);

                // 清除合同行的监制信息
                String[] arr = CoreOrderStatusCommFun.getOrderLinePrdcrNo(con,
                        ordLnPk);
                CoreOrderStatusCommFun.clearOrderLinePrdcrNo(con, ordLnPk);
                if (arr != null && arr.length > 0) {
                    CoreOrderStatusCommFun.deleteOrderLinePrdcrList(con, arr);
                }
                if (isClear) {
                    clearOrderLineCustAlpha(con, ordLnPk);
                }
                //同步修改crm表
//                doCrmEvent(con, "",ordLnPk,"","1");
                con.commit();
                cro.setV_errCode(0);
            }
            else if (cosLine.getOrderLnStatus().equals("12020210")) {// 待交货期评审
                cro.setV_errCode(-1);
                cro.setResult("合同行处于‘待交货期评审’状态，不允许修改！");
            }
            else if (cosLine.getOrderLnStatus().equals("12020211")) { // 交货期评审失败
                updateOrderLineInfo(con, parm);
                updateOrderHeadStatus(con, ordPk, "12020211", "12020101", "录入");
                updateOneOrderLineStatus(con, ordLnPk, "12020211", "12020101");
                updateOrderDeliveryLineStatusWithOrdLnPk(con, ordLnPk,
                        "12020211", "12020101");

                String reviewNo = getOrderReviewNo(con, ordPk);
                String obj = dept + "-" + name
                        + "在[合同信息维护]界面，合同状态[交货期失败]时，修改合同行信息。";
                CoreOrderStatusCommFun.updateOrderReviewItemList(con, reviewNo,
                        "D", "H", ordPk, obj);
                updateOrderReviewItem(con, reviewNo, "D", "L");
                CoreOrderStatusCommFun.insertOrderReviewItemList(con, reviewNo,
                        "D", "H", ordPk, "L", name, dept, obj);
                if (isClear) {
                    clearOrderLineCustAlpha(con, ordLnPk);
                }
                // 2015-07-13新增处理逻辑 7-24 国贸 没有价格 法务
                if (!saleOrg.equals("100102")) { // 不等于国贸公司
                    updateOrderReviewItem(con, reviewNo, "P", "L");
                    CoreOrderStatusCommFun.updateOrderReviewItemList(con,
                            reviewNo, "P", "H", ordPk, obj);
                    // CoreOrderStatusCommFun.updateOrderReviewItem
                    CoreOrderStatusCommFun.insertOrderReviewItemList(con,
                            reviewNo, "P", "H", ordPk, "L", name, dept, obj);

                    updateOrderReviewItem(con, reviewNo, "F", "L");
                    CoreOrderStatusCommFun.updateOrderReviewItemList(con,
                            reviewNo, "F", "H", ordPk, obj);
                    CoreOrderStatusCommFun.insertOrderReviewItemList(con,
                            reviewNo, "F", "H", ordPk, "L", name, dept, obj);
                }

                if (flag) { // 涉及到技术项的修改。

                    CoreOrderStatusCommFun.updateOrderReviewItemList(con,
                            reviewNo, "T", "L", ordLnPk, obj);
                    updateOrderReviewItem(con, reviewNo, "T", "L");
                    CoreOrderStatusCommFun.insertOrderReviewItemList(con,
                            reviewNo, "T", "L", ordLnPk, "L", name, dept, obj);
                    // 清除合同行的监制信息
                    String[] arr = CoreOrderStatusCommFun.getOrderLinePrdcrNo(
                            con, ordLnPk);
                    CoreOrderStatusCommFun.clearOrderLinePrdcrNo(con, ordLnPk);
                    if (arr != null && arr.length > 0) {
                        CoreOrderStatusCommFun.deleteOrderLinePrdcrList(con,
                                arr);
                    }
                }
                //同步修改crm表
//                doCrmEvent(con, "",ordLnPk,"","1");
                con.commit();
                cro.setV_errCode(0);
            }
            else if (lineStatus.contains(cos.getOrderSts())) {

                cro.setV_errCode(-1);
                cro.setResult("当前合同处于‘" + map.get(cos.getOrderSts())
                        + "’状态,不允许修改合同行！");
            }
        }
        catch (Exception e) {
            try {
                con.rollback();
                cro.setV_errCode(-1);
                cro.setResult(e.getMessage());
            }
            catch (SQLException e1) {
                e1.printStackTrace();
            }
        }
        finally {
            try {
                if (con != null && !con.isClosed()) {
                    con.close();
                }
            }
            catch (SQLException e) {
                e.printStackTrace();
            }
        }

        return cro;

    }

    /**
     * 删除合同行
     * @param ordPk
     * @param ordLnPk
     * @param parm
     * @return
     */
    public CoreReturnObject deleteLine(String ordPk, String ordLnPk,
            ArrayList<Object> parm, String name, String dept, String ordType) {
        CoreReturnObject cro = new CoreReturnObject();
        Connection con = null;
        try {
            con = this.getDao(CoreConstantData.sysbeanstr).getConnection();
            con.setAutoCommit(false);
            String errMsg = deleteOrderLineAndStatus(con, ordPk, ordLnPk, parm,
                    name, dept, ordType);
            if (!errMsg.equals("")) {
                cro.setV_errCode(-1);
                cro.setResult(errMsg);
            }
            else {
                cro.setV_errCode(0);
                con.commit();
            }
        }
        catch (Exception e) {
            try {
                con.rollback();
                cro.setV_errCode(-1);
                cro.setResult(e.getMessage());
            }
            catch (SQLException e1) {
                e1.printStackTrace();
            }
        }
        finally {
            try {
                if (con != null && !con.isClosed()) {
                    con.close();
                }
            }
            catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return cro;
    }

    /**
     * 根据合同的状态判断是否删除合同行。
     * @param ordPk
     * @param ordLnPk
     * @param parm
     * @return
     */
    public String deleteOrderLineAndStatus(Connection con, String ordPk,
            String ordLnPk, ArrayList<Object> parm, String name, String dept,
            String ordType) throws SQLException {

        String cro = "";
        map = getOrderStatus(con);
        CoreOrderStatus cos = getOrderStatus(con, ordPk); // 合同头状态
        CoreOrderStatus cosLine = getOrderLineStatus(con, ordLnPk); // 合同行状态
        if (cos == null || cosLine == null) {
            cro = "合同行出现异常，废除合同行失败！";
            return cro;
        }
        String reviewNo = getOrderReviewNo(con, ordPk);
        if (cosLine.getOrderLnStatus().equals("12020101")) {// 录入
        	doCrmEvent(con, "",parm.get(1).toString(),"","2");
            deleteOrderLine(con, parm);
            updateOrderDeliveryValidFlag(con, ordLnPk, "0", "1");
            String obj = dept + "-" + name + "在[合同信息维护]界面，合同状态[录入]时，删除合同行。";
            CoreOrderStatusCommFun.updateOrderReviewItemList(con, reviewNo,
                    "L", ordLnPk, name, dept, obj);
            if (ordType.equals("120102")) { // 现货合同
                takeOff(con, ordLnPk);
            }
            if (ordType.equals("120105") || ordType.equals("120106")) {
                deletePurchaseLine(con, ordLnPk);
            }

        }
        else if (cosLine.getOrderLnStatus().equals("12020102")) { // 待提报评审
            //updateOrderHeadStatus(con, ordPk, "12020102", "12020101", "录入");
        	doCrmEvent(con, "",parm.get(1).toString(),"","2");
            updateOneOrderLineStatus(con, ordLnPk, "12020102", "0", "1");
            updateOrderDeliveryValidFlag(con, ordLnPk, "0", "1");
            deleteOrderLine(con, parm);
            if (ordType.equals("120102")) { // 现货合同
                takeOff(con, ordLnPk);
            }
            if (ordType.equals("120105") || ordType.equals("120106")) {
                deletePurchaseLine(con, ordLnPk);
            }
        }
        else if (cosLine.getOrderLnStatus().equals("12020201")) {// 待技术评审
            cro = "当前合同行处于‘技术评审中’，不允许废除合同行！";
        }
        else if (cosLine.getOrderLnStatus().equals("12020202")) { // 技术评审通过
            //updateOrderHeadStatus(con, ordPk, "12020202", "12020101", "录入");
        	doCrmEvent(con, "",parm.get(1).toString(),"","2");
            updateOneOrderLineStatus(con, ordLnPk, "12020202", "0", "1");
            updateOrderDeliveryValidFlag(con, ordLnPk, "12020202", "0", "1");
            deleteOrderLine(con, parm);
            // 评审明细
            String obj = dept + "-" + name + "在[合同信息维护]界面，合同状态[技术评审通过]时，删除合同行。";
            CoreOrderStatusCommFun.updateOrderReviewItemList(con, reviewNo,
                    "L", ordLnPk, name, dept, obj);
        }
        else if (cosLine.getOrderLnStatus().equals("12020203")) { // 技术评审失败
        	doCrmEvent(con, "",parm.get(1).toString(),"","2");
            deleteOrderLine(con, parm);
            //updateOrderHeadStatus(con, ordPk, "12020203", "12020101", "录入");
            updateOneOrderLineStatus(con, ordLnPk, "12020203", "0", "1");
            updateOrderDeliveryValidFlag(con, ordLnPk, "12020203", "0", "1");
            // 评审明细
            String obj = dept + "-" + name + "在[合同信息维护]界面，合同状态[技术评审失败]时，删除合同行。";
            CoreOrderStatusCommFun.updateOrderReviewItemList(con, reviewNo,
                    "L", ordLnPk, name, dept, obj);
            List<String> list = getOrderReviewStatus(con, reviewNo);
            if (!list.contains("L") && !list.contains("W")
                    && !list.contains("D") && !list.contains("F")) {
                updateOrderReviewItem(con, reviewNo, "T", "S");
            }
            else if (list.contains("F")) {
                updateOrderReviewItem(con, reviewNo, "T", "F");
            }
            else if (list.contains("W")) {
                updateOrderReviewItem(con, reviewNo, "T", "W");
            }
        }
        else if (cosLine.getOrderLnStatus().equals("12020210")) {// 待交货期评审
            cro = "当前合同行处于‘待交货期评审’状态，不允许废除合同行！";
        }
        else if (cosLine.getOrderLnStatus().equals("12020211")) {// 交货期评审失败

            //updateOrderHeadStatus(con, ordPk, "12020211", "12020101", "录入");
        	doCrmEvent(con, "",parm.get(1).toString(),"","2");
            updateOneOrderLineStatus(con, ordLnPk, "12020211", "0", "1");
            updateOrderDeliveryValidFlag(con, ordLnPk, "12020211", "0", "1");
            deleteOrderLine(con, parm);
            // 评审明细
            String obj = dept + "-" + name
                    + "在[合同信息维护]界面，合同状态[交货期评审失败]时，删除合同行。";
            CoreOrderStatusCommFun.updateOrderReviewItemList(con, reviewNo,
                    "L", ordLnPk, name, dept, obj);
            updateOrderReviewItem(con, reviewNo, "D", "L");
            updateOrderReviewItem(con, reviewNo, "P", "L");
            updateOrderReviewItem(con, reviewNo, "F", "L");

            CoreOrderStatusCommFun.updateOrderReviewItemList(con, reviewNo,
                    "D", ordLnPk, name, dept, obj);
            CoreOrderStatusCommFun.updateOrderReviewItemList(con, reviewNo,
                    "P", ordLnPk, name, dept, obj);
            CoreOrderStatusCommFun.updateOrderReviewItemList(con, reviewNo,
                    "F", ordLnPk, name, dept, obj);

            CoreOrderStatusCommFun.insertOrderReviewItemList(con, reviewNo,
                    "D", "H", ordPk, "L", name, dept, obj);
            CoreOrderStatusCommFun.insertOrderReviewItemList(con, reviewNo,
                    "P", "H", ordPk, "L", name, dept, obj);
            CoreOrderStatusCommFun.insertOrderReviewItemList(con, reviewNo,
                    "F", "H", ordPk, "L", name, dept, obj);
        }
        else if (cosLine.getOrderLnStatus().equals("12020212")) { // 交货期评审通过

            cro = "当前合同行处于‘交货期评审通过’状态，不允许废除合同行！";
        }
        else if (cosLine.getOrderLnStatus().equals("12020220")) { // 待审批

            cro = "当前合同行处于‘待审批’状态，不允许废除合同行！";
        }
        else if (cosLine.getOrderLnStatus().equals("12020301")) { // 待审批

            cro = "当前合同行处于‘生效’状态，不允许废除合同行！";
        }
        else if (lineStatus.contains(cos.getOrderSts())) {

            cro = "当前合同处于‘" + map.get(cos.getOrderSts()) + "’状态,不允许废除合同行！";
        }
        return cro;
    }

    /**
     * 合同头的确认
     * @param ordPk
     * @param parm
     * @param name
     * @param saleOrg
     * @return
     */
    public CoreReturnObject doConfirmOrder(String ordPk,
            ArrayList<Object> parm, String name, String saleOrg) {
        CoreReturnObject cro = new CoreReturnObject();
        Connection con = null;
        try {
            con = this.getDao(CoreConstantData.sysbeanstr).getConnection();
            con.setAutoCommit(false);
            String reviewNo = getOrderReviewNo(con, ordPk);
            CoreOrderStatus cos = getOrderStatus(con, ordPk);
            if (!cos.getOrderSts().equals("12020101")) {
                cro.setV_errCode(-1);
                cro.setResult("非‘录入’状态的合同，不能进行确认！");
            }
            else if (cos.getOrderSts().equals("12020101")) {
                String stsF = getOrderReviewItemSatus(con, reviewNo, "F");
                String stsP = getOrderReviewItemSatus(con, reviewNo, "P");
                String stsD = getOrderReviewItemSatus(con, reviewNo, "D");
                String stsT = getOrderReviewItemSatus(con, reviewNo, "T");
                String ComputerInfo = "";
                if(parm.size()>5) ComputerInfo = String.valueOf(parm.get(5));


                confirmOrderHead(con, stsF, stsP, stsD, stsT, ordPk, reviewNo,
                        name, saleOrg,ComputerInfo);
                cro.setV_errCode(0);
                List<String> listPk = CoreOrderStatusCommFun.getOrderLnPkValue(
                        con, ordPk);
                for (String ordLnPk : listPk) {
                    CoreOrderStatus cosLine = getOrderLineStatus(con, ordLnPk);
                    if (cosLine.getOrderLnStatus().equals("12020201")) { // 技术评审中
                                                                         // （需要做技术评审的）
                        deleteMscDepartment(con, ordLnPk); // 删除MSC管理科室
                        QualityDesignMain qdm = new QualityDesignMain();
                        ArrayList<Object> list = new ArrayList<Object>();
                        list.add("SYSTEM");
                        qdm.qualityDesign(ordPk, ordLnPk, "", list); // 自动调用后台质量设计
                    }
                }
                CoreOrderCopy coreOrderCopy = new CoreOrderCopy();
                coreOrderCopy.OrderCopy(con,ordPk);
                con.commit();
            }
        }
        catch (Exception e) {
            try {
                con.rollback();
                cro.setV_errCode(-1);
                cro.setResult(e.getMessage());
            }
            catch (SQLException e1) {
                e1.printStackTrace();
            }
        }
        finally {
            try {
                if (con != null && !con.isClosed()) {
                    con.close();
                }
            }
            catch (SQLException e) {
                e.printStackTrace();
            }
        }

        return cro;
    }

    /**
     * 按照法务评审F，价格P，交货期D，技术评审T顺序进行分析,确认合同
     * @param con
     * @param stsF
     * @param stsP
     * @param stsD
     * @param stsT
     * @param ordPk
     * @param reviewNo
     * @param name
     * @param saleOrg
     * @throws SQLException
     */
    public void confirmOrderHead(Connection con, String stsF, String stsP,
                                 String stsD, String stsT, String ordPk, String reviewNo,
                                 String name, String saleOrg) throws SQLException {

        confirmOrderHead( con,  stsF,  stsP,
                 stsD,  stsT,  ordPk,  reviewNo,name
                ,  saleOrg,"");
    }

    /**
     * 按照法务评审F，价格P，交货期D，技术评审T顺序进行分析,确认合同
     * @param con
     * @param stsF
     * @param stsP
     * @param stsD
     * @param stsT
     * @param ordPk
     * @param reviewNo
     * @param name
     * @param saleOrg
     * @throws SQLException
     */
    public void confirmOrderHead(Connection con, String stsF, String stsP,
            String stsD, String stsT, String ordPk, String reviewNo,
            String name, String saleOrg,String ComputerInfo) throws SQLException {
        String headStatus = ""; // 合同头状态
        java.sql.Date date = new java.sql.Date(new java.util.Date().getTime());


        updateOrderHeadIPMac(con, ordPk, ComputerInfo);
        // 查询合同
        SqlBuilder b = new SqlBuilder("CoreOrderCopy.queryHead");
        b.Fill(new String[]{ordPk});
        SlmOrderHeadCopy orderHead = EntityTool.getEntityBySqlNoClsCon(b.toString(), con, SlmOrderHeadCopy.class);
        // 首次收票人（卖出单位）不是天淮                          制造商是天淮
        if (!orderHead.getFstDraweeUnit().equals("120607") && orderHead.getSupplyUnit().equals("120504")) {
            stsD = "";stsT = "";
        }
        // 1.
        if (stsF.equals("S") && stsP.equals("S") && stsD.equals("S")
                && stsT.equals("S")) {
            // 四个都通过

            CoreOrderStatusCommFun.updateOrderHeadStatusConfirm(con, ordPk,
                    "12020251", "评审通过", name, date.toString());
            updateOrderLineOnlyStatus(con, ordPk, "12020251");
            updateOrderDeliveryLineOneStatus(con, ordPk, "12020251");
            doCrmEvent(con, ordPk,"","","1");
        }
        else if (stsF.equals("") && stsP.equals("") && stsD.equals("")
                && stsT.equals("")) {
            // 不存在
            CoreOrderStatusCommFun.updateOrderHeadStatusConfirm(con, ordPk,
                    "12020102", "待提报评审", name, date.toString());
            updateOrderLineOnlyStatus(con, ordPk, "12020102");
            updateOrderDeliveryLineOneStatus(con, ordPk, "12020102");
            doCrmEvent(con, ordPk,"","","1");
        }
        else { // 四个值都不为空且都不为"S"
            if (stsF.equals("S") && !saleOrg.equals("100102")) {// 法务评审通过

                CoreOrderStatusCommFun.updateOrderHeadStatusConfirm(con, ordPk,
                        "12020242", "法务评审通过", name, date.toString());
                updateOrderLineOnlyStatus(con, ordPk, "12020242");
                updateOrderDeliveryLineOneStatus(con, ordPk, "12020242");
                doCrmEvent(con, ordPk,"","","1");
            }
            else if (stsF.equals("F") && !saleOrg.equals("100102")) {// 法务评审失败

                CoreOrderStatusCommFun.updateOrderHeadStatusConfirm(con, ordPk,
                        "12020241", "法务评审失败", name, date.toString());
                updateOrderLineOnlyStatus(con, ordPk, "12020241");
                updateOrderDeliveryLineOneStatus(con, ordPk, "12020241");
                doCrmEvent(con, ordPk,"","","1");
            }
            else {// stsF 接下来可能的状态L W D
                if (stsP.equals("S")) { // 价格评审通过

                    CoreOrderStatusCommFun.updateOrderHeadStatusConfirm(con,
                            ordPk, "12020232", "价格评审通过", name, date.toString());
                    updateOrderLineOnlyStatus(con, ordPk, "12020232");
                    updateOrderDeliveryLineOneStatus(con, ordPk, "12020232");
                    doCrmEvent(con, ordPk,"","","1");
                }
                else if (stsP.equals("F")) { // 价格评审失败

                    CoreOrderStatusCommFun.updateOrderHeadStatusConfirm(con,
                            ordPk, "12020231", "价格评审失败", name, date.toString());
                    updateOrderLineOnlyStatus(con, ordPk, "12020231");
                    updateOrderDeliveryLineOneStatus(con, ordPk, "12020231");
                    doCrmEvent(con, ordPk,"","","1");
                }
                else {// stsP接下来可能的状态 L W D
                    if (stsD.equals("S")) { // 交货期评审通过

                        CoreOrderStatusCommFun.updateOrderHeadStatusConfirm(
                                con, ordPk, "12020212", "交货期评审通过", name,
                                date.toString());
                        updateOrderLineOnlyStatus(con, ordPk, "12020212");
                        updateOrderDeliveryLineOneStatus(con, ordPk, "12020212");
                        doCrmEvent(con, ordPk,"","","1");
                    }
                    else if (stsD.equals("F")) { // 交货期评审失败

                        CoreOrderStatusCommFun.updateOrderHeadStatusConfirm(
                                con, ordPk, "12020211", "交货期评审失败", name,
                                date.toString());
                        updateOrderLineOnlyStatus(con, ordPk, "12020211");
                        updateOrderDeliveryLineOneStatus(con, ordPk, "12020211");
                        doCrmEvent(con, ordPk,"","","1");
                    }
                    else {// stsD接下来的值可能为 L W D
                        if (stsT.equals("S")) { // 技术评审通过

                            CoreOrderStatusCommFun
                                    .updateOrderHeadStatusConfirm(con, ordPk,
                                            "12020202", "技术评审通过", name,
                                            date.toString());
                            updateOrderLineOnlyStatus(con, ordPk, "12020202");
                            updateOrderDeliveryLineOneStatus(con, ordPk,
                                    "12020202");
                            doCrmEvent(con, ordPk,"","","1");
                        }
                        else if (stsT.equals("F")) { // 技术评审失败

                            CoreOrderStatusCommFun
                                    .updateOrderHeadStatusConfirm(con, ordPk,
                                            "12020203", "技术评审失败", name,
                                            date.toString());
                            headStatus = "12020203";
                        }
                        else {

                            CoreOrderStatusCommFun
                                    .updateOrderHeadStatusConfirm(con, ordPk,
                                            "12020201", "待技术评审", name,
                                            date.toString());
                            headStatus = "12020201";
                        }
                    }
                }
            }
        }
        // 2.
        if (headStatus.equals("12020201") || headStatus.equals("12020203")) { // 合同头待技术评审
            // SlmOrderReviewItemListEntity
            List<SlmOrderReviewItemListEntity> list = getOrderReviewItemList(
                    con, reviewNo);
            for (SlmOrderReviewItemListEntity review : list) {
                if (review.getReviewStatus().equals("S")) {// 合同行的评审状态为通过
                    updateOneOrderLineStatus(con, review.getListPkVal(),
                            "12020202");
                    updateOrderDeliveryLineStatusWithOrdLnPk(con,
                            review.getListPkVal(), "12020202");
//                    doCrmEvent(con, "",review.getListPkVal(),"","1");
                }
                else if (review.getReviewStatus().equals("F")) {// 合同行的评审状态失败
                    updateOneOrderLineStatus(con, review.getListPkVal(),
                            "12020203");
                    updateOrderDeliveryLineStatusWithOrdLnPk(con,
                            review.getListPkVal(), "12020203");
//                    doCrmEvent(con, "",review.getListPkVal(),"","1");
                }
                else {
                    updateOneOrderLineStatus(con, review.getListPkVal(),
                            "12020201");
                    updateOrderDeliveryLineStatusWithOrdLnPk(con,
                            review.getListPkVal(), "12020201");
                    deletePlSTITC(con, ordPk, review.getListPkVal());
//                    doCrmEvent(con, "",review.getListPkVal(),"","1");
                }
            }
        }
        // 3.
        updateOrderReviewItemD(con, reviewNo, "W", "L");
        updateOrderReviewItemList(reviewNo, con, "W", "L", "1");
        // 新增处理逻辑，若数据经过 质量设计 打回来的 修改信息 改为 待技术评审 判断是否存在ReviewNo 存在则将
        // 技术评审的封锁状态改为评审中。
        // 再次提报的删掉其冶金规范码的管理科室，同时调用质量设计。2015-07-21
        // 查询合同行的状态
        // 2015-10-09新增逻辑 如果是现货合同的不需要走下面步骤，直接交货期评审通过
        String ordType = CoreOrderStatusCommFun.getOrderType(con, ordPk);
        if (ordType.equals("120102") || ordType.equals("120105")) { // 现货合同--》评审通过
            if (reviewNo != null && !reviewNo.equals("")) {
                if (saleOrg.equals("100102")) {
                    updateOrderHeadStatus(con, ordPk, "12020220", "待审批");
                    updateOrderLineOnlyStatus(con, ordPk, "12020220");
                    updateOrderDeliveryLineStatus(con, ordPk, "12020220");
                    updateOrderReviewItem(con, reviewNo, "D", "L");
                    doCrmEvent(con, ordPk,"","","1");
                }
                else {
                    updateOrderHeadStatus(con, ordPk, "12020212", "交货期评审通过");
                    updateOrderLineOnlyStatus(con, ordPk, "12020212");
                    updateOrderDeliveryLineStatus(con, ordPk, "12020212");
                    updateOrderReviewItem(con, reviewNo, "D", "L");
                    updateOrderReviewItem(con, reviewNo, "P", "L");
                    updateOrderReviewItem(con, reviewNo, "F", "L");
                    doCrmEvent(con, ordPk,"","","1");
                }
            }
        }
        else if (ordType.equals("120103")) {
            if (reviewNo != null && !reviewNo.equals("")) {
                updateOrderHeadStatus(con, ordPk, "12020201", "技术评审中");
                updateOrderLineOnlyStatus(con, ordPk, "12020201");
                updateOrderDeliveryLineStatus(con, ordPk, "12020201");
                updateOrderReviewItem(con, reviewNo, "T", "D");
                List<String> listPk = CoreOrderStatusCommFun.getOrderLnPkValue(
                        con, ordPk);
                for (String ordLnPk : listPk) {
                    CoreOrderStatusCommFun.updateOrderItemListOrdLnPk(con,
                            reviewNo, "T", "L", ordLnPk, "D");
                    CoreOrderStatusCommFun.updateOrderReviewItemClearEDate(con,
                            reviewNo, "T", "D");
                }
                doCrmEvent(con, ordPk,"","","1");
            }
        }
        else {
            if (headStatus.equals("12020201") || headStatus.equals("12020203")) { // 合同头待技术评审

                List<String> listPk = CoreOrderStatusCommFun.getOrderLnPkValue(
                        con, ordPk);

                for (String ordLnPk : listPk) {
                    String sts = CoreOrderStatusCommFun
                            .getOrderItemListStatusOrdLnPk(con, reviewNo, "T",
                                    "L", ordLnPk);
                    if (sts.equals("S")) { // 技术评审通过
                        CoreOrderStatusCommFun.updateOrderItemListOrdLnPk(con,
                                reviewNo, "T", "L", ordLnPk, "S");
                    }
                    else if (sts.equals("F")) { // 技术评审失败
                        CoreOrderStatusCommFun.updateOrderItemListOrdLnPk(con,
                                reviewNo, "T", "L", ordLnPk, "F");
                    }
                    else { // 技术评审中
                        CoreOrderStatusCommFun.updateOrderItemListOrdLnPk(con,
                                reviewNo, "T", "L", ordLnPk, "D");
                    }
                }

                List<String> list = getOrderLineStatusAll(con, ordPk);
                if (list.contains("12020202") && !list.contains("12020203")
                        && !list.contains("12020201")) { // 技术评审通过

                    CoreOrderStatusCommFun.updateOrderReviewItemClearEDate(con,
                            reviewNo, "T", "S");
                    CoreOrderStatusCommFun.updateOrderHeadStatusReport(con,
                            ordPk, "12020202", "技术评审通过");
                    doCrmEvent(con, ordPk,"","","1");

                }
                else if (list.contains("12020203")
                        && !list.contains("12020202")
                        && !list.contains("12020201")) { // 技术评审失败

                    CoreOrderStatusCommFun.updateOrderReviewItemClearEDate(con,
                            reviewNo, "T", "F");
                    CoreOrderStatusCommFun.updateOrderHeadStatusReport(con,
                            ordPk, "12020203", "技术评审失败");
                    doCrmEvent(con, ordPk,"","","1");
                }
                else if (list.contains("12020201")
                        && !list.contains("12020203")
                        && !list.contains("12020202")) {

                    CoreOrderStatusCommFun.updateOrderReviewItemClearEDate(con,
                            reviewNo, "T", "D");
                }
            }
        }




    }

    /**
     * 获得新增行时的OrdLnPk值。
     * @param con
     * @param ordPk
     * @return
     * @throws SQLException
     */
    public String getAddLineOrdLnPk(Connection con, String ordPk)
            throws SQLException {
        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.GetOrderLinePkWithAdd");
        PreparedStatement ps = con.prepareStatement(sql);
        ps.setObject(1, ordPk);
        ps.setObject(2, ordPk);
        ResultSet rs = ps.executeQuery();
        String ordLnPk = "";
        if (rs.next()) {
            ordLnPk = rs.getString(1);
        }
        rs.close();
        ps.close();
        return ordLnPk;

    }

    /**
     * 获取合同下的所有交货行的PK值
     * @param con
     * @param ordPk
     * @return
     * @throws SQLException
     */
    public List<String> getOrderDeliveryLinePK(Connection con, String ordPk)
            throws SQLException {
        List<String> list = new ArrayList<String>();
        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.GetAllDeliveryLinePk");
        PreparedStatement ps = con.prepareStatement(sql);
        ps.setObject(1, ordPk);
        ResultSet rs = ps.executeQuery();
        while (rs.next()) {
            list.add(rs.getString(1));
        }
        rs.close();
        ps.close();
        return list;
    }

    /**
     * 更新合同头信息
     * @param con
     * @param parm
     * @throws SQLException
     */
    public void updateOrderHead(Connection con, ArrayList<Object> parm,String ordPk)
            throws SQLException {

        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.UpdateOrderHead");
        PreparedStatement ps = con.prepareStatement(sql);

        for (int i = 0; i < parm.size(); i++) {
            ps.setObject(i + 1, parm.get(i));
        }

        ps.executeUpdate();
        ps.close();

        doCrmEvent(con,ordPk,"","","1","0");
    }

    /**
     * 更新合同头对应CRM信息
     * @param con
     * @param parm
     * @throws SQLException
     */
    public void updateCrmHead(Connection con, CrmSlmOrder CrmEntity)
            throws SQLException {
        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.updateCrmHead");
        PreparedStatement ps = con.prepareStatement(sql);
        sql = EntityTool.fillSqlByEntity(sql, CrmEntity);
        ps = con.prepareStatement(sql);
        ps.executeUpdate();
        ps.close();
    }

    /**
     * 获取CRM合同信息
     * @param con
     * @param reviewNo
     * @return
     * @throws SQLException
     */
    public List<CrmSlmOrder> getCrmOrderHeadInfo(
            Connection con, String ordPk) throws SQLException {
        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.getCrmOrderHeadInfo");
        List<CrmSlmOrder> list = new ArrayList<CrmSlmOrder>();
        PreparedStatement ps = con.prepareStatement(sql);
        ps.setObject(1, ordPk);
        ResultSet rs = ps.executeQuery();
        list = EntityTool
                .getEntitysByRs(rs, CrmSlmOrder.class);

        rs.close();
        ps.close();
        return list;
    }

    /**
     * 获取CRM合同和合同行信息
     * @param con
     * @param reviewNo
     * @return
     * @throws SQLException
     */
    public List<CrmSlmOrder> getCrmOrderHeadAndLine(
            Connection con, String ordLnPk) throws SQLException {
        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.getCrmOrderHeadAndLine");
        List<CrmSlmOrder> list = new ArrayList<CrmSlmOrder>();
        PreparedStatement ps = con.prepareStatement(sql);
        ps.setObject(1, ordLnPk);
        ResultSet rs = ps.executeQuery();
        list = EntityTool
                .getEntitysByRs(rs, CrmSlmOrder.class);

        rs.close();
        ps.close();
        return list;
    }

    /**
     * 更新合同头对应CRM信息
     * @param con
     * @param parm
     * @throws SQLException
     */
    public void updateCrmHeadAndLine(Connection con, CrmSlmOrder CrmEntity)
            throws SQLException {
        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.updateCrmHeadAndLine");
        PreparedStatement ps = con.prepareStatement(sql);
        sql = EntityTool.fillSqlByEntity(sql, CrmEntity);
        ps = con.prepareStatement(sql);
        ps.executeUpdate();
        ps.close();
    }

    /**
     * 新增合同行
     * @param con
     * @param parm
     * @throws SQLException
     */
    public void addOrderLineAndStatus(Connection con, ArrayList<Object> parm)
            throws SQLException {
        // CoreOrderManager.doAddLine

        // 2015年12月21日 13:56:10 陈希
        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderManager.doAddLine");
        // String sql =
        // CoreXmlSqlParsersFactory.getSql("CoreOrderInfoUpdate.doAddLine");
        PreparedStatement ps = con.prepareStatement(sql);

        for (int i = 0; i < parm.size(); i++) {
            ps.setObject(i + 1, parm.get(i));
        }
        ps.executeUpdate();
        ps.close();
    }

    /**
     * 新增合同行 指定OrdLnPk
     * @param con
     * @param ordLnPk
     * @param parm
     * @throws SQLException
     */
    public void addOrderLineAndStatus(Connection con, String ordLnPk,
            ArrayList<Object> parm) throws SQLException {
        // CoreOrderManager.doAddLine

        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.doAddLine");
        PreparedStatement ps = con.prepareStatement(sql);

        parm.remove(0);
        parm.remove(0);
        parm.add(0, ordLnPk);
        for (int i = 0; i < parm.size(); i++) {
            ps.setObject(i + 1, parm.get(i));
        }
        ps.executeUpdate();
        ps.close();
    }

    /**
     * 修改合同行的信息
     * @param con
     * @param parm
     * @throws SQLException
     */
    public void updateOrderLineInfo(Connection con, ArrayList<Object> parm)
            throws SQLException {
        // CoreOrderManager.doUpdateLine

        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderManager.doUpdateLine");
        PreparedStatement ps = con.prepareStatement(sql);

        for (int i = 0; i < parm.size(); i++) {
            ps.setObject(i + 1, parm.get(i));
        }
        ps.executeUpdate();
        ps.close();
    }

    /**
     * 将选择的某一行合同行删掉。
     * @param con
     * @param parm
     * @throws SQLException
     */
    public void deleteOrderLine(Connection con, ArrayList<Object> parm)
            throws SQLException {
        // CoreOrderManager.DELETE
        String sql = CoreXmlSqlParsersFactory.getSql("CoreOrderManager.DELETE");
        PreparedStatement ps = con.prepareStatement(sql);

        for (int i = 0; i < parm.size(); i++) {
            ps.setObject(i + 1, parm.get(i));
        }
        ps.executeUpdate();
        ps.close();
    }

    /**
     * 将选择的某一行合同行对应crm信息删掉。
     * @param con
     * @param parm
     * @throws SQLException
     */
    public void deleteCrmByLine(Connection con, ArrayList<Object> parm)
            throws SQLException {
        // CoreOrderManager.DELETE
        String sql = CoreXmlSqlParsersFactory.getSql("CoreOrderManager.deleteCrmByLine");
        PreparedStatement ps = con.prepareStatement(sql);
        ps.setObject(1, parm.get(1));
        ps.executeUpdate();
        ps.close();
    }

    /**
     * 更新crm合同状态。
     * @param con
     * @param parm
     * @throws SQLException
     */
    public void updateCrmStatus(Connection con, String status, String statusDesc,String ordPk )
            throws SQLException {
        // CoreOrderManager.DELETE
        String sql = CoreXmlSqlParsersFactory.getSql("CoreOrderInfoUpdate.updateCrmStatus");
        PreparedStatement ps = con.prepareStatement(sql);
        ps.setObject(1, status);
        ps.setObject(2, statusDesc);
        ps.setObject(3, ordPk);
        ps.executeUpdate();
        ps.close();
    }

    /**
     * 更新合同头的状态(指定前后状态)
     * @param con
     * @param ordPk
     * @param bestatus
     * @param status
     * @throws SQLException
     */
    public void updateOrderHeadStatus(Connection con, String ordPk,
            String bestatus, String status, String statusDesc)
            throws SQLException {
        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.UpdateOrderHeadStatus");
        PreparedStatement ps = con.prepareStatement(sql);
        ps.setObject(1, status);
        ps.setObject(2, statusDesc);
        ps.setObject(3, bestatus);
        ps.setObject(4, ordPk);
        ps.executeUpdate();
        ps.close();

        doCrmEvent(con, ordPk,"","","1");
    }

    /**
     * 更新合同头当前状态，前一状态不管
     * @param con
     * @param ordPk
     * @param status
     * @param statusDesc
     * @throws SQLException
     */
    public void updateOrderHeadStatus(Connection con, String ordPk,
            String status, String statusDesc) throws SQLException {
        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.UpdateOrderHeadOneStatus");
        PreparedStatement ps = con.prepareStatement(sql);
        ps.setObject(1, status);
        ps.setObject(2, statusDesc);
        ps.setObject(3, ordPk);
        ps.executeUpdate();
        ps.close();
    }

    /**
     * 更新合同头确认人电脑信息
     * @param con
     * @param ordPk
     * @param ComputerInfo
     * @throws SQLException
     */
    public void updateOrderHeadIPMac(Connection con,String ordPk, String ComputerInfo) throws SQLException {
        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.updateOrderHeadIPMac");
        PreparedStatement ps = con.prepareStatement(sql);
        ps.setObject(1, ComputerInfo);
        ps.setObject(2, ordPk);
        ps.executeUpdate();
        ps.close();
    }

    /**
     * 更新合同行的状态（批量）
     * @param con
     * @param ordPk
     * @param status
     * @throws SQLException
     */
    public void updateOrderLineStatus(Connection con, String ordPk,
            String status) throws SQLException {
        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.UpdateOrderLineStatus");
        PreparedStatement ps = con.prepareStatement(sql);
        ps.setObject(1, status);
        ps.setObject(2, ordPk);
        ps.executeUpdate();
        ps.close();

        doCrmEvent(con,ordPk,"","","1","1");
    }

    /**
     * 指定了前后状态，更新合同行状态(某一OrdPk下的所有)。
     * @param con
     * @param ordPk
     * @param bestatus 前一状态
     * @param status 当前状态
     * @throws SQLException
     */
    public void updateOrderLineStatus(Connection con, String ordPk,
            String bestatus, String status) throws SQLException {
        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.UpdateOrderLineStatusWithBe");
        PreparedStatement ps = con.prepareStatement(sql);
        ps.setObject(1, status);
        ps.setObject(2, bestatus);
        ps.setObject(3, ordPk);
        ps.executeUpdate();
        ps.close();

        new CoreOrderInfoUpdate().doCrmEvent(con, ordPk,"","","1","1");
    }

    /**
     * 修改指定的那一条合同行状态
     * @param con
     * @param ordLnPk
     * @param bestatus
     * @param status
     * @throws SQLException
     */
    public void updateOneOrderLineStatus(Connection con, String ordLnPk,
            String bestatus, String status) throws SQLException {
        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.UpdateOneOrderLineStatus");
        PreparedStatement ps = con.prepareStatement(sql);
        ps.setObject(1, status);
        ps.setObject(2, bestatus);
        ps.setObject(3, ordLnPk);
        ps.executeUpdate();
        ps.close();

        doCrmEvent(con, "",ordLnPk,"","1");
    }

    /**
     * 修改指定的那一条合同行状态,不管前一状态
     * @param con
     * @param ordLnPk
     * @param status
     * @throws SQLException
     */
    public void updateOneOrderLineStatus(Connection con, String ordLnPk,
            String status) throws SQLException {
        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.UpdateOneOrderLineOneStatus");
        PreparedStatement ps = con.prepareStatement(sql);
        ps.setObject(1, status);
        ps.setObject(2, ordLnPk);
        ps.executeUpdate();
        ps.close();

        doCrmEvent(con, "",ordLnPk,"","1");
    }

    /**
     * 更新某一合同行的前一状态和有效标志
     * @param con
     * @param ordLnPk
     * @param bestatus
     * @param valid
     * @param bevalid
     * @throws SQLException
     */
    public void updateOneOrderLineStatus(Connection con, String ordLnPk,
            String bestatus, String valid, String bevalid) throws SQLException {
        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.UpdateOneOrderLineStsValid");
        PreparedStatement ps = con.prepareStatement(sql);
        ps.setObject(1, bestatus);
        ps.setObject(2, valid);
        ps.setObject(3, ordLnPk);
        ps.setObject(4, bevalid);
        ps.executeUpdate();
        ps.close();
    }

    /**
     * 只更新合同行当前状态，前一状态不变。
     * @param con
     * @param ordPk
     * @param bestatus
     * @param status
     * @throws SQLException
     */
    public void updateOrderLineOnlyStatus(Connection con, String ordPk,
            String status) throws SQLException {
        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.UpdateOrderLineOnlyStatus");
        PreparedStatement ps = con.prepareStatement(sql);
        ps.setObject(1, status);
        ps.setObject(2, ordPk);
        ps.executeUpdate();
        ps.close();

        doCrmEvent(con, ordPk,"","","1","1");
    }

    /**
     * 更新交货行的状态（批量）
     * @param con
     * @param ordPk
     * @param status
     * @throws SQLException
     */
    public void updateOrderDeliveryLineStatus(Connection con, String ordPk,
            String status) throws SQLException {
        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.UpdateOrderDeliveryLineStatus");
        PreparedStatement ps = con.prepareStatement(sql);
        ps.setObject(1, status);
        ps.setObject(2, ordPk);
        ps.executeUpdate();
        ps.close();

        doCrmEvent(con,ordPk,"","","1","2");
    }

    /**
     * 更新交货行的状态（批量）,前一状态不变
     * @param con
     * @param ordPk
     * @param status
     * @throws SQLException
     */
    public void updateOrderDeliveryLineOneStatus(Connection con, String ordPk,
            String status) throws SQLException {
        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.UpdateOrderDeliveryLineOneStatus");
        PreparedStatement ps = con.prepareStatement(sql);
        ps.setObject(1, status);
        ps.setObject(2, ordPk);
        ps.executeUpdate();
        ps.close();

        doCrmEvent(con, ordPk,"","","1","2");
    }

    /**
     * 指定前后状态的更新交货行状态(同一合同下的所有交货行)。
     * @param con
     * @param ordPk
     * @param bestatus 前一状态
     * @param status 当前状态
     * @throws SQLException
     */
    public void updateOrderDeliveryLineStatus(Connection con, String ordPk,
            String bestatus, String status) throws SQLException {
        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.UpdateSingleOrderDeliveryLineStatus");
        PreparedStatement ps = con.prepareStatement(sql);
        ps.setObject(1, status);
        ps.setObject(2, bestatus);
        ps.setObject(3, ordPk);
        ps.executeUpdate();
        ps.close();

        new CoreOrderInfoUpdate().doCrmEvent(con, ordPk,"","","1","2");
    }

    /**
     * 指定某一合同行下的所有的交货行的修改。
     * @param con
     * @param ordLnPk
     * @param bestatus
     * @param status
     * @throws SQLException
     */
    public void updateOrderDeliveryLineStatusWithOrdLnPk(Connection con,
            String ordLnPk, String bestatus, String status) throws SQLException {
        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.UpdateOrderDeliveryLineStatusOrdLnPk");
        PreparedStatement ps = con.prepareStatement(sql);
        ps.setObject(1, status);
        ps.setObject(2, bestatus);
        ps.setObject(3, ordLnPk);
        ps.executeUpdate();
        ps.close();

        doCrmEvent(con, "",ordLnPk,"","1","2");
    }

    /**
     * 指定某一合同行下的所有的交货行的修改,前一状态不管
     * @param con
     * @param ordLnPk
     * @param status
     * @throws SQLException
     */
    public void updateOrderDeliveryLineStatusWithOrdLnPk(Connection con,
            String ordLnPk, String status) throws SQLException {
        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.UpdateOrderDeliveryLineOneStatusOrdLnPk");
        PreparedStatement ps = con.prepareStatement(sql);
        ps.setObject(1, status);

        ps.setObject(2, ordLnPk);
        ps.executeUpdate();
        ps.close();

        doCrmEvent(con, "","ordLnPk","","1","2");
    }

    /**
     * 更新合同行下的交货行的有效标志 (对于后面的两个参数，在逻辑上应该是互反的。)
     * @param con
     * @param ordLnPk 合同行PK
     * @param valid 有效状态，1有效，0，无效
     * @param beValid 合同行下交货行之前的状态 1有效，0，无效
     * @throws SQLException
     */
    public void updateOrderDeliveryValidFlag(Connection con, String ordLnPk,
            String valid, String beValid) throws SQLException {
        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.SetOrderDeliveryLineValidFlag");
        PreparedStatement ps = con.prepareStatement(sql);
        ps.setObject(1, valid);
        ps.setObject(2, ordLnPk);
        ps.setObject(3, beValid);
        ps.executeUpdate();
        ps.close();
    }

    /**
     * 更新合同行下的交货行的前一状态和有效标志 (对于后面的两个参数，在逻辑上应该是互反的。)
     * @param con
     * @param ordLnPk
     * @param bestatus
     * @param valid
     * @param beValid 合同行下交货行之前的状态 1有效，0，无效
     * @throws SQLException
     */
    public void updateOrderDeliveryValidFlag(Connection con, String ordLnPk,
            String bestatus, String valid, String beValid) throws SQLException {
        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.SetOrderDeliveryLineStsValid");
        PreparedStatement ps = con.prepareStatement(sql);
        ps.setObject(1, valid);
        ps.setObject(2, bestatus);
        ps.setObject(3, ordLnPk);
        ps.setObject(4, beValid);
        ps.executeUpdate();
        ps.close();
    }

    /**
     * 获取指定合同的评审单号
     * @param con
     * @param ordPk
     * @return
     * @throws SQLException
     */
    public String getOrderReviewNo(Connection con, String ordPk)
            throws SQLException {
        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.SelectREVIEWNO");
        String no = "";
        PreparedStatement ps = con.prepareStatement(sql);
        ps.setObject(1, ordPk);
        ResultSet rs = ps.executeQuery();
        if (rs.next()) {
            no = rs.getString(1);
        }
        rs.close();
        ps.close();
        return no;
    }

    /**
     * 更行合同评审单状态
     * @param con
     * @param reviewNo 评审单号
     * @param item 项目 T 技术 D交货 P 价格 F 法务
     * @param status 什么状态 L:封锁;W:待审;D:评审中;S:评审通过;F评审失败
     * @throws SQLException
     */
    public void updateOrderReviewItem(Connection con, String reviewNo,
            String item, String status) throws SQLException {
        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.UpdateOrderReviewItem");
        PreparedStatement ps = con.prepareStatement(sql);
        ps.setObject(1, status);
        ps.setObject(2, reviewNo);
        ps.setObject(3, item);
        ps.executeUpdate();
        ps.close();
    }

    /**
     * 更新评审项目表的状态，所有 项目 T 技术 D交货 P 价格 F 法务
     * @param con
     * @param reviewNo
     * @param status
     * @param bestatus 之前状态
     * @throws SQLException
     */
    public void updateOrderReviewItemD(Connection con, String reviewNo,
            String status, String bestatus) throws SQLException {
        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.UpdateOrderReviewAllItem");
        PreparedStatement ps = con.prepareStatement(sql);
        ps.setObject(1, status);
        ps.setObject(2, reviewNo);
        ps.setObject(3, bestatus);

        ps.executeUpdate();
        ps.close();
    }

    /**
     * 将合同评审明细合同行对应的项目的状态都置为0
     * @param con
     * @param reviewNo
     * @param item T 技术 D交货 P 价格 F 法务
     * @param listTyp H合同头;L合同行;D交货行
     * @param listVal
     * @throws SQLException
     */
    public void updateOrderReviewItemList(Connection con, String reviewNo,
            String item, String listTyp, String listVal) throws SQLException {
        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.UpdateOrderReviewItemList");
        PreparedStatement ps = con.prepareStatement(sql);
        ps.setObject(1, reviewNo);
        ps.setObject(2, item);
        ps.setObject(3, listTyp);
        ps.setObject(4, listVal);

        ps.executeUpdate();
        ps.close();
    }

    /**
     * 评审明细表中对应合同行的所有项目状态置0.
     * @param con
     * @param reviewNo
     * @param listTyp
     * @param listVal
     * @throws SQLException
     */
    public void updateOrderReviewItemList(Connection con, String reviewNo,
            String listTyp, String listVal) throws SQLException {
        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.UpdateOrderReviewAllItemList");
        PreparedStatement ps = con.prepareStatement(sql);
        ps.setObject(1, reviewNo);
        ps.setObject(2, listTyp);
        ps.setObject(3, listVal);

        ps.executeUpdate();
        ps.close();
    }

    /**
     * 更新评审明细表，状态是否当前评审的记录
     * @param reviewNo
     * @param con
     * @param status
     * @param bestatus
     * @param iscur
     * @throws SQLException
     */
    public void updateOrderReviewItemList(String reviewNo, Connection con,
            String status, String bestatus, String iscur) throws SQLException {
        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.UpdateOrderReviewItemListAll");
        PreparedStatement ps = con.prepareStatement(sql);
        ps.setObject(1, status);
        ps.setObject(2, reviewNo);
        ps.setObject(3, bestatus);
        ps.setObject(4, iscur);

        ps.executeUpdate();
        ps.close();
    }

    /**
     * 新增一条评审明细记录
     * @param con
     * @param reviewNo 评审单号
     * @param item 项目 T 技术 D交货 P 价格 F 法务
     * @param listTyp 明细类型 H合同头;L合同行;D交货行
     * @param listVal 明细类型值
     * @param status 状态
     * @param name 创建人名字
     * @param dept 科室
     * @throws SQLException
     */
    public void insertOrderReviewItemList(Connection con, String reviewNo,
            String item, String listTyp, String listVal, String status,
            String name, String dept) throws SQLException {
        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.InsertOrderReviewItemList");
        PreparedStatement ps = con.prepareStatement(sql);
        ps.setObject(1, reviewNo);
        ps.setObject(2, item);
        ps.setObject(3, listTyp);
        ps.setObject(4, listVal);

        ps.setObject(5, reviewNo);
        ps.setObject(6, item);
        ps.setObject(7, listTyp);
        ps.setObject(8, listVal);
        ps.setObject(9, status);

        ps.setObject(10, name);
        ps.setObject(11, dept);
        ps.executeUpdate();
        ps.close();
    }

    /**
     * 取得交货行的交货地点
     * @param con
     * @param ordPk
     * @return
     * @throws SQLException
     */
    public String getThDeliveryCount(Connection con, String ordPk)
            throws SQLException {
        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.getThDeliveryCount");
        PreparedStatement ps = con.prepareStatement(sql);
        ps.setObject(1, ordPk);
        String count="";
        ResultSet rs = ps.executeQuery();
        if (rs.next()) {
        	count=rs.getString("COUNT");
            return count;
        }
        rs.close();
        ps.close();
        return count;
    }

    /**
     * 取得交货行的交货地点
     * @param con
     * @param ordPk
     * @return
     * @throws SQLException
     */
    public String getTgDeliveryCount(Connection con, String ordPk)
            throws SQLException {
        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.getTgDeliveryCount");
        PreparedStatement ps = con.prepareStatement(sql);
        ps.setObject(1, ordPk);
        String count="";
        ResultSet rs = ps.executeQuery();
        if (rs.next()) {
        	count=rs.getString("COUNT");
            return count;
        }
        rs.close();
        ps.close();
        return count;
    }

    /**
     * 取得合同头的状态
     * @param con
     * @param ordPk
     * @return
     * @throws SQLException
     */
    public CoreOrderStatus getOrderStatus(Connection con, String ordPk)
            throws SQLException {
        CoreOrderStatus cos = new CoreOrderStatus();
        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.SelectOrderHeadStatus");
        PreparedStatement ps = con.prepareStatement(sql);
        ps.setObject(1, ordPk);

        ResultSet rs = ps.executeQuery();
        if (rs.next()) {
            cos.setOrderSts(rs.getString("ORDER_STS"));
            cos.setOrderStsDesc(rs.getString("ORDER_STS_DESC"));
            cos.setBeOrderSts(rs.getString("BE_ORDER_STS"));

            return cos;
        }
        cos = null;
        rs.close();
        ps.close();
        return cos;
    }

    /**
     * 获取合同行的状态
     * @param con
     * @param ordLnPk
     * @return
     * @throws SQLException
     */
    public CoreOrderStatus getOrderLineStatus(Connection con, String ordLnPk)
            throws SQLException {
        CoreOrderStatus cos = new CoreOrderStatus();
        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.SelectOrderLineStatus");
        PreparedStatement ps = con.prepareStatement(sql);
        ps.setObject(1, ordLnPk);

        ResultSet rs = ps.executeQuery();
        if (rs.next()) {
            cos.setOrderLnStatus(rs.getString("ORDER_LN_STATUS"));
            return cos;
        }
        cos = null;
        rs.close();
        ps.close();
        return cos;
    }

    /**
     * 获取交货行的状态。
     * @param con
     * @param ordLnPk
     * @return
     * @throws SQLException
     */
    public CoreOrderStatus getOrderLineDeliveryStatus(Connection con,
            String ordLnDlyPk) throws SQLException {
        CoreOrderStatus cos = new CoreOrderStatus();
        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.SelectOrderLineDeliveryStatus");
        PreparedStatement ps = con.prepareStatement(sql);
        ps.setObject(1, ordLnDlyPk);

        ResultSet rs = ps.executeQuery();
        if (rs.next()) {
            cos.setDeliveryStatus(rs.getString("DELIVERY_STATUS"));
            rs.close();
            ps.close();
            return cos;
        }
        cos = null;
        rs.close();
        ps.close();
        return cos;
    }

    /**
     * 获取合同下的合同行的评审明细状态。
     * @param con
     * @param reviewNo
     * @return
     * @throws SQLException
     */
    public List<String> getOrderReviewStatus(Connection con, String reviewNo)
            throws SQLException {
        List<String> list = new ArrayList<String>();

        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.SelectAllOrderLineReviewSts");
        PreparedStatement ps = con.prepareStatement(sql);
        ps.setObject(1, reviewNo);
        ResultSet rs = ps.executeQuery();
        while (rs.next()) {
            list.add(rs.getString(1));
        }
        rs.close();
        ps.close();
        return list;
    }

    /**
     * 取得评审明细表的内容，实体类
     * @param con
     * @param reviewNo
     * @return
     * @throws SQLException
     */
    public List<SlmOrderReviewItemListEntity> getOrderReviewItemList(
            Connection con, String reviewNo) throws SQLException {
        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.GetOrderReviewItemList");
        List<SlmOrderReviewItemListEntity> list = new ArrayList<SlmOrderReviewItemListEntity>();
        PreparedStatement ps = con.prepareStatement(sql);
        ps.setObject(1, reviewNo);

        ResultSet rs = ps.executeQuery();
        list = EntityTool
                .getEntitysByRs(rs, SlmOrderReviewItemListEntity.class);
        rs.close();
        ps.close();
        return list;
    }


    /**
     * 向crm表插入信息
     * @param con
     * @param reviewNo
     * @return
     * @throws SQLException
     */
    public void doCrmEvent(Connection con,String ordPk,
                           String ordLnPk, String ordLnDlyPk,String flag) throws SQLException {
        doCrmEvent(con,ordPk,ordLnPk,ordLnDlyPk,flag,"");
    }
    public void doCrmEvent(Connection con,String ordPk,
    		String ordLnPk, String ordLnDlyPk,String flag,String dataFlag1) throws SQLException {
        if(StringUtils.isEmpty(ordPk) && StringUtils.isEmpty(ordLnPk) && StringUtils.isEmpty(ordLnDlyPk)){
            return;
        }
     	List<CrmSlmOrder> list = new ArrayList<CrmSlmOrder>();
        String dataFlag = "";
        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.getCrmOrderInfo");
        if(!"".equals(ordPk)){
            dataFlag = "0";
            if(flag.equals("2")){
                sql+=" AND H.ORD_PK='"+ordPk+"'";
            } else if ("1".equals(dataFlag1)){
                sql+=" AND H.ORD_PK='"+ordPk+"' AND L.VALIDFLAG='1' AND H.VALIDFLAG='1'";
            } else if("2".equals(dataFlag1)){
                sql+=" AND H.ORD_PK='"+ordPk+"' AND L.VALIDFLAG='1' AND D.VALIDFLAG='1' AND H.VALIDFLAG='1'";
            } else if(flag.equals("1")){
                sql+=" AND H.ORD_PK='"+ordPk+"' AND L.VALIDFLAG='1' AND H.VALIDFLAG='1'";
            } else {
                sql+=" AND H.ORD_PK='"+ordPk+"' AND H.VALIDFLAG='1'";
            }
        }
        if(!"".equals(ordLnPk)){
            dataFlag = "1";
            if("2".equals(dataFlag1)){
                sql+=" AND L.ORD_LN_PK='"+ordLnPk+"' AND L.VALIDFLAG='1' AND D.VALIDFLAG='1' ";
            } else {
                sql+=" AND L.ORD_LN_PK='"+ordLnPk+"' AND L.VALIDFLAG='1' ";
            }
        }
        if(!"".equals(ordLnDlyPk)){
            dataFlag = "2";
        	sql+=" AND D.ORD_LN_DLY_PK='"+ordLnDlyPk+"' AND D.VALIDFLAG='1' ";
        }
        if(!StringUtils.isEmpty(dataFlag1)){
            dataFlag = dataFlag1;
        }
        if(flag.equals("2") && !dataFlag.equals("2")){
            sql += " AND ROWNUM = 1";
        }
        PreparedStatement ps = con.prepareStatement(sql);
        ResultSet rs = ps.executeQuery();
        list = EntityTool
                .getEntitysByRs(rs, CrmSlmOrder.class);

        if (list == null || list.size() <= 0) {
            return;
        }


        Map<String,List<CrmSlmOrder>> map = new HashMap<String,List<CrmSlmOrder>>();
        List<CrmSlmOrder> crmSlmOrderList = new ArrayList<CrmSlmOrder>();
        if("0".equals(dataFlag)){
            crmSlmOrderList.add(list.get(0));
            map.put(list.get(0).getOrdPk(), crmSlmOrderList);
        }
        for (CrmSlmOrder crmSlmOrder : list) {
            if("1".equals(dataFlag) && !map.containsKey(crmSlmOrder.getOrdLnPk())){
                crmSlmOrderList.add(crmSlmOrder);
                map.put(crmSlmOrder.getOrdLnPk(), crmSlmOrderList);
            }
            if("2".equals(dataFlag) && !map.containsKey(crmSlmOrder.getOrdLnDlyPk())){
                crmSlmOrderList.add(crmSlmOrder);
                map.put(crmSlmOrder.getOrdLnDlyPk(), crmSlmOrderList);
            }
        }
        list = crmSlmOrderList;
        for(CrmSlmOrder crm: list){
            if (!StringUtils.isEmpty(crm.getIslock()) && crm.getIslock().equals("1")) {
                continue;
            }
            sql = CoreXmlSqlParsersFactory
                    .getSql("" +
                            "CoreOrderInfoUpdate.insertCrmOrder");
            if(!"".equals(crm.getPorderstatus())){
            	if("0".equals(crm.getPorderstatus())){
                	crm.setOrderSts("12020402");
                	crm.setOrderStsDesc("待接收");
            	}else{
                	crm.setOrderSts("12020502");
                	crm.setOrderStsDesc("已接收");
            	}
            }
            crm.setDataStatus(flag);
            crm.setDataFlag(dataFlag);
            sql = EntityTool.fillSqlByEntity(sql, crm);
            ps = con.prepareStatement(sql);
            ps.executeUpdate();
            rs.close();
            ps.close();
        }
    }


    public void doCrmHeadEvent(Connection con,String ordPk,String flag,String dataFlag1) throws SQLException {
        List<CrmSlmOrder> list = new ArrayList<CrmSlmOrder>();
        String dataFlag = "";
        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.getOrderHeadInfo");
        sql+=" AND H.ORD_PK='"+ordPk+"'";
        PreparedStatement ps = con.prepareStatement(sql);
        ResultSet rs = ps.executeQuery();
        list = EntityTool
                .getEntitysByRs(rs, CrmSlmOrder.class);
        for(CrmSlmOrder crm: list){
            if (!StringUtils.isEmpty(crm.getIslock()) && crm.getIslock().equals("1")) {
                continue;
            }
            sql = CoreXmlSqlParsersFactory
                    .getSql("" +
                            "CoreOrderInfoUpdate.insertCrmOrder");
            if(!"".equals(crm.getPorderstatus())){
                if("0".equals(crm.getPorderstatus())){
                    crm.setOrderSts("12020402");
                    crm.setOrderStsDesc("待接收");
                }else{
                    crm.setOrderSts("12020502");
                    crm.setOrderStsDesc("已接收");
                }
            }
            crm.setDataStatus(flag);
            crm.setDataFlag(dataFlag);
            sql = EntityTool.fillSqlByEntity(sql, crm);
            ps = con.prepareStatement(sql);
            ps.executeUpdate();
            rs.close();
            ps.close();
        }
    }


    /**
     * 获取评审项目表中指定项目的状态值。
     * @param con
     * @param reviewNo
     * @param item
     * @return
     * @throws SQLException
     */
    public String getOrderReviewItemSatus(Connection con, String reviewNo,
            String item) throws SQLException {
        String status = "";
        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.GetOrderReviewItemSts");
        PreparedStatement ps = con.prepareStatement(sql);
        ps.setObject(1, reviewNo);
        ps.setObject(2, item);

        ResultSet rs = ps.executeQuery();
        if (rs.next()) {
            status = rs.getString(1);
        }
        rs.close();
        ps.close();
        return status;
    }

    /**
     * 获取和同行的状态 交货期评审通过到生效
     * @param con
     * @return
     * @throws SQLException
     */
    public HashMap<String, String> getOrderStatus(Connection con)
            throws SQLException {
        HashMap<String, String> map = new HashMap<String, String>();
        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.QueryOrderStatus");
        PreparedStatement ps = con.prepareStatement(sql);
        ResultSet rs = ps.executeQuery();
        while (rs.next()) {
            map.put(rs.getString(1), rs.getString(2));
        }
        rs.close();
        ps.close();
        return map;
    }

    /**
     * 删除质量设计制程-工艺参数表
     * @param con
     * @param ordPk
     * @param ordLnPk
     * @throws SQLException
     */
    public void deletePlSTITC(Connection con, String ordPk, String ordLnPk)
            throws SQLException {
        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.DeleteDisignPLSTITC");
        PreparedStatement ps = con.prepareStatement(sql);
        ps.setObject(1, ordPk);
        ps.setObject(2, ordLnPk);
        ps.executeUpdate();
        ps.close();
    }

    /**
     * 获取ORDPK下的所有合同行的状态
     * @param con
     * @param ordPk
     * @return
     * @throws SQLException
     */
    public List<String> getOrderLineStatusAll(Connection con, String ordPk)
            throws SQLException {
        List<String> list = new ArrayList<String>();
        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.SELECTAllLineStatus");
        PreparedStatement ps = con.prepareStatement(sql);
        ps.setObject(1, ordPk);

        ResultSet rs = ps.executeQuery();
        while (rs.next()) {
            list.add(rs.getString(1));
        }
        rs.close();
        ps.close();
        return list;
    }

    /**
     * 删除冶金规范码科室
     * @param con
     * @param ordLnPk
     * @throws SQLException
     */
    public void deleteMscDepartment(Connection con, String ordLnPk)
            throws SQLException {

        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.DeleteMscDepartment");
        PreparedStatement ps = con.prepareStatement(sql);
        ps.setObject(1, ordLnPk);
        ps.executeUpdate();
        ps.close();
    }

    /**
     * 清空合同行CUST_ALPHA2字段值
     * @param con
     * @param ordLnPk
     * @throws SQLException
     */
    public void clearOrderLineCustAlpha(Connection con, String ordLnPk)
            throws SQLException {
        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.ClearOrderLineCustAlpha");
        PreparedStatement ps = con.prepareStatement(sql);
        ps.setObject(1, ordLnPk);
        ps.executeUpdate();
        ps.close();
    }

    /**
     * 商品脱单
     * @param con
     * @param ordPk
     * @throws SQLException
     */
    public void takeOff(Connection con, String ordLnPk) throws SQLException {
        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.TakeOff");
        PreparedStatement ps = con.prepareStatement(sql);
        ps.setObject(1, ordLnPk);
        ps.executeUpdate();
        ps.close();
    }

    // --------------------------------------------2015-12-02
    // 新增采购合同--------------------------------------------

    /**
     * 新增采购期货（不加工）合同行
     * @param parm 合同行
     * @param parm1 采购清单
     * @param dept 部门+科室
     * @param saleOrg 销售组织
     * @return
     */
    public CoreReturnObject addPurchaseLine(String parm, String dept,
            String saleOrg) {
        CoreReturnObject cro = new CoreReturnObject();
        Connection con = null;
        JSONObject json = JSONObject.fromObject(parm);
        SlmOrderLineNewEntity sol = (SlmOrderLineNewEntity) JSONObject.toBean(
                json, SlmOrderLineNewEntity.class);
        try {
            String ordPk = sol.getOrdPk();
            String name = sol.getCreateName();
            con = this.getDao(CoreConstantData.sysbeanstr).getConnection();
            con.setAutoCommit(false);
            map = getOrderStatus(con);
            CoreOrderStatus cos = getOrderStatus(con, ordPk); // 合同状态
            if (cos == null) {
                cro.setV_errCode(-1);
                cro.setV_errMsg("合同头处于‘技术评审中’状态，不能新增合同行！");
                return cro;
            }

            if (cos.getOrderSts().equals("12020101")) { // 录入
                String reviewNo = getOrderReviewNo(con, ordPk);
                String ordLnPk = getAddLineOrdLnPk(con, ordPk);
                addPurchaseLineAndStatus(con, ordLnPk, sol);
                String ordType = CoreOrderStatusCommFun
                        .getOrderType(con, ordPk);
                if (!reviewNo.equals("") && !ordType.equals("120102")
                        && !ordType.equals("120105")) { // 不是现货合同 、采购期货不加工
                    String obj = dept + "-" + name
                            + "在[合同信息维护]界面，合同状态[录入]时，新增合同行。";
                    updateOrderReviewItem(con, reviewNo, "T", "L");
                    CoreOrderStatusCommFun.insertOrderReviewItemList(con,
                            reviewNo, "T", "L", ordLnPk, "L", name, dept, obj);
                }
                CoreOrderStatusCommFun.clearOrderPriceStatus(con, ordPk);
                cro.setV_errCode(0);
                // 添加crm
                doCrmEvent(con, "",ordLnPk,"","0");
                con.commit();

            }
            else if (cos.getOrderSts().equals("12020102")) { // 待提报评审
                updateOrderHeadStatus(con, ordPk, "12020102", "12020101", "录入");
                updateOrderLineStatus(con, ordPk, "12020102", "12020101");
                updateOrderDeliveryLineStatus(con, ordPk, "12020102",
                        "12020101");
                String ordLnPk = getAddLineOrdLnPk(con, ordPk);
                addPurchaseLineAndStatus(con, ordLnPk, sol);
                CoreOrderStatusCommFun.clearOrderPriceStatus(con, ordPk);
                // 添加crm
                doCrmEvent(con, "",ordLnPk,"","0");
                con.commit();
                cro.setV_errCode(0);
            }
            else if (cos.getOrderSts().equals("12020201")) {// 待技术评审
                cro.setV_errCode(-1);
                cro.setV_errMsg("合同头处于‘技术评审中’状态，不能新增合同行！");
            }
            else if (cos.getOrderSts().equals("12020202")) { // 技术评审通过
                updateOrderHeadStatus(con, ordPk, "12020202", "12020101", "录入");
                // 评审明细
                String reviewNo = getOrderReviewNo(con, ordPk);
                String ordLnPk = getAddLineOrdLnPk(con, ordPk);
                addPurchaseLineAndStatus(con, ordLnPk, sol);
                String obj = dept + "-" + name
                        + "在[合同信息维护]界面，合同状态[技术评审通过]时，新增合同行。";
                updateOrderReviewItem(con, reviewNo, "T", "L");
                CoreOrderStatusCommFun.insertOrderReviewItemList(con, reviewNo,
                        "T", "L", ordLnPk, "L", name, dept, obj);
                CoreOrderStatusCommFun.clearOrderPriceStatus(con, ordPk);
                // 添加crm
                doCrmEvent(con, "",ordLnPk,"","0");
                con.commit();
                cro.setV_errCode(0);
            }
            else if (cos.getOrderSts().equals("12020203")) {// 技术评审失败
                updateOrderHeadStatus(con, ordPk, "12020203", "12020101", "录入");
                // 评审明细
                String reviewNo = getOrderReviewNo(con, ordPk);
                String ordLnPk = getAddLineOrdLnPk(con, ordPk);
                addPurchaseLineAndStatus(con, ordLnPk, sol);
                String obj = dept + "-" + name
                        + "在[合同信息维护]界面，合同状态[技术评审失败]时，新增合同行。";
                CoreOrderStatusCommFun.insertOrderReviewItemList(con, reviewNo,
                        "T", "L", ordLnPk, "L", name, dept, obj);
                CoreOrderStatusCommFun.clearOrderPriceStatus(con, ordPk);
                // 添加crm
                doCrmEvent(con, "",ordLnPk,"","0");
                con.commit();
                cro.setV_errCode(0);
            }
            else if (cos.getOrderSts().equals("12020210")) { // 待交货期评审
                cro.setV_errCode(-1);
                cro.setV_errMsg("合同头处于‘待交货期评审’状态，不能新增合同行！");
            }
            else if (cos.getOrderSts().equals("12020211")) { // 交货期评审失败
                updateOrderHeadStatus(con, ordPk, "12020211", "12020101", "录入");
                updateOrderLineOnlyStatus(con, ordPk, "12020202");
                updateOrderDeliveryLineStatus(con, ordPk, "12020202",
                        "12020202");
                // 评审明细
                String reviewNo = getOrderReviewNo(con, ordPk);
                String ordLnPk = getAddLineOrdLnPk(con, ordPk);

                String obj = dept + "-" + name
                        + "在[合同信息维护]界面，合同状态[交货期评审失败]时，新增合同行。";
                CoreOrderStatusCommFun.insertOrderReviewItemList(con, reviewNo,
                        "T", "L", ordLnPk, "L", name, dept, obj);
                updateOrderReviewItem(con, reviewNo, "T", "L");
                CoreOrderStatusCommFun.updateOrderReviewItemList(con, reviewNo,
                        "D", "H", ordPk, obj);
                CoreOrderStatusCommFun.insertOrderReviewItemList(con, reviewNo,
                        "D", "H", ordPk, "L", name, dept, obj);
                updateOrderReviewItem(con, reviewNo, "D", "L");
                addPurchaseLineAndStatus(con, ordLnPk, sol);

                // 2015-07-13 add 封锁后面的状态 07-24 国贸没有价格 法务
                if (!saleOrg.equals("100102")) {
                    updateOrderReviewItem(con, reviewNo, "P", "L");
                    CoreOrderStatusCommFun.updateOrderReviewItemList(con,
                            reviewNo, "P", "H", ordPk, obj);
                    CoreOrderStatusCommFun.insertOrderReviewItemList(con,
                            reviewNo, "P", "H", ordPk, "L", name, dept, obj);

                    updateOrderReviewItem(con, reviewNo, "F", "L");
                    CoreOrderStatusCommFun.updateOrderReviewItemList(con,
                            reviewNo, "F", "H", ordPk, obj);
                    CoreOrderStatusCommFun.insertOrderReviewItemList(con,
                            reviewNo, "F", "H", ordPk, "L", name, dept, obj);
                }
                CoreOrderStatusCommFun.clearOrderPriceStatus(con, ordPk);
                // 添加crm
                doCrmEvent(con, "",ordLnPk,"","0");
                con.commit();
                cro.setV_errCode(0);
            }
            else if (lineStatus.contains(cos.getOrderSts())) {
                cro.setV_errCode(-1);
                cro.setV_errMsg("当前合同处于‘" + map.get(cos.getOrderSts())
                        + "’状态,不允许新增合同行！");
            }
        }
        catch (Exception e) {
            try {
                con.rollback();
                cro.setV_errCode(-1);
                cro.setV_errMsg(e.getMessage());
            }
            catch (SQLException e1) {
                e1.printStackTrace();
            }
        }
        finally {
            try {
                if (con != null && !con.isClosed()) {
                    con.close();
                }
            }
            catch (SQLException e) {
                e.printStackTrace();
            }
        }

        return cro;
    }

    /**
     * 新增合同行和采购清单
     * @param con 数据库连接
     * @param sol 合同行对象
     * @param ordLnPk 合同行PK值
     * @throws SQLException
     */
    public void addPurchaseLineAndStatus(Connection con, String ordLnPk,
            SlmOrderLineNewEntity sol) throws SQLException {
        // 生成ORD_LN_PK值 新增合同行+新增采购清单
        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.AddOrderLine");
        String sql1 = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.AddPurchaseLine");
        sol.setOrdLnPk(ordLnPk);
        sql = EntityTool.fillSqlByEntity(sql, sol);
        sql1 = EntityTool.fillSqlByEntity(sql1, sol);
        PreparedStatement ps = con.prepareStatement(sql);
        ps.executeUpdate();
        ps.close();
        ps = con.prepareStatement(sql1);
        ps.executeUpdate();
        ps.close();
    }

    /**
     * 修改采购期货合同不加工
     * @param con
     * @param sol
     * @param olp
     * @throws SQLException
     */
    public void updatePurchaseLineAndStatus(Connection con,
            SlmOrderLineNewEntity sol) throws SQLException {
        // 生成ORD_LN_PK值 新增合同行+新增采购清单
        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.UpdateOrderLine");
        String sql1 = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.UpdatePurchaseLine");

        sql = EntityTool.fillSqlByEntity(sql, sol);
        sql1 = EntityTool.fillSqlByEntity(sql1, sol);
        PreparedStatement ps = con.prepareStatement(sql);
        ps.executeUpdate();
        ps.close();
        ps = con.prepareStatement(sql1);
        ps.executeUpdate();
        ps.close();
    }

    /**
     * 采购期货不加工合同行修改
     * @param parm
     * @param parm1
     * @param dept
     * @param saleOrg
     * @return
     */
    public CoreReturnObject updatePurchaseLine(String parm, String dept,
            String saleOrg) {
        CoreReturnObject cro = new CoreReturnObject();
        Connection con = null;
        JSONObject json = JSONObject.fromObject(parm);
        SlmOrderLineNewEntity sol = (SlmOrderLineNewEntity) JSONObject.toBean(
                json, SlmOrderLineNewEntity.class);

        try {
            con = this.getDao(CoreConstantData.sysbeanstr).getConnection();
            con.setAutoCommit(false);
            map = getOrderStatus(con);
            String ordPk = sol.getOrdPk();
            String ordLnPk = sol.getOrdLnPk();
            CoreOrderStatus cos = getOrderStatus(con, ordPk); // 合同头状态
            CoreOrderStatus cosLine = getOrderLineStatus(con, ordLnPk); // 合同行状态

            if (cosLine.getOrderLnStatus().equals("12020101")) { // 合同行 录入状态
                updatePurchaseLineAndStatus(con, sol);
                updateOneOrderLineStatus(con, ordLnPk, "12020101", "12020101");
                updateOrderDeliveryLineStatusWithOrdLnPk(con, ordLnPk,
                        "12020101", "12020101");
                con.commit();
                cro.setV_errCode(0);
            }
            else if (cosLine.getOrderLnStatus().equals("12020102")) { // 待提报评审
                updatePurchaseLineAndStatus(con, sol);
                updateOrderHeadStatus(con, ordPk, "12020102", "12020101", "录入");
                updateOneOrderLineStatus(con, ordLnPk, "12020102", "12020101");
                updateOrderDeliveryLineStatusWithOrdLnPk(con, ordLnPk,
                        "12020102", "12020101");
                con.commit();
                cro.setV_errCode(0);
            }
            else if (cosLine.getOrderLnStatus().equals("12020201")) { // 待技术评审
                cro.setV_errCode(-1);
                cro.setV_errMsg("合同行处于‘技术评审中’状态，不允许修改！");
            }
            else if (cosLine.getOrderLnStatus().equals("12020202")) { // 技术评审通过

            }
            else if (cosLine.getOrderLnStatus().equals("12020203")) { // 技术评审失败

            }
            else if (cosLine.getOrderLnStatus().equals("12020210")) {// 待交货期评审
                cro.setV_errCode(-1);
                cro.setV_errMsg("合同行处于‘待交货期评审’状态，不允许修改！");
            }
            else if (cosLine.getOrderLnStatus().equals("12020211")) { // 交货期评审失败

            }
            else if (lineStatus.contains(cos.getOrderSts())) {

                cro.setV_errCode(-1);
                cro.setV_errMsg("当前合同处于‘" + map.get(cos.getOrderSts())
                        + "’状态,不允许修改合同行！");
            }
        }
        catch (Exception e) {
            try {
                con.rollback();
                cro.setV_errCode(-1);
                cro.setV_errMsg(e.getMessage());
            }
            catch (SQLException e1) {
                e1.printStackTrace();
            }
        }
        finally {
            try {
                if (con != null && !con.isClosed()) {
                    con.close();
                }
            }
            catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return cro;
    }

    /**
     * 更新交货信息
     * @param ordLnPk
     * @param dlyDesc
     * @return
     */
    public CoreReturnObject updateOrderLineDesc(String ordLnPk, String dlyDesc) {
        Object[] obj = new Object[] { dlyDesc, ordLnPk, ordLnPk };
        return this.setDataBySqlID("CoreOrderInfoUpdate.UpdateOrderLineDesc",
                obj);
    }

    /**
     * 删除采购清单
     * @param con
     * @param ordLnPk
     * @throws SQLException
     */
    public void deletePurchaseLine(Connection con, String ordLnPk)
            throws SQLException {
        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.DeletePurchaseLine");
        PreparedStatement ps = con.prepareStatement(sql);
        ps.setObject(1, ordLnPk);
        ps.executeUpdate();
        ps.close();
    }

    /**
     * 采购期货加工合同行新增
     * @param parm
     * @param parm1
     * @param dept
     * @param saleOrg
     * @return
     * @throws SQLException
     */
    public CoreReturnObject addOrdPurLine(String parm, String parm1,
            String dept, String saleOrg) throws SQLException {
        CoreReturnObject cro = new CoreReturnObject();
        Connection con = null;
        JSONObject json = JSONObject.fromObject(parm);
        JSONObject json1 = JSONObject.fromObject(parm1);
        ChgeSlmOrderLineEntity soe = (ChgeSlmOrderLineEntity) JSONObject
                .toBean(json, ChgeSlmOrderLineEntity.class);
        SlmOrderLineNewEntity sol = (SlmOrderLineNewEntity) JSONObject.toBean(
                json1, SlmOrderLineNewEntity.class);
        try {
            con = this.getDao(CoreConstantData.sysbeanstr).getConnection();
            con.setAutoCommit(false);
            map = getOrderStatus(con);
            String ordPk = soe.getOrdPk();
            String name = soe.getCreateName();
            CoreOrderStatus cos = getOrderStatus(con, ordPk); // 合同状态
            if (cos.getOrderSts().equals("12020101")) { // 录入
                String reviewNo = getOrderReviewNo(con, ordPk);
                String ordLnPk = getAddLineOrdLnPk(con, ordPk);
                addOrdLine(con, ordLnPk, soe);
                addPurLine(con, ordLnPk, sol);
                String ordType = CoreOrderStatusCommFun
                        .getOrderType(con, ordPk);
                if (!reviewNo.equals("") && !ordType.equals("120102")) { // 不是现货合同
                    String obj = dept + "-" + name
                            + "在[合同信息维护]界面，合同状态[录入]时，新增合同行。";
                    updateOrderReviewItem(con, reviewNo, "T", "L");
                    CoreOrderStatusCommFun.insertOrderReviewItemList(con,
                            reviewNo, "T", "L", ordLnPk, "L", name, dept, obj);
                }
                CoreOrderStatusCommFun.clearOrderPriceStatus(con, ordPk);
                cro.setV_errCode(0);
                // 添加crm
                doCrmEvent(con, "",ordLnPk,"","0");
                con.commit();
            }
            else if (cos.getOrderSts().equals("12020102")) { // 待提报评审
                updateOrderHeadStatus(con, ordPk, "12020102", "12020101", "录入");
                updateOrderLineStatus(con, ordPk, "12020102", "12020101");
                updateOrderDeliveryLineStatus(con, ordPk, "12020102",
                        "12020101");
                String ordLnPk = getAddLineOrdLnPk(con, ordPk);
                addOrdLine(con, ordLnPk, soe);
                addPurLine(con, ordLnPk, sol);
                CoreOrderStatusCommFun.clearOrderPriceStatus(con, ordPk);
                // 添加crm
                doCrmEvent(con, "",ordLnPk,"","0");
                con.commit();
                cro.setV_errCode(0);
            }
            else if (cos.getOrderSts().equals("12020201")) {// 技术评审中

                cro.setV_errCode(-1);
                cro.setV_errMsg("合同头处于‘技术评审中’状态，不能新增合同行！");
            }
            else if (cos.getOrderSts().equals("12020202")) { // 技术评审通过
                updateOrderHeadStatus(con, ordPk, "12020202", "12020101", "录入");
                // 评审明细
                String reviewNo = getOrderReviewNo(con, ordPk);
                String ordLnPk = getAddLineOrdLnPk(con, ordPk);
                addOrdLine(con, ordLnPk, soe);
                addPurLine(con, ordLnPk, sol);
                String obj = dept + "-" + name
                        + "在[合同信息维护]界面，合同状态[技术评审通过]时，新增合同行。";
                updateOrderReviewItem(con, reviewNo, "T", "L");
                CoreOrderStatusCommFun.insertOrderReviewItemList(con, reviewNo,
                        "T", "L", ordLnPk, "L", name, dept, obj);
                CoreOrderStatusCommFun.clearOrderPriceStatus(con, ordPk);
                // 添加crm
                doCrmEvent(con, "",ordLnPk,"","0");
                con.commit();
                cro.setV_errCode(0);
            }
            else if (cos.getOrderSts().equals("12020203")) {// 技术评审失败
                updateOrderHeadStatus(con, ordPk, "12020203", "12020101", "录入");
                // 评审明细
                String reviewNo = getOrderReviewNo(con, ordPk);
                String ordLnPk = getAddLineOrdLnPk(con, ordPk);
                addOrdLine(con, ordLnPk, soe);
                addPurLine(con, ordLnPk, sol);
                String obj = dept + "-" + name
                        + "在[合同信息维护]界面，合同状态[技术评审失败]时，新增合同行。";
                CoreOrderStatusCommFun.insertOrderReviewItemList(con, reviewNo,
                        "T", "L", ordLnPk, "L", name, dept, obj);
                CoreOrderStatusCommFun.clearOrderPriceStatus(con, ordPk);
                // 添加crm
                doCrmEvent(con, "",ordLnPk,"","0");
                con.commit();
                cro.setV_errCode(0);

            }
            else if (cos.getOrderSts().equals("12020210")) { // 待交货期评审
                cro.setV_errCode(-1);
                cro.setV_errMsg("合同头处于‘待交货期评审’状态，不能新增合同行！");
            }
            else if (cos.getOrderSts().equals("12020211")) { // 交货期评审失败
                updateOrderHeadStatus(con, ordPk, "12020211", "12020101", "录入");
                updateOrderLineOnlyStatus(con, ordPk, "12020202");
                updateOrderDeliveryLineStatus(con, ordPk, "12020202",
                        "12020202");
                // 评审明细
                String reviewNo = getOrderReviewNo(con, ordPk);
                String ordLnPk = getAddLineOrdLnPk(con, ordPk);

                String obj = dept + "-" + name
                        + "在[合同信息维护]界面，合同状态[交货期评审失败]时，新增合同行。";
                CoreOrderStatusCommFun.insertOrderReviewItemList(con, reviewNo,
                        "T", "L", ordLnPk, "L", name, dept, obj);
                updateOrderReviewItem(con, reviewNo, "T", "L");
                CoreOrderStatusCommFun.updateOrderReviewItemList(con, reviewNo,
                        "D", "H", ordPk, obj);
                CoreOrderStatusCommFun.insertOrderReviewItemList(con, reviewNo,
                        "D", "H", ordPk, "L", name, dept, obj);
                updateOrderReviewItem(con, reviewNo, "D", "L");
                addOrdLine(con, ordLnPk, soe);
                addPurLine(con, ordLnPk, sol);

                // 2015-07-13 add 封锁后面的状态 07-24 国贸没有价格 法务
                if (!saleOrg.equals("100102")) {
                    updateOrderReviewItem(con, reviewNo, "P", "L");
                    CoreOrderStatusCommFun.updateOrderReviewItemList(con,
                            reviewNo, "P", "H", ordPk, obj);
                    CoreOrderStatusCommFun.insertOrderReviewItemList(con,
                            reviewNo, "P", "H", ordPk, "L", name, dept, obj);

                    updateOrderReviewItem(con, reviewNo, "F", "L");
                    CoreOrderStatusCommFun.updateOrderReviewItemList(con,
                            reviewNo, "F", "H", ordPk, obj);
                    CoreOrderStatusCommFun.insertOrderReviewItemList(con,
                            reviewNo, "F", "H", ordPk, "L", name, dept, obj);
                }
                CoreOrderStatusCommFun.clearOrderPriceStatus(con, ordPk);
                // 添加crm
                doCrmEvent(con, "",ordLnPk,"","0");
                con.commit();
                cro.setV_errCode(0);
            }
            else if (lineStatus.contains(cos.getOrderSts())) {
                cro.setV_errCode(-1);
                cro.setV_errMsg("当前合同处于‘" + map.get(cos.getOrderSts())
                        + "’状态,不允许新增合同行！");
            }
        }
        catch (Exception e) {
            try {
                con.rollback();
                cro.setV_errCode(-1);
                cro.setV_errMsg(e.getMessage());
            }
            catch (SQLException e1) {
                e1.printStackTrace();
            }
        }
        finally {
            try {
                if (con != null && !con.isClosed()) {
                    con.close();
                }
            }
            catch (SQLException e) {
                e.printStackTrace();
            }
        }

        return cro;
    }

    /**
     * 新增采购期货加工的合同行
     * @param con
     * @param ordLnPk
     * @param soe
     * @throws SQLException
     */
    public void addOrdLine(Connection con, String ordLnPk,
            ChgeSlmOrderLineEntity soe) throws SQLException {
        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.AddOrdLine");
        soe.setOrdLnPk(ordLnPk);
        sql = EntityTool.fillSqlByEntity(sql, soe);
        PreparedStatement ps = con.prepareStatement(sql);
        ps.executeUpdate();
        ps.close();

    }

    /**
     * 新增采购期货加工的采购清单
     * @param con
     * @param ordLnPk
     * @param sol
     * @throws SQLException
     */
    public void addPurLine(Connection con, String ordLnPk,
            SlmOrderLineNewEntity sol) throws SQLException {
        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.AddPurLine");
        sol.setOrdLnPk(ordLnPk);
        sql = EntityTool.fillSqlByEntity(sql, sol);
        PreparedStatement ps = con.prepareStatement(sql);
        ps.executeUpdate();
        ps.close();
    }

    /**
     * 修改采购期货加工合同行和采购清单
     * @param parm
     * @param parm1
     * @param dept
     * @param saleOrg
     * @param flag
     * @param reviewMemo
     * @return
     */
    public CoreReturnObject updateOrdPurchaseLine(String parm, String parm1,
            String dept, String saleOrg, Boolean flag, String reviewMemo,
            Boolean isClear) {
        CoreReturnObject cro = new CoreReturnObject();
        Connection con = null;
        JSONObject json = JSONObject.fromObject(parm);
        JSONObject json1 = JSONObject.fromObject(parm1);
        ChgeSlmOrderLineEntity soe = (ChgeSlmOrderLineEntity) JSONObject
                .toBean(json, ChgeSlmOrderLineEntity.class);
        SlmOrderLineNewEntity sol = (SlmOrderLineNewEntity) JSONObject.toBean(
                json1, SlmOrderLineNewEntity.class);
        try {
            con = this.getDao(CoreConstantData.sysbeanstr).getConnection();
            con.setAutoCommit(false);
            map = getOrderStatus(con);
            String ordPk = soe.getOrdPk();
            String ordLnPk = soe.getOrdLnPk();
            String name = soe.getCreateName();
            CoreOrderStatus cos = getOrderStatus(con, ordPk); // 合同头状态
            CoreOrderStatus cosLine = getOrderLineStatus(con, ordLnPk); // 合同行状态

            if (cosLine.getOrderLnStatus().equals("12020101")) { // 合同行 录入状态
                String reviewNo = getOrderReviewNo(con, ordPk);
                if (isClear) {
                    clearOrderLineCustAlpha(con, ordLnPk);
                }
                if (!reviewNo.equals("")) {
                    if (flag) { // 存在评审单号 同时修改了技术项
                        String obj = dept + "-" + name
                                + "在[合同信息维护]界面，合同状态[录入]时，修改合同行信息。";

                        CoreOrderStatusCommFun.updateOrderReviewItemList(con,
                                reviewNo, "T", "L", ordLnPk, obj);
                        updateOrderReviewItem(con, reviewNo, "T", "L");
                        CoreOrderStatusCommFun.insertOrderReviewItemList(con,
                                reviewNo, "T", "L", ordLnPk, "L", name, dept,
                                obj);
                        // 清除合同行的监制信息
                        String[] arr = CoreOrderStatusCommFun
                                .getOrderLinePrdcrNo(con, ordLnPk);
                        CoreOrderStatusCommFun.clearOrderLinePrdcrNo(con,
                                ordLnPk);
                        if (arr != null && arr.length > 0) {
                            CoreOrderStatusCommFun.deleteOrderLinePrdcrList(
                                    con, arr);
                        }
                    }
                }
                updateOrdLine(con, soe);
                updatePurLine(con, sol);
                updateOneOrderLineStatus(con, ordLnPk, "12020101", "12020101");
                updateOrderDeliveryLineStatusWithOrdLnPk(con, ordLnPk,
                        "12020101", "12020101");
                con.commit();
                cro.setV_errCode(0);
            }
            else if (cosLine.getOrderLnStatus().equals("12020102")) { // 待提报评审
                updateOrdLine(con, soe);
                updatePurLine(con, sol);
                updateOrderHeadStatus(con, ordPk, "12020102", "12020101", "录入");
                updateOneOrderLineStatus(con, ordLnPk, "12020102", "12020101");
                updateOrderDeliveryLineStatusWithOrdLnPk(con, ordLnPk,
                        "12020102", "12020101");
                con.commit();
                cro.setV_errCode(0);
            }
            else if (cosLine.getOrderLnStatus().equals("12020201")) { // 待技术评审

                cro.setV_errCode(-1);
                cro.setResult("合同行处于‘技术评审中’状态，不允许修改！");
            }
            else if (cosLine.getOrderLnStatus().equals("12020202")) { // 技术评审通过
                updateOrderHeadStatus(con, ordPk, "12020202", "12020101", "录入");
                updateOneOrderLineStatus(con, ordLnPk, "12020202", "12020101");
                updateOrderDeliveryLineStatusWithOrdLnPk(con, ordLnPk,
                        "12020202", "12020101");
                updateOrdLine(con, soe);
                updatePurLine(con, sol);
                if (isClear) {
                    clearOrderLineCustAlpha(con, ordLnPk);
                }
                if (flag) { // 涉及到技术项的修改。
                    String reviewNo = getOrderReviewNo(con, ordPk);
                    String obj = dept + "-" + name
                            + "在[合同信息维护]界面，合同状态[技术评审通过]时，修改合同行信息。";

                    CoreOrderStatusCommFun.updateOrderReviewItemList(con,
                            reviewNo, "T", "L", ordLnPk, obj);
                    updateOrderReviewItem(con, reviewNo, "T", "L");

                    CoreOrderStatusCommFun.insertOrderReviewItemList(con,
                            reviewNo, "T", "L", ordLnPk, "L", name, dept, obj);

                    // 清除合同行的监制信息
                    String[] arr = CoreOrderStatusCommFun.getOrderLinePrdcrNo(
                            con, ordLnPk);
                    CoreOrderStatusCommFun.clearOrderLinePrdcrNo(con, ordLnPk);
                    if (arr != null && arr.length > 0) {
                        CoreOrderStatusCommFun.deleteOrderLinePrdcrList(con,
                                arr);
                    }
                }
                con.commit();
                cro.setV_errCode(0);
            }
            else if (cosLine.getOrderLnStatus().equals("12020203")) { // 技术评审失败
                updateOrderHeadStatus(con, ordPk, "12020203", "12020101", "录入");
                updateOneOrderLineStatus(con, ordLnPk, "12020203", "12020101");
                updateOrderDeliveryLineStatusWithOrdLnPk(con, ordLnPk,
                        "12020203", "12020101");
                updateOrdLine(con, soe);
                updatePurLine(con, sol);
                // 涉及到技术项的修改。
                String reviewNo = getOrderReviewNo(con, ordPk);
                String obj = dept + "-" + name
                        + "在[合同信息维护]界面，合同状态[技术评审失败]时，修改合同行信息。";
                // updateOrderReviewItemList(con, reviewNo, "T", "L",
                // ordLnPk);
                CoreOrderStatusCommFun.updateOrderReviewItemList(con, reviewNo,
                        "T", "L", ordLnPk, obj);
                updateOrderReviewItem(con, reviewNo, "T", "L");
                CoreOrderStatusCommFun.updateOrderReviewItemList(con, reviewNo,
                        "T", "L", ordLnPk, obj);

                CoreOrderStatusCommFun.insertOrderReviewItemList(con, reviewNo,
                        "T", "L", ordLnPk, "L", name, dept, obj, reviewMemo);

                // 清除合同行的监制信息
                String[] arr = CoreOrderStatusCommFun.getOrderLinePrdcrNo(con,
                        ordLnPk);
                CoreOrderStatusCommFun.clearOrderLinePrdcrNo(con, ordLnPk);
                if (arr != null && arr.length > 0) {
                    CoreOrderStatusCommFun.deleteOrderLinePrdcrList(con, arr);
                }
                if (isClear) {
                    clearOrderLineCustAlpha(con, ordLnPk);
                }
                con.commit();
                cro.setV_errCode(0);
            }
            else if (cosLine.getOrderLnStatus().equals("12020210")) {// 待交货期评审
                cro.setV_errCode(-1);
                cro.setResult("合同行处于‘待交货期评审’状态，不允许修改！");
            }
            else if (cosLine.getOrderLnStatus().equals("12020211")) { // 交货期评审失败
                updateOrderHeadStatus(con, ordPk, "12020211", "12020101", "录入");
                updateOneOrderLineStatus(con, ordLnPk, "12020211", "12020101");
                updateOrderDeliveryLineStatusWithOrdLnPk(con, ordLnPk,
                        "12020211", "12020101");
                updateOrdLine(con, soe);
                updatePurLine(con, sol);

                String reviewNo = getOrderReviewNo(con, ordPk);
                String obj = dept + "-" + name
                        + "在[合同信息维护]界面，合同状态[交货期失败]时，修改合同行信息。";
                CoreOrderStatusCommFun.updateOrderReviewItemList(con, reviewNo,
                        "D", "H", ordPk, obj);
                updateOrderReviewItem(con, reviewNo, "D", "L");
                CoreOrderStatusCommFun.insertOrderReviewItemList(con, reviewNo,
                        "D", "H", ordPk, "L", name, dept, obj);
                if (isClear) {
                    clearOrderLineCustAlpha(con, ordLnPk);
                }
                // 2015-07-13新增处理逻辑 7-24 国贸 没有价格 法务
                if (!saleOrg.equals("100102")) { // 不等于国贸公司
                    updateOrderReviewItem(con, reviewNo, "P", "L");
                    CoreOrderStatusCommFun.updateOrderReviewItemList(con,
                            reviewNo, "P", "H", ordPk, obj);
                    // CoreOrderStatusCommFun.updateOrderReviewItem
                    CoreOrderStatusCommFun.insertOrderReviewItemList(con,
                            reviewNo, "P", "H", ordPk, "L", name, dept, obj);

                    updateOrderReviewItem(con, reviewNo, "F", "L");
                    CoreOrderStatusCommFun.updateOrderReviewItemList(con,
                            reviewNo, "F", "H", ordPk, obj);
                    CoreOrderStatusCommFun.insertOrderReviewItemList(con,
                            reviewNo, "F", "H", ordPk, "L", name, dept, obj);
                }

                if (flag) { // 涉及到技术项的修改。

                    CoreOrderStatusCommFun.updateOrderReviewItemList(con,
                            reviewNo, "T", "L", ordLnPk, obj);
                    updateOrderReviewItem(con, reviewNo, "T", "L");
                    CoreOrderStatusCommFun.insertOrderReviewItemList(con,
                            reviewNo, "T", "L", ordLnPk, "L", name, dept, obj);
                    // 清除合同行的监制信息
                    String[] arr = CoreOrderStatusCommFun.getOrderLinePrdcrNo(
                            con, ordLnPk);
                    CoreOrderStatusCommFun.clearOrderLinePrdcrNo(con, ordLnPk);
                    if (arr != null && arr.length > 0) {
                        CoreOrderStatusCommFun.deleteOrderLinePrdcrList(con,
                                arr);
                    }
                }
                con.commit();
                cro.setV_errCode(0);
            }
            else if (lineStatus.contains(cos.getOrderSts())) {

                cro.setV_errCode(-1);
                cro.setResult("当前合同处于‘" + map.get(cos.getOrderSts())
                        + "’状态,不允许修改合同行！");
            }
        }
        catch (Exception e) {
            try {
                con.rollback();
                cro.setV_errCode(-1);
                cro.setV_errMsg(e.getMessage());
            }
            catch (SQLException e1) {
                e1.printStackTrace();
            }
        }
        finally {
            try {
                if (con != null && !con.isClosed()) {
                    con.close();
                }
            }
            catch (SQLException e) {
                e.printStackTrace();
            }
        }

        return cro;
    }

    /**
     * 修改采购期货加工合同行
     * @param con
     * @param soe
     * @throws SQLException
     */
    public void updateOrdLine(Connection con, ChgeSlmOrderLineEntity soe)
            throws SQLException {
        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.UpdateOrdLine");
        sql = EntityTool.fillSqlByEntity(sql, soe);
        PreparedStatement ps = con.prepareStatement(sql);
        ps.executeUpdate();
        ps.close();
    }

    /**
     * 修改采购期货加工采购清单
     * @param con
     * @param sol
     * @throws SQLException
     */
    public void updatePurLine(Connection con, SlmOrderLineNewEntity sol)
            throws SQLException {
        String sql = CoreXmlSqlParsersFactory
                .getSql("CoreOrderInfoUpdate.UpdatePurLine");
        sql = EntityTool.fillSqlByEntity(sql, sol);
        PreparedStatement ps = con.prepareStatement(sql);
        ps.executeUpdate();
        ps.close();
    }

    /**
     * 获取基础数据 COM_BASE_INFO
     * @param baseCode
     * @return
     */
    public CoreReturnObject getComBaseInfo(String sortCode) {
        Object[] obj = new Object[] { sortCode };
        return this.getDataBySqlID("CoreOrderInfoUpdate.getComBaseInfo", obj);
    }
}
