javascript创设xmlDom对象02

/**
 * delHighCapTempTabReq      发送删除临时表的请求
 * @param {string} sTempTabNo  临时表号
 * 
 */
function delHighCapTempTabReq(sTempTabNo)
{	
	//入参检查
	if (!sTempTabNo)
	{
		return;
	}
	var oRequestNode= creatHighCapDelTblCMD(sTempTabNo);
	
	//modify by z56317 20120523 更改为HTTPS协议后，由于返回给UI的结果用时较长，导致页面关闭后命令无法返回，连接无法释放，采用同步的机制进行处理, 
	//超时时间也修改为2秒，以免用户点击关闭页面后，服务器返回时间过长后页面关闭不掉，对用户感受不好。	
	//toXMLPack(oRequestNode, g_sendType.Asy, null);
	toXMLPack(oRequestNode, g_sendType.Syn, null, g_time.TwoSec);
}

/*******************************************************************************
函数名：    creatHighCapDelTblCMD
功能：     构造删除临时表的XML片段
            Return:  XML片段（DOM）-成功 null-失败
*******************************************************************************/
function creatHighCapDelTblCMD(tmpTblId)
{
    if(!tmpTblId)
    {
        return null;
    }

    var oXmlDom = initXmlDom(g_cmdCode.CHR_CMD_HIGHCAP_DEL_TMP_TBL);
    var doc = oXmlDom[0];
    var requestNode = oXmlDom[1];

	var sessionId = parseCookie();
    var SESSIONIDNode = creatSingleChildParaNode(doc,"SESSIONID",sessionId);
    requestNode.appendChild(SESSIONIDNode);
	
	var arrTmpTblId = tmpTblId.split(",");
    var tmpTblIdNode = creatMulitChildParaNode(doc,"TEMP_TBL",arrTmpTblId);
    requestNode.appendChild(tmpTblIdNode);

    return requestNode;
}
//----------------------------------------------------------------

//--------------------------------xml解析 孙国峰----------------------------------------
/*******************************************************************************
函数名：    XMLToDict
功能：     结果集合XML解析成节点字典 节点以area为单位！
*******************************************************************************/
function XMLToDict(oRoot)
{
    if(null == oRoot)
    {
        //alert("正在解析的XML为空!");
        return null;
    }
    //alert("in XMLToDict-->"+oRoot.xml)
    //获取DOM对象的根节点名称 
    var sNodeName = oRoot.nodeName;     //取得dom对象根节点
        
    //检查传入的data数据包是否正确
    if ("response" != sNodeName)
    {
        //alert("in parseTBL()! request error");
        return null;
    }

    var areaNodeList = oRoot.getElementsByTagName("area");     //取得dom节点集合area
    if(null == areaNodeList)
    {
        return null;
    }
    else
    {
        var nodeDict = {};      //声明节点字典变量
        //for(var i in pageNodeList)
        for(var i = 0 ;i<areaNodeList.length; i++)            //循环area节点集合
        {   
            var sKey = areaNodeList[i].getAttribute("name")   //取得每一个节点的name属性
            //alert(sKey);
            nodeDict[sKey] = areaNodeList[i];                 //将每一个area节点赋给节点字典nodeDict
        }
        
        var recode = oRoot.getAttribute("recode");            //取得根节点的recode属性
        //if("-1" == recode)
		if("0" != recode)
        {
            /*
            if(null == nodeDict["DETAIL"])
            {
                //alert("no DETAIL node!!");
            }
            else
            {
                var errDetal = nodeDict["DETAIL"].childNodes[0].attributes[0].nodeValue;
                alert("Server:" + errDetal);
            }
            */
            
            return null;
        
        }
        
        return nodeDict;
    }

}

/*******************************************************************************
函 数 名  : XMLToDictForRequestNode
功能描述  : 序列化request请求xml
输入参数  : oRoot - xmldom对象
返 回 值  : arrNodeDict - para节点字典，元素为xmldom节点对象，可以通过name索引，
           例如：arrNodeDict["test"]访问name属性为test的xml节点。
           null - 解析失败或参数错误。
调用函数  : 无
被调函数  : 模板管理模块requestTemplateInfoCallBack
*******************************************************************************/
function XMLToDictForRequestNode(oRoot)
{
    if(null == oRoot)
    {
        return null;
    }
    
    //获取DOM对象的根节点名称 
    var sNodeName = oRoot.nodeName;
        
    //检查传入的data数据包是否正确
    if ("request" != sNodeName)
    {
        return null;
    }

    var arrAreaNodeList = oRoot.getElementsByTagName("para");
    if(null == arrAreaNodeList)
    {
        return null;
    }
    else
    {
        var arrNodeDict = new Object();
        for(var i = 0 ;i < arrAreaNodeList.length; i++)
        {   
            var sKey = arrAreaNodeList[i].getAttribute("name")
            arrNodeDict[sKey] = arrAreaNodeList[i];
        }
        
        return arrNodeDict;
    }
}

/*******************************************************************************
函数名：    parseTBL
功能：     结果集合解析函数
            Return:  null--失败
                成功解析返回数组如下：[record,DETAILString] or [record,tblDict] 
                tblDict = {
                    PAGE = {
                            BEGIN_RECORD ="0" END_RECORD ="2" 
                            ALL_NUM ="10000" DISPATCH_NUM="0"
                            }
                    HEAD = [
                        {ID ="o_0" NAME ="MSC"}
                        {ID ="c_0" NAME ="接通率"}
                        {ID ="c_1" NAME ="试呼次数"}
                        ]
                    DATA = [
                        {o_0= " MSC1" c_0="111"  c_1="111" c_2="111"}
                        {o_0= " MSC2" c_0="111"  c_1="111" c_2="111"}
                        ]   
                }
*******************************************************************************/
function parseTBL(tblData)
{
    var nodeDict = XMLToDict(tblData);
    if(null == nodeDict)
    {
        return null;
    }
    
    if(null == nodeDict["PAGE"])
    {
        //alert("no PAGE node!!");
        return null;
    }
    if(null == nodeDict["HEAD"])
    {
        //alert("no HEAD node!!");
        return null;
    }
    if(null == nodeDict["DATA"])
    {
        //alert("no DATA node!!");
        return null;
    }

    var tblDict = {};
    //构造PAGE节点的字典
    var pageDict = {};
    var pageAttributes = nodeDict["PAGE"].childNodes[0].attributes
    for(var i=0; i<pageAttributes.length; i++)
    {
        var sKey = pageAttributes[i].nodeName;
        var sValue = pageAttributes[i].nodeValue;
        pageDict[sKey] = sValue;

        //alert(sKey + "--" +sValue);
    }
    tblDict["PAGE"] = pageDict;

    //构造HEAD（表头）节点的对象数组
    var headList = [];
    var headChildNodes = nodeDict["HEAD"].childNodes
    for(var i=0; i<headChildNodes.length; i++)
    {
        var descDict = {};
        var descNodeAttributes = headChildNodes[i].attributes
        for (var j=0; j<descNodeAttributes.length; j++ )
        {
            var sKey = descNodeAttributes[j].nodeName;
            var sValue = descNodeAttributes[j].nodeValue;

            descDict[sKey] = sValue;
        }
        headList.push(descDict);
        descDict = null;

    }
    tblDict["HEAD"] = headList;

    //构造DATA（表数据）节点的对象数组
    var dataList = [];
    var dataChildNodes = nodeDict["DATA"].childNodes
    for(var i=0; i<dataChildNodes.length; i++)
    {
        var descDict = {};
        var descNodeAttributes = dataChildNodes[i].attributes
        for (var j=0; j<descNodeAttributes.length; j++ )
        {
            var sKey = descNodeAttributes[j].nodeName;
            var sValue = descNodeAttributes[j].nodeValue;

            descDict[sKey] = sValue;
        }
        dataList.push(descDict);
        descDict = null;
    }
    tblDict["DATA"] = dataList;

    return tblDict;
    
}
/*******************************************************************************
函数名：    parseCFGList
功能：     结果集合解析函数
            Return:  null--失败
                成功解析返回数组如下：
                    list = [
                        {id :"o_0", value :"MSC1"}
                        {id :"o_1", value :"MSC2"}
                        {id :"o_2", value :"MSC3"}
                        ]
*******************************************************************************/
function parseCFGList(tblData)
{
    var nodeDict = XMLToDict(tblData);
    if(null == nodeDict)
    {
        return null;
    }
    if(null == nodeDict["HEAD"])
    {
        //alert("no HEAD node!!");
        return null;
    }
    if(null == nodeDict["DATA"])
    {
        //alert("no DATA node!!");
        return null;
    }

    var IDID="";
    var NAMEID=""
    var headChildNodes = nodeDict["HEAD"].childNodes
    for(var i=0; i<headChildNodes.length; i++)
    {
    	var sName = headChildNodes[i].getAttribute("NAME");
    	switch(sName)
    	{
            case "ID":
            	IDID = headChildNodes[i].getAttribute("ID");
            	break;
            case "NAME":
            	NAMEID = headChildNodes[i].getAttribute("ID");
            	break;
            default:
            	break;
    	}
    }
    
    if(("" == IDID)||("" == NAMEID))
    {
    	//alert("HEAD node information is not enough!");
    	return null;
    }

    //构造节点的对象数组
    var cfgList = [];
    var dataChildNodes = nodeDict["DATA"].childNodes
    for(var i=0; i<dataChildNodes.length; i++)
    {
        var descDict = {};
        descDict["id"] = dataChildNodes[i].getAttribute(IDID);
        descDict["value"] = dataChildNodes[i].getAttribute(NAMEID);

        cfgList.push(descDict);
        descDict = null;
    }

    return cfgList;
    
}
/*
function parseCFGList(tblData)
{
    var nodeDict = XMLToDict(tblData);
    if(null == nodeDict)
    {
        return null;
    }
    if(null == nodeDict["HEAD"])
    {
        alert("no HEAD node!!");
        return null;
    }

    //构造节点的对象数组
    var headList = [];
    var headChildNodes = nodeDict["HEAD"].childNodes
    for(var i=0; i<headChildNodes.length; i++)
    {
        var descDict = {};
        descDict["id"] = headChildNodes[i].getAttribute("ID");
        descDict["value"] = headChildNodes[i].getAttribute("NAME");

        headList.push(descDict);
        descDict = null;
    }

    return headList;
    
}
*/
/*******************************************************************************
函数名：    parseSaveResult
功能：     结果集合解析函数
            Return:  null--失败 sURL--成功
                成功解析返回数组如下：
*******************************************************************************/
function parseSaveResult(tblData)
{
    var nodeDict = XMLToDict(tblData);
    if(null == nodeDict)
    {
        return null;
    }
    if(null == nodeDict["FILE"])
    {
        //alert("no FILE node!!");
        return null;
    }

    var sURL = nodeDict["FILE"].childNodes[0].getAttribute("URL");
    
    return sURL;
    
}

/**
 * 函 数 名 ： createGetSGSNListCMD
 * 功能描述 ： 组装查询SGSN列表的XML
 * 参   数 ： 无
 * 返 回 值 ： oXml 请求SGSN列表的XML对象
 */
function createGetSGSNListCMD()
{
	//创建XML对象
	var oXmlDom = initXmlDom(g_cmdCode.RSM_CMD_GET_MEAS_DATA);
	var oDoc = oXmlDom[0];
	var oXml = oXmlDom[1];
    var oPara = null;
    var oValue = null;
    
    //添加业务码
    //modified by z00110907 2010-03-02 for CDMA Version.
    if ((g_oVersionEnum.CS == g_sVersion) || (g_oVersionEnum.CDMA == g_sVersion))
    {
        oPara = creatSingleChildParaNode(oDoc, "REPORT_NAME", g_report.CHR_GET_MSC_LIST);
    }
    else if (g_oVersionEnum.PS == g_sVersion)
    {
        oPara = creatSingleChildParaNode(oDoc, "REPORT_NAME", g_report.CHR_GET_SGSN_LIST);
    }
    
    if (null == oPara)
    {
    	return null;
    }
    oXml.appendChild(oPara);
  
   //添加查询范围
    oPara = creatParaNode(oDoc, "RECORD_THRESHOLD");
    oValue = oDoc.createElement("value");
    oProperty = creatPropertyNode(oDoc, "questNum", "1");
    oValue.appendChild(oProperty);
    oProperty = creatPropertyNode(oDoc, "beginRecord", "1");
    oValue.appendChild(oProperty);
    oProperty = creatPropertyNode(oDoc, "endRecord", "100");
    oValue.appendChild(oProperty);
    oProperty = creatPropertyNode(oDoc, "isSample", "0");
    oValue.appendChild(oProperty);
    oProperty = creatPropertyNode(oDoc, "dispatchRecord", "1");
    oValue.appendChild(oProperty);
    oPara.appendChild(oValue);
    oXml.appendChild(oPara);
    
    return oXml
}

/**
 * 函 数 名 ： createGetGGSNListCMD
 * 功能描述 ： 组装查询GGSN列表的XML
 * 参   数 ： 无
 * 返 回 值 ： oXml 请求GGSN列表的XML对象
 */
function createGetGGSNListCMD()
{
	//创建XML对象
	var oXmlDom = initXmlDom(g_cmdCode.RSM_CMD_GET_MEAS_DATA);
	var oDoc = oXmlDom[0];
	var oXml = oXmlDom[1];
    var oPara = null;
    var oValue = null;
    
    //添加业务码
    //modified by z00110907 2010-03-02 for CDMA Version.
    if ((g_oVersionEnum.CS == g_sVersion) || (g_oVersionEnum.CDMA == g_sVersion))
    {
        oPara = creatSingleChildParaNode(oDoc, "REPORT_NAME", g_report.CHR_GET_MGW_LIST);
    }
    else if (g_oVersionEnum.PS == g_sVersion)
    {
        oPara = creatSingleChildParaNode(oDoc, "REPORT_NAME", g_report.CHR_GET_GGSN_LIST);
    }
    
    if (null == oPara)
    {
    	return null;
    }
    oXml.appendChild(oPara);
    
   //添加查询范围
    oPara = creatParaNode(oDoc, "RECORD_THRESHOLD");
    oValue = oDoc.createElement("value");
    oProperty = creatPropertyNode(oDoc, "questNum", "1");
    oValue.appendChild(oProperty);
    oProperty = creatPropertyNode(oDoc, "beginRecord", "1");
    oValue.appendChild(oProperty);
    oProperty = creatPropertyNode(oDoc, "endRecord", "100");
    oValue.appendChild(oProperty);
    oProperty = creatPropertyNode(oDoc, "isSample", "0");
    oValue.appendChild(oProperty);
    oProperty = creatPropertyNode(oDoc, "dispatchRecord", "1");
    oValue.appendChild(oProperty);
    oPara.appendChild(oValue);
    oXml.appendChild(oPara);
    
    return oXml
}

//********************需要提取出去***********************
//超时信息打印标志，true表示已经打印过提示信息。
var g_bTimeOutPrintFlag = false;
/*******************************************************************************
函 数 名  : checkConnect
功能描述  : 超时检查函数
输入参数  : oResultXML - 结果XML
            sRelaLocation - 当前页面到登录页面的相对路径
返 回 值  : true - 登录超时 false - 非登录超时
*******************************************************************************/
function checkConnect(oResultXML, sRelaLocation)
{
    //数值类型的值不属于超时
    if ((null == oResultXML) || ("number" == typeof(oResultXML)))
    {
        return false;
    }
    
    //当前页面是否在主框架页面中
    var bInMainPage = false;
    
    //主框架页面
    if (null != parent && null != parent.g_oMainFrame)
    {
        bInMainPage = true;
    }
    
    var sRecode = 0;
    try
    {
        var oResponse = oResultXML.getElementsByTagName("response")[0];     //取得xml数据中response标签
        if (oResponse)
        {
            sRecode = oResponse.getAttribute("recode");           //取得rcode属性值
        }
        else
        {
            sRecode = oResultXML.getAttribute("recode");          //取得recode属性值
        }
    }
    catch(e)
    {
        e = null;
    }    
    finally
    {                      //610004
        if (g_returncode.RSM_AUTO_LOGOUT == sRecode)          //超过15分钟，Server自动注销
        {
          try //这里有可能抛异常
	      {
				if (true == parent.g_bTimeOutPrintFlag)		  //超时信息打印，为true表示已打印
				{
					;
				}
				else
				{
					g_bTimeOutPrintFlag = true;
				
				    alert(g_oPublicAlertInfo.PUB_TimeOut);   //弹出对话框--会话时段已超时，请重新登录
				}
	        }
	        catch(e)
	        {
	        	if(true == g_bTimeOutPrintFlag)
	        	{
	        		;
	        	}
	        	else
	        	{
	        		g_bTimeOutPrintFlag = true;
				
				    alert(g_oPublicAlertInfo.PUB_TimeOut);
				    e = null;
	        	}
	        	
	        }
            try
            {
	            if (null != parent.g_oMainFrame)      //全局框架对象
	            {
	            	//modified by z00110907  2009-05-26 主框架直接跳转到登录页面
					top.location.pathname = "/index.html";        //top为window属性，表示获取最顶层的祖先窗口
					//top.location = sRelaLocation + "index.html";
	            }
            }
            catch(e)
            {
            	e = null;
            	return true;
            }
            
            return true;
        }
        else
        {
            g_bTimeOutPrintFlag = false;       //超时是否打印过提示信息
            return false;
        }
    }
}

/**
 * getAreaByName 通过name获取相应的area
 * @param {object} oResXml 结果XML对象 
 * @param {string} sName area结点的name属性
 * 
 * @return {object} 属性name为sName的area结点对象
*/
function getAreaByName(oResXml, sName)
{
    //入参检查
    if (!oResXml || !sName)
    {
        return null
    }
    var oRes = null;
    var oAreas = oResXml.getElementsByTagName("area");
    for (var i = 0; i < oAreas.length; i++)
    {
        if (oAreas[i].getAttribute("name") == sName)
        {
            oRes = oAreas[i];
            break;
        }
    }
    return oRes;
}

/**
 * getParaByName 在XML对象中通过name获取相应的para节点对象
 * @param {obj} oXML 被寻找的XML对象
 * @param {string} sName para结点的name属性
 * 
 * @return {object} 属性name为sName的para结点对象
 */
function getParaByName(oXML, sName)
{
	//入参检查
	if (!sName || !oXML)
	{
		return null
	}
	var oRes = null;
	var oParas = oXML.getElementsByTagName("para");
	for (var i = 0; i < oParas.length; i++)
	{
		if (oParas[i].getAttribute("name") == sName)
		{
			oRes = oParas[i];
			break;
		}
	}
	return oRes;
}

/**
 * 函 数 名：createTmpTblNo
 * 功能描述：创建临时表名称
 * 参   数: 无
 * 返 回 值：临时表名称字符串
 */
function createTmpTblNo()
{
	var sessionid = parseCookie();
	var millisecond = Date.parse(new Date());
	var randomnum = Math.floor(Math.random( )*100);
	return sessionid + "_" + millisecond + "_" + randomnum;
}

/**
 * 函数名称： createProParaNode
 * 函数功能： 分析报告中特有的xml节点
 * 参数：    oDoc xmlDom对象，sName节点名称，arrIdList各子节点的Id名称数组，arrValueList各子节点的值
 * 返回：    oParaNode节点结构形如
 * <para name="name">
 *       <value>
 *          <property name="id">arrIdList[0]</property>
 *          <property name="value">arrValueList[0]</property>
 *       </value>
 *       <value>
 *           <property name="id">arrIdList[1]</property>
 *           <property name="value">arrValueList[1]</property>
 *       </value>
 * </para>
 */
function createProParaNode(oDoc,sName,arrIdList,arrValueList)
{
	var oParaNode = creatParaNode(oDoc, sName);
	
	for (var i = 0 ;i < arrIdList.length; i++)
	{
		var oValueNode = creatValueNode(oDoc);
		var oPropertyIdNode = creatPropertyNode(oDoc,"id",arrIdList[i]);
		var oPropertyValueNode = creatPropertyNode(oDoc,"value",arrValueList[i]);
		
		oValueNode.appendChild(oPropertyIdNode);
		oValueNode.appendChild(oPropertyValueNode);
		
		oParaNode.appendChild(oValueNode);
	}
	 return oParaNode;
}

/**
 * 名称： createLogNode
 * 功能： 创建日志节点
 * 参数： oDom  document对象
 *       userName  用户名
 *       operationName 操作名
 *       detail  详细信息， 如果没有的话，传入null
 * 返回： 构造的日志节点
 */
function createLogNode(oDom ,userName, operationName, detail)
{
	if (null != detail)    //判断日志详情
	{
		detail = detail.replace(/^\s+/,'').replace(/\s+$/,'');    //取出空格
	}
		
   	var oLogNode = oDom.createElement("para");                   //创建para节点
	var oLogAttribute = oDom.createAttribute("name");            //创建name属性
	oLogAttribute.value = "log";                                 //设置属性值
	var oValue = oDom.createElement("value");                    //创建value节点
	oLogNode.setAttributeNode(oLogAttribute);                    //为para节点添加属性子节点
	oLogNode.appendChild(oValue);                                //为para节点添加value子节点
	
	//操作日志的用户
	var oUserNode = creatPropertyNode(oDom, "user", userName);              //创建用户节点
	//日志的操作名称
	var operationNode = creatPropertyNode(oDom, "action", operationName);   //创建操作节点
	
	//日志的详细信息	
	var oDetailNode = oDom.createElement("property");           
	var oDeatilAttribute = oDom.createAttribute("name");
	oDeatilAttribute.value = "detail";
	oDetailNode.setAttributeNode(oDeatilAttribute);
	
	//如果详细信息为空的话，赋空格
	if (null == detail || "" == detail)
	{
		detail = " ";
	}

	var cdataContent = oDom.createCDATASection(detail);
	oDetailNode.appendChild(cdataContent);

	oValue.appendChild(oUserNode);
	oValue.appendChild(operationNode);
	oValue.appendChild(oDetailNode);

	return oLogNode;
}

//存放服务器时间的全局变量
var g_iServerTime = null;

//获取时间后，业务层的后继处理函数
var postDealFunction = null;

//标志是否成功获取服务器时间，是否能够获取memory时间标志位g_bHasMemoryTime定义在mainfram.js中
var g_bIsQueryServerTimeSucc = false;

//服务器时间记忆功能，保存获取到的时间到当前框架中
var g_iCurMemoryStartTime = null;
var g_iCurMemoryEndTime = null;
var g_bCurHasMemoryTime = false;

//产生记忆时间的按钮，-1表示“时间段”，1--9表示“最近查询”
var g_bCurCreateMemoryTimeRadio = "-1";

//页面时间控件类型
var g_oTimeCtrlEnum = 
{
	"range" : "1",
	"rangeAndLatest"  : "2" //具有"最近查询"和"时间段"类型
}

//记忆对比分析页面时间段A的时间
var g_iCurComparisonAStartTime = null;
var g_iCurComparisonAEndTime = null;
var g_bCurHasComparisonATime = false;
/**
 * 名称： getServerTime
 * 功能： 查询服务器时间
 * 参数： serverTimePostDeal，获取服务器时间后，业务层的后继处理函数
 * 返回： 无
*/
function getServerTime(serverTimePostDeal)
{
	postDealFunction = serverTimePostDeal;
	
	//创建dom对象和XML对象
	var oDoc = new XmlDom();
	var oXml= creatRequestNode(oDoc, g_cmdCode.CHR_GET_SERVER_SYSTIME);
	toXMLPack(oXml, g_sendType.Asy, queryServerTimeCallBack, g_time.Normal);
}

/**
 * 名称： queryServerTimeCallBack
 * 功能： 查询服务器时间通信回调函数，保存服务器时间为全局变量g_iServerTime,并调用后继处理函数
 * 参数： oResultXML，通信返回的xml
 * 返回： 无
*/
function queryServerTimeCallBack(oResXML)
{
	if (!oResXML || typeof(oResXML) == "number")
	{
		//如果查询Server时间失败的话，采用UI的系统时间
		g_iServerTime = new Date().getTime();
	}
	else
	{
      	if (checkConnect(oResXML, "../../"))      //超时会话
		{
			return;
		}
		
		try
		{
			var iSuccess = oResXML.getAttribute("recode"); 
			if (g_returncode.RSM_SUCCESS != iSuccess)          //任务执行是否成功
			{
				g_iServerTime = new Date().getTime();          //取得系统毫秒时间
			}
			else
			{
				var nodeDict = XMLToDict(oResXML);            //返回节点字典
				if (null == nodeDict || null == nodeDict["TIME"])
				{
					g_iServerTime = new Date().getTime();
				}
				else
				{
					g_iServerTime = parseFloat(nodeDict["TIME"].childNodes[0].getAttribute("TIMESTR"));
					g_bIsQueryServerTimeSucc = true;
				}
			}
		}
		catch(e)
		{
			g_iServerTime = new Date().getTime();
		}
	}
	
	if ("function" == typeof(postDealFunction))
	{
		postDealFunction([g_iServerTime]);
	}
}

/**
 * 名称： getMemoryTime
 * 功能： 获取UI记忆时间，获取不到，则查询server Time
 *       弹出页面里使用该函数会出错
 * 参数： postDeal，获取时间后的处理函数
 * 返回： 无
*/
function getMemoryTime(postDeal)
{
	try
	{
		if (true == parent.g_bHasMemoryTime)
		{
			g_bCurCreateMemoryTimeRadio = parent.g_bCreateMemoryTimeRadio;
			g_bCurHasMemoryTime = true;
			
			if (("-1" == parent.g_bCreateMemoryTimeRadio && g_sTimeCtrlType == g_oTimeCtrlEnum.rangeAndLatest) 
			    || (g_sTimeCtrlType == g_oTimeCtrlEnum.range) )
			{
				g_iCurMemoryStartTime = parent.g_iMemoryStartTime;
				g_iCurMemoryEndTime = parent.g_iMemoryEndTime;
				
				if ("function" == typeof(postDeal))
				{
					postDeal([g_iCurMemoryStartTime, g_iCurMemoryEndTime]);
				}
			}
			else
			{
				getServerTime(postDeal);
			}
		}
		else
		{
			getServerTime(postDeal);
		}
	}
	catch (e)
	{
		getServerTime(postDeal);
	}
}

/**
 * 名称： setMemoryTime
 * 功能： 设置UI记忆时间，UI记忆时间存放在主框架的head frame中，
 *       所以弹出页面里使用该函数会出错
 * 参数： 无
 * 返回： 无
*/
function setMemoryTime(arrMemoryTime)
{
	try
	{
		parent.g_iMemoryStartTime = arrMemoryTime[0];
		parent.g_iMemoryEndTime = arrMemoryTime[1];
		parent.g_bCreateMemoryTimeRadio = g_bCurCreateMemoryTimeRadio;
		parent.g_bHasMemoryTime = true;
		parent.g_bHasComparisonATime = false;
	}
	catch(e)
	{
		
	}
}

/**
 * 名称： getStartEndTimeInOneDay
 * 功能： 获取一天之内的开始时间和结束时间，因为记忆中的时间可能跨天，而有些页面操作时间不能跨天
 * 参数： arrTiem
 * 返回： arrTiemInOneDay
*/
function getStartEndTimeInOneDay(arrTime)
{
	var arrTiemInOneDay = [];
	
	//开始时间所处的日期对象
	var oDate = new Date(arrTime[0]); 
	var iEndTimeOfStartTimeDay = new Date(oDate.getFullYear(), oDate.getMonth(), oDate.getDate()).getTime() + 86400000;
	
	if (arrTime[1] >= iEndTimeOfStartTimeDay)
	{
		return [arrTime[0], iEndTimeOfStartTimeDay - 1];
	}
	else
	{
		return arrTime;
	}
}

/**
 * 名称： getLatestTimeId
 * 功能： 在arrLatestTimeItemId中获取与sLatestTimeItemId相等或最相近的ID
 * 参数： sLatestTimeItemId
 *       arrLatestTimeItemId
 * 返回： ID
*/
function getLatestTimeId(sLatestTimeItemId,arrLatestTimeItemId)
{
	var arrItemId = arrLatestTimeItemId.slice(0);
	
	arrItemId.sort();
	
	var sItemId = "," + arrItemId.join(",") + ",";
	
	if ( -1 != sItemId.indexOf("," + sLatestTimeItemId + ","))
	{
		return sLatestTimeItemId;
	}
	else
	{
		return arrItemId[arrItemId.length - 1];
	}
}

/**
 * 名称： setComparisonAMemoryTime
 * 功能： 设置UI记忆对比分析中的时间段A的时间，UI记忆时间存放在主框架的head frame中，
 *       所以弹出页面里使用该函数会出错
 * 参数： 无
 * 返回： 无
*/
function setComparisonAMemoryTime(arrMemoryTime)
{
	try
	{
		parent.g_bHasComparisonATime = true;
		parent.g_iComparisonAStartTime = arrMemoryTime[0];
		parent.g_iComparisonAEndTime = arrMemoryTime[1];
	}
	catch(e)
	{
		
	}
}

/**
 * 名称： getComparisonAMemoryTime
 * 功能： 获取UI记忆对比分析中的时间段A的时间，UI记忆时间存放在主框架的head frame中，
 *       所以弹出页面里使用该函数会出错
 * 参数： 无
 * 返回： 无
*/
function getComparisonAMemoryTime()
{
	try
	{
		if (true == parent.g_bHasComparisonATime)
		{
			g_iCurComparisonAStartTime = parent.g_iComparisonAStartTime;
			g_iCurComparisonAEndTime = parent.g_iComparisonAEndTime;
			
			if (null != g_iCurComparisonAStartTime && null != g_iCurComparisonAEndTime)
			{
				return [g_iCurComparisonAStartTime, g_iCurComparisonAEndTime];
			}
			else
			{
				return [];
			}
		}
		else
		{
			return [];
		}
		
	}
	catch(e)
	{
		return [];
	}
}

/**
 * 函 数 名：addMCC2NumberField
 * 功能描述：号码字段添加国家码
 * 参   数: oFieldInfo - 字段信息对象
 * 			sOperType - 业务类型
 * 返 回 值：处理后的字段值
 */
function addMCC2NumberField (oField, sOperType)
{
	if (null == g_sMCCNO || null == g_arrNumberField[sOperType])//g_sMCCNO为查询知识库得来。
	{
		return oField;
	}
	
	var oFieldInfo = {};
	oFieldInfo["FIELD_ID"] = oField.FIELD_ID;
	oFieldInfo["FIELD_NAME"] = oField.FIELD_NAME;
	oFieldInfo["FIELD_TYPE"] = oField.FIELD_TYPE;
	oFieldInfo["OPERATOR_ID"] = oField.OPERATOR_ID;
	oFieldInfo["OPERATOR_LABEL"] = oField.OPERATOR_LABEL;
	oFieldInfo["FIELD_VALUE"] = oField.FIELD_VALUE;
		
	var sNumbers = g_arrNumberField[sOperType].join("#") + "#";
	if (sNumbers.indexOf(oFieldInfo["FIELD_ID"] + "#") > -1)//需要处理的号码字段
	{
		var arrTemp = oFieldInfo["FIELD_VALUE"].split(";");//多值用分号分隔
		for (var i = 0; i < arrTemp.length; i++)
		{
			if (0 == arrTemp[i].indexOf("*"))//模糊匹配
			{
				continue;
			}
			// 没有区间范围range操作符"~"
			if (arrTemp[i].indexOf("~") == -1)
			{
				if (0 == arrTemp[i].indexOf(g_sMCCNO))//用户输入了国家码
				{
					arrTemp[i] = arrTemp[i].slice(g_sMCCNO.length) + ";" + arrTemp[i] + ";" + g_sMCCNO + arrTemp[i];
				}
				else//没有输入国家码
				{
					arrTemp[i] = arrTemp[i] + ";" + g_sMCCNO + arrTemp[i];
				}
			}
			else
			{
				var arrV = arrTemp[i].split("~");
				// 两边儿都没有国家码,下发2个条件
				if (0 != arrV[0].indexOf(g_sMCCNO) && 0 != arrV[1].indexOf(g_sMCCNO))
				{
					arrV[0] = g_sMCCNO + arrV[0];
					arrV[1] = g_sMCCNO + arrV[1];
					arrTemp[i] = arrTemp[i] + ";" + arrV.join("~");
				}
				else if (0 == arrV[0].indexOf(g_sMCCNO) && 0 == arrV[1].indexOf(g_sMCCNO))
				{
					// 两边儿都有国家码,下发3个条件
					arrTemp[i] = arrV[0].slice(g_sMCCNO.length) + "~" + arrV[1].slice(g_sMCCNO.length) + ";"
							+ arrTemp[i] + ";" + g_sMCCNO + arrV[0] + "~" + g_sMCCNO + arrV[1];
				}
				else
				{
					// 只有一个有国家码,下发4个条件
					var c1, c2, c3;
					// 左区间值输入国家码
					if (0 == arrV[0].indexOf(g_sMCCNO))
					{
						c1 = arrV[0].slice(g_sMCCNO.length) + "~" + arrV[1];
						c2 = arrV[0] + "~" + g_sMCCNO + arrV[1];
					}
					else
					{
						c1 = arrV[0] + "~" + arrV[1].slice(g_sMCCNO.length);
						c2 = g_sMCCNO + arrV[0] + "~" + arrV[1];
					}
					c3 = g_sMCCNO + arrV[0] + "~" + g_sMCCNO + arrV[1];
					arrTemp[i] = c1 + ";" + arrTemp[i] + ";" + c2 + ";" + c3;
				}
			}
		}
		
		//去重
		var sTemp = arrTemp.join(";");
		arrTemp = sTemp.split(";");
		arrTemp.sort();//先排序，再一次遍历比较并去重
		for (var i = 0; i < arrTemp.length - 1; i++)
		{
			if (arrTemp[i] == arrTemp[i + 1])//重复值一定相邻
			{
				arrTemp.splice(i + 1, 1);
				i--;//计数回退
			}
		}
		
		oFieldInfo["FIELD_VALUE"] = arrTemp.join(";");
	}
	
	return oFieldInfo;
}

//转换网元类型
function getNETypeForBarFied(arrAllFlowType, sAllFlowType)
{
	var sSGSNFlag = false;
	var sGGSNFlag = false;
	var sOperType = sAllFlowType;
	var sFlowType = "," + arrAllFlowType.toString() + ",";
	for (var i = 0; i < g_sNEGroupEnum[g_sNETypeEnum.SGSN].length; i++)
	{
	    if (sFlowType.indexOf("," + g_sNEGroupEnum[g_sNETypeEnum.SGSN][i] + ",") > -1)
    	{
	    	sSGSNFlag = true;
	    	break;
    	}
	}
	for (var i = 0; i < g_sNEGroupEnum[g_sNETypeEnum.GGSN].length; i++)
	{
		if (sFlowType.indexOf("," + g_sNEGroupEnum[g_sNETypeEnum.GGSN][i] + ",") > -1)
    	{
	    	sGGSNFlag = true;
	    	break;
    	}
	}
	
	if (sSGSNFlag && sGGSNFlag)
	{
		sOperType = g_sNETypeEnum.SGSNAndGGSN;
	}
	else if (sSGSNFlag)
	{
		sOperType = g_sNETypeEnum.SGSN;
	}
	else if (sGGSNFlag)
	{
		sOperType = g_sNETypeEnum.GGSN;
	}
	
	return sOperType;
}