package com.steering.pss.sale.order;

import CoreFS.SA06.CoreReturnObject;
import CoreFS.SA08.CoreXmlSqlParsersFactory;
import CoreFS.SC01.CoreConstantData;
import com.steering.comm.db.DBCommon;
import com.steering.comm.tools.StringTool;
import com.steering.pss.sale.order.model.CoreOrderStatus;
import com.steering.pss.sale.order.model.SlmOrderPriceEntity;
import com.steering.pss.sale.order.model.SlmOrderReviewItemListEntity;
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.List;

public class CorePriceConfirm extends DBCommon {

    /**
     * 查询功能
     * @param ordPk
     * @return
     */
    public CoreReturnObject getOrderInfo(String ordPk) {
        Object[] obj = new Object[] { ordPk, ordPk };
        return this.getDataBySqlID("CorePriceConfirm.GetOrderInfo", obj);
    }

    /**
     * 修改价格（第一次新增，N次则修改）
     * @param ordPk
     * @param parm
     * @param parm1
     * @param saleOrg 销售组织
     * @param form 哪个界面的请求 等于2第一次业务员录入界面 需要判断合同状态
     * @param name 操作人
     * @return
     */
    @SuppressWarnings("unchecked")
    public CoreReturnObject savePrice(String ordPk, ArrayList<Object> parm,
            String parm1, String saleOrg, String form, String name) {
        CoreReturnObject cro = new CoreReturnObject();
        Connection con = null;
        try {
            con = this.getDao(CoreConstantData.sysbeanstr).getConnection();
            con.setAutoCommit(false);
            // 第一次业务员录入 这里的功能代码采用了原有的定价维护里面的SQL
            // 所以ID在其他XML
            if (form.equals("2")) {
                CoreOrderInfoUpdate cou = new CoreOrderInfoUpdate();
                CoreOrderStatus cos = cou.getOrderStatus(con, ordPk);
                if (cos.getOrderSts().equals("12020212")
                        || cos.getOrderSts().equals("12020213")
                        || cos.getOrderSts().equals("12020221")
                        || cos.getOrderSts().equals("12020223")
                        || cos.getOrderSts().equals("12020231")
                        || cos.getOrderSts().equals("12020241")) {
                    List<String> statuses = new ArrayList<String>();
                    statuses.add("12020221");
                    statuses.add("12020223");
                    statuses.add("12020241");
                    statuses.add("12020231");
                    if (statuses.contains(cos.getOrderSts())) {
                        // 修改合同头状态
                        String sql = CoreXmlSqlParsersFactory
                                .getSql("CoreOrderApproval.updateOrderHeadStatus");
                        PreparedStatement ps = con.prepareStatement(sql);
                        ps.setObject(1, "12020212");
                        ps.setObject(2, "交货期评审通过");
                        ps.setObject(3, ordPk);
                        ps.executeUpdate();
                        cou.doCrmEvent(con, ordPk,"","","1","0");
                        // 修改合同行状态
                        sql = CoreXmlSqlParsersFactory
                                .getSql("CoreOrderApproval.updateOrderLineStatus");
                        ps = con.prepareStatement(sql);
                        ps.setObject(1, "12020212");
                        ps.setObject(2, ordPk);
                        ps.executeUpdate();
                        cou.doCrmEvent(con, ordPk,"","","1","1");
                        // 修改交货行状态
                        sql = CoreXmlSqlParsersFactory
                                .getSql("CoreOrderApproval.updateOrderDeliveryStatus");
                        ps = con.prepareStatement(sql);
                        ps.setObject(1, "12020212");
                        ps.setObject(2, ordPk);
                        ps.executeUpdate();
                        //修改crm状态
                        cou.doCrmEvent(con, ordPk,"","","1","2");
                        // 修改评审明细中价格评审（标识为“1”）的标识为“0”，评审项目中价格评审的状态为“封锁”
                        sql = CoreXmlSqlParsersFactory
                                .getSql("CoreOrderPriceDetails.updateItemListP");
                        ps = con.prepareStatement(sql);
                        ps.setObject(1, ordPk);
                        ps.executeUpdate();
                        // 修改评审项目表价格状态为封锁
                        sql = CoreXmlSqlParsersFactory
                                .getSql("CoreOrderPriceDetails.updateItemP");
                        ps = con.prepareStatement(sql);
                        ps.setObject(1, ordPk);
                        ps.executeUpdate();
                        // 新增评审明细中价格评审明细记录，状态为“封锁”，标识为“1”
                        sql = CoreXmlSqlParsersFactory
                                .getSql("CoreOrderPriceDetails.addItemListP");
                        ps = con.prepareStatement(sql);
                        ps.setObject(1, ordPk);
                        ps.setObject(2, ordPk);
                        ps.setObject(3, ordPk);
                        ps.setObject(4, ordPk);
                        ps.setObject(5, name);
                        ps.executeUpdate();
                    }
                }
                else {
                    con.rollback();
                    cro.setV_errCode(-1);
                    cro.setV_errMsg("合同处于的状态不允许启动价格评审！");
                    return cro;
                }
            }
            JSONObject json = JSONObject.fromObject(parm1);
            SlmOrderPriceEntity sop = (SlmOrderPriceEntity) JSONObject.toBean(
                    json, SlmOrderPriceEntity.class);
            // 先判断这个合同是否存在价格审批单号，存在则判断价格评审单状态，允许修改的就更新，不允许的提示；不存在价格评审单号的则新增记录
            if (isExistsPriceNo(con, ordPk)) {
                String priceNo = getOrderPriceNo(con, ordPk);
                String status = getPriceNoStatus(con, priceNo);
                if (status.equals("L")) { // 修改价格
                    // 修改主表
                    String sql = CoreXmlSqlParsersFactory
                            .getSql("CorePriceConfirm.UpdateOrderPrice");
                    PreparedStatement ps = con.prepareStatement(sql);
                    ps.setObject(1, sop.getPriceBase());
                    ps.setObject(2, sop.getCreateName());
                    ps.setObject(3, priceNo);
                    ps.executeUpdate();
                    ps.close();
                    // 修改从表
                    for (int i = 0; i < parm.size(); i++) {
                        String sql1 = CoreXmlSqlParsersFactory
                                .getSql("CorePriceConfirm.UpdateOrderPriceList");
                        ArrayList<Object> list = (ArrayList<Object>) parm
                                .get(i);
                        ps = con.prepareStatement(sql1);
                        ps.setObject(1, list.get(0));
                        ps.setObject(2, list.get(1));
                        ps.setObject(3, list.get(2));
                        ps.setObject(4, list.get(3));
                        ps.setObject(5, sop.getCreateName());
                        ps.setObject(6, list.get(5));
                        ps.setObject(7, list.get(6));
                        ps.setObject(8, list.get(7));
                        ps.setObject(9, list.get(8));
                        ps.setObject(10, priceNo);
                        ps.setObject(11, list.get(4));
                        ps.executeUpdate();
                        ps.close();
                    }
                    con.commit();
                    cro.setV_errCode(0);
                    return cro;
                }
                else if (status.equals("") || status.equals("F")) {// 不通过的
                                                                   // 重新生成价格评审单号，通过的要想修改需要价格变更
                    String errMsg = insertOrderPriceData(con, parm, saleOrg,
                            sop, ordPk);
                    if (!errMsg.equals("")) {
                        con.rollback();
                        cro.setV_errCode(-1);
                        cro.setV_errMsg(errMsg);
                        return cro;
                    }
                    else {
                        cro.setV_errCode(0);
                        con.commit();
                        return cro;
                    }
                }
                else if (status.equals("S")) { // 价格评审通过 的不能再改！
                    con.rollback();
                    cro.setV_errCode(-1);
                    cro.setV_errMsg("价格评审单已经通过，不能再保存价格！");
                }
                else {
                    con.rollback();
                    cro.setV_errCode(-1);
                    cro.setV_errMsg("已存在待处理的价格评审单，请先处理！");
                }
            }
            else { // 不存在，新增价格评审单
                String errMsg = insertOrderPriceData(con, parm, saleOrg, sop,
                        ordPk);
                if (!errMsg.equals("")) {
                    con.rollback();
                    cro.setV_errCode(-1);
                    cro.setV_errMsg(errMsg);
                    return cro;
                }
                else {
                    cro.setV_errCode(0);
                    con.commit();
                    return cro;
                }
            }
        }
        catch (SQLException 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 parm 价格参数
     * @param saleOrg 销售组织
     * @param sop 价格单实体类
     * @param ordPk 合同主键
     * @return 错误信息
     * @throws SQLException
     */
    @SuppressWarnings("unchecked")
    private String insertOrderPriceData(Connection con, ArrayList<Object> parm,
            String saleOrg, SlmOrderPriceEntity sop, String ordPk)
            throws SQLException {
        String errMsg = "";
        String code = generatePriceNo(con, saleOrg);
        if (code.equals("")) {
            errMsg = "价格评审单号生成错误！";
        }
        else {
            // 插入主表
            String sql2 = CoreXmlSqlParsersFactory
                    .getSql("CorePriceConfirm.InsertOrderPrice");
            PreparedStatement ps = con.prepareStatement(sql2);
            ps.setObject(1, code);
            ps.setObject(2, sop.getPriceBase());
            ps.setObject(3, sop.getCreateName());
            ps.setObject(4, ordPk);
            ps.executeUpdate();
            ps.close();
            // 插入从表
            for (int i = 0; i < parm.size(); i++) {
                String sql1 = CoreXmlSqlParsersFactory
                        .getSql("CorePriceConfirm.InsertOrderPriceList");
                ArrayList<Object> list = (ArrayList<Object>) parm.get(i);
                ps = con.prepareStatement(sql1);
                ps.setObject(1, code);
                ps.setObject(2, list.get(4));
                ps.setObject(3, list.get(0));
                ps.setObject(4, list.get(1));
                ps.setObject(5, list.get(2));
                ps.setObject(6, list.get(3));
                ps.setObject(7, sop.getCreateName());
                ps.setObject(8, list.get(5));
                ps.setObject(9, list.get(6));
                ps.setObject(10, list.get(7));
                ps.executeUpdate();
                ps.close();
            }
            // 编号写入合同头
            String sqlH = CoreXmlSqlParsersFactory
                    .getSql("CorePriceConfirm.UpdateOrderHeadPriceNo");
            ps = con.prepareStatement(sqlH);
            ps.setObject(1, code);
            ps.setObject(2, ordPk);
            ps.executeUpdate();
            ps.close();
        }
        return errMsg;
    }

    /**
     * 价格确认
     * @param ordPk
     * @return
     */
    public CoreReturnObject confirmPrice(String ordPk, String parm) {
        CoreReturnObject cro = new CoreReturnObject();
        Connection con = null;
        try {
            JSONObject json = JSONObject.fromObject(parm);
            SlmOrderPriceEntity sop = (SlmOrderPriceEntity) JSONObject.toBean(
                    json, SlmOrderPriceEntity.class);
            con = this.getDao(CoreConstantData.sysbeanstr).getConnection();
            con.setAutoCommit(false);
            // 先判断是否有价格审批单，再判断其状态
            if (isExistsPriceNo(con, ordPk)) {
                String priceNo = getOrderPriceNo(con, ordPk);
                String status = getPriceNoStatus(con, priceNo);
                if (status.equals("")) {
                    cro.setV_errCode(-1);
                    cro.setV_errMsg("没有有效的价格审批单！");
                }
                else if (status.equals("L")) { // 可以确认
                    String sql = CoreXmlSqlParsersFactory
                            .getSql("CorePriceConfirm.ConfirmPrice");
                    PreparedStatement ps = con.prepareStatement(sql);
                    ps.setObject(1, sop.getReportDeptcode());
                    ps.setObject(2, sop.getReportDeptdesc());
                    ps.setObject(3, sop.getReportUnitcode());
                    ps.setObject(4, sop.getReportUnitdesc());
                    ps.setObject(5, sop.getReportName());
                    ps.setObject(6, priceNo);
                    ps.executeUpdate();
                    ps.close();
                    con.commit();
                    cro.setV_errCode(0);
                }
                else {
                    if (status.equals("W")) {
                        cro.setV_errCode(-1);
                        cro.setV_errMsg("该合同价格正在评审中，不必重复确认！");
                    }
                    else if (status.equals("S")) {
                        cro.setV_errCode(-1);
                        cro.setV_errMsg("该合同价格评审已通过，不必重复确认！");
                    }
                    else if (status.equals("F")) {
                        cro.setV_errCode(-1);
                        cro.setV_errMsg("该合同价格评审不通过，请先修改价格，再确认价格！");
                    }
                }
            }
            else {
                cro.setV_errCode(-1);
                cro.setV_errMsg("该合同尚未启动价格评审，不能确认！");
            }
        }
        catch (SQLException 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 ordPk
     * @param parm
     * @return
     */
    public CoreReturnObject deletePrice(String ordPk, String name) {
        CoreReturnObject cro = new CoreReturnObject();
        Connection con = null;
        try {
            con = this.getDao(CoreConstantData.sysbeanstr).getConnection();
            con.setAutoCommit(false);
            // 先判断是否有价格审批单，再判断其状态
            if (isExistsPriceNo(con, ordPk)) {
                String priceNo = getOrderPriceNo(con, ordPk);
                String status = getPriceNoStatus(con, priceNo);
                if (status.equals("")) {
                    cro.setV_errCode(-1);
                    cro.setV_errMsg("没有有效的价格审批单！");
                }
                else if (status.equals("L") || status.equals("W")) { // 可以作废
                    String sql = CoreXmlSqlParsersFactory
                            .getSql("CorePriceConfirm.DeletePrice");
                    PreparedStatement ps = con.prepareStatement(sql);
                    ps.setObject(1, name);
                    ps.setObject(2, priceNo);
                    ps.executeUpdate();
                    ps.close();
                    // String sql1 = CoreXmlSqlParsersFactory
                    // .getSql("CorePriceConfirm.DeletePriceCLearOrderHead");
                    // ps = con.prepareStatement(sql1);
                    // ps.setObject(1, ordPk);
                    // ps.executeUpdate();
                    // ps.close();
                    con.commit();
                    cro.setV_errCode(0);
                }
                else if (status.equals("S")) {
                    cro.setV_errCode(-1);
                    cro.setV_errMsg("该合同价格评审已通过，不能作废！");
                }
            }
            else {
                cro.setV_errCode(-1);
                cro.setV_errMsg("该合同尚未启动价格评审，不能作废！");
            }
        }
        catch (SQLException 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;
    }

    /**
     * 价格评审单通过 0时 需要更改合同状态为 价格评审通过 1时 不用更改合同状态
     * @param ordPk
     * @param name
     * @param dept
     * @param parm
     * @param form 来自于哪个界面的请求0 价格评审 1 价格变更
     * @param price 价格列表
     * @return
     */
    @SuppressWarnings("unchecked")
    public CoreReturnObject passPrice(String ordPk, String name, String dept,
            String parm, String form, ArrayList<Object> price) {
        CoreReturnObject cro = new CoreReturnObject();
        JSONObject json = JSONObject.fromObject(parm);
        SlmOrderPriceEntity sop = (SlmOrderPriceEntity) JSONObject.toBean(json,
                SlmOrderPriceEntity.class);
        Connection con = null;
        CoreOrderInfoUpdate cou = new CoreOrderInfoUpdate();
        try {
            con = this.getDao(CoreConstantData.sysbeanstr).getConnection();
            con.setAutoCommit(false);
            java.sql.Date date = new java.sql.Date(
                    new java.util.Date().getTime());
            // 先判断是否有价格审批单，再判断其状态
            String priceNo = ""; // 价格评审单号
            if (isExistsPriceNo(con, ordPk)) {
                priceNo = getOrderPriceNo(con, ordPk);
                String status = getPriceNoStatus(con, priceNo);
                if (status.equals("")) {
                    cro.setV_errCode(-1);
                    cro.setV_errMsg("没有有效的价格审批单！");
                }
                else if (status.equals("L")) { //
                    cro.setV_errCode(-1);
                    cro.setV_errMsg("价格评审尚未确认，不能评审通过！");
                }
                else if (status.equals("S")) {
                    cro.setV_errCode(-1);
                    cro.setV_errMsg("该合同价格评审已通过，不能重复评审！");
                }
                else if (status.equals("F")) {
                    cro.setV_errCode(-1);
                    cro.setV_errMsg("该合同价格评审不通过，不能重复评审！");
                }
            }
            else {
                cro.setV_errCode(-1);
                cro.setV_errMsg("该合同尚未启动价格评审，不能评审通过！");
            }

            if (form.equals("1") || form.equals("4")) {
                // 价格变更不更改合同状态
                // 更改价格评审状态为通过
                String sql = CoreXmlSqlParsersFactory
                        .getSql("CorePriceConfirm.PassOrBackPrice");
                PreparedStatement ps = con.prepareStatement(sql);
                ps.setObject(1, "S");
                ps.setObject(2, name);
                ps.setObject(3, sop.getDealDeptcode());
                ps.setObject(4, sop.getDealDeptdesc());
                ps.setObject(5, sop.getDealUnitcode());
                ps.setObject(6, sop.getDealUnitdesc());
                ps.setObject(7, priceNo);
                ps.executeUpdate();
                ps.close();
                // 保存修改的价格
                for (int i = 0; i < price.size(); i++) {
                    String sql1 = CoreXmlSqlParsersFactory
                            .getSql("CorePriceConfirm.UpdateOrderPriceList");
                    ArrayList<Object> list = (ArrayList<Object>) price.get(i);
                    ps = con.prepareStatement(sql1);
                    ps.setObject(1, list.get(0));
                    ps.setObject(2, list.get(1));
                    ps.setObject(3, list.get(2));
                    ps.setObject(4, list.get(3));
                    ps.setObject(5, sop.getDealName());
                    ps.setObject(6, list.get(5));
                    ps.setObject(7, list.get(6));
                    ps.setObject(8, list.get(7));
                    ps.setObject(9, list.get(9));
                    ps.setObject(10, priceNo);
                    ps.setObject(11, list.get(4));
                    ps.executeUpdate();
                    ps.close();
                }
                // 保存价格到合同行上
                savePriceToLine(con, priceNo);
                updateOrderConfirmTime(con, ordPk);
//                cou.doCrmEvent(con, ordPk,"","","1","1");
                con.commit();
                cro.setV_errCode(0);
                return cro;
            }
            else { // 业务员第一次录入价格
                CoreOrderStatus cos = cou.getOrderStatus(con, ordPk);
                if (cos.getOrderSts().equals("12020224")) { // 审批通过
                    String reviewNo = cou.getOrderReviewNo(con, ordPk);
                    CoreOrderStatusCommFun.updateOrderHeadStatus(con, ordPk,
                            "12020224", "12020232", "价格评审通过", name,
                            date.toString());
                    cou.updateOrderLineStatus(con, ordPk, "12020224",
                            "12020232");
                    cou.updateOrderDeliveryLineStatus(con, ordPk, "12020224",
                            "12020232");
                    // 评审表
                    String obj = dept + "-" + name + "在[合同价格评审]界面,点击[价格评审],并点击[评审通过]";
                    CoreOrderStatusCommFun.updateOrderReviewItemList(con,
                            reviewNo, "P", "H", ordPk, "S", "1", name, dept,
                            "", obj);
                    CoreOrderStatusCommFun.updateOrderReviewItemEDate(con,
                            reviewNo, "P", "S");
                    String stsT = cou.getOrderReviewItemSatus(con, reviewNo,
                            "T");
                    String stsD = cou.getOrderReviewItemSatus(con, reviewNo,
                            "D");
                    String stsP = cou.getOrderReviewItemSatus(con, reviewNo,
                            "P");
                    String stsF = cou.getOrderReviewItemSatus(con, reviewNo,
                            "F");
                    if (stsT.equals("S") && stsD.equals("S")
                            && stsP.equals("S") && stsF.equals("S")) {
                        CoreOrderStatusCommFun.updateOrderHeadStatus(con,
                                ordPk, "12020224", "12020251", "评审通过", name,
                                date.toString());
                        cou.updateOrderLineStatus(con, ordPk, "12020224",
                                "12020251");
                        cou.updateOrderDeliveryLineStatus(con, ordPk,
                                "12020224", "12020251");
                    }
                    else {
                        List<SlmOrderReviewItemListEntity> list = CoreOrderStatusCommFun
                                .selectOrderReviewItemListInfo(con, reviewNo,
                                        "P", "H", ordPk);
                        CoreOrderStatusCommFun.setOrderReviewItemListValue(con,
                                reviewNo, "P", "H", ordPk);
                        if (list != null && list.size() > 0) {
                            SlmOrderReviewItemListEntity slm = list.get(0);
                            slm.setCreateName(name);
                            slm.setReviewDept(dept);
                            slm.setReviewEdate("");
                            slm.setReviewBdate("");
                            CoreOrderStatusCommFun.addOrderReviewItemListInfo(
                                    con, slm);
                        }
                        else {
                            con.rollback();
                        }
                    }
                    // 更改价格评审状态为通过
                    String sql = CoreXmlSqlParsersFactory
                            .getSql("CorePriceConfirm.PassOrBackPrice");
                    PreparedStatement ps = con.prepareStatement(sql);
                    ps.setObject(1, "S");
                    ps.setObject(2, name);
                    ps.setObject(3, sop.getDealDeptcode());
                    ps.setObject(4, sop.getDealDeptdesc());
                    ps.setObject(5, sop.getDealUnitcode());
                    ps.setObject(6, sop.getDealUnitdesc());
                    ps.setObject(7, priceNo);
                    ps.executeUpdate();
                    ps.close();
                    // 保存修改的价格
                    for (int i = 0; i < price.size(); i++) {
                        String sql1 = CoreXmlSqlParsersFactory
                                .getSql("CorePriceConfirm.UpdateOrderPriceList");
                        ArrayList<Object> list = (ArrayList<Object>) price
                                .get(i);
                        ps = con.prepareStatement(sql1);
                        ps.setObject(1, list.get(0));
                        ps.setObject(2, list.get(1));
                        ps.setObject(3, list.get(2));
                        ps.setObject(4, list.get(3));
                        ps.setObject(5, sop.getDealName());
                        ps.setObject(6, list.get(5));
                        ps.setObject(7, list.get(6));
                        ps.setObject(8, list.get(7));
                        ps.setObject(9, list.get(9));
                        ps.setObject(10, priceNo);
                        ps.setObject(11, list.get(4));
                        ps.executeUpdate();
                        ps.close();
                    }
                    // 保存价格到合同行上
                    savePriceToLine(con, priceNo);
                    updateOrderConfirmTime(con, ordPk);
//                    cou.doCrmEvent(con, ordPk,"","","1","1");
                    con.commit();
                    cro.setV_errCode(0);
                }
                else {
                    cro.setV_errCode(-1);
                    cro.setV_errMsg("合同状态不是‘经理审批通过’，不能进行审批通过操作！");
                }
            }
        }
        catch (SQLException 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 con
     * @param priceNo
     * @throws SQLException
     */
    public void savePriceToLine(Connection con, String priceNo)
            throws SQLException {
        String sql = CoreXmlSqlParsersFactory
                .getSql("CorePriceConfirm.UpdateOrderLinePrice");
        PreparedStatement ps = con.prepareStatement(sql);
        ps.setObject(1, priceNo);
        ps.setObject(2, priceNo);
        ps.setObject(3, priceNo);
        ps.setObject(4, priceNo);
        ps.setObject(5, priceNo);
        ps.setObject(6, priceNo);
        ps.setObject(7, priceNo);
        ps.setObject(8, priceNo);
        ps.executeUpdate();
        ps.close();
    }

    /**
     * 价格评审不通过 0需要控制合同状态 1 不需要合同状态判断
     * @param ordPk
     * @param parm
     * @param form 来自于哪个界面的请求0 价格评审 1 价格变更
     * @return
     */
    public CoreReturnObject backPrice(String ordPk, String parm, String form,
            String name, String dept, String reviewMemo) {
        CoreReturnObject cro = new CoreReturnObject();
        JSONObject json = JSONObject.fromObject(parm);
        SlmOrderPriceEntity sop = (SlmOrderPriceEntity) JSONObject.toBean(json,
                SlmOrderPriceEntity.class);
        Connection con = null;
        try {
            con = this.getDao(CoreConstantData.sysbeanstr).getConnection();
            con.setAutoCommit(false);
            // 先判断是否有价格审批单，再判断其状态
            String priceNo = ""; // 价格评审单号
            if (isExistsPriceNo(con, ordPk)) {
                priceNo = getOrderPriceNo(con, ordPk);
                String status = getPriceNoStatus(con, priceNo);
                if (status.equals("")) {
                    cro.setV_errCode(-1);
                    cro.setV_errMsg("价格评审单状态错误！");
                }
                else if (status.equals("L")) { //
                    cro.setV_errCode(-1);
                    cro.setV_errMsg("价格评审尚未确认，不能评审不通过！");
                }
                else if (status.equals("S")) {
                    cro.setV_errCode(-1);
                    cro.setV_errMsg("该合同价格评审已通过，不能重复评审！");
                }
                else if (status.equals("F")) {
                    cro.setV_errCode(-1);
                    cro.setV_errMsg("该合同价格评审已经不通过，不能重复评审！");
                }
            }
            else {
                cro.setV_errCode(-1);
                cro.setV_errMsg("该合同尚未启动价格评审，不能评审通过！");
            }

            if (form.equals("1") || form.equals("4")) { // 价格变更时 不考虑合同状态
                // 更改价格评审状态为不通过
                String sql = CoreXmlSqlParsersFactory
                        .getSql("CorePriceConfirm.PassOrBackPrice");
                PreparedStatement ps = con.prepareStatement(sql);
                ps.setObject(1, "F");
                ps.setObject(2, sop.getDealName());
                ps.setObject(3, sop.getDealDeptcode());
                ps.setObject(4, sop.getDealDeptdesc());
                ps.setObject(5, sop.getDealUnitcode());
                ps.setObject(6, sop.getDealUnitdesc());
                ps.setObject(7, priceNo);
                ps.executeUpdate();
                ps.close();
                con.commit();
                cro.setV_errCode(0);
                return cro;
            }
            else {
                // 这里去掉以前的评审不通过逻辑，不再将合同退给业务员（后来流程退回）
                CoreOrderInfoUpdate cou = new CoreOrderInfoUpdate();
                CoreOrderStatus cos = cou.getOrderStatus(con, ordPk);
                if (cos.getOrderSts().equals("12020224")) { // 审批通过
                    String reviewNo = cou.getOrderReviewNo(con, ordPk);
                    java.sql.Date date = new java.sql.Date(
                            new java.util.Date().getTime());
                    CoreOrderStatusCommFun.updateOrderHeadStatus(con, ordPk,
                            "12020224", "12020231", "价格评审失败", name,
                            date.toString());
                    cou.updateOrderLineStatus(con, ordPk, "12020224",
                            "12020231");
                    cou.updateOrderDeliveryLineStatus(con, ordPk, "12020224",
                            "12020231");
//                    cou.doCrmEvent(con, ordPk,"","","1","1");
                    // 评审表
                    String obj = dept + "-" + name + "在[合同价格评审]界面,点击[价格评审]，并点击[评审不通过]";
                    CoreOrderStatusCommFun.updateOrderReviewItemList(con,
                            reviewNo, "P", "H", ordPk, "F", "1", name, dept,
                            reviewMemo, obj);
                    CoreOrderStatusCommFun.updateOrderReviewItemNoDate(con,
                            reviewNo, "P", "F");
                    // 更改价格评审状态为不通过
                    String sql = CoreXmlSqlParsersFactory
                            .getSql("CorePriceConfirm.PassOrBackPrice");
                    PreparedStatement ps = con.prepareStatement(sql);
                    ps.setObject(1, "F");
                    ps.setObject(2, sop.getDealName());
                    ps.setObject(3, sop.getDealDeptcode());
                    ps.setObject(4, sop.getDealDeptdesc());
                    ps.setObject(5, sop.getDealUnitcode());
                    ps.setObject(6, sop.getDealUnitdesc());
                    ps.setObject(7, priceNo);
                    ps.executeUpdate();
                    ps.close();
                    con.commit();
                    cro.setV_errCode(0);
                }
                else {
                    cro.setV_errCode(-1);
                    cro.setV_errMsg("合同状态不是‘经理审批通过’，不能进行审批不通过操作！");
                }
            }
        }
        catch (SQLException 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 con
     * @param ordPk
     * @return
     * @throws SQLException
     */
    public Boolean isExistsPriceNo(Connection con, String ordPk)
            throws SQLException {
        String sql = CoreXmlSqlParsersFactory
                .getSql("CorePriceConfirm.isExistsPriceNo");
        PreparedStatement ps = con.prepareStatement(sql);
        ps.setObject(1, ordPk);
        ResultSet rs = ps.executeQuery();
        if (rs.next()) {
            if (StringTool.isNullOrEmpty(rs.getString(1))) {
                rs.close();
                ps.close();
                return false;
            }
            rs.close();
            ps.close();
            return true;
        }
        rs.close();
        ps.close();
        return false;
    }

    /**
     * 获取价格评审单号
     * @param con
     * @param ordPk
     * @return
     * @throws SQLException
     */
    public String getOrderPriceNo(Connection con, String ordPk)
            throws SQLException {
        String sql = CoreXmlSqlParsersFactory
                .getSql("CorePriceConfirm.isExistsPriceNo");
        PreparedStatement ps = con.prepareStatement(sql);
        ps.setObject(1, ordPk);
        ResultSet rs = ps.executeQuery();
        String priceNo = "";
        if (rs.next()) {
            priceNo = rs.getString(1);
        }
        rs.close();
        ps.close();
        return priceNo;
    }

    /**
     * 获取价格评审单号状态
     * @param con
     * @param priceNo
     * @return
     * @throws SQLException
     */
    public String getPriceNoStatus(Connection con, String priceNo)
            throws SQLException {
        String sql = CoreXmlSqlParsersFactory
                .getSql("CorePriceConfirm.getPriceNoStatus");
        PreparedStatement ps = con.prepareStatement(sql);
        ps.setObject(1, priceNo);
        ResultSet rs = ps.executeQuery();
        String status = "";
        if (rs.next()) {
            status = rs.getString(1);
        }
        rs.close();
        ps.close();
        return status;
    }

    /**
     * 生成价格评审编号
     * @param con
     * @param ordPk
     * @param saleOrg 销售组织
     * @return
     * @throws SQLException
     */
    public String generatePriceNo(Connection con, String saleOrg)
            throws SQLException {
        String sql = CoreXmlSqlParsersFactory
                .getSql("CorePriceConfirm.GeneratePriceNo");
        java.sql.Date date = new java.sql.Date(new java.util.Date().getTime());
        String str = date.toString().substring(0, 7).replaceAll("-", "");
        if (saleOrg.equals("100101")) {
            str = str + "-1-";
        }
        else if (saleOrg.equals("100103")) {
            str = str + "-2-";
        }
        else if (saleOrg.equals("100102")) {
            str = str + "-3-"; // 国贸
        }
        else if (saleOrg.equals("100105")) {
            str = str + "-4-"; // 天淮
        }
        PreparedStatement ps = con.prepareStatement(sql);
        ps.setObject(1, str);
        ps.setObject(2, str);
        String priceNo = "";
        ResultSet rs = ps.executeQuery();
        if (rs.next()) {
            priceNo = rs.getString(1);
        }
        rs.close();
        ps.close();
        return priceNo;
    }

    /**
     * 更新确认时间
     * @param con
     * @param ordPk
     * @throws SQLException
     */
    public void updateOrderConfirmTime(Connection con, String ordPk)
            throws SQLException {
        String sql = CoreXmlSqlParsersFactory
                .getSql("CorePriceConfirm.UpdateOrderConfirmTime");
        PreparedStatement ps = con.prepareStatement(sql);
        ps.setObject(1, ordPk);
        ps.executeUpdate();
        ps.close();

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

    public CoreReturnObject getOrderPriceNo(String ordPk) {
        Object[] obj = new Object[] { ordPk };
        return this.getDataBySqlID("CorePriceConfirm.isExistsPriceNo", obj);
    }
    
     
}
