using System;
using System.Data;
using System.Configuration;
using System.Collections;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using GThinking.N_MODEL.Page;
using GThinking.N_MISPRO.Utility;
using GThinking.N_MISPRO.Data;
using GThinking.N_MISPRO;
using GThinking.N_WORKFLOW;
using System.Collections.Generic;
using GThinking.N_MISPRO.TableCache;
using GThinking.N_PUBLIC2;
using GThinking.N_PUBLIC;

namespace GThinking.U20261363_N_XLXSBJ
{
    public partial class XLBJDList : SingleGridBase
    {
        XLBJD entity = new XLBJD();
        XLBJD_M queryentity = new XLBJD_M();

        //附加信息扩展列显示配置的缓存key（全局共享，缓存30分钟，配置调整后最迟30分钟生效）
        private const string S_FJXX_CONFIG_CACHE_KEY = "XLBJDList_FJXXConfig";

        private class ZDColumn
        {
            public string sMC = "";     // 列标题
            public string sDYZD = "";   // 对照字
        }

        private class ZFOption
        {
            public string sSRFS = "";                            // 输入方式（B=下拉单选）
            public List<string> listCode = new List<string>();   // 选项代码
            public List<string> listName = new List<string>();   // 选项名称
        }

        private class FJXXConfig
        {
            public Dictionary<string, string> dicXSBZ = new Dictionary<string, string>();
            public Dictionary<string, string> dicSYBJFL = new Dictionary<string, string>();
            public List<ZDColumn> listZDColumn = new List<ZDColumn>();   // 列表显示的扩展列定义（按BH排序）
            public string sFJXXSZ = "";
        }

        //选择类型扩展字段的选项缓存（每请求惰性加载一次）
        private Dictionary<string, ZFOption> dicZFOptionCache = null;

        //当前选中记录的报价单号
        private string CurBJDID
        {
            get { return ContentGrid.DataKeys[ContentGrid.SelectedIndex]["XLXSBJD_BJDID"].ToString().Trim(); }
        }

        //排序方式选项（与查询页XLBJDQuery的下拉选项保持一致）
        private const string PXFS_BJD_DESC = "报价单号倒序↓";
        private const string PXFS_BJD_ASC = "报价单号正序↑";
        private const string PXFS_BJRQ_DESC = "报价日期倒序↓";
        private const string PXFS_BJRQ_ASC = "报价日期正序↑";



        #region Page类事件继承

        protected void Page_Load(object sender, EventArgs e)
        {
            this.UMID = 100860174;
            this.UMName = "线缆销售报价单";
            this.CurMaster = Master;
            this.ModuleGV = ContentGrid;
            this.CurEntity = entity;
            this.CurQueryEntity = queryentity;
            this.PageHeight = 500;
            this.PageWidth = 700;
            this.sURLTarget = "XLBJDInfo.aspx";
            this.sQueryURLTarget = "XLBJDQuery.aspx";
            base.DataKeyNames = new string[] { "XLXSBJD_BJDID", "XLXSBJD_CLHQJGBID", "XLXSBJD_BJFLID", "XLXSBJD_XMMC", "XLXSBJD_BJRQ", "XLXSBJD_ZJE" };
            this.Master.EnableAttachBtn = true;

            if (!IsPostBack)
            {
                CurQueryEntity.FieldByName("SW").Value = "W";
                CurQueryEntity.FieldByName("PXFS").Value = PXFS_BJRQ_ASC;
            }
            ContentGrid.FindColumnExByFieldName("XLXSBJD_TJ").NumberDecimalPlace = XLBJDUtils.BJCLPriceDecimal;
            ContentGrid.FindColumnExByFieldName("XLXSBJD_LJ").NumberDecimalPlace = XLBJDUtils.BJCLPriceDecimal;
            SetFJXX();
            base.InitPage();

            //解决复制明细、与复制主记录分开处理的情况
            this.Master.StandardCopyButton.OnClientClick = "";
            this.Master.StandardCopyButton.Click += new EventHandler(btnCopyEx_Click);

            if (!IsPostBack)
            {  
                Master_OnStandardQuery(null, null);
            }
            if (!CheckModule(100860008))
            {
                int index1 = ContentGrid.Columns.IndexOf(ContentGrid.FindColumnByFieldName("XLXSBJD_LRL"));
                int index2 = ContentGrid.Columns.IndexOf(ContentGrid.FindColumnByFieldName("XLXSBJD_ZDXJJCL"));

                if (index1 > -1)
                    ContentGrid.Columns[index1].Visible = false;
                if (index2 > -1)
                    ContentGrid.Columns[index2].Visible = false;
            }
            if (!CheckModule(100860068))
            {
                int index1 = ContentGrid.Columns.IndexOf(ContentGrid.FindColumnByFieldName("ZDFXYQR"));
                if (index1 > -1)
                    ContentGrid.Columns[index1].Visible = false;
            }
            
        }

        #endregion

        #region 模板继承事件

        protected override bool CanSubmit()
        {
            string sBJDID   = CurBJDID;
            string sWarningMsg = "";
            string sBJFLID  = "";
            TDatabase dberp = TContextDatabases.GetDatabase("DBERP");
            TSQL SQL = new TSQL(dberp);
            SQL.Clear();
            SQL.Add(" SELECT XLXSBJD_BJFLID FROM XLXSBJD WHERE XLXSBJD_BJDID=:pXLXSBJD_BJDID ");
            SQL.ParamByName("pXLXSBJD_BJDID").Value = sBJDID;
            DataSet data = dberp.OpenDataSet(SQL);
            if (data.Tables[0].Rows.Count > 0)
            {
                sBJFLID = data.Tables[0].Rows[0][0].ToString().Trim();
            }
            BJFLXX bjflxx = XLBJDUtils.GetBJFLXX(sBJFLID);

            if (bjflxx.XLXSBJFL_XTCPBJYZ.Trim().Equals("Y") || bjflxx.XLXSBJFL_XTCPBJYZ.Trim().Equals("5"))
            {
                XLBJD_BDOBill.JudgeDifBJCP(sBJDID, GetOption(100860000,"BJU003"), ref sWarningMsg, bjflxx.XLXSBJFL_XTCPBJYZ.Trim());
                if (!sWarningMsg.Equals(""))
                {
                    ShowMessage("显示序号为【" + sWarningMsg + "】的相同报价产品的报价不同，不允许提交！");
                    return false;
                }
            }

            XLBJD_BDOBill.JudgeDifBJZJE(sBJDID, ref sWarningMsg);
            if (!sWarningMsg.Equals(""))
            {
                ShowMessage(sWarningMsg);
                return false;
            }
            return base.CanSubmit();
        }

        protected override bool Master_BeforeDeleteAction(object sender, EventArgs e)
        {
            string sBJDID = CurBJDID;
            TDatabase dberp = TContextDatabases.GetDatabase("DBERP");
            TSQL SQL = new TSQL(dberp);
            SQL.Clear();
            SQL.Add(" select top 1 XLXSBJYLZD_BJDID from XLXSBJYLZD where XLXSBJYLZD_BJDID=:pBJDID ");
            SQL.ParamByName("pBJDID").Value = sBJDID;
            if (dberp.OpenDataSet(SQL).Tables[0].Rows.Count > 0)
            {
                ShowMessage("已申请材料用量制定，不允许删除！");
                return false;
            }

            SQL.Clear();
            SQL.Add(" select 1 from BJD where BJD_BJDID=:pBJDID ");
            SQL.ParamByName("pBJDID").Value = sBJDID;
            if (dberp.OpenDataSet(SQL).Tables[0].Rows.Count > 0)
            {
                ShowMessage("报价单已反馈，不允许删除！");
                return false;
            }

            CurEntity.Param.Add("XLXSBJD_BJDID", CurBJDID);

            XLBJDUtils.UpdateTJBZ(CurBJDID, "Delete");

            return base.Master_BeforeDeleteAction(sender, e);
        }

        protected override void AfterDelete(TDatabase db, ref bool ActionIsDone)
        {
            base.AfterDelete(db, ref ActionIsDone);
            TSQL tSQL = new TSQL(db);
            XLBJDUtils.AfterDeleteBJD(db, tSQL, CurBJDID);
        }

        protected override bool Master_AfterDeleteAction(object sender, EventArgs e)
        {
            if (!base.Master_AfterDeleteAction(sender, e)) return false;

            base.InitEntityByCondition();
            RebindGrid();
            ContentGrid.SelectedIndex = -1;
            return true;
        }

        protected override void Master_OnStandardQuery(object sender, EventArgs e)
        {
            base.InitEntityByCondition();
            base.Master_OnStandardQuery(sender, e);
            RebindGrid();
        }

        protected override void moduleGV_PageIndexChanging(object sender, GridViewPageEventArgs e)
        {
            base.InitEntityByCondition();
            entity.EntityTable.QuerySelSql = GetQuerySql();
            ContentGrid.SelectedIndex = -1;
            base.moduleGV_PageIndexChanging(sender, e);
        }

        protected override void moduleGV_RowDataBound(object sender, GridViewRowEventArgs e)
        {
            if (e.Row.RowType == DataControlRowType.DataRow)
            {
                int iWPID = GetColumnIndexByField("XLXSBJD_WPID");
                int iXSJGB = GetColumnIndexByField("XSJGB");
                int iWFAWAITER = GetColumnIndexByField("XLXSBJD_WFAWAITER");
                int iWFHANDLER = GetColumnIndexByField("XLXSBJD_WFHANDLER");
                string sWPID = iWPID > -1 ? e.Row.Cells[iWPID].Text.Trim() : "";
                string sBJFLID = ContentGrid.DataKeys[e.Row.RowIndex]["XLXSBJD_BJFLID"].ToString().Trim();
                if (sBJFLID.Contains("|"))
                    sBJFLID = sBJFLID.Split('|')[0];
                FJXXConfig cfgFJXX = GetFJXXConfig();
                if (iWPID > -1)
                    e.Row.Cells[iWPID].Text = _curWorkFlow.GetWPName("XLXSBJ_BJD", sWPID);
                if (iWFAWAITER > -1)
                    e.Row.Cells[iWFAWAITER].Text = _curWorkFlow.UserInfo.GetUserNames(e.Row.Cells[iWFAWAITER].Text.Trim());
                if (iWFHANDLER > -1)
                    e.Row.Cells[iWFHANDLER].Text = _curWorkFlow.UserInfo.GetUserNames(e.Row.Cells[iWFHANDLER].Text.Trim());
                if (ContentGrid.DataKeys[e.Row.RowIndex]["XLXSBJD_CLHQJGBID"].ToString().Trim().Equals("ZZZZZZZZ"))
                {
                    if (iXSJGB > -1)
                        e.Row.Cells[iXSJGB].Text = e.Row.Cells[iXSJGB].Text.Trim() + ",ZZZZZZZZ|基础材料行情";
                }
                else if (ContentGrid.DataKeys[e.Row.RowIndex]["XLXSBJD_CLHQJGBID"].ToString().Trim().Equals("YYYYYYYY"))
                {
                    if (iXSJGB > -1)
                        e.Row.Cells[iXSJGB].Text = e.Row.Cells[iXSJGB].Text.Trim() + ",YYYYYYYY|报价单材料行情";
                }

                SetExtColumnsVisible(e.Row, "KZSZ", 4, false, cfgFJXX, sWPID, sBJFLID);
                SetExtColumnsVisible(e.Row, "KZZF", 10, true, cfgFJXX, sWPID, sBJFLID);
                SetExtColumnsVisible(e.Row, "KZRQ", 4, false, cfgFJXX, sWPID, sBJFLID);
                SetExtColumnsVisible(e.Row, "KZWB", 4, false, cfgFJXX, sWPID, sBJFLID);


                Dictionary<string, string> dicZBLM = GetZBLMBJFL();
                foreach (string sKey in dicZBLM.Keys)
                {
                    if (("," + dicZBLM[sKey] + ",").Contains("," + sBJFLID + ","))
                    {
                        int indexLM = ContentGrid.Columns.IndexOf(ContentGrid.FindColumnByFieldName(sKey));
                        e.Row.Cells[indexLM].Text = "";
                    }
                }

                LinkPageParam.AddString("WFID", ContentGrid.DataKeys[e.Row.RowIndex]["XLXSBJD_WFID"].ToString().Trim());
                LinkPageParam.AddString("WFINST", ContentGrid.DataKeys[e.Row.RowIndex]["XLXSBJD_WFINST"].ToString().Trim());
                LinkPageParam.AddString("XLXSBJD_BJDID", ContentGrid.DataKeys[e.Row.RowIndex]["XLXSBJD_BJDID"].ToString().Trim());
                
            }
            base.moduleGV_RowDataBound(sender, e);
        }

        protected override void BeforeAttach()
        {
            attDoc.WorkTableName = "XLXSBJD";
            attDoc.UpdCondition = string.Format(" XLXSBJD_BJDID='{0}'", CurBJDID.Replace("'", "''"));

            base.BeforeAttach();
        }

        protected override void Master_BeforeAction(TWorkflow Sender, TWFAction Action, ref bool CanAction)
        {
            base.Master_BeforeAction(Sender, Action, ref CanAction);
        }
        protected override void Master_wfAfterActionEvent(TWorkflow Sender, TWFAction Action, bool ActionIsDone)
        {
            base.Master_wfAfterActionEvent(Sender, Action, ActionIsDone);

            if (!ActionIsDone)
                return;
            string sBJDID = CurBJDID;
            TSQL SQL = new TSQL(Sender.dbe);
            SQL.Clear();
            SQL.Add("select XLXSBJD_WPID,XLXSBJD_BJSQDH,XLXSBJD_BJJSJD,XLXSBJD_ZB from XLXSBJD where XLXSBJD_BJDID=:pBJDID");
            SQL.ParamByName("pBJDID").Value = sBJDID;
            DataSet ds = Sender.dbe.OpenDataSet(SQL);
            string sWPID = "";
            string sBJSQDH = "";
            string sBJJSJD = "";
            string sZB = "";
            if (ds.Tables[0].Rows.Count > 0)
            {
                sWPID = ds.Tables[0].Rows[0]["XLXSBJD_WPID"].ToString().Trim();
                sBJSQDH = ds.Tables[0].Rows[0]["XLXSBJD_BJSQDH"].ToString().Trim();
                sBJJSJD = ds.Tables[0].Rows[0]["XLXSBJD_BJJSJD"].ToString().Trim();
                sZB = ds.Tables[0].Rows[0]["XLXSBJD_ZB"].ToString().Trim();
            }
            string sZDQRWPID = XLBJDUtils.GetXLXSBJPZXX(100860068).XLXSBJPZ_ZDQRWPID;

            UpdZDQRRGH(Sender, Action, sBJDID, sWPID, sZDQRWPID);
            UpdBJJSJD(Sender, Action, sBJDID, sBJSQDH, sWPID, sBJJSJD);
            UpdWFField(Sender, Action, sBJDID);
            string sCurZT = TWorkflow.Utils.WFGetBZSWID(Sender.WFID, Sender.WPID);
            InsBJPSAndDispatch(Sender, Action, sBJDID, sCurZT);
            UpdZDZDLX(Sender, Action, sBJDID, sZDQRWPID);
            DispXLBJSQ(Sender, sBJSQDH, sZB, sCurZT);
        }

        //自动撞单确认：提交到指定环节时回写撞单确认人与确认时间
        private void UpdZDQRRGH(TWorkflow Sender, TWFAction Action, string sBJDID, string sWPID, string sZDQRWPID)
        {
            if (sZDQRWPID.Equals("") || Action != TWFAction.wfaSubmit || !sZDQRWPID.Contains(sWPID))
                return;
            TSQL SQL = new TSQL(Sender.dbe);
            SQL.Clear();
            SQL.Add("update XLXSBJD  set XLXSBJD_ZDQRRGH=:pZDQRRGH ,XLXSBJD_ZDQRSJ=:pZDQRSJ WHERE  XLXSBJD_BJDID=:pBJDID");
            SQL.ParamByName("pZDQRRGH").Value = tSession.UserId;
            SQL.ParamByName("pZDQRSJ").Value = CMISproConvert.ConvertTime(DateTime.Now);
            SQL.ParamByName("pBJDID").Value = sBJDID;
            Sender.dbe.ExecSQL(SQL);
        }

        //追加报价进展记录
        private void UpdBJJSJD(TWorkflow Sender, TWFAction Action, string sBJDID, string sBJSQDH, string sWPID, string sBJJSJD)
        {
            if (sBJSQDH.Trim().Equals("") || !XLBJDInfo.CheckXSYBJSQ_SS())
                return;
            string sWPNAME = Sender.GetWPName(Sender.WFID, sWPID);
            string sJSJD = tSession.UserName + " " + Sender.WAend.ToString().Trim() + " " + sWPNAME + " " + Sender.GetWFActionName(Action);
            if (!sBJJSJD.Equals(""))
                sBJJSJD += "\r\n";
            sBJJSJD += sJSJD;
            TSQL SQL = new TSQL(Sender.dbe);
            SQL.Clear();
            SQL.Add(" update XLXSBJD set XLXSBJD_BJJSJD = :pJSJD where XLXSBJD_BJDID = :pBJDID ");
            SQL.ParamByName("pJSJD").Value = sBJJSJD;
            SQL.ParamByName("pBJDID").Value = sBJDID;
            Sender.dbe.ExecSQL(SQL);
        }

        //回写流程字段
        private void UpdWFField(TWorkflow Sender, TWFAction Action, string sBJDID)
        {
            TSQL SQL = new TSQL(Sender.dbe);
            SQL.Clear();
            SQL.Add(" update XLXSBJD");
            SQL.Add(" set XLXSBJD_WFID = :XLXSBJD_WFID, ");
            SQL.Add("     XLXSBJD_WPID = :XLXSBJD_WPID, ");
            SQL.Add("     XLXSBJD_WFAWAITER = :XLXSBJD_WFAWAITER, ");
            SQL.Add("     XLXSBJD_WFHANDLER = :XLXSBJD_WFHANDLER, ");
            SQL.Add("     XLXSBJD_WFINST = :XLXSBJD_WFINST, ");
            SQL.Add("     XLXSBJD_ACTNAME = :XLXSBJD_ACTNAME ");
            SQL.Add(" where XLXSBJD_BJDID = :XLXSBJD_BJDID ");
            SQL.ParamByName("XLXSBJD_WFID").Value = Sender.WFID;
            SQL.ParamByName("XLXSBJD_WFINST").Value = Sender.WFInst;
            SQL.ParamByName("XLXSBJD_WPID").Value = Sender.WPID;
            SQL.ParamByName("XLXSBJD_WFAWAITER").Value = Sender.Awaiter;
            SQL.ParamByName("XLXSBJD_WFHANDLER").Value = Sender.Handler;
            SQL.ParamByName("XLXSBJD_ACTNAME").Value = Sender.GetWFActionName(Action);
            SQL.ParamByName("XLXSBJD_BJDID").Value = sBJDID;
            Sender.dbe.ExecSQL(SQL);
        }

        //生成报价派工单并分发（环节标识为ZZZZ时）
        private void InsBJPSAndDispatch(TWorkflow Sender, TWFAction Action, string sBJDID, string sCurZT)
        {
            if (sCurZT != "ZZZZ")
                return;
            string sPSDH = "";
            bool bINS = false;
            TSQL SQL = new TSQL(Sender.dbe);
            XLBJD_BDOBill.InsBJPS(SQL, Sender.dbe, Sender, Action, sBJDID, tSession, "100860000", ref sPSDH, ref bINS);
            if (bINS)
            {
                XLBJD_BDOBill.DispatchtoZZZZ(sPSDH, tSession);
            }
        }

        //回写中标类型（提交到指定环节时）
        private void UpdZDZDLX(TWorkflow Sender, TWFAction Action, string sBJDID, string sZDQRWPID)
        {
            if (sZDQRWPID.Equals("") || Action != TWFAction.wfaSubmit || !sZDQRWPID.Contains(Sender.WPID))
                return;
            TSQL SQL = new TSQL(Sender.dbe);
            SQL.Clear();
            SQL.Add("update XLXSBJD  set XLXSBJD_ZDZDLX=:pZDZDLX  WHERE  XLXSBJD_BJDID=:pBJDID");
            SQL.ParamByName("pZDZDLX").Value = XLBJD_BDOBill.getZDZDLX(sBJDID);
            SQL.ParamByName("pBJDID").Value = sBJDID;
            Sender.dbe.ExecSQL(SQL);
        }

        //分发报价申请流程（环节标识为ZZZZ且已有报价申请单号时）
        private void DispXLBJSQ(TWorkflow Sender, string sBJSQDH, string sZB, string sCurZT)
        {
            if (sCurZT != "ZZZZ" || sBJSQDH.Trim().Equals("") || !XLBJDInfo.CheckXSYBJSQ_SS())
                return;
            if (sZB.Equals("Y"))
                XLBJD_BDOBill.DispatchXLBJSQ(sBJSQDH, "ZZZZ", tSession);
            else
                XLBJD_BDOBill.DispatchXLBJSQ(sBJSQDH, "0060", tSession);
        }

        protected override void OnReportUnknownFunction(string Name, string Params, ref string ValueType, ref string Value, TDatabase db)
        { 
            string[] Param;
            Param = Params.Split(',');
            if (Name.Trim().ToUpper() == "GETCPBJ")
            {
                ValueType = "N";
                if (Param.Length >= 5)
                {
                    Value = XLBJDUtils.GetCPBJ(Param[0], Param[1], Param[2], Param[3], Param[4]).ToString();
                }
                else
                {
                    Value = "0";
                }
            }
        }

        protected override void Master_wfOnGetParamName(ref List<string> ParamList)
        {
            base.Master_wfOnGetParamName(ref ParamList);
            ParamList.Add("自动撞单");
        }

        protected override void Master_wfOnGetParamEvent(TWorkflow Sender, string ParamName, ref string Value, ref bool Succeess)
        {
            base.Master_wfOnGetParamEvent(Sender, ParamName, ref Value, ref Succeess);
            if (ParamName == "自动撞单")
            {
                if (XLBJD_BDOBill.getZDZDLX(CurBJDID).Equals(""))
                {
                    Value = "N";
                }
                else
                {
                    Value = "Y";
                }
                Succeess = true;
            }
        }

        protected override bool ConfirmWFAction(TWFAction Action)
        {
            if (Action == TWFAction.wfaSubmit)
            {
                string sBJDID = CurBJDID;
                string sWarningMsg = "";
                string sBJFLID = "";
                TDatabase dberp = TContextDatabases.GetDatabase("DBERP");
                TSQL SQL = new TSQL(dberp);
                SQL.Clear();
                SQL.Add(" SELECT XLXSBJD_BJFLID FROM XLXSBJD WHERE XLXSBJD_BJDID=:pXLXSBJD_BJDID ");
                SQL.ParamByName("pXLXSBJD_BJDID").Value = sBJDID;
                DataSet data = dberp.OpenDataSet(SQL);
                if (data.Tables[0].Rows.Count > 0)
                {
                    sBJFLID = data.Tables[0].Rows[0][0].ToString().Trim();
                }

                BJFLXX bjflxx = XLBJDUtils.GetBJFLXX(sBJFLID);
                if (bjflxx.XLXSBJFL_XTCPBJYZ.Trim().Equals("Z") || bjflxx.XLXSBJFL_XTCPBJYZ.Trim().Equals("6"))
                {
                    XLBJD_BDOBill.JudgeDifBJCP(sBJDID, GetOption(100860000,"BJU003"), ref sWarningMsg, bjflxx.XLXSBJFL_XTCPBJYZ.Trim());
                    if (!sWarningMsg.Equals(""))
                    {
                        Confirm.Register("ask", "显示序号为" + sWarningMsg + "的相同报价产品的报价不同，是否确认提交？");
                        Confirm.ShowBtnText = TConfirm.cBtnText.Yes_No;
                        if (Confirm.GetValue("ask").Trim().Equals(""))
                        {
                            Confirm.Ask("ask");
                            return false;
                        }
                        else if (Confirm.GetValue("ask").Trim().Equals("N"))
                        {
                            Confirm.Clear();
                            return false;
                        }
                        else if (Confirm.GetValue("ask").Trim().Equals("Y"))
                        {
                            Confirm.Clear();
                        }
                    }
                }
            }
            return base.ConfirmWFAction(Action);
        }

        #endregion

        #region 私有函数

        //获取当前用户需隐藏列（按用户缓存30分钟；角色/配置调整后最迟30分钟生效）
        private Dictionary<string, string> GetZBLMBJFL()
        {
            string sKey = "XLBJDList_ZBLM_" + tSession.UserId;
            Dictionary<string, string> dicZBLM = HttpRuntime.Cache[sKey] as Dictionary<string, string>;
            if (dicZBLM == null)
            {
                dicZBLM = LoadZBLMBJFLFromDB();
                HttpRuntime.Cache.Insert(sKey, dicZBLM, null,
                    DateTime.Now.AddMinutes(30), System.Web.Caching.Cache.NoSlidingExpiration);
            }
            return dicZBLM;
        }

        //查询当前用户角色对应的需隐藏列
        private Dictionary<string, string> LoadZBLMBJFLFromDB()
        {
            Dictionary<string, string> dicZBLM = new Dictionary<string, string>();
            TYGXX tRYXX = TRYXX.GetRYXXByGH(tSession.UserId);
            string sXJYROLEID = string.Empty;
            string sSJYROLEID = string.Empty;
            string sHJYROLEID = string.Empty;
            XLXSBJPZXX pzxx = XLBJDUtils.GetXLXSBJPZXX(100860000);
            if (!string.IsNullOrEmpty(pzxx.XLXSBJPZ_XJYROLEID))
                sXJYROLEID = pzxx.XLXSBJPZ_XJYROLEID;

            if (!string.IsNullOrEmpty(pzxx.XLXSBJPZ_SJYROLEID))
                sSJYROLEID = pzxx.XLXSBJPZ_SJYROLEID;

            if (!string.IsNullOrEmpty(pzxx.XLXSBJPZ_HJYROLEID))
                sHJYROLEID = pzxx.XLXSBJPZ_HJYROLEID;

            Dictionary<string, string> dicLMID = new Dictionary<string, string>();
            dicLMID.Add("txtBZ", "XLXSBJD_BZ");

            TDatabase dberp = TContextDatabases.GetDatabase("DBERP");
            bool IsXJY = HasUserRole(dberp, tRYXX.RYID, sXJYROLEID);
            bool IsSJY = HasUserRole(dberp, tRYXX.RYID, sSJYROLEID);
            bool IsHJY = HasUserRole(dberp, tRYXX.RYID, sHJYROLEID);
            TSQL sSQL = new TSQL(dberp);
            sSQL.Clear();
            sSQL.Add("select distinct XLXSBJFLJSLM_BJFLID,XLXSBJFLJSLM_LMID from XLXSBJFLJSLM where XLXSBJFLJSLM_YCBZ='Y' and XLXSBJFLJSLM_LMLX='W'   ");
            if(IsXJY||IsSJY||IsHJY)
            {
                sSQL.Add(" and ( 1<>1 ");
                if(IsXJY)
                    sSQL.Add(" or XLXSBJFLJSLM_JSLX='X' ");
                if (IsSJY)
                    sSQL.Add("  or XLXSBJFLJSLM_JSLX='S' ");
                if (IsHJY)
                    sSQL.Add("  or XLXSBJFLJSLM_JSLX='H' ");
                sSQL.Add(" ) ");

            }
            else
            {
                sSQL.Add(" and  XLXSBJFLJSLM_JSLX='Q' ");
            }
            DataSet ds = dberp.OpenDataSet(sSQL);
            for (int i = 0; i < ds.Tables[0].Rows.Count; i++)
            {
                string sBJFLID = ds.Tables[0].Rows[i]["XLXSBJFLJSLM_BJFLID"].ToString().Trim();
                string sLMID = ds.Tables[0].Rows[i]["XLXSBJFLJSLM_LMID"].ToString().Trim();
                if (dicLMID.ContainsKey(sLMID))
                {
                    sLMID = dicLMID[sLMID];
                    if (!dicZBLM.ContainsKey(sLMID))
                        dicZBLM.Add(sLMID, sBJFLID);
                    else
                        dicZBLM[sLMID] += "," + sBJFLID;
                }

            }
            return dicZBLM;
        }

        //判断人员是否具有指定角色
        private static bool HasUserRole(TDatabase db, string sRYID, string sRoleID)
        {
            TSQL SQL = new TSQL(db);
            SQL.Add(" select 1 from USERROLE where URUSERID=:pRYID and " + CMISproDataBase.GetWhereEqual("URROLEID", sRoleID));
            SQL.ParamByName("pRYID").Value = sRYID;
            return db.OpenDataSet(SQL).Tables[0].Rows.Count > 0;
        }

        //获取附加信息扩展列显示配置（全局共享，缓存30分钟，避免每个用户首次打开都重复查询配置表）
        private static FJXXConfig GetFJXXConfig()
        {
            FJXXConfig cfg = HttpRuntime.Cache[S_FJXX_CONFIG_CACHE_KEY] as FJXXConfig;
            if (cfg == null)
            {
                cfg = LoadFJXXConfigFromDB();
                HttpRuntime.Cache.Insert(S_FJXX_CONFIG_CACHE_KEY, cfg, null,
                    DateTime.Now.AddMinutes(30), System.Web.Caching.Cache.NoSlidingExpiration);
            }
            return cfg;
        }

        //查询附加信息扩展列显示配置
        private static FJXXConfig LoadFJXXConfigFromDB()
        {
            FJXXConfig cfg = new FJXXConfig();
            TDatabase dberp = TContextDatabases.GetDatabase("DBERP");
            TSQL sSQL = new TSQL(dberp);
            sSQL.Clear();
            sSQL.Add("select XLXSBJKZXXSZ_MJSQL, XLXSBJKZXXSZ_SRFS,XLXSBJKZXXSZ_DYZD from XLXSBJKZXXSZ ");
            sSQL.Add("where 1=1 ");
            sSQL.Add("  and  rtrim(convert(varchar(4000),isnull(XLXSBJKZXXSZ_MJSQL ,' ')))||' ' <> ' ' and  isnull(XLXSBJKZXXSZ_SRFS,' ') <> 'A' ");
            sSQL.Add("  and isnull(XLXSBJKZXXSZ_LBXS,'N') = 'Y'");
            DataSet ds = dberp.OpenDataSet(sSQL);
            if (ds.Tables[0].Rows.Count > 0)
            {
                for (int i = 0; i < ds.Tables[0].Rows.Count; ++i)
                {
                    cfg.sFJXXSZ += ds.Tables[0].Rows[i]["XLXSBJKZXXSZ_DYZD"].ToString().Trim() + ",";
                }
            }

            sSQL.Clear();
            sSQL.Add(" select XLXSBJKZXXSZ_XSBZ,XLXSBJKZXXSZ_DYZD from XLXSBJKZXXSZ ");
            sSQL.Add(" where 1=1 ");
            sSQL.Add(" and isnull(XLXSBJKZXXSZ_XSBZ,' ') <> ' '");
            sSQL.Add(" and isnull(XLXSBJKZXXSZ_LBXS,'N') = 'Y'");
            ds = dberp.OpenDataSet(sSQL);
            if (ds.Tables[0].Rows.Count > 0)
            {
                for (int i = 0; i < ds.Tables[0].Rows.Count; ++i)
                {
                    string sXSBZ = ds.Tables[0].Rows[i]["XLXSBJKZXXSZ_XSBZ"].ToString().Trim();
                    string sDYZD = ds.Tables[0].Rows[i]["XLXSBJKZXXSZ_DYZD"].ToString().Trim();
                    if (!cfg.dicXSBZ.ContainsKey(sDYZD))
                        cfg.dicXSBZ.Add(sDYZD, sXSBZ);
                }
            }

            sSQL.Clear();
            sSQL.Add(" select XLXSBJKZXXSZ_SYBJFLID,XLXSBJKZXXSZ_DYZD from XLXSBJKZXXSZ ");
            sSQL.Add(" where 1=1 ");
            sSQL.Add(" and isnull(XLXSBJKZXXSZ_SYBJFLID,' ') <> ' '");
            sSQL.Add(" and isnull(XLXSBJKZXXSZ_LBXS,'N') = 'Y'");
            ds = dberp.OpenDataSet(sSQL);
            if (ds.Tables[0].Rows.Count > 0)
            {
                for (int i = 0; i < ds.Tables[0].Rows.Count; ++i)
                {
                    string sSYBJFL = ds.Tables[0].Rows[i]["XLXSBJKZXXSZ_SYBJFLID"].ToString().Trim();
                    string sDYZD = ds.Tables[0].Rows[i]["XLXSBJKZXXSZ_DYZD"].ToString().Trim();
                    if (!cfg.dicSYBJFL.ContainsKey(sDYZD))
                        cfg.dicSYBJFL.Add(sDYZD, sSYBJFL);
                }
            }

            sSQL.Clear();
            sSQL.Add("select XLXSBJKZXXSZ_MC, XLXSBJKZXXSZ_DYZD from XLXSBJKZXXSZ where isnull(XLXSBJKZXXSZ_LBXS,'N') = 'Y' order by XLXSBJKZXXSZ_BH");
            ds = dberp.OpenDataSet(sSQL);
            if (ds.Tables[0].Rows.Count > 0)
            {
                for (int i = 0; i < ds.Tables[0].Rows.Count; ++i)
                {
                    ZDColumn col = new ZDColumn();
                    col.sMC = ds.Tables[0].Rows[i]["XLXSBJKZXXSZ_MC"].ToString().Trim();
                    col.sDYZD = ds.Tables[0].Rows[i]["XLXSBJKZXXSZ_DYZD"].ToString().Trim();
                    cfg.listZDColumn.Add(col);
                }
            }
            return cfg;
        }

        //按流程/报价分类显示规则处理一组扩展列（KZSZ/KZZF/KZRQ/KZWB）：
        //对照字配置了显示范围且当前流程状态或报价分类不匹配时清空单元格；
        //bZFSelected为true（选择类型字段）且对照字在配置的显示清单内时，先把代码值转换为显示值
        private void SetExtColumnsVisible(GridViewRow row, string sPrefix, int iCount, bool bZFSelected,
            FJXXConfig cfgFJXX, string sWPID, string sBJFLID)
        {
            int iStart = ContentGrid.Columns.IndexOf(ContentGrid.FindColumnByFieldName(sPrefix + "01"));
            if (iStart < 0)
                return;
            for (int i = 1; i <= iCount; i++)
            {
                string sZDM = sPrefix + i.ToString().PadLeft(2, '0');
                int iCell = iStart + i - 1;
                if (iCell >= row.Cells.Count)
                    continue;
                if (bZFSelected)
                {
                    ZFOption opt;
                    if (("," + cfgFJXX.sFJXXSZ).Contains("," + sZDM + ",")
                        && GetZFOptions(cfgFJXX).TryGetValue(sZDM, out opt))
                        row.Cells[iCell].Text = GetZFSelectedEx(opt, row.Cells[iCell].Text.Trim());
                }
                if (cfgFJXX.dicXSBZ.ContainsKey(sZDM))
                {
                    string sXSBZ = "," + cfgFJXX.dicXSBZ[sZDM] + ",";
                    if (!sXSBZ.Contains("," + sWPID + ","))
                    {
                        row.Cells[iCell].Text = "";
                    }
                }
                if (cfgFJXX.dicSYBJFL.ContainsKey(sZDM))
                {
                    string sSYBJFL = "," + cfgFJXX.dicSYBJFL[sZDM] + ",";
                    if (!sSYBJFL.Contains("," + sBJFLID + ","))
                    {
                        row.Cells[iCell].Text = "";
                    }
                }
            }
        }

        //设置附加信息是否显示（列定义来自FJXXConfig缓存；因EnableViewState=false，须每请求在数据绑定前执行）
        private void SetFJXX()
        {
            List<ZDColumn> listZD = GetFJXXConfig().listZDColumn;
            for (int i = 0; i < listZD.Count; i++)
            {
                ContentGrid.FindColumnByFieldName(listZD[i].sDYZD).Visible = true;
                ContentGrid.FindColumnByFieldName(listZD[i].sDYZD).HeaderText = listZD[i].sMC;
            }
        }

        //选择类型扩展字段的选项一次性加载（sFJXXSZ清单内各对照字的MJSQL结果），行绑定期间共用
        private Dictionary<string, ZFOption> GetZFOptions(FJXXConfig cfgFJXX)
        {
            if (dicZFOptionCache != null)
                return dicZFOptionCache;
            dicZFOptionCache = new Dictionary<string, ZFOption>();
            string sZDMList = cfgFJXX.sFJXXSZ.TrimEnd(',');
            if (sZDMList.Equals(""))
                return dicZFOptionCache;
            string[] arrZDM = sZDMList.Split(',');
            TDatabase dberp = TContextDatabases.GetDatabase("DBERP");
            TSQL sSQL = new TSQL(dberp);
            sSQL.Clear();
            sSQL.Add("select XLXSBJKZXXSZ_MJSQL, XLXSBJKZXXSZ_SRFS, XLXSBJKZXXSZ_DYZD from XLXSBJKZXXSZ ");
            sSQL.Add("where 1=1 ");
            string sIn = "";
            for (int i = 0; i < arrZDM.Length; i++)
            {
                if (i > 0)
                    sIn += ",";
                sIn += ":pZDM" + i.ToString();
            }
            sSQL.Add(" and XLXSBJKZXXSZ_DYZD in (" + sIn + ") ");
            sSQL.Add("  and  rtrim(convert(varchar(4000),isnull(XLXSBJKZXXSZ_MJSQL ,' ')))||' ' <> ' ' and  isnull(XLXSBJKZXXSZ_SRFS,' ') <> 'A' ");
            for (int i = 0; i < arrZDM.Length; i++)
                sSQL.ParamByName("pZDM" + i.ToString()).Value = arrZDM[i].Trim();
            DataSet dsCfg = dberp.OpenDataSet(sSQL);
            for (int i = 0; i < dsCfg.Tables[0].Rows.Count; i++)
            {
                ZFOption opt = new ZFOption();
                opt.sSRFS = dsCfg.Tables[0].Rows[i]["XLXSBJKZXXSZ_SRFS"].ToString().Trim();
                string sDYZD = dsCfg.Tables[0].Rows[i]["XLXSBJKZXXSZ_DYZD"].ToString().Trim();
                string sMJSQL = dsCfg.Tables[0].Rows[i]["XLXSBJKZXXSZ_MJSQL"].ToString().Trim();
                sSQL.Clear();
                sSQL.Add(sMJSQL);
                DataSet dsResult = dberp.OpenDataSet(sSQL);
                for (int j = 0; j < dsResult.Tables[0].Rows.Count; j++)
                {
                    opt.listCode.Add(dsResult.Tables[0].Rows[j][0].ToString().Trim());
                    opt.listName.Add(dsResult.Tables[0].Rows[j][1].ToString().Trim());
                }
                if (!dicZFOptionCache.ContainsKey(sDYZD))
                    dicZFOptionCache.Add(sDYZD, opt);
            }
            return dicZFOptionCache;
        }

        //按预加载的选项把选中的代码值转换为显示值（对照字无配置时由调用方保持原值）
        private string GetZFSelectedEx(ZFOption opt, string sValue)
        {
            string sWrapped = "," + sValue.Trim() + ",";
            string sResult = "";
            if (opt.sSRFS.Equals("B"))
            {
                for (int i = 0; i < opt.listCode.Count; i++)
                {
                    if (sWrapped.Contains("," + opt.listCode[i] + ","))
                    {
                        sResult = opt.listCode[i] + "|" + opt.listName[i];
                        break;
                    }
                }
            }
            else
            {
                for (int i = 0; i < opt.listCode.Count; i++)
                {
                    if (sWrapped.Contains("," + opt.listCode[i] + ","))
                        sResult += opt.listName[i] + ",";
                }
                sResult = sResult.TrimEnd(',');
            }
            return sResult;
        }

        private string GetQuerySql()
        {
            string sSQL = " select XLXSBJD_BJDID, case when isnull(XLXSBJFL_BJFLID,' ')=' ' then XLXSBJD_BJFLID else rtrim(XLXSBJD_BJFLID)||'|'||XLXSBJFL_BJFLMC end as XLXSBJD_BJFLID,"
                        + " case isnull(XLXSBJD_JGBID,' ') when ' ' then ' ' else rtrim(XLXSBJD_JGBID)||'|'||XLXSJGB_JGBMC end as XSJGB,XLXSBJD_TJ,XLXSBJD_LJ,XLXSBJD_CLHQJGBID,";
            if (XSCBXKHID())
                sSQL += " case isnull(XLXSBJD_KHID,' ') when ' ' then rtrim(XLXSBJD_SYDWID)||'|'||GS_GSMC else rtrim(XLXSBJD_KHID)||'|'||KH_MC end as XHDW,";
            else
                sSQL += " case isnull(XLXSBJD_SYDWID,' ') when ' ' then ' ' else rtrim(XLXSBJD_SYDWID)||'|'||GS_GSMC end as XHDW,";

            sSQL += " case isnull(XLXSBJD_XSBMID,' ') when ' ' then ' ' else rtrim(XLXSBJD_XSBMID)||'|'||BM_MC end as XSBM,XLXSBJD_FKSM,"
                 + " case isnull(XLXSBJD_XSQYID,' ') when ' ' then ' ' else rtrim(XLXSBJD_XSQYID)||'|'||XSQY_XSQYMC end as XSQY, "
                 + " XLXSBJD_TXY, XLXSBJD_KH, XLXSBJD_KHLXR, XLXSBJD_LXDH, XLXSBJD_CZ, XLXSBJD_XMMC, XLXSBJD_XXDZ, XLXSBJD_BZ,XLXSBJD_ZJE,XLXSBJD_LRL, "
                 + " XLXSBJD_BJRQ, XLXSBJD_XSJLMC,XLXSBJD_CZJSXY,XLXSBJD_KHDH,XLXSBJD_LRL,XLXSBJD_ZDXJJCL,XLXSBJD_SQR, "
                 + " XLXSBJD_FKQXNR,XLXSBJD_FKRQ,case when isnull(XLXSBJD_ZDQRRGH,' ')<>' ' then 'Y' else 'N' end as ZDFXYQR,"
                 + " case isnull(XLXSBJD_ZBZT,' ') when 'Y' then '全部中标' when 'P' then '部分中标' when 'N' then '未中标' when 'F' then '废标' when 'Q' then '弃标' else ' ' end as FKJG,   "
                 + " XLXSBJKZXX_KZSZ01 as KZSZ01, XLXSBJKZXX_KZSZ02 as KZSZ02, XLXSBJKZXX_KZSZ03 as KZSZ03, XLXSBJKZXX_KZSZ04 as KZSZ04, XLXSBJKZXX_KZSZ05 as KZSZ05, "
                 + " XLXSBJKZXX_KZZF01 as KZZF01, XLXSBJKZXX_KZZF02 as KZZF02, XLXSBJKZXX_KZZF03 as KZZF03, XLXSBJKZXX_KZZF04 as KZZF04, XLXSBJKZXX_KZZF05 as KZZF05, "
                 + " XLXSBJKZXX_KZZF06 as KZZF06, XLXSBJKZXX_KZZF07 as KZZF07, XLXSBJKZXX_KZZF08 as KZZF08, XLXSBJKZXX_KZZF09 as KZZF09, XLXSBJKZXX_KZZF10 as KZZF10, "
                 + " XLXSBJKZXX_KZRQ01 as KZRQ01, XLXSBJKZXX_KZRQ02 as KZRQ02, XLXSBJKZXX_KZRQ03 as KZRQ03, XLXSBJKZXX_KZRQ04 as KZRQ04, XLXSBJKZXX_KZRQ05 as KZRQ05, "
                 + " XLXSBJKZXX_KZWB01 as KZWB01, XLXSBJKZXX_KZWB02 as KZWB02, XLXSBJKZXX_KZWB03 as KZWB03, XLXSBJKZXX_KZWB04 as KZWB04, XLXSBJKZXX_KZWB05 as KZWB05, "
                 + " XLXSBJD_DOCGRPID,XLXSBJD_FJS,XLXSBJD_WHR, XLXSBJD_WHRID, XLXSBJD_WHSJ, XLXSBJD_WFID, XLXSBJD_WFINST, XLXSBJD_WPID, XLXSBJD_WFAWAITER, XLXSBJD_WFHANDLER, XLXSBJD_ACTNAME "
                 + " from XLXSBJD "
                 + " left join XLXSBJKZXX on XLXSBJKZXX_BJDID = XLXSBJD_BJDID "
                 + " left join GS on GS_SYDWID=XLXSBJD_SYDWID"
                 + " left join BM on BM_BMID=XLXSBJD_XSBMID"
                 + " left join XLXSBJFL on XLXSBJD_BJFLID=XLXSBJFL_BJFLID"
                 + " left join XSQY on XSQY_XSQYID=XLXSBJD_XSQYID"
                 + " left join KH on KH_KHID=XLXSBJD_KHID"
                 + " left join XLXSJGB on XLXSJGB_JGBID=XLXSBJD_JGBID and XLXSJGB_MXBH in ('JGB','JGE')"
                 + " where 1=1 "
                 + " and isnull(XLXSBJD_YWLX,' ') = ' ' ";
            switch (CurQueryEntity.FieldByName("SW").Value.Trim())
            {
                case "W":
                    sSQL += "\r\n and " + _curWorkFlow.GetWhereAgent("XLXSBJ_BJD", tSession.UserId, "XLXSBJD_WFAWAITER", "XLXSBJD_WFID", "XLXSBJD_WPID");
                    break;
                case "H":
                    sSQL += "\r\n and XLXSBJD_WFHANDLER LIKE :XLXSBJD_WFHANDLER ";
                    entity.Param.Add("XLXSBJD_WFHANDLER", "%," + tSession.UserId + ",%");
                    break;
                case "A":
                    break;
            }
            if (!string.IsNullOrEmpty(CurQueryEntity.FieldByName("WFAWAITER").Value.Trim()))
            {
                sSQL += " \r\n and XLXSBJD_WFAWAITER like :pWFAWITER  ";
                entity.Param.Add("pWFAWITER", string.Format("%,{0},%", CurQueryEntity.FieldByName("WFAWAITER").Value.Trim()));
            }
            if (!string.IsNullOrEmpty(CurQueryEntity.FieldByName("STATE").Value.Trim()))
            {
                sSQL += "\r\n and " + CMISproDataBase.GetWhereEqual("XLXSBJD_WPID", CurQueryEntity.FieldByName("STATE").Value.Trim());
            }
            if (!CurQueryEntity.FieldByName("XHDW").Value.Trim().Equals(""))
            {
                sSQL += "\r\n and (GS_GSMC like :pXHDW or KH_MC like :pXHDW) ";
                entity.Param.Add("pXHDW", "%" + CurQueryEntity.FieldByName("XHDW").Value.Trim() + "%");
            }
            if (!CurQueryEntity.FieldByName("XSBM").Value.Trim().Equals(""))
            {
                sSQL += "\r\n and " + CMISproDataBase.GetWhereEqual("XLXSBJD_XSBMID", CurQueryEntity.FieldByName("XSBM").Value.Trim());
            }
            string sHJU006 = GetOption(100860000, "HJU006").Trim();
            if (!string.IsNullOrEmpty(sHJU006))
            {
                sSQL += " and (" + CMISproDataBase.GetWhereEqual("XLXSBJD_XSBMID", sHJU006);
                sSQL += "      or isnull(XLXSBJD_XSBMID, ' ') = ' ')";
            }
            if (!CurQueryEntity.FieldByName("TXY").Value.Trim().Equals(""))
            {
                sSQL += "\r\n and (XLXSBJD_TXY = :pTXY) ";
                entity.Param.Add("pTXY", CurQueryEntity.FieldByName("TXY").Value.Trim());
            }
            if (!CurQueryEntity.FieldByName("KH").Value.Trim().Equals(""))
            {
                sSQL += "\r\n and (XLXSBJD_KH like :pKH) ";
                entity.Param.Add("pKH", "%" + CurQueryEntity.FieldByName("KH").Value.Trim() + "%");
            }
            if (!CurQueryEntity.FieldByName("SQRGH").Value.Trim().Equals(""))
            {
                sSQL+=" and " + CMISproDataBase.GetWhereEqual("XLXSBJD_SQRGH", CurQueryEntity.FieldByName("SQRGH").Value.Trim());
            }
            if (!CurQueryEntity.FieldByName("XM").Value.Trim().Equals(""))
            {
                sSQL += "\r\n and " + CMISproDataBase.GetWhereLike("XLXSBJD_XMMC", CurQueryEntity.FieldByName("XM").Value.Trim());
            }
            if (!CurQueryEntity.FieldByName("BJDID").Value.Trim().Equals(""))
            {
                sSQL += "\r\n and XLXSBJD_BJDID like :pBJDID ";
                entity.Param.Add("pBJDID", "%" + CurQueryEntity.FieldByName("BJDID").Value.Trim() + "%");
            }
            if (!CurQueryEntity.FieldByName("BJFLID").Value.Trim().Equals(""))
            {
                sSQL += "\r\n and XLXSBJD_BJFLID = :pBJFLID ";
                entity.Param.Add("pBJFLID", CurQueryEntity.FieldByName("BJFLID").Value.Trim());
            }
            if (!CurQueryEntity.FieldByName("BJBZ").Value.Trim().Equals(""))
            {
                sSQL += "\r\n and XLXSBJD_BZ like :pBJBZ ";
                entity.Param.Add("pBJBZ",'%'+CurQueryEntity.FieldByName("BJBZ").Value.Trim()+'%');
            }
            if (!CurQueryEntity.FieldByName("KHDH").Value.Trim().Equals(""))
            {
                sSQL += "\r\n and XLXSBJD_KHDH like :pKHDH ";
                entity.Param.Add("pKHDH", '%' + CurQueryEntity.FieldByName("KHDH").Value.Trim() + '%');
            }
            //报价金额
            if (!string.IsNullOrEmpty(CurQueryEntity.FieldByName("BJZJES").Value.Trim()) && !CurQueryEntity.FieldByName("BJZJES").Value.Trim().Equals("0"))
            {
                sSQL +="\r\n and XLXSBJD_ZJE >=:pBJZJES ";
                entity.Param.Add("pBJZJES", CMISproConvert.StrToFloat(CurQueryEntity.FieldByName("BJZJES").Value.Trim(),0));

            }
            if (!string.IsNullOrEmpty(CurQueryEntity.FieldByName("BJZJEZ").Value.Trim()) && !CurQueryEntity.FieldByName("BJZJEZ").Value.Trim().Equals("0"))
            {
                sSQL += "\r\n and XLXSBJD_ZJE <=:pBJZJEZ ";
                entity.Param.Add("pBJZJEZ", CMISproConvert.StrToFloat(CurQueryEntity.FieldByName("BJZJEZ").Value.Trim(), 0));

            }

            
            string sBJU012 = GetOption(100860000, "BJU012").Trim();
            if (!string.IsNullOrEmpty(sBJU012))
            {
                sSQL += " and (" + CMISproDataBase.GetWhereEqual("XLXSBJD_BJFLID", sBJU012);
                sSQL += "      or isnull(XLXSBJD_BJFLID, ' ') = ' ')";
            }
            if (CurQueryEntity.FieldByName("ZDFXYQR").Value.ToUpper().Trim().Equals("TRUE"))
            {
                sSQL += " and isnull(XLXSBJD_ZDQRRGH,' ')<>' ' ";
            }
            if (CurQueryEntity.FieldByName("JCFZCS").Value.ToUpper().Trim().Equals("TRUE"))
            {
                sSQL += " and isnull(XLXSBJD_FZBZ,'N') ='Y' ";
            }
            if (!string.IsNullOrEmpty(CurQueryEntity.FieldByName("FKJG").Value.Trim()))
            {
                sSQL += "\r\n and " + CMISproDataBase.GetWhereEqual("XLXSBJD_ZBZT", CurQueryEntity.FieldByName("FKJG").Value.Trim());
            }
            sSQL += CMISproDataBase.GetTimeConditionSQL("XLXSBJD_BJRQ",
                                            CurQueryEntity.FieldByName("BJRQS").Value.ToString().Trim(),
                                            CurQueryEntity.FieldByName("BJRQZ").Value.ToString().Trim(),
                                            DateTimeType.dtDate, DateTimeType.dtDate);
            sSQL += CMISproDataBase.GetTimeConditionSQL("XLXSBJD_WHSJ",
                                            CurQueryEntity.FieldByName("WHSJS").Value.ToString().Trim(),
                                            CurQueryEntity.FieldByName("WHSJZ").Value.ToString().Trim(),
                                            DateTimeType.dtTime, DateTimeType.dtTime);
            sSQL += CMISproDataBase.GetTimeConditionSQL("XLXSBJD_FKRQ",
                                           CurQueryEntity.FieldByName("FKRQS").Value.ToString().Trim(),
                                           CurQueryEntity.FieldByName("FKRQZ").Value.ToString().Trim(),
                                           DateTimeType.dtDate, DateTimeType.dtDate);
            for (int i = 1; i <= 5; i++)
            {
                string fieldNumber = i.ToString().PadLeft(2, '0');
                string fieldName = "KZSZ" + fieldNumber;

                string fieldValue = CurQueryEntity.FieldByName(fieldName).Value.ToString().Trim();
                if (!string.IsNullOrEmpty(fieldValue) && fieldValue != "0")
                {
                    string paramName = "pKZSZ" + fieldNumber;
                    sSQL+=string.Format(" and isnull(XLXSBJKZXX_KZSZ{0},0) = :{1} ",
                        fieldNumber,
                        paramName);

                    entity.Param.Add(paramName, CMISproConvert.StrToFloat(fieldValue));
                }
            }

            for (int i = 1; i <= 10; i++)
            {
                string fieldNumber = i.ToString().PadLeft(2, '0');
                string fieldName = "KZZF" + fieldNumber+"1";

                string fieldValue = CurQueryEntity.FieldByName(fieldName).Value.ToString().Trim();
                if (!string.IsNullOrEmpty(fieldValue))
                {
                    string paramName = "p" + fieldName;
                    sSQL += string.Format(" and isnull(XLXSBJKZXX_KZZF{0},' ') like :{1} ",
                        fieldNumber,
                        paramName);

                    entity.Param.Add(paramName, "%" + fieldValue+"%" );
                }
            }

            for (int i = 1; i <= 10; i++)
            {
                string fieldNumber = i.ToString().PadLeft(2, '0');
                string fieldName = "KZZF" + fieldNumber + "2";

                string fieldValue = CurQueryEntity.FieldByName(fieldName).Value.ToString().Trim();
                if (!string.IsNullOrEmpty(fieldValue))
                {
                    string paramName = "p" + fieldName;
                    sSQL += string.Format(" and ','||Rtrim(isnull(XLXSBJKZXX_KZZF{0},' '))||','  like :{1} ",
                        fieldNumber,
                        paramName);

                    entity.Param.Add(paramName, "%," + fieldValue + ",%");
                }
            }

            for (int i = 1; i <= 5; i++)
            {
                string fieldNumber = i.ToString().PadLeft(2, '0');
                string fieldName = "KZWB" + fieldNumber;

                string fieldValue = CurQueryEntity.FieldByName(fieldName).Value.ToString().Trim();
                if (!string.IsNullOrEmpty(fieldValue))
                {
                    string paramName = "pKZWB" + fieldNumber;
                    sSQL += string.Format(" and isnull(XLXSBJKZXX_KZWB{0},' ') like :{1} ",
                       fieldNumber,
                       paramName);

                    entity.Param.Add(paramName, "%" + fieldValue + "%");
                }
            }

            for (int i = 1; i <= 5; i++)
            {
                string fieldNumber = i.ToString().PadLeft(2, '0');
                string fieldName = "KZRQ" + fieldNumber;

                sSQL+=CMISproDataBase.GetTimeConditionSQL("XLXSBJKZXX_KZRQ"+fieldNumber, CurQueryEntity.FieldByName(fieldName + "S").Value.Trim(), CurQueryEntity.FieldByName(fieldName+"Z").Value.Trim(), DateTimeType.dtDate, DateTimeType.dtDate);
            }
           
            switch (CurQueryEntity.FieldByName("PXFS").Value.Trim())
            {
                case PXFS_BJD_DESC:
                    sSQL += " order by XLXSBJD_BJDID desc ";
                    break;
                case PXFS_BJD_ASC:
                    sSQL += " order by XLXSBJD_BJDID ";
                    break;
                case PXFS_BJRQ_DESC:
                    sSQL += " order by XLXSBJD_BJRQ DESC, XLXSBJD_BJDID DESC ";
                    break;
                case PXFS_BJRQ_ASC:
                default:
                    sSQL += " order by XLXSBJD_BJRQ, XLXSBJD_BJDID ";
                    break;
            }
            return sSQL;
        }

        //按当前查询条件重建查询SQL并重新绑定表格
        private void RebindGrid()
        {
            entity.EntityTable.QuerySelSql = GetQuerySql();
            entity.GridDataBind(ContentGrid, tSession);
        }

        //按字段名定位列索引（列不存在时返回-1，避免硬编码列序号在aspx改列后写错列）
        private int GetColumnIndexByField(string sFieldName)
        {
            return ContentGrid.Columns.IndexOf(ContentGrid.FindColumnByFieldName(sFieldName));
        }

        //判断模块是否存在并且是否有权限
        private bool CheckModule(int iUMID)
        {
            UserRight UR = OpRightUtils.GetUserRight(tSession.UserId, iUMID);
            return (DSActiveModule.IsActiveModule(iUMID) && UR.Open);
        }

        private bool XSCBXKHID()
        {
            TDatabase dberp = TContextDatabases.GetDatabase("DBERP");
            TSQL SQL = new TSQL(dberp);
            //客户ID
            XLXSBJPZXX pzxx = XLBJDUtils.GetXLXSBJPZXX(100860000);

            //销售报价业务配置“客户检索来源”为“KH|客户”、且“新增客户要求”为“报价前维护”时，txtKHID显示，cbxKHID不显示
            if (pzxx.XLXSBJPZ_KHJSLY == "KH" && pzxx.XLXSBJPZ_XZKHYQ == "Q")
                return false;

            return true;
        }

        #endregion

        protected void btnCopyEx_Click(object sender, EventArgs e)
        {
            if (ContentGrid.SelectedIndex == -1)
            {
                ShowMessage("请选择处理记录！");
                return;
            }
            TPageParams pageParams = new TPageParams();
            pageParams.UrlPath = this.sURLTarget;
            pageParams.CallAction = TPageCallAction.pcaCopy;
            pageParams.AddString("CopyFromList", "Y");
            pageParams.AddString("WFID", ContentGrid.DataKeys[ContentGrid.SelectedIndex]["XLXSBJD_WFID"].ToString().Trim());
            pageParams.AddString("WFINST", ContentGrid.DataKeys[ContentGrid.SelectedIndex]["XLXSBJD_WFINST"].ToString().Trim());
            pageParams.AddString("XLXSBJD_BJDID", CurBJDID);
            OpenDialog(pageParams);
        }

       

       
    }
}