analytics/webcontent/ags/metadataTree.js

/********************************************************************************************************************************
* Licensed Materials - Property of IBM                                                                                          *
*                                                                                                                               *
* IBM Cognos Products: AGS                                                                                                      *
*                                                                                                                               *
* (C) Copyright IBM Corp. 2005, 2021                                                                                            *
*                                                                                                                               *
* US Government Users Restricted Rights - Use, duplication or disclosure restricted by GSA ADP Schedule Contract with IBM Corp. *
*********************************************************************************************************************************/

var metadataTree = null;
var memberTree = null;
var activeNodeFetches = new Array();
var metadataErrors = new Array();

var METADATA_REPLY = "metadata";

// this is the name of the frame that we're dropping into
var dropFrame = null;

// an array of nodes that are to be loaded. we need the array
// as the passport might have expired
var loadingmdtNodes = new Array();

function initMetadataTree()
{
    var cmLastModel = cfgGet("cmLastModel");
    if (cmLastModel != null && cfgGet("queryLoaded"))
    {
        if (metadataTree == null)
        {
            if (browserCheck.isNav6Up())
            {
                document.getElementById("metadataTreeContainer").addEventListener("mouseup", function(e) {if(e.target.toString().indexOf("XULElement") > -1){e.cancelBubble = true;return false;}}, true);
                document.getElementById("metadataTreeContainer").addEventListener("dragover", function(e) {cancelBub(e);}, true);
                document.getElementById("metadataTreeContainer").addEventListener("dragdrop", function(e) {cancelBub(e);}, true);
            }
            var metadataTreeNode = document.getElementById("metadataTreeContainer");
            // at this point - this is the only node with this id
            metadataTreeNode.setAttribute("container", "true");
            metadataTreeNode.setAttribute("tabindex", "-1");
            // now create and render the tree
            metadataTree = new CTree (metadataTreeNode, "" , false, true, "metadataTree");
            metadataTree.setLoadOnTheFlyFunction(pushAndLoadmdtNode);
            metadataTree.setSelectionMode(CONTIGUOUS_TREE_SELECTION);
            metadataTree.setSelectTreeUI(NORMAL_TREE);
            metadataTree.setAllowDragDrop(true);
            metadataTree.setOnDragStart(onDragStartF);
            metadataTree.setOnDrag(onDragF);
            metadataTree.setOnDragEnd(onDragEndF);
            metadataTree.setContextMenu(showContextMenu);
            metadataTree.setTrackSelectionOrder(true);
            metadataTree.setDoubleClickFunc(addSelectedDblClick);
            metadataTree.setSingleClickFunc(metadataClicked);
            metadataTree.setHideOuterTable(true);
            metadataTree.drawAll();
            metadataTree.checkData();
        }
    }
    else
        setTimeout(initMetadataTree, 250);
}

function initMemberSearch()
{
    if (memberTree == null)
    {
        if (browserCheck.isNav6Up())
        {
            document.getElementById("memberTreeContainer").addEventListener("mouseup", function(e) {if(e.target.toString().indexOf("XULElement") > -1){e.cancelBubble = true;return false;}}, true);
            document.getElementById("memberTreeContainer").addEventListener("dragover", function(e) {cancelBub(e);}, true);
            document.getElementById("memberTreeContainer").addEventListener("dragdrop", function(e) {cancelBub(e);}, true);
        }
        var memberTreeNode = document.getElementById("memberTreeContainer");
        // at this point - this is the only node with this id
        memberTreeNode.setAttribute("container", "true");
        memberTreeNode.setAttribute("tabindex", "-1");
        // now create and render the tree
        memberTree = new CTree (memberTreeNode, "" , false, true, "memberTree");
        memberTree.setSelectionMode(CONTIGUOUS_TREE_SELECTION);
        memberTree.setSelectTreeUI(NORMAL_TREE);
        memberTree.setAllowDragDrop(true);
        memberTree.setOnDragStart(onDragStartF);
        memberTree.setOnDrag(onDragF);
        memberTree.setOnDragEnd(onDragEndF);
        memberTree.setContextMenu(showContextMenu);
        memberTree.setTrackSelectionOrder(true);
        memberTree.setDoubleClickFunc(addSelectedDblClick);
        memberTree.setSingleClickFunc(metadataClicked);
        memberTree.setHideOuterTable(true);
        memberTree.drawAll();
        memberTree.checkData();
        
        // set the loading on the fly function last - we don't want to promp a call 
        memberTree.setLoadOnTheFlyFunction(pushAndLoadmdtNode);
    }
}

/*
 * Lose the focus from any textual input controls in the message frame
 */
function loseFocus() {
	var msgDoc = getMessageIFrame().document;
	var bodyTags;
	bodyTags=msgDoc.getElementsByTagName('BODY');
    //activate the page, this will have the effect of removing focus from any input controls
    if (bodyTags.length > 0) {
        if(bodyTags[0].setActive)bodyTags[0].setActive();
    }
}

function metadataClicked(event) {
	//get UI Node
	var uiNode = getUINode(event);

    loseFocus();

	uiNodeTreeRef = uiNode.getAttribute('treeRef').toString();
	//get the tree object
	var tree = uiNode.getAttribute('tree').toString();

	//get tree Node
	var node = getTreeNode(tree, uiNodeTreeRef);
    var visibleTree = cfgGet("lastMenu");

	if ((visibleTree == TAB_MODEL || visibleTree == TAB_MEMBERS) && node && node.isSelected) {
    	var nodeTypeObject = node.getNodeTypeObject();
    	var menuItem = menuItemMap['asDataItem'];
    	if (node.getValue() instanceof mdSearch) { 
    	    // have to launch the selectMembers dialog
    	    selectMember(node.getValue().path, node.getValue().type);
    	} 
    	else if (nodeTypeObject.m_oProps.isAgentItemsInsertable()) {
            menuItem.enable();
            cfgSet("asDataItemState", true);
	    } else {
	        menuItem.disable();
	        cfgSet("asDataItemState", false);
	    }
	}
}

function reloadMetadataTree(force)
{
    if (cfgGet("reloadMetadataTree") != null || force) {
        resetMetadataTree();
        // load it up again 
        initMetadataTree();
    } else {
        // pop the command stack
        setTimeout("getCommandStackManager().processCommandStack()", 100);    
    }
    // clear out the flag
    cfgRemove("reloadMetadataTree");
}

function refreshMetaDataTree() {
    removeTreeRendering('metadataTreeContainer');
    initMetadataTree();
}

function resetMetadataTree()
{
    if (metadataTree != null) {
        // we have to remove the tree
        metadataTree = null;
        // remove the rendering of the tree
        removeTreeRendering("metadataTreeContainer");
        // rebuild the arrays
        activeNodeFetches = new Array();
        metadataErrors = new Array();
        // say that we've not loaded the tree
        cfgSet("META_TreeLoadedFirstTime",null);
    }
}

function removeTreeRendering(treeId)
{
    // remove the display of the tree.
    var treeNodes = document.getElementsByName(treeId);
    // for IE - this will return multiple elements - for NS we should only get one
    // but check them all for the contain attribute
    var treeNode = null;
    // find the correct node
    for (var i = 0; i < treeNodes.length && treeNode==null; i++) {
        // get the container attribute
        var containerAtt = treeNodes[i].getAttribute("container");
        if (containerAtt!=null && containerAtt=="true") {
            // we've found the outer container
            treeNode = treeNodes[i];
        }
    }
    // now have to remove all the children of the container
    for (var j = treeNode.childNodes.length-1; j >= 0 ; --j) {
        // remove the node
        treeNode.removeChild(treeNode.childNodes[j]);
    }
}

function getMetadataRequestString(model, startAtPath, depth, context)
{
    var clk = "cl";
	var plk = "pl";
	var locales = getLocales(clk, plk);	

    var sURL = "";

    sURL += URIEncode("model", model);
    sURL += URIEncode(clk, locales[clk]);
	sURL += URIEncode(plk, locales[plk]);
    sURL += URIEncode("el",getExpressionLocale());
    
    sURL += URIEncode("depth",depth);
    sURL += URIEncode("startAtPath", startAtPath);
    sURL += URIEncode("context", context);
    sURL += URIEncode("parameterValues",getConnectionParameterValues());
    sURL += URIEncode("inlineSpecType", "reportServiceMetadataSpecification");
    sURL += URIEncode("method", "runSpecification");
    sURL += URIEncode("prompt", "false");

    return sURL;
}

function doMemberSearch(startAtPath, filter, filter_type, case_sensitive, search_descendants)
{
    // show the correct tab
    showAgsMenu(TAB_MEMBERS);
    
    // remove anything from before 
    tidyMemberTree();
    // restart the member tree
    initMemberSearch();
    
    // display the loading for the tree
    var v_oRootNode = memberTree.getRootNode();
    v_oRootNode.setLoading(true);
    v_oRootNode.getTree().setLoading(true);
    if (v_oRootNode.getShowUI())
    {
	    v_oRootNode.setOpen(true);
	    v_oRootNode.getTree().redrawNodeToggle(v_oRootNode, v_oRootNode.getTree().getName() + v_oRootNode.getTreeRef());
	    v_oRootNode.getTree().drawLoading(v_oRootNode, v_oRootNode.getTree().getName() + v_oRootNode.getTreeRef());
    } 
    
    // prime the tree ready for the search - when using root node we have to associate the startAtPath 
    // with the tree's root node 
    activeNodeFetches[startAtPath] = memberTree.getRootNode();
    
    // get the right request 
    var v_sRequest= getMemberRequestString(cfgGet("cmLastModel"), startAtPath, startAtPath, filter, filter_type, case_sensitive, search_descendants);
    // send the request 
    doMemberRequest(v_sRequest);
}

function getMemberRequestString(sModel, sStartAtPath, sContext, sFilter, sFilterType, sCaseSensitive, sSearchDescendants)
{
    var v_sClk = "cl";
	var v_sPlk = "pl";
	var locales = getLocales(v_sClk, v_sPlk);	

    var v_sURL = "";

    v_sURL += URIEncode("model", sModel);
    v_sURL += URIEncode(v_sClk, locales[v_sClk]);
	v_sURL += URIEncode(v_sPlk, locales[v_sPlk]);
    v_sURL += URIEncode("el",getExpressionLocale());
    
    // depth is dependant upon whether we're searching descendants or not - if not depth="2"
    // if we are - then depth="" - see MQP member queries document
    
    if (sSearchDescendants == true) { 
        v_sURL += URIEncode("depth","");
    } else { 
        v_sURL += URIEncode("depth","2");
    }       
    v_sURL += URIEncode("startAtPath", sStartAtPath);
    v_sURL += URIEncode("context", sContext);
    v_sURL += URIEncode("parameterValues",getConnectionParameterValues());
    v_sURL += URIEncode("inlineSpecType", "reportServiceMetadataSpecification");
    v_sURL += URIEncode("method", "runSpecification");
    v_sURL += URIEncode("prompt", "false");
    // add the extra ones for searching
    v_sURL += URIEncode("filter",sFilter);
    v_sURL += URIEncode("filter_type", sFilterType);
    v_sURL += URIEncode("case_sensitive", sCaseSensitive);
    v_sURL += URIEncode("search_descendants", sSearchDescendants);

    return v_sURL;
}

function doMemberRequest(request)
{
    var url = "b_action=xts.run";
    url += URIEncode("m", "/ags/async/asyncConv.xts");
    url += URIEncode("buildRequestXTS","/ags/async/metadataRequest.xts");
    url += URIEncode("buildResponseXTS","/ags/async/metadataResponse.xts");
    // force SOAPFault for passport expire instead of getting a logon page 
    url += URIEncode("forceSOAPFault","false");
    // have to always give the limits for members from package configuration
    url += URIEncode("memberDisplayCountDefault",""+cfgGet("memberDisplayCountDefault"));
    url += URIEncode("memberDisplayCountLimit",""+cfgGet("memberDisplayCountLimit"));
    url += URIEncode("memberRequest","true");
    url += request;

    if (cafContextId != "") {
        url += URIEncode("cafcontextid",cafContextId);
    }
    
    try{
        // send off the resquest
        sendDispatcherRequestWithXMLTextResponse(url, memberXMLTextResponse);
    }catch(ex){
        applicationActionManager.httpStop();    
    }
}

function doMetadataRequest(request)
{
    var url = "b_action=xts.run";
    url += URIEncode("m", "/ags/async/asyncConv.xts");
    url += URIEncode("buildRequestXTS","/ags/async/metadataRequest.xts");
    url += URIEncode("buildResponseXTS","/ags/async/metadataResponse.xts");
    // force off SOAPFault for passport expire so we get an xml logon page.
    url += URIEncode("forceSOAPFault","false");
    url += request;

    if (cafContextId != "") {
        url += URIEncode("cafcontextid",cafContextId);
    }
    
    try{
        // send off the resquest
        sendDispatcherRequestWithXMLTextResponse(url, metadataXMLTextResponse);
    }catch(ex){
        applicationActionManager.httpStop();    
    }
}

function promptMetadataResponse(parameters, response, conversation, clientContext, tracking)
{
    if (response == "Cancel" || response == "Error")
    {
        // this is reasonable in this instance - we wouldn't be able to load the metadata tree
        // if we cancel out.
        closeAGS();
    }
    else
    {
        //re write any parameterValues saved
		saveParameterValues(parameters);

        // send the context and the final response from prompts back
        var request = getMetadataRequestString()
        request += URIEncode("context", clientContext);
        request += URIEncode("promptResponse", response);
        request += URIEncode("disp_trackingInfo", tracking);       

        // hide the dialog frame
        showDialogFrame(0);
        doSetPopUpClosureFlag();
        // resubmit the request
        setTimeout("doMetadataRequest('" + request + "');", 100);
    }
}

function promptMemberResponse(parameters, response, conversation, clientContext, tracking)
{
    if (response == "Cancel" || response == "Error")
    {
        // this is reasonable in this instance - we wouldn't be able to load the metadata tree
        // if we cancel out.
        closeAGS();
    }
    else
    {
        //re write any parameterValues saved
		saveParameterValues(parameters);

        // send the context and the final response from prompts back
        var request = getMemberRequestString()
        request += URIEncode("context", clientContext);
        request += URIEncode("promptResponse", response);
        request += URIEncode("disp_trackingInfo", tracking);       

        // hide the dialog frame
        showDialogFrame(0);
        doSetPopUpClosureFlag();
        // resubmit the request
        setTimeout("doMemberRequest('" + request + "');", 100);
    }
}

// add the command to load the nodes to the stack
function addTomdtStack()
{
    var treeCommand = getCommandStackManager().createCommandStack("checkmdtPassportStatus()");
    var currentStack = getCommandStackManager().getCommandStack();
    var newStack = currentStack.concat(treeCommand);
    getCommandStackManager().setCommandStack(newStack);
}

function memberXMLTextResponse(responseArray)
{
     metadataTreeXMLTextResponse(responseArray, true);   
}

function metadataXMLTextResponse(responseArray)
{
     metadataTreeXMLTextResponse(responseArray, false);
}

function metadataTreeXMLTextResponse(responseArray, bMemberRequest)
{
    // get the values returned
    var responseXML = responseArray[0];
    var responseText = responseArray[1];

    var workingRoot = responseXML.getElementsByTagName(ASYNC_WORKING);
    var promptingRoot = responseXML.getElementsByTagName(ASYNC_PROMPTING);
    var metadataReply = responseXML.getElementsByTagName(METADATA_REPLY);

    var httpStop = true;

    // the loading nodes should be remembered only if passport has expired
    var keeploadingmdtNodes = false;

    var parsedResponse = parseResponse(responseXML,responseText);
    // decide what we're going to do
    //This is a case when getContent in asyncConv faults with either session expiry or
    //external logon to a different name space fault.
    if (parsedResponse.isLogonFault()) {
        getCommandStackManager().getCommandStack().push("reloadMetadataTree(true)");

        doPassportExpire(responseXML,null,parsedResponse);

        // load the nodes after login succeeds
        keeploadingmdtNodes = true;
    } else if (parsedResponse.isSoapFault()) {
        if (parsedResponse.isCancelledWait()) {
            //This was a server cancelled wait. We need to resubmit. This could happen
            //if we have a SSO on and we hit an password protected external datasource,
            //The dispacther will fire the same request again, in this wait fired twice
            //Will cancel conversation if first wait fails. WO1903, WO2338
            getCommandStackManager().getCommandStack().push("reloadMetadataTree(true)");
            setTimeout("getCommandStackManager().processCommandStack()", 100);
        } else {
            // we have a fault which is a genuine fault fault
            if (bMemberRequest) { 
                doSOAPFault(responseXML,tidyMemberTree,parsedResponse);
            } else { 
                doSOAPFault(responseXML,tidyMetaDataTree,parsedResponse);
            }
        }
    }
    else if (workingRoot.length == 1) {
        httpStop = false;
        
        // we have a working response
        if (bMemberRequest) {
            doWorking(workingRoot[0], "doMemberRequest");
        } else { 
            doWorking(workingRoot[0], "doMetadataRequest");
        }
    }
    else if (promptingRoot.length == 1) {
        if (bMemberRequest) { 
            // are we prompting - promptMemberResponse
            doPrompting(promptingRoot[0], 5);
        } else { 
            // are we prompting - promptMetadataResponse
            doPrompting(promptingRoot[0], 6);
        }
    }
    else if (metadataReply.length == 1) {
        // we have the actually information
        // clear the response
        response = "";

        buildMetadata(metadataReply[0]);
    }
    else {
        tidyMetaDataTree();

        if (parsedResponse.isHTML() && !parsedResponse.isEmptyBody()) {
            // check the text response to see if we got a html page back in the response
            doHTMLResponse(responseText);
        } else {
            // none of the above - we really don't know what happened.
            alert(asyncMetadataError_string);		
        }
    }

    if(httpStop){
	    applicationActionManager.httpStop();    
	}	
	
	if (keeploadingmdtNodes == false) {
	    //empty the array
	    loadingmdtNodes.splice(0, loadingmdtNodes.length);
	}
}

function buildMetadata(response)
{
    var metadataObjects = response.childNodes;
    var activeNodeName;
    var isStartUp = false;

    try {
	    for (var i = 0; i < metadataObjects.length; i++)
	    {
	        if (metadataObjects[i].childNodes.length > 0)
	        {
	            if (i == 0)
	            {
	                var metaObj = metadataObjects[0].childNodes;
	                activeNodeName = getTextNodeValue(metaObj[0]);
	                var decimalSeparator = getTextNodeValue(metaObj[1]);
	                var listSeparator = getTextNodeValue(metaObj[2]);
	                // want to maintain the decimal and list separator
	                cfgSet("decimalSeparator", decimalSeparator);
	                cfgSet("listSeparator", listSeparator);
	            }
	            else if (i == 1)
	            {
	                if (cfgGet("META_TreeLoadedFirstTime") == "loading")
	                {
	                    var metaObj = metadataObjects[i].childNodes;
	                    var metadataModelName = getTextNodeValue(metaObj[0]);
	                    var metadataModelScreentip = getTextNodeValue(metaObj[1]);
	
	                    metadataTree.getRootNode().setName(metadataModelName);
	                    metadataTree.setRootNodeType(tntModelRoot);
	                    metadataTree.setRootNodeShowing(true);
	                    if (metadataModelScreentip != "")
	                        metadataTree.getRootNode().setTooltip(metadataModelScreentip);
	                    metadataTree.drawAll();
	                
	                    isStartUp = true;
	                }
	                else
	                    continue;
	            }
	            else
	                createNewMetaObject(metadataObjects[i], activeNodeName);
	        }
	    }

	    var thisNode = activeNodeFetches[activeNodeName];
	    thisNode.getTree().childrenReadyForNode(thisNode);
	    delete activeNodeFetches[activeNodeName];
	    cfgSet("META_TreeLoadedFirstTime", true);
    }
    catch (ex) {
        console.error(ex);
        applicationActionManager.httpStop();    
    }
    
    if(isStartUp){
        setTimeout("getCommandStackManager().processCommandStack()", 100);    
    }
    
    return true;
}

function getTextNodeValue(obj)
{
    var text_data = "";
    
    if(obj && obj.childNodes){
        
        for(var i = 0; i < obj.childNodes.length; i++){
             text_data += obj.childNodes[i].data;   
        }    
    }
    
    return text_data;
}

function URIEncode(name, value)
{
    return (value) ? "&" + encodeURIComponent(name) + "=" + encodeURIComponent(value) : "";
}

function createNewMetaObject(metaStr, activeNodeName)
{
    var newNode;
    var newObj;

    // convert all the items out of XML mode
    var metaObj = new Array();
    for (var i = 0; i < metaStr.childNodes.length; i++) {
        metaObj[i] = getTextNodeValue(metaStr.childNodes[i]);
    }

    var path = metaObj[3];
    switch (metaObj[0])
    {
        case K_sQUERYSUBJECT:
            newObj = new mdFolder(metaObj[1], path, metaObj[4], metaObj[5], metaObj[0]);
            newNode = new CTreeNode(activeNodeFetches[activeNodeName], tntQuerySubject, false, metaObj[1], newObj,  false);
            break;
        case K_sHIERARCHY:
            newObj = new mdFolder(metaObj[1], path, metaObj[4], metaObj[5], metaObj[0]);
            newNode = new CTreeNode(activeNodeFetches[activeNodeName], tntHeirarchy, false, metaObj[1], newObj,  false);
            break;
        case K_sDIMENSION:
            newObj = new mdFolder(metaObj[1], path, metaObj[4], metaObj[5], metaObj[0]);
            newNode = new CTreeNode(activeNodeFetches[activeNodeName], tntDimension, false, metaObj[1], newObj,  false);
            break;
        case K_sFILTER:
            newObj = new mdFilter(metaObj[1], path, metaObj[4], metaObj[5], metaObj[0]);
            newNode = new CTreeNode(activeNodeFetches[activeNodeName], tntFilter, false, metaObj[1], newObj,  false);
            break;
        case K_sMEASUREDIMENSION:
            newObj = new mdFolder(metaObj[1], path, metaObj[4], metaObj[5], metaObj[0]);
            newNode = new CTreeNode(activeNodeFetches[activeNodeName], tntMeasureDimension, false, metaObj[1], newObj,  false);
            break;
        case K_sMEASURE_FOLDER:            
        case K_sHIERARCHY_FOLDER:            
        case K_sQUERYITEMFOLDER:
        case K_sFOLDER:
            newObj = new mdFolder(metaObj[1], path, metaObj[4], metaObj[5], metaObj[0]);
            newNode = new CTreeNode(activeNodeFetches[activeNodeName], tntFolder, false, metaObj[1], newObj,  false);
            break;
        case K_sNAMESPACE:
            newObj = new mdFolder(metaObj[1], path, metaObj[4], metaObj[5], metaObj[0]);
            newNode = new CTreeNode(activeNodeFetches[activeNodeName], tntNamespace, false, metaObj[1], newObj,  false);
            break;
        case K_sCALCULATION:
            newObj = new mdCalculation(metaObj[1], path, metaObj[4], metaObj[5], metaObj[6], metaObj[7], metaObj[8], metaObj[9], metaObj[10], metaObj[11], metaObj[12], metaObj[13], metaObj[14], metaObj[0]);
            if (metaObj[6] == 'fact')
                newNode = new CTreeNode(activeNodeFetches[activeNodeName], tntCalculationFact, false, metaObj[1], newObj,  false);
            else if(metaObj[6] == 'identifier')
                newNode = new CTreeNode(activeNodeFetches[activeNodeName], tntCalculationDimension, false, metaObj[1], newObj,  false);
            else
                newNode = new CTreeNode(activeNodeFetches[activeNodeName], tntCalculationAttribute, false, metaObj[1], newObj,  false);
            break;
        case K_sCALCULATIONCONSTANT:
            newObj = new mdCalculation(metaObj[1], path, metaObj[4], metaObj[5], metaObj[6], metaObj[7], metaObj[8], metaObj[9], metaObj[10], metaObj[11], metaObj[12], metaObj[13], metaObj[14], metaObj[0]);
            newNode = new CTreeNode(activeNodeFetches[activeNodeName], tntCalculationConstant, false, metaObj[1], newObj,  false);
            cfgSetAt("calcConstants", cfgSize("calcConstants"), new Array(metaObj[1], path, metaObj[5]));
            break;
        case K_sMEASURE:
            newObj = new mdQueryItem(metaObj[1], path, metaObj[4], metaObj[5], metaObj[6], metaObj[7], metaObj[8], metaObj[9], metaObj[10], metaObj[11], metaObj[12], metaObj[13], metaObj[14], metaObj[0]);
            newNode = new CTreeNode(activeNodeFetches[activeNodeName], tntMeasure, false, metaObj[1], newObj,  false);
            break;
        case K_sROLLUPMEASURE:
            newObj = new mdQueryItem(metaObj[1], path, metaObj[4], metaObj[5], metaObj[6], metaObj[7], metaObj[8], metaObj[9], metaObj[10], metaObj[11], metaObj[12], metaObj[13], metaObj[14], metaObj[0]);
            newNode = new CTreeNode(activeNodeFetches[activeNodeName], tntRollupMeasure, false, metaObj[1], newObj,  false);
            break;
        case K_sNAMEDSET:
            newObj = new mdQueryItem(metaObj[1], path, metaObj[4], metaObj[5], metaObj[6], metaObj[7], metaObj[8], metaObj[9], metaObj[10], metaObj[11], metaObj[12], metaObj[13], metaObj[14], metaObj[0]);
            newNode = new CTreeNode(activeNodeFetches[activeNodeName], tntNamedSet, false, metaObj[1], newObj,  false);
            break;
        case K_sLEVEL:
            newObj = new mdQueryItem(metaObj[1], path, metaObj[4], metaObj[5], metaObj[6], metaObj[7], metaObj[8], metaObj[9], metaObj[10], metaObj[11], metaObj[12], metaObj[13], metaObj[14], metaObj[0]);
            newNode = new CTreeNode(activeNodeFetches[activeNodeName], tntLevel, false, metaObj[1], newObj,  false);
            break;
        case K_sQUERYITEM:
            newObj = new mdQueryItem(metaObj[1], path, metaObj[4], metaObj[5], metaObj[6], metaObj[7], metaObj[8], metaObj[9], metaObj[10], metaObj[11], metaObj[12], metaObj[13], metaObj[14], metaObj[0]);
            if (metaObj[6] == 'fact')
                newNode = new CTreeNode(activeNodeFetches[activeNodeName], tntQueryItemFact, false, metaObj[1], newObj,  false);
            else if (metaObj[6] == 'identifier')
                newNode = new CTreeNode(activeNodeFetches[activeNodeName], tntQueryItemIdentifier, false, metaObj[1], newObj,  false);
            else
                newNode = new CTreeNode(activeNodeFetches[activeNodeName], tntQueryItem, false, metaObj[1], newObj,  false);
            break;
		case K_sMEMBER:
			newObj = new mdMember(metaObj[1], metaObj[2], metaObj[3], metaObj[4], metaObj[5], metaObj[6], metaObj[7], metaObj[8], metaObj[0]); 
			newNode = new CTreeNode(activeNodeFetches[activeNodeName], tntMember, false, metaObj[6], newObj,  false);
			break;
		case K_sMEMBER_FOLDER:
			newObj = new mdFolder(metaObj[1], path, metaObj[4], metaObj[5], metaObj[0]);
			newNode = new CTreeNode(activeNodeFetches[activeNodeName], tntMemberFolder, false, metaObj[1], newObj,  false);
			break;
		case K_sMEMBER_SEARCH:
			newObj = new mdSearch(path, metaObj[0]);
			newNode = new CTreeNode(activeNodeFetches[activeNodeName], tntMemberSearch, false, metaObj[1], newObj,  false);
			break;			
        default:
            //alert("I don't know what this is: " + metaObj[0]);
            return false;
    }
    newNode.setTooltip(metaObj[2]);
}

function metadataFault(metaFaultObjects)
{
    if ((typeof metaFaultObjects == "string") && (metaFaultObjects.indexOf("<HTML>") > -1) && (metaFaultObjects.indexOf("<ERROR_COMPONENT>") > -1) && (metaFaultObjects.indexOf("<ERROR_CODE>") > -1))
    {
        document.getElementById("metadataTree").innerHTML = metaFaultObjects;
        return;
    }
    metadataErrors = new Array();

    for (var i = 0; i < metaFaultObjects.length; i++)
    {
        metadataErrors[metadataErrors.length] = metaFaultObjects[i].replace(/&apos;/g,"'");
    }
    
    setTimeout("MAErrorPage()", 100);
}

// push the loading node into the array of loading nodes
function pushAndLoadmdtNode(loadingNode)
{
    loadingmdtNodes.push(loadingNode);
    loadFunc(loadingNode);
}     

function loadFunc(loadingNode)
{
    var startAtPath = "";
    var context = loadingNode.getValue();
    var v_bMemberRequest = false;
    if (loadingNode.getValue() != "root") {
        // we have a folder type
        startAtPath = loadingNode.getValue().path;
        context = loadingNode.getValue().path;
    }
    v_bMemberRequest = loadingNode.getNodeTypeObject().m_oProps.getMemberRequestFlag();

    // only want to explode levels to another depth - in order to get the role fields.
    var depth = 2;
    if (loadingNode.getValue().type == "level") {
        depth = 3;
    }

    if (cfgGet("META_TreeLoadedFirstTime") == null)
    {
        cfgSet("META_TreeLoadedFirstTime", "loading");
        activeNodeFetches[loadingNode.getValue()] = loadingNode;
        if (v_bMemberRequest) {
            // we're doing a member request
            var req = getMemberRequestString(cfgGet("cmLastModel"), startAtPath, context);
            applicationActionManager.httpStart();
            doMemberRequest(req);
        } else {
            var req = getMetadataRequestString(cfgGet("cmLastModel"), startAtPath, depth, context);
            applicationActionManager.httpStart();
            doMetadataRequest(req);
        }
    }
    else if (cfgGet("META_TreeLoadedFirstTime") != "loading" )
    {

        activeNodeFetches[loadingNode.getValue().path] = loadingNode;
        if (v_bMemberRequest) {
            // we're doing a member request
            var req = getMemberRequestString(cfgGet("cmLastModel"), startAtPath, context);
            applicationActionManager.httpStart();
            doMemberRequest(req);
        } else {
            var req = getMetadataRequestString(cfgGet("cmLastModel"), startAtPath, depth, context);
            applicationActionManager.httpStart();
            doMetadataRequest(req);
        }
    }
}

// if no node is to be loaded, tidyup the tree otherwise load the nodes
function checkmdtPassportStatus() {
    // no node is in the load mode
    if (loadingmdtNodes.length < 1 ) {
        tidyMetaDataTree();
    } else {
        // load all the nodes waiting to be loaded
        while (loadingmdtNodes.length > 0) {
            var theLoadingNode = loadingmdtNodes.pop();
            loadFunc(theLoadingNode);
        }
    }
}

function tidyMemberTree()
{
    removeTreeRendering('memberTreeContainer');
    // remove the member tree 
    memberTree = null;
}

function tidyMetaDataTree() {
    //Go through all nodes that are active
    //and set loading to false and then colapse tree.
    for (i in activeNodeFetches) {
        var theNode = activeNodeFetches[i];
        
        if (theNode.getNodeType() == TREE_ROOT) {
            //Resets the tree so when tabs change it will
            //attempt a reload.
            resetMetadataTree();
            var treeContainer = document.getElementById("metadataTreeContainer");
            if (treeContainer) {
               var html = '<a href="#" class="menuItem_normal" onclick="refreshMetaDataTree()">' + refresh_string + '</a>';
               treeContainer.innerHTML = html;
            }
        } else {
            var theNodeRef = theNode.getTree().getName() + theNode.getTreeRef();
            theNode.setLoading(false);
    	    theNode.getTree().setLoading(false);
    	    
    	    if (theNode.getShowUI())
    		    theNode.getTree().removeLoading(theNode);
    
    		theNode.setCanHaveChildren(true);
            theNode.setOpen(false);
            delete activeNodeFetches[i];
            theNode.getTree().redrawNodeToggle(theNode, theNodeRef);
    		theNode.getTree().redraw();
        }
    }
}


function onDragStartF(evt)
{
    //get the event in a cross-browser fashion
    evt = (evt) ? evt : ((event) ? event : null);

    // clear out the dataTransfer text - which is added in by 
    // PRMT - with text which defines which items are being dragged. 
    // We have a different method - and the text get's dragging into 
    // non-drop zones which is very annoying. 
    evt.dataTransfer.setData("Text","");

    // build all the selected nodes
    var nodesHolder = new SelectedNodesHolder();
    // This is to prevent dragging items table in the selection
    if (nodesHolder.selectedNodes.droppable.length > 0) {
        showDragToolTip(nodesHolder.toolTip, evt);
        cfgSet("selectedTreeNodes",nodesHolder);
    }
}
function onDragF(evt)
{
    var dtt = document.getElementById('dragToolTip');
    if (dtt && dtt.style)
    {
        dtt.style.left = (event.clientX + 20) + "px";
        dtt.style.top = event.clientY + "px";
    }
}

function onDragEndF(evt)
{
    var dtt = document.getElementById('dragToolTip');
    if (dtt && dtt.style)
    {
        dtt.style.display = "none";
    }
    //flag that we have ended the drag.
    cfgRemove("selectedTreeNodes");
}

function showDragToolTip(arr, event)
{
    var htmlOUT = "";
    for (var i in arr) {
        var iconArr = arr[i];

        htmlOUT += "<div class=\"clsTooltipTable\">";
        htmlOUT += "<nobr>";
        htmlOUT += "<span>";
        htmlOUT += "<img src=\"" + iconArr[0] + "\" align=\"middle\"/>";
        if (iconArr[1] != null) {
        htmlOUT += "<span style=\"padding-left: 3px\">";
        htmlOUT += "<img src=\"" + iconArr[1] + "\" align=\"middle\"/>";
        htmlOUT += "</span>";
        }
        htmlOUT += "<span style=\"vertical-align:middle;padding-left:3px;\">" + i + "</span>";
        htmlOUT += "</span>";
        htmlOUT += "</nobr>";
        htmlOUT += "</div>";
    }

    var dtt = document.getElementById("dragToolTip");
    if (dtt && dtt.style)
    {
        dtt.innerHTML = htmlOUT;
        dtt.style.zIndex = 100;
        dtt.style.position = "absolute";
        dtt.style.left = (event.clientX + 20) + "px";
        dtt.style.top = event.clientY + "px";
        dtt.style.display = "inline";
    }
}

function MAErrorPage()
{
    dlgReset();
	//this is in cmd
	initialiseDialog();
    dlgSetParm("m", "/ags/maError.xts");
    dlgSubmit("popUpFrame");
}

function addSelectedDblClick(evt)
{    
    insertStartMC(undefined, evt);
}

function getTreeNodeObjectIcon(leafNode)
{
    return leafNode.m_sIconSrc;
}

function getTreeNodeIndicatorIcon(leafNode)
{
    var ret_value = null;
    if (leafNode.getIndicator) {
        ret_value = leafNode.getIndicator();
    }
    return ret_value;
}

function insertStartMC(id, evt)
{
    var frame = getFrame(dropFrame);
    
    if(!frame)return;
    
    var uiNode = null;
    //Build the object holding list of selected tree nodes.
    var nodesHolder = new SelectedNodesHolder();
    // need to save the id of the item we're dropping into and also need to prevent inserting 
    // items floder into the selection
    if (frame && (frame.droppy != null && frame.droppy != 'undefined') && (nodesHolder.selectedNodes.insertable.length > 0 || nodesHolder.selectedNodes.droppable.length > 0)) {

        //Set it.
        cfgSet("selectedTreeNodes",nodesHolder);
        
        frame.droppy.handleInsert(id);
        
        //We are done remove it.
        cfgRemove("selectedTreeNodes");
    }
    
    // useless code
    /*	 
    else if (evt != null){ 
        var uiNode = getUINode(evt);
        
        var uiNodeTreeRef = uiNode.getAttribute('treeRef').toString();
        
        var treeRef = uiNode.getAttribute('tree').toString();
        
        var newToggleIcon = document.getElementById(treeRef + uiNodeTreeRef + "toggle");
        
        toggle(null,newToggleIcon);

    }
    */
}

function getSelectedTree()
{
    // check to see if we have a selectedTree
    var selectedTreeObj = null;

    // determine the tree from which tree is visible
    var visibleTree = cfgGet("lastMenu");
    // pick the tree
    if (visibleTree == TAB_MODEL) {
        selectedTreeObj = metadataTree;
    } else if (visibleTree == TAB_FUNCTIONS) {
        selectedTreeObj = functionsTree;
    } else if (visibleTree == TAB_DATAITEMS) {
        selectedTreeObj = agentItemsTree;
    } else if (visibleTree == TAB_PARAMETERS) {
        selectedTreeObj = agentParameterTree;
    } else if (visibleTree == TAB_HISTORY) {
        selectedTreeObj = historyTree;
    } else if (visibleTree == TAB_MEMBERS) { 
        selectedTreeObj = memberTree;
    }

    return selectedTreeObj;
}

function dataItemSingleSelection()
{
    result = false;
    var holder = new SelectedNodesHolder();
    if (!holder.containsFunctions && !holder.containsParams) {
        result = holder.droppableNodes.length == 1;
    }
    return result;
}

function metadataSelectedQueryItems() {
    var selectedNodes = new SelectedNodesHolder().droppableNodes;
    var result = new Array();

    for (var i=0;i < selectedNodes.length;i++) {
        result.push(selectedNodes[i].getValue());
    }
    return result;
}

function getSelectedTreeNodes()
{
    var items = new Object();
    var toolTipArray = new Array();

    //Those are just like accessor arrays
    //to make life a bit simpler.
    //You can always use the all and
    //check for properties yourself.
    items["all"] = new Array();
    items["insertable"] = new Array();
    items["droppable"] = new Array();
    items["toolTip"] = new Object();
    items["containsFunctions"] = false;
    items["containsParams"] = false;
    items["containsHistory"] = false;

    var tree = getSelectedTree();

    var visibleTree = cfgGet("lastMenu");
    var canUseNodes = true;

    // pick the tree
    if (visibleTree == TAB_MODEL || visibleTree == TAB_DATAITEMS) {
       canUseNodes = !cfgGet("isCurrentFailureTask") || isDialogFrameShowing();
    }

    // pick the tree
    if (visibleTree == TAB_FUNCTIONS) {
       items["containsFunctions"] = true;
        canUseNodes = !cfgGet("isCurrentFailureTask") || isDialogFrameShowing();;
    }

    // pick the tree
    if (visibleTree == TAB_PARAMETERS) {
       items["containsParams"] = true;
       canUseNodes = !cfgGet("isCurrentFailureTask") || isDialogFrameShowing();;
    }

    // pick the tree
    if (visibleTree == TAB_HISTORY) {
       items["containsHistory"] = true;
       canUseNodes = cfgGet("isCurrentFailureTask") && !isDialogFrameShowing();
    }

    if (tree && tree != 'undefined' && canUseNodes ) {
        var allSelectedLeafNodes = tree.getSelectionOrder();
        for (var i = 0; i < allSelectedLeafNodes.length; i++)
        {
            var nodeObj = allSelectedLeafNodes[i];
            var nodeType = nodeObj.getNodeType();
            var nodeTypeObject = nodeObj.getNodeTypeObject();

            //Filter the nodes.
            if (nodeTypeObject.m_oProps.isDroppable() && nodeTypeObject.m_oProps.isAgentItemsInsertable()) {
                items["insertable"].push(nodeObj);
            }

            //Filter the droppable
            if (nodeTypeObject.m_oProps.isDroppable()) {
                items["droppable"].push(nodeObj);
                //Set the tool tip aray now.
                items["toolTip"][nodeObj.getName()] = new Array(getTreeNodeObjectIcon(nodeTypeObject), getTreeNodeIndicatorIcon(nodeObj));
            }
            items["all"].push(nodeObj);
        }
    }
    // return all the items
    return items;
}

function SelectedNodesHolder() {
    this.selectedNodes = getSelectedTreeNodes();
    this.toolTip = this.selectedNodes["toolTip"];
    this.insertableNodes = this.selectedNodes["insertable"];
    this.droppableNodes = this.selectedNodes["droppable"];
    this.allNodes = this.selectedNodes["all"];
    this.containsFunctions = this.selectedNodes["containsFunctions"];
    this.containsParams = this.selectedNodes["containsParams"];
    this.containsHistory = this.selectedNodes["containsHistory"];
}