//************************************************************************
//********************* eLink Javascript SOAP API ************************
//************************************************************************


//*****************************************//
//*** TLinkSession object definition ******//
//*****************************************//
function TLinkSession() {
}
var LinkSession = new TLinkSession()

//**************************************************************
//*** tools ****************************************************
//**************************************************************

/******************* base 64 tools *****************************************************/
var keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";

function encode64(input) {
   var output = "";
   var chr1, chr2, chr3;
   var enc1, enc2, enc3, enc4;
   var i = 0;

   do {
      chr1 = input.charCodeAt(i++);
      chr2 = input.charCodeAt(i++);
      chr3 = input.charCodeAt(i++);

      enc1 = chr1 >> 2;
      enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
      enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
      enc4 = chr3 & 63;

      if (isNaN(chr2)) {
         enc3 = enc4 = 64;
      } else if (isNaN(chr3)) {
         enc4 = 64;
      }

      output = output + keyStr.charAt(enc1) + keyStr.charAt(enc2) + 
         keyStr.charAt(enc3) + keyStr.charAt(enc4);
   } while (i < input.length);
   
   return output;
}

function decode64(input) {
   var output = "";
   var chr1, chr2, chr3;
   var enc1, enc2, enc3, enc4;
   var i = 0;

   // remove all characters that are not A-Z, a-z, 0-9, +, /, or =
   input = input.replace(/[^A-Za-z0-9\+\/\=]/g, "");

   do {
      enc1 = keyStr.indexOf(input.charAt(i++));
      enc2 = keyStr.indexOf(input.charAt(i++));
      enc3 = keyStr.indexOf(input.charAt(i++));
      enc4 = keyStr.indexOf(input.charAt(i++));

      chr1 = (enc1 << 2) | (enc2 >> 4);
      chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
      chr3 = ((enc3 & 3) << 6) | enc4;

      output = output + String.fromCharCode(chr1);

      if (enc3 != 64) {
         output = output + String.fromCharCode(chr2);
      }
      if (enc4 != 64) {
         output = output + String.fromCharCode(chr3);
      }
   } while (i < input.length);

   return output;
}

function SHA1 (msg) {
 
	function rotate_left(n,s) {
		var t4 = ( n<<s ) | (n>>>(32-s));
		return t4;
	};
 
	function lsb_hex(val) {
		var str="";
		var i;
		var vh;
		var vl;
 
		for( i=0; i<=6; i+=2 ) {
			vh = (val>>>(i*4+4))&0x0f;
			vl = (val>>>(i*4))&0x0f;
			str += vh.toString(16) + vl.toString(16);
		}
		return str;
	};
 
	function cvt_hex(val) {
		var str="";
		var i;
		var v;
 
		for( i=7; i>=0; i-- ) {
			v = (val>>>(i*4))&0x0f;
			str += v.toString(16);
		}
		return str;
	};
 
 
	function Utf8Encode(string) {
		string = string.replace(/\r\n/g,"\n");
		var utftext = "";
 
		for (var n = 0; n < string.length; n++) {
 
			var c = string.charCodeAt(n);
 
			if (c < 128) {
				utftext += String.fromCharCode(c);
			}
			else if((c > 127) && (c < 2048)) {
				utftext += String.fromCharCode((c >> 6) | 192);
				utftext += String.fromCharCode((c & 63) | 128);
			}
			else {
				utftext += String.fromCharCode((c >> 12) | 224);
				utftext += String.fromCharCode(((c >> 6) & 63) | 128);
				utftext += String.fromCharCode((c & 63) | 128);
			}
 
		}
 
		return utftext;
	};
 
	var blockstart;
	var i, j;
	var W = new Array(80);
	var H0 = 0x67452301;
	var H1 = 0xEFCDAB89;
	var H2 = 0x98BADCFE;
	var H3 = 0x10325476;
	var H4 = 0xC3D2E1F0;
	var A, B, C, D, E;
	var temp;
 
	msg = Utf8Encode(msg);
 
	var msg_len = msg.length;
 
	var word_array = new Array();
	for( i=0; i<msg_len-3; i+=4 ) {
		j = msg.charCodeAt(i)<<24 | msg.charCodeAt(i+1)<<16 |
		msg.charCodeAt(i+2)<<8 | msg.charCodeAt(i+3);
		word_array.push( j );
	}
 
	switch( msg_len % 4 ) {
		case 0:
			i = 0x080000000;
		break;
		case 1:
			i = msg.charCodeAt(msg_len-1)<<24 | 0x0800000;
		break;
 
		case 2:
			i = msg.charCodeAt(msg_len-2)<<24 | msg.charCodeAt(msg_len-1)<<16 | 0x08000;
		break;
 
		case 3:
			i = msg.charCodeAt(msg_len-3)<<24 | msg.charCodeAt(msg_len-2)<<16 | msg.charCodeAt(msg_len-1)<<8	| 0x80;
		break;
	}
 
	word_array.push( i );
 
	while( (word_array.length % 16) != 14 ) word_array.push( 0 );
 
	word_array.push( msg_len>>>29 );
	word_array.push( (msg_len<<3)&0x0ffffffff );
 
 
	for ( blockstart=0; blockstart<word_array.length; blockstart+=16 ) {
 
		for( i=0; i<16; i++ ) W[i] = word_array[blockstart+i];
		for( i=16; i<=79; i++ ) W[i] = rotate_left(W[i-3] ^ W[i-8] ^ W[i-14] ^ W[i-16], 1);
 
		A = H0;
		B = H1;
		C = H2;
		D = H3;
		E = H4;
 
		for( i= 0; i<=19; i++ ) {
			temp = (rotate_left(A,5) + ((B&C) | (~B&D)) + E + W[i] + 0x5A827999) & 0x0ffffffff;
			E = D;
			D = C;
			C = rotate_left(B,30);
			B = A;
			A = temp;
		}
 
		for( i=20; i<=39; i++ ) {
			temp = (rotate_left(A,5) + (B ^ C ^ D) + E + W[i] + 0x6ED9EBA1) & 0x0ffffffff;
			E = D;
			D = C;
			C = rotate_left(B,30);
			B = A;
			A = temp;
		}
 
		for( i=40; i<=59; i++ ) {
			temp = (rotate_left(A,5) + ((B&C) | (B&D) | (C&D)) + E + W[i] + 0x8F1BBCDC) & 0x0ffffffff;
			E = D;
			D = C;
			C = rotate_left(B,30);
			B = A;
			A = temp;
		}
 
		for( i=60; i<=79; i++ ) {
			temp = (rotate_left(A,5) + (B ^ C ^ D) + E + W[i] + 0xCA62C1D6) & 0x0ffffffff;
			E = D;
			D = C;
			C = rotate_left(B,30);
			B = A;
			A = temp;
		}
 
		H0 = (H0 + A) & 0x0ffffffff;
		H1 = (H1 + B) & 0x0ffffffff;
		H2 = (H2 + C) & 0x0ffffffff;
		H3 = (H3 + D) & 0x0ffffffff;
		H4 = (H4 + E) & 0x0ffffffff;
 
	}
 
	var temp = cvt_hex(H0) + cvt_hex(H1) + cvt_hex(H2) + cvt_hex(H3) + cvt_hex(H4);
 
	return temp.toLowerCase();
 
}
/******************* INI tools *********************************************************/
function getInisValue(aIniArray, key) {
	for (var i=0; i<aIniArray.length; i++) {
		if (aIniArray[i].toUpperCase().indexOf(key.toUpperCase()) == 0) return aIniArray[i].substring(aIniArray[i].indexOf('=')+1)
	}
	return null
}

function TIni() {
	var allSections = new Array()
	
	function setTxt(aText) {
 		var allLines = aText.replace(/\r\n/g,'\n')
  		allLines = aText.split("\n")  		
		var currentSection = null
		for (var i=0; i<allLines.length; i++) {
			var str = allLines[i]
			if (str.indexOf("[")==0) {
				currentSection = new Object()
				currentSection.name = str.substr(1, str.indexOf("]")-1)				
				currentSection.values = new Array()
				allSections.push(currentSection)
			} else {
				if (str.indexOf("=")==-1) continue
				var newKeyValue = new Object()
				newKeyValue.key = str.substr(0, str.indexOf("="))
				newKeyValue.value = str.substr(str.indexOf("=")+1, str.length)
				currentSection.values.push(newKeyValue)
			}
		}
	}
	
	function getTxt() {
		var str = ""
		for (var i=0; i<allSections.length; i++) {
			str += "[" +allSections[i].name +"]" +"\r\n"
			for (var j=0; j<allSections[i].values.length; j++) {
				str += allSections[i].values[j].key +"=" +allSections[i].values[j].value +"\r\n"
			}
		}
		return str
	}
	
	function getValue(aSection, aKey) {
		for (var i=0; i<allSections.length; i++) {
			if (allSections[i].name.toUpperCase() == aSection.toUpperCase()) {
				for (var j=0; j<allSections[i].values.length; j++) {
					if (allSections[i].values[j].key.toUpperCase() == aKey.toUpperCase()) {
						return allSections[i].values[j].value
					}
				}
			}
		}
		return null
	}
	
	function setValue(aSection, aKey, aValue) {
		var currentSection = null
		var currentKey = null
		for (var i=0; i<allSections.length; i++) {
			if (allSections[i].name.toUpperCase() == aSection.toUpperCase()) {
				currentSection = allSections[i]
			}
		}
		if (currentSection != null) {
			for (var j=0; j<currentSection.values.length; j++) {
				if (currentSection.values[j].key.toUpperCase() == aKey.toUpperCase()) {
					currentKey = currentSection.values[j]
				}
			}
		}
		
		if (currentSection == null) {
			currentSection = new Object()
			currentSection.name = aSection
			currentSection.values = new Array()
			allSections.push(currentSection)
		}
		
		if (currentKey == null) {
			currentKey = new Object()
			currentKey.key = aKey
			currentKey.value = aValue
			currentSection.values.push(currentKey)
		} else {
			currentKey.value = aValue
		}
	}
	
	this.setTxt = setTxt
	this.getTxt = getTxt
	this.getValue = getValue
	this.setValue = setValue
	this.sections = allSections
}

/******************* Response tools ****************************************************/
function TResponse() {
	var xmlDoc = null
	var isError = false
	var lastError = ''
	var lastMessage = ''
	var shortError = ''
	
	xmlDoc = getNewXMLDocument()
	
	function setXml(xmlText) {
		loadXML(xmlDoc, xmlText)
		this.lastMessage = ''
		var allRows = selectNodes(xmlDoc, '*/*/SOAP-ENV:Message')
		for (var i=0; i<allRows.length; i++) {
			var messageValue = getNodeValue(allRows[i])
			this.lastMessage = messageValue
			// NOTE: This alert causes the current database message to be displayed
			// during database creation.  - A pain so hide it
			//alert(messageValue)
		}
		var allRows = selectNodes(xmlDoc, '*/*/SOAP-ENV:SilentMessage')
		for (var i=0; i<allRows.length; i++) {
			var silentMessageValue = getNodeValue(allRows[i])
			addSilentMessage(silentMessageValue)
		}
		faultNode = selectSingleNode(xmlDoc, '*/*/SOAP-ENV:Fault')
		if (faultNode!=null) {
			this.isError = true
			var errorCodeNode = selectSingleNode(faultNode, 'faultcode')
			var errorStringNode = selectSingleNode(faultNode, 'faultstring')
			this.shortError = getNodeValue(errorCodeNode) +' : ' +getNodeValue(errorStringNode)
			this.lastError = getNodeValue(errorCodeNode) +' : ' +getNodeValue(errorStringNode) +'\r\n' +xmlText
			//alert(this.lastError)
		} else {
			this.isError = false
			this.lastError = ''
		}
	}
	
	function getXml() {
		return serializeXML(xmlDoc)
	}
	
	function onReceive() {
		if (req.readyState == 4) {
			if (req.status == 200) {
				setXml(req.responseText)
			}else{
				this.isError = true
				this.lastError = "Ajax Error: returned status code " + req.status + " " + req.statusText
			}
		} 
	}
	
	function getNodeByID(aSOAPID) {
		var result = selectSingleNode(xmlDoc, '*/*/*/*[@ID="'+ aSOAPID +'"]')
		if (result == null) result = selectSingleNode(xmlDoc, '*/*/*[@ID="'+ aSOAPID +'"]')
		return result
	}

	function getNodeValueByID(aSOAPID) {
		var aNode = getNodeByID(aSOAPID)
		if (aNode == null) return null
		return getNodeValue(aNode)
	}
	
	function getNodeDataByID(aSOAPID, removePrefix) {
		var aNode = getNodeByID(aSOAPID)
		if (aNode == null) return null
		if (aNode.getAttribute('handled') != 'true') {
			alert('SOAP Error: Exception while creating Object, SOAP request not handled');
			this.isError = true
			this.lastError = 'SOAP Error: Exception while creating Object, SOAP request not handled'
			return null
		}
		var documentNode = selectSingleNode(aNode, 'DOCUMENT')
		return internalGetNodeData(documentNode, removePrefix)
	}

	function internalGetNodeData(aNode, removePrefix) {
		var result = null
		var nodeClass = aNode.getAttribute("CLASS")
		if (nodeClass != null) nodeClass = nodeClass.toUpperCase()
		if ((nodeClass == null) || (nodeClass == "")) {
			result = getNodeValue(aNode)
		} else if (nodeClass == "COLLECTION") {
			result = new TDataSet()
			result.type = 'TDataSet'
			var allRows = selectNodes(aNode, 'ROWS/ROW')
			for (var i=0; i<allRows.length; i++) {
				result.append()
				for (var j=0; j<allRows[i].childNodes.length; j++) {
					if (allRows[i].childNodes.item(j).nodeName=='#text') continue
					result.setFieldValue(allRows[i].childNodes.item(j).nodeName, internalGetNodeData(allRows[i].childNodes.item(j)))
				}
			}
			result.first()
		} else if (nodeClass == "DATASET") {
			result = new TDataSet()
			result.type = 'TDataSet'			
			var allDefinitions = selectNodes(aNode, 'ROWDEFINITION')
			for (var i=0; i<allDefinitions[0].childNodes.length; i++) {
				if (allDefinitions[0].childNodes.item(i).nodeName == '#text') continue
				var aFieldName = allDefinitions[0].childNodes.item(i).nodeName.toUpperCase()
				var aFieldType = allDefinitions[0].childNodes.item(i).getAttribute('TYPE')
				var aFieldSize = allDefinitions[0].childNodes.item(i).getAttribute('SIZE')
				var aFieldRequired = allDefinitions[0].childNodes.item(i).getAttribute('REQUIRED')
				
				var aFieldLib = getNodeValue(allDefinitions[0].childNodes.item(i))
				result.addFieldName(aFieldName, aFieldSize, aFieldType, aFieldRequired, aFieldLib)
			}					
			var allRows = selectNodes(aNode, 'ROWS/ROW')
			for (var i=0; i<allRows.length; i++) {
				result.append()
				for (var j=0; j<allRows[i].childNodes.length; j++) {
					if (allRows[i].childNodes.item(j).nodeName=='#text') continue
					var aEncodingKind = allRows[i].childNodes.item(j).getAttribute('EncodingKind')
					var ISNULL = ((allRows[i].childNodes.item(j).getAttribute('ISNULL') != null) && (allRows[i].childNodes.item(j).getAttribute('ISNULL').toLowerCase() == 'true'))
					var tmp = allRows[i].childNodes.item(j).nodeName
					var aName = (removePrefix?tmp.substr(tmp.indexOf(removePrefix+'_')+removePrefix.length+1):tmp)
					if (ISNULL)
						result.setFieldValue(aName, null, aEncodingKind)
					else
						result.setFieldValue(aName, internalGetNodeData(allRows[i].childNodes.item(j)), aEncodingKind)
				}
			}
			result.first()
		} else if (nodeClass == "COMPONENT") {
			var allRows = aNode.childNodes
			var result = new Object()
			result.type = 'TObject'
			for (var i=0; i<allRows.length; i++) {
				if (allRows.item(i).nodeName=='#text') continue
				eval('result.' +allRows.item(i).nodeName.toUpperCase() +'=internalGetNodeData(allRows.item(i))')
				}
		} else if (nodeClass == "STRINGLIST") {
			result = new Array()
			result.type = 'Array'
			var allRows = selectNodes(aNode, 'ROWS/ROW')
			for (var i=0; i<allRows.length; i++) {
				result.push(internalGetNodeData(allRows[i]))
			}
		}
		return result
	}
		
	this.isError = isError
	this.setXml = setXml
	this.getXml = getXml
	this.onReceive = onReceive
	this.getNodeValueByID = getNodeValueByID
	this.getNodeDataByID = getNodeDataByID
	this.getNodeByID = getNodeByID
}

/******************* TDataSet tools ****************************************************/
function TDataSet() {
	var fValues = new Array()
	var fCurrentPos = -1
	var fieldsNames = new Array()
	var fieldsSizes = new Array()
	var fieldsTypes = new Array()
	var fieldsRequireds = new Array()
	var fieldsLibs = new Array()
	
	function recordcount() {
		return fValues.length
	}
	
	function append() {
		fCurrentPos = fValues.length
		fValues.push(new Object())
	}
	
	function remove() {
		if ((fCurrentPos==-1) || (fCurrentPos==recordcount())) return null
		var newValues = new Array()
		for (var i=0; i<fValues.length; i++) {
			if (i != fCurrentPos) newValues.push(fValues[i])
		}
		fValues = newValues
	}
	
	function addFieldName(fieldName, fieldSize, fieldType, fieldRequired, fieldLib) {
		for (i=0; i<fieldsNames.length; i++)
			if (fieldsNames[i]==fieldName) return
		fieldsNames.push(fieldName)
		fieldsSizes.push(fieldSize)
		fieldsTypes.push(fieldType)
		fieldsRequireds.push(fieldRequired)
		fieldsLibs.push(fieldLib)		
	}
	
	function currentElement() {
		if ((fCurrentPos==-1) || (fCurrentPos==recordcount())) return null
		return fValues[fCurrentPos]
	}
	
	function fieldByName(fieldName) {
		if ((fCurrentPos==-1) || (fCurrentPos==recordcount())) return
		fieldName = fieldName.toUpperCase()
		var fieldValue = ''
		eval('fieldValue = fValues[fCurrentPos].' +fieldName)
		return fieldValue
	}

	function setFieldValue(fieldName, fieldValue, encodingKind) {
		fieldName = fieldName.toUpperCase()
		if (fieldValue == null) {
			eval('fValues[fCurrentPos].ISNULL_' +fieldName +'=true')
			eval('fValues[fCurrentPos].' +fieldName +'=\'\'')
		}else eval('fValues[fCurrentPos].' +fieldName +'=fieldValue')
		if (encodingKind != null) {
			eval('fValues[fCurrentPos].ENCODINGKIND_' +fieldName +'=encodingKind')
		}
		addFieldName(fieldName)
	}

	function first() {
		if (recordcount()>0) fCurrentPos = 0
		else fCurrentPos = -1
	}
	
	function last() {
		if (recordcount()>0) fCurrentPos = recordcount()-1
		else fCurrentPos = -1
	}
	function next() {
		if ((recordcount()>0) && (fCurrentPos<recordcount())) fCurrentPos+=1
	}
	
	function prior() {
		if ((recordcount()>0) && (fCurrentPos>-1)) fCurrentPos-=1
	}
	
	function eof() {
		return ((fCurrentPos==recordcount()) || (recordcount()==0))
	}
	
	function bof() {
		return ((fCurrentPos==-1) || (recordcount()==0))
	}
	
	function sort(sortFunction) {//function sortFunction(a, b)
		fValues.sort(sortFunction)
		first()
	}
	
	function toXmlNode() {
		var xmlNode = getNewXMLDocument()
		xmlNode.async = false
		var xmlDoc = xmlNode.appendChild(xmlNode.createElement('DOCUMENT'))
		xmlDoc.setAttribute('CLASS', 'dataset')
		xmlRowDefinition = xmlDoc.appendChild(xmlNode.createElement('ROWDEFINITION'))
		for (var i=0; i<fieldsNames.length; i++) {
			var xmlField = xmlRowDefinition.appendChild(xmlNode.createElement(fieldsNames[i]))
			if (fieldsTypes[i] != null) xmlField.setAttribute('TYPE', fieldsTypes[i])
			if (fieldsSizes[i] != null) xmlField.setAttribute('SIZE', fieldsSizes[i])
			if (fieldsRequireds[i] != null) xmlField.setAttribute('REQUIRED', fieldsRequireds[i])
			setNodeValue(xmlField, fieldsLibs[i])
		}		
		var xmlRows = xmlDoc.appendChild(xmlNode.createElement('ROWS'))
		first()
		for (var i=0; i<recordcount(); i++) {
			var xmlRow = xmlRows.appendChild(xmlNode.createElement('ROW'))
			//xmlRow.setAttribute('STATE', 'inserting')
			for (var j=0; j<fieldsNames.length; j++) {
				var xmlField = xmlRow.appendChild(xmlNode.createElement(fieldsNames[j]))
				if ((fieldByName(fieldsNames[j]) == null) || (fieldByName('ISNULL_' +fieldsNames[j]))) xmlField.setAttribute('ISNULL', 'true')
				else {
					setNodeValue(xmlField, fieldByName(fieldsNames[j]))
					if (fieldByName('ENCODINGKIND_' +fieldsNames[j]) != null) xmlField.setAttribute('EncodingKind', fieldByName('ENCODINGKIND_' +fieldsNames[j]))
				}
			}
			next()
		}
		return xmlDoc
	}
	
	this.recordcount = recordcount
	this.append = append
	this.remove = remove
	this.currentElement = currentElement
	this.fieldByName = fieldByName
	this.setFieldValue = setFieldValue
	this.first = first
	this.last = last
	this.next = next
	this.prior = prior
	this.EOF = eof
	this.BOF = bof
	this.fieldsNames = fieldsNames
	this.addFieldName = addFieldName
	this.toXmlNode = toXmlNode
	this.sort = sort
}

/******************* TParameter tools **************************************************/
function TParameter(aName, aValue) {
	var fName
	var fValue
	
	fName = aName
	fValue = aValue
	
	this.name = fName
	this.value = fValue
}

function TParameters() {
	var fAllParameters = new Array()
	
	function Clear() {
		while (fAllParameters.length>0) fAllParameters.pop()
	}
	
	function setValue(aParamName, aParamValue) {
		for (var i=0; i<fAllParameters.length; i++) {
			if (fAllParameters[i].name == aParamName) {
				fAllParameters[i].value = aParamValue
				return
			}
		}
		if (i>=fAllParameters.length) fAllParameters.push(new TParameter(aParamName, aParamValue))
	}
	
	this.setValue = setValue
	this.Clear = Clear;
	this.allParameters = fAllParameters
}

/******************* TSOAPRequest tools ************************************************/
function TSOAPRequest() {
	var fUniqueSOAPResponseID = 0
	var fSOAPRequest = ''
	var xmlDoc = null
	var xmlRoot = null
	var xmlBody = null
	
	function initXmlRequest() {
		if (xmlDoc == null) {
			xmlDoc = getNewXMLDocument()
			xmlDoc.async = false
			xmlRoot = xmlDoc.appendChild(xmlDoc.createElement("SOAP-ENV:Envelope"))
			xmlRoot.setAttribute("xmlns:SOAP-ENV", "http://schemas.xmlsoap.org/soap/envelope")
			xmlRoot.setAttribute("xmlns:elink", "http://www.nextapplication.com")
			xmlBody = xmlRoot.appendChild(xmlDoc.createElement("SOAP-ENV:Body"))
		}
	}
	
	function Clear() {
		xmlDoc = null
		xmlRoot = null
		xmlBody = null
	}
	
	function getNodeByID(aSOAPID) {
		var result = selectSingleNode(xmlDoc, '*/*/*/*[@ID="'+ aSOAPID +'"]')
		if (result == null) result = selectSingleNode(xmlDoc, '*/*/*[@ID="'+ aSOAPID +'"]')
		return result
	}

	function getUniqueSOAPResponseID() {
		fUniqueSOAPResponseID += 1
		return fUniqueSOAPResponseID
	}

	function addRequest(name, parameters) {
		initXmlRequest()
		var newNode
		newNode = xmlBody.appendChild(xmlDoc.createElement("elink:" +name))
		parameters.setValue('ID', getUniqueSOAPResponseID())
		for (var i=0; i<parameters.allParameters.length; i++) {
			newNode.setAttribute(parameters.allParameters[i].name, parameters.allParameters[i].value)
		}
		return newNode
	}
	
	function addRequestData(xmlNode, name, parameters) {
		initXmlRequest()
		var newNode
		newNode = xmlNode.appendChild(xmlDoc.createElement(name))

		parameters.setValue('ID', getUniqueSOAPResponseID())
		for (var i=0; i<parameters.allParameters.length; i++) {
			newNode.setAttribute(parameters.allParameters[i].name, parameters.allParameters[i].value)
		}
		return newNode
	}
	
	function addNode(xmlNode, name, value) {
		initXmlRequest()
		var newNode
		newNode = xmlNode.appendChild(xmlDoc.createElement(name))
		setNodeValue(newNode, value)
		return newNode
	}
	function addEmptyNode(xmlNode, name) {
		initXmlRequest()
		var newNode
		newNode = xmlNode.appendChild(xmlDoc.createElement(name))
		return newNode
	}
	
	function getSOAPRequest() {
		return '<?xml version="1.0" encoding="utf-8"?>'
			  +serializeXML(xmlDoc)
	}
	
	this.addRequest = addRequest
	this.addRequestData = addRequestData
	this.addNode = addNode
	this.addEmptyNode = addEmptyNode
	this.getSOAPRequest = getSOAPRequest
	this.Clear = Clear
	this.getNodeByID = getNodeByID
}

/******************* XML tools *********************************************************/
function getNewXMLHTTPRequest() {
	var result = null
	if (window.XMLHttpRequest) {
		result = new XMLHttpRequest();
		if (result.overrideMimeType) result.overrideMimeType('text/xml');
	} else if (window.ActiveXObject) {
		try {
			result = new ActiveXObject("Msxml2.XMLHTTP");
		} catch (e)	{
			try {
				result = new ActiveXObject("Microsoft.XMLHTTP");
			} catch (e) {}
		}
	}
	return result
}

function loadXML(xmlDocument, xmlText) {
	if (window.ActiveXObject)
		xmlDocument.loadXML(xmlText)
	else {
		var objDOMParser = new DOMParser()
		var tmpDoc = objDOMParser.parseFromString(xmlText, "text/xml")
		while (xmlDocument.hasChildNodes()) xmlDocument.removeChild(xmlDocument.lastChild)
		for (var i=0; i < tmpDoc.childNodes.length; i++) {            
			var objImportedNode = xmlDocument.importNode(tmpDoc.childNodes[i], true);
  			xmlDocument.appendChild(objImportedNode);
		}
	}
}

function serializeXML(xmlDocument) {
	if (window.ActiveXObject) 
		return xmlDocument.xml
	else
		return (new XMLSerializer()).serializeToString(xmlDocument)
}

function getNewXMLDocument() {
	var result = null
	if (window.ActiveXObject) {
		try {
		  result = new ActiveXObject('Msxml2.XMLDOM');
		} catch (e) {
		  result = new ActiveXObject('Microsoft.XMLDOM');
		}
		result.async = false
	} else
		result = document.implementation.createDocument("", "", null)
	return result
}

function setNodeValue(aNode, value) {
	if (window.ActiveXObject)
		aNode.text = value
	else {
		try {aNode.textContent = value}
		catch(e){aNode.firstChild.textContent = value}
	}
}

function getNodeValue(aNode) {
	if (window.ActiveXObject)
		return aNode.text
	else {
		try {return aNode.firstChild.textContent}
		catch(e){return aNode.textContent}
	}
}

function selectNodes(xmlDocument, xPath) {
	var result = null
	if (window.ActiveXObject) {
		tmpRes = xmlDocument.selectNodes(xPath)
		result = new Array()
		for (var i=0; i<tmpRes.length; i++)
			result.push(tmpRes.item(i))
	} else {
		var oXpe = new XPathEvaluator();
		var oNsResolver = oXpe.createNSResolver(xmlDocument.ownerDocument == null ? xmlDocument.documentElement : xmlDocument.ownerDocument.documentElement)
		var allResultNodes = oXpe.evaluate(xPath, xmlDocument, oNsResolver, XPathResult.ANY_TYPE, null)
		var tmpNode
		result = new Array()
		while (tmpNode = allResultNodes.iterateNext()) {
			result.push(tmpNode)
		}
	}
	return result
}

function selectSingleNode(xmlDocument, xPath) {
	var result = null
	if (window.ActiveXObject)
		result = xmlDocument.selectSingleNode(xPath)
	else {
		var oXpe = new XPathEvaluator();
		var oNsResolver = oXpe.createNSResolver(xmlDocument.ownerDocument == null ? xmlDocument.documentElement : xmlDocument.ownerDocument.documentElement)
		result = oXpe.evaluate(xPath, xmlDocument, oNsResolver, XPathResult.ANY_TYPE, null).iterateNext()
	}
	return result
}

/******************* Miscealenous tools ************************************************/
function boolean2String(b) {
	if (b) 
		return 'T'
	else
		return '';
}

function isArray(obj) {
   if (obj.constructor.toString().indexOf("Array") == -1)
      return false;
   else
      return true;
}

/******************* Global variables **************************************************/
var parameters = new TParameters()
var request = new TSOAPRequest()
var response = new TResponse()
var req = null;

/******************* AJAX tools ********************************************************/
TLinkSession.prototype.executeBatch = function(waitForResponse, onSuccessFunction, onFailureFunction) {
	if (waitForResponse == null) waitForResponse = true
	new Ajax.Request(sBase +'api', {
									asynchronous: !waitForResponse,
	                                method:'POST',
	                                onSuccess:function(requete){
		                                						response.setXml(requete.responseText); 
		                                						if (!response.isError)
		                                							onSuccessFunction()
		                                						else
		                                							onFailureFunction();
		                                						},
	                                onFailure:function(requete){onFailureFunction();},
	                                postBody:request.getSOAPRequest()
	                               }
	                 )
	request.Clear()
}

/******************* API functions *****************************************************/

/*******************************/
/*********** eConfig ***********/
/*******************************/

TLinkSession.prototype.GetTranslationsForField = function(tableID, fieldID) {
	parameters.Clear()
	var configNode = request.addRequest('configure', parameters)
	parameters.setValue('type', 'fieldtranslations')
	parameters.setValue('tableid', tableID)
	parameters.setValue('fieldid', fieldID)
	return request.addRequestData(configNode, 'datacontainer', parameters).getAttribute("ID")
}

TLinkSession.prototype.GetTranslationsForTable = function(tableID) {
	return this.GetTranslationsForField(tableID, 0)
}

TLinkSession.prototype.RenameField = function(tableID, langID, fieldID, newFieldName) {
	parameters.Clear()
	var configNode = request.addRequest('configure', parameters)
	parameters.setValue('tableid', tableID)
	parameters.setValue('langid', langID)
	parameters.setValue('fieldid', fieldID)
	parameters.setValue('newtablename', newFieldName)
	return request.addRequestData(configNode, 'renamefield', parameters).getAttribute("ID")
}

TLinkSession.prototype.RenameTable = function(tableID, langID, newTableName) {
	return this.RenameField(tableID, langID, 0, newTableName)
}

TLinkSession.prototype.SearchLdap = function(host, userName, password, baseName, filter, scope, encrypt, portnumber) {
	parameters.Clear()	
	var searchLdapNode = request.addRequest('configure', parameters)
	parameters.setValue('type', 'ldapsearch')
	parameters.setValue('host', host)
	parameters.setValue('username', userName)
	parameters.setValue('password', password)
	parameters.setValue('basename', baseName)
	parameters.setValue('filter', filter)
	parameters.setValue('scope', scope)
	parameters.setValue('encrypt', (encrypt?'true':'false'))
	parameters.setValue('portnumber', portnumber)
	var queryNode = request.addRequestData(searchLdapNode, 'datacontainer', parameters)
	return queryNode.getAttribute("ID")
}

TLinkSession.prototype.EditTypeRightsForType = function(IDType) {
	parameters.Clear()
	var configNode = request.addRequest('configure', parameters)
	parameters.setValue('type', 'edittyperightsfortype')
	parameters.setValue('typeid', IDType)
	return request.addRequestData(configNode, 'datacontainer', parameters).getAttribute("ID")
}

TLinkSession.prototype.AssignRoleToManyUsers = function(roleID, userIDs) {
	parameters.Clear()
	var configNode = request.addRequest('configure', parameters)
	parameters.setValue('roleid', roleID)
	parameters.setValue('userids', userIDs)
	return request.addRequestData(configNode, 'assignroletomanyusers', parameters).getAttribute("ID")
}

TLinkSession.prototype.AssignRole = function(roleID) {
	parameters.Clear()
	var configNode = request.addRequest('configure', parameters)
	parameters.setValue('roleid', roleID)
	return request.addRequestData(configNode, 'assignrole', parameters).getAttribute("ID")		
}

TLinkSession.prototype.ApplyUserProperties = function() {
	parameters.Clear()
	var configNode = request.addRequest('configure', parameters)
	return request.addRequestData(configNode, 'applyuserproperties', parameters).getAttribute("ID")	
}

TLinkSession.prototype.EditUserPropertiesDataSet = function(detail) {
	parameters.Clear()
	var configNode = request.addRequest('configure', parameters)
	parameters.setValue('type', 'userpropertiesdataset')
	var detailName = this.GetTargetName(detail)
	if (detailName) {
		parameters.setValue('detail', detailName)
	}
	return request.addRequestData(configNode, 'datacontainer', parameters).getAttribute("ID")	}

TLinkSession.prototype.EditUserProperties = function(userID, refresh) {
	parameters.Clear()
	var configNode = request.addRequest('configure', parameters)
	parameters.setValue('userid', userID)
	parameters.setValue('refresh', (refresh?'true':'false'))
	return request.addRequestData(configNode, 'getuserproperties', parameters).getAttribute("ID")
}

TLinkSession.prototype.PostUserProperties = function(detail, userDataSet) {
	parameters.Clear()
	var configNode = request.addRequest('configure', parameters)
	var detailName = this.GetTargetName(detail)
	if (detailName) {
		parameters.setValue('detail', detailName)
	}
	var componentNode = request.addRequestData(configNode, 'postuserproperties', parameters)
	return componentNode.appendChild(userDataSet.toXmlNode()).getAttribute("ID")
}

TLinkSession.prototype.CloseServerEventsQueue = function(eventQueueID) {
	parameters.Clear()
	var configNode = request.addRequest('configure', parameters)
	parameters.setValue('type', 'closeservereventqueue')
	parameters.setValue('queueid', eventQueueID)
	return request.addRequestData(configNode, 'data', parameters).getAttribute("ID")
}

TLinkSession.prototype.GetServerEventsQueueState = function(eventQueueID, incremental) {
	parameters.Clear()
	var configNode = request.addRequest('configure', parameters)
	parameters.setValue('type', 'servereventqueuestate')
	parameters.setValue('queueid', eventQueueID)
	parameters.setValue('incremental', (incremental?'true':'false'))
	return request.addRequestData(configNode, 'datacontainer', parameters).getAttribute("ID")
}

TLinkSession.prototype.OpenServerEventsQueue = function() {
	parameters.Clear()
	var configNode = request.addRequest('configure', parameters)
	parameters.setValue('type', 'openservereventqueue')	
	return request.addRequestData(configNode, 'data', parameters).getAttribute("ID")
}

TLinkSession.prototype.Replicate = function(replicationType, queueID, otherDBAlias, otherDBUserName, otherDBPassword) {
	parameters.Clear()
	var configNode = request.addRequest('configure', parameters)
	parameters.setValue('type', 'replicate')
	parameters.setValue('replicationtype', replicationType)
	parameters.setValue('eventqueueid', queueID)
	parameters.setValue('alias', otherDBAlias)
	parameters.setValue('ownercode', otherDBUserName)
	parameters.setValue('ownerpass', otherDBPassword)
	var updateNode = request.addRequestData(configNode, 'data', parameters)
}

TLinkSession.prototype.CreateContUsrPair = function(IDUser, IDContact, exchangeAlias, exchangeServer, emailAddress,
						   isOutlookUser) {
	parameters.Clear()
	var configNode = request.addRequest('configure', parameters)
	parameters.setValue('userid', IDUser)
	parameters.setValue('idcontact', IDContact)
	parameters.setValue('exchangealias', exchangeAlias)
	parameters.setValue('exchangeserver', exchangeServer)
	parameters.setValue('emailaddress', emailAddress)
	parameters.setValue('outlookuser', (isOutlookUser?'true':'false'))
	var updateNode = request.addRequestData(configNode, 'createcontusrpair', parameters)
}

TLinkSession.prototype.PromoteTable = function(IDTable) {
	parameters.Clear()
	var configNode = request.addRequest('configure', parameters)
	parameters.setValue('tableid', IDTable)
	return request.addRequestData(configNode, 'promotetable', parameters).getAttribute("ID")
}

TLinkSession.prototype.GetTablesForRestruct = function() {
	parameters.Clear()
	var configNode = request.addRequest('configure', parameters)
	parameters.setValue('type', 'db_structure')
	return request.addRequestData(configNode, 'datacontainer', parameters).getAttribute("ID")
}

TLinkSession.prototype.GetRestructTables = function() {
	parameters.Clear()
	var configNode = request.addRequest('configure', parameters)
	parameters.setValue('type', 'restructtables')
	return request.addRequestData(configNode, 'datacontainer', parameters).getAttribute("ID")
}

TLinkSession.prototype.GetTypesDataSet = function() {
	parameters.Clear()
	var configNode = request.addRequest('configure', parameters)
	parameters.setValue('type', 'stypes')
	return request.addRequestData(configNode, 'datacontainer', parameters).getAttribute("ID")
}

TLinkSession.prototype.DeleteUserFromServer = function(userCode, DBALogin, DBAPassword) {
	parameters.Clear()
	var configNode = request.addRequest('configure', parameters)
	parameters.setValue('dbacode', DBALogin)
	parameters.setValue('dbapass', DBAPassword)
	parameters.setValue('ownercode', userCode)
	var updateNode = request.addRequestData(configNode, 'deleteuserfromserver', parameters)
}

TLinkSession.prototype.ModifyServerLogin = function(userCode, userPassword, DBALogin, DBAPassword) {
	parameters.Clear()
	var configNode = request.addRequest('configure', parameters)
	parameters.setValue('type', 'modifyserverlogin')
	parameters.setValue('ownercode', userCode)
	parameters.setValue('ownerpass', userPassword)
	parameters.setValue('dbacode', DBALogin)
	parameters.setValue('dbapass', DBAPassword)
	return request.addRequestData(configNode, 'data', parameters).getAttribute("ID")
}

TLinkSession.prototype.AddUser2Server = function(DBACode, DBAPass, userCode, userPass, canAddUser) {
	parameters.Clear()
	var configNode = request.addRequest('configure', parameters)
	parameters.setValue('dbacode', DBACode)
	parameters.setValue('dbapass', DBAPass)
	parameters.setValue('ownercode', userCode)
	parameters.setValue('ownerpass', userPass)
	//canAddUser: boolean not used
	var updateNode = request.addRequestData(configNode, 'adduser2server', parameters)
}

TLinkSession.prototype.LoginExistsOnServer = function(DBACode, DBAPass, userCode) {
	parameters.Clear()
	var configNode = request.addRequest('configure', parameters)
	parameters.setValue('dbacode', DBACode)
	parameters.setValue('dbapass', DBAPass)
	parameters.setValue('ownercode', userCode)
	return request.addRequestData(configNode, 'loginexistsonserver', parameters).getAttribute("ID")		
}

TLinkSession.prototype.AddUser = function(kind, name, userCode, category, isActive, authMethod, password, ldapCode) {
	parameters.Clear()
	var configNode = request.addRequest('configure', parameters)
	parameters.setValue('kind', kind)
	parameters.setValue('name', name)
	parameters.setValue('usercode', userCode)
	parameters.setValue('category', category)
	parameters.setValue('authmethod', authMethod)
	parameters.setValue('isactive', (isActive?'true':'false'))
	if (password != '') {
		parameters.setValue('password', SHA1(password).toUpperCase()) 
	}
	parameters.setValue('ldapcode', ldapCode)
	return request.addRequestData(configNode, 'adduser', parameters).getAttribute("ID")	
}

TLinkSession.prototype.GetLicenses = function() {
	parameters.Clear()
	var configNode = request.addRequest('configure', parameters)
	parameters.setValue('type', 'getlicenses')
	return request.addRequestData(configNode, 'datacontainer', parameters).getAttribute("ID")
}

TLinkSession.prototype.SetLicenses = function(aliasName, userCode, password, DBName, licenseArray) {
	parameters.Clear()
	var configNode = request.addRequest('configure', parameters)
	parameters.setValue('alias', aliasName)
	parameters.setValue('ownercode', userCode)
	parameters.setValue('ownerpass', password)
	parameters.setValue('dbname', DBName)
	parameters.setValue('licensearray', licenseArray)
	var updateNode = request.addRequestData(configNode, 'modifylicences', parameters)
}

TLinkSession.prototype.UpgradeDatabase = function(sourcePath, eventQueueID) {
	parameters.Clear()
	var configNode = request.addRequest('configure', parameters)
	parameters.setValue('sourcepath', sourcePath)
	parameters.setValue('queueid', eventQueueID)
	return request.addRequestData(configNode, 'upgradedatabase', parameters).getAttribute("ID")
}

TLinkSession.prototype.RecycleChildDBFromCurrent = function(alias, ownerLogin, ownerPassword, ownerID, addrBookDstMode,
								   otherDstMode, options, groupAddr, groupOther, oldDaughterAlias,
								   oldDaughterUserName, oldDaughterPassword) {
	parameters.Clear()
	var configNode = request.addRequest('configure', parameters)
	parameters.setValue('type', 'recyclechlddbfromcurrent')
	parameters.setValue('alias', alias)
	parameters.setValue('ownercode', ownerLogin)
	parameters.setValue('ownerpass', ownerPassword)
	parameters.setValue('ownerid', ownerID)
	parameters.setValue('addrbookdistrmode', addrBookDstMode)
	parameters.setValue('otherbookdistrmode', otherDstMode)
	parameters.setValue('options', options)
	parameters.setValue('groupaddr', groupAddr)
	parameters.setValue('groupother', groupOther)
	parameters.setValue('olddbalias', oldDaughterAlias)
	parameters.setValue('olddbusername', oldDaughterUserName)
	parameters.setValue('olddbpassword', oldDaughterPassword)
	var updateNode = request.addRequestData(configNode, 'data', parameters)
	return updateNode.getAttribute("ID")
}

TLinkSession.prototype.MakeChildDBFromCurrent = function(alias, ownerLogin, ownerPassword, ownerID, addrBookDstMode,
								otherDstMode, options, groupAddr, groupOther) {
	parameters.Clear()
	var configNode = request.addRequest('configure', parameters)
	parameters.setValue('alias', alias)
	parameters.setValue('ownercode', ownerLogin)
	parameters.setValue('ownerpass', ownerPassword)
	parameters.setValue('ownerid', ownerID)
	parameters.setValue('addrbookdistrmode', addrBookDstMode)
	parameters.setValue('otherbookdistrmode', otherDstMode)
	parameters.setValue('options', options)
	parameters.setValue('groupaddr', groupAddr)
	parameters.setValue('groupother', groupOther)
	var updateNode = request.addRequestData(configNode, 'makechilddbfromcurrent', parameters)
	return updateNode.getAttribute("ID")
}

TLinkSession.prototype.GetUsersCodeWithoutDaughter = function() {
	parameters.Clear()
	var configNode = request.addRequest('configure', parameters)
	parameters.Clear()
	parameters.setValue('type', 'userswithoutdaughter')
	return request.addRequestData(configNode, 'datacontainer', parameters).getAttribute("ID")
}

TLinkSession.prototype.CreateDatabase = function(DBAUserName, DBAPassword, ownerName, ownerPassword, newAliasName,
						specificDBParameters, eventQueueID) {
	parameters.Clear()
	var configNode = request.addRequest('configure', parameters)
	parameters.setValue('dbacode', DBAUserName)
	parameters.setValue('dbapass', DBAPassword)
	parameters.setValue('ownercode', ownerName)
	parameters.setValue('ownerpass', ownerPassword)
	parameters.setValue('alias', newAliasName)
	parameters.setValue('specificparams', specificDBParameters)
	parameters.setValue('eventqueueid', eventQueueID)
	var updateNode = request.addRequestData(configNode, 'createdatabase', parameters)
}

TLinkSession.prototype.DeleteScript = function(IDScript) {
	parameters.Clear()
	var configNode = request.addRequest('configure', parameters)
	parameters.setValue('scriptid', IDScript)
	return request.addRequestData(configNode, 'deletescript', parameters).getAttribute("ID")
}

TLinkSession.prototype.GetScriptsDataSet = function() {
	parameters.Clear()
	var configNode = request.addRequest('configure', parameters)
	parameters.setValue('type', 'scripts')
	return request.addRequestData(configNode, 'datacontainer', parameters).getAttribute("ID")
}

TLinkSession.prototype.UpdateReference = function(referenceID, refDataSet) {
	parameters.Clear()
	var configNode = request.addRequest('configure', parameters)
	parameters.Clear()
	parameters.setValue('referenceid', referenceID)
	var updateNode = request.addRequestData(configNode, 'updatereference', parameters)
	return updateNode.appendChild(refDataSet.toXmlNode()).getAttribute("ID")
}

TLinkSession.prototype.EditReference = function(referenceID) {
	parameters.Clear()
	var xmlCommon = request.addRequest('configure', parameters)
	parameters.Clear()
	parameters.setValue('type', 'editreference')
	parameters.setValue('referenceid', referenceID)
	return request.addRequestData(xmlCommon, 'datacontainer', parameters).getAttribute("ID")
}

TLinkSession.prototype.GetCandidateStructTables = function() {
	parameters.Clear()
	var configNode = request.addRequest('configure', parameters)
	parameters.setValue('type', 'candidatestructtables')
	return request.addRequestData(configNode, 'datacontainer', parameters).getAttribute("ID")
}

TLinkSession.prototype.GetLookupTableKeyFields = function(IDTable) {
	parameters.Clear()
	var configNode = request.addRequest('configure', parameters)
	parameters.setValue('type', 'keyfields')
	parameters.setValue('tableid', IDTable)
	return request.addRequestData(configNode, 'data', parameters).getAttribute("ID")
}

TLinkSession.prototype.FetchLookupTable = function(IDTable) {
	parameters.Clear()
	var configNode = request.addRequest('configure', parameters)
	parameters.setValue('type', 'lookuptable')
	parameters.setValue('tableid', IDTable)
	return request.addRequestData(configNode, 'datacontainer', parameters).getAttribute("ID")
}

TLinkSession.prototype.GetUsersDataSet = function(kind, includeEveryone) {
	parameters.Clear()
	var configNode = request.addRequest('configure', parameters)
	parameters.setValue('type', 'users')
	parameters.setValue('kind', kind)
	if (includeEveryone) {
		parameters.setValue('includeeveryone', (includeEveryone?'true':'false'))
	}
	return request.addRequestData(configNode, 'datacontainer', parameters).getAttribute("ID")	
}

TLinkSession.prototype.GetUsr_UsrDataSet = function() {
	parameters.Clear()
	var configNode = request.addRequest('configure', parameters)
	parameters.setValue('type', 'usr_usr')
	return request.addRequestData(configNode, 'datacontainer', parameters).getAttribute("ID")
}

TLinkSession.prototype.RenameUser = function(IDUser, newName, newFullName) {
	parameters.Clear()
	var configNode = request.addRequest('configure', parameters)
	parameters.setValue('userid', IDUser)
	parameters.setValue('newname', newName)
	parameters.setValue('newfullname', newFullName)
	var updateNode = request.addRequestData(configNode, 'renameuser', parameters)
}

TLinkSession.prototype.SetGroupMembers = function(IDGroup, members) {
	parameters.Clear()
	var configNode = request.addRequest('configure', parameters)
	parameters.setValue('groupid', IDGroup)
	var updateNode = request.addRequestData(configNode, 'setgroupmembers', parameters)
	setNodeValue(updateNode, members)
}	

TLinkSession.prototype.DeleteLookupTable = function(TableID, forceDeletion) {
	parameters.Clear()
	var configNode = request.addRequest('configure', parameters)
	parameters.setValue('type', 'deletelookuptable')
	parameters.setValue('tableid', TableID)
	parameters.setValue('forcedeletion', (forceDeletion?'true':'false'))
	return request.addRequestData(configNode, 'data', parameters).getAttribute("ID")
}

/*****************************/
/*********** eLink ***********/
/*****************************/

TLinkSession.prototype.KeyFieldName = function(target) {
	return eval('targets.kfn' +target)
}

TLinkSession.prototype.TableIDFromTarget = function(target) {
	return eval('targets.revid' +target)
}

TLinkSession.prototype.TargetFromID = function(contextID) {
	var target = request.getNodeByID(contextID).getAttribute("target")
	return this.GetTargetIndex(target)
}

TLinkSession.prototype.TargetFromTableID = function(tableID) {
	return eval('targets.tid' +tableID)
}

TLinkSession.prototype.TableIDFromTargetName = function(targetName) {
	return eval('targets.id' +targetName)
}

function onFailureFunction() {
	throw "SOAP Error: can't handle IsSessionOpened request"
}

TLinkSession.prototype.IsSessionOpened = function() {
	try {		
		var requestSOAP = new TSOAPRequest()
		var responseSOAP = new TResponse()
		var node = requestSOAP.addRequest('common', parameters)
		parameters.Clear()
		parameters.setValue('type', 'issessionopened')
		var ID = requestSOAP.addRequestData(node, 'data', parameters).getAttribute("ID")
				
		new Ajax.Request(sBase +'api',
						{asynchronous: false, 
						method:'POST', onSuccess:function(requete){responseSOAP.setXml(requete.responseText);
																	if (!responseSOAP.isError)
		                                								onSuccessFunction()
		                                							else
		                                								onFailureFunction();
		                                						  },
	                    onFailure:function(requete){onFailureFunction();},
	                    postBody:requestSOAP.getSOAPRequest()
	                    })
		requestSOAP.Clear()
		if (responseSOAP.isError == false) {
			var value = responseSOAP.getNodeValueByID(ID)
			if (value == null) {return false}
			return value
		}
		else {
			throw "Error while handling isSessionOpened request."
			return false
		}
	}
	catch(e) {
		alert("Exception : " +e)
		return false
	}
}

TLinkSession.prototype.GetTargetIndex = function(targetName) {
	return eval('targets.tg' +targetName)
}

TLinkSession.prototype.GetTargetName = function(target) {
	return eval('targets.revtg' +target)
}

TLinkSession.prototype.CReport = function(reportFile, formatType, reportParams, documentID, documentEditID, getReportContent) {
	parameters.Clear()
	parameters.setValue('formattype', formatType)
	parameters.setValue('reportfile', reportFile)
	if (documentID != null) {
		parameters.setValue('inelinkdoc', 'T')
		parameters.setValue('iddocument', documentID)
	} else if (documentEditID != null) {
		parameters.setValue('inelinkdoc', 'T')
		parameters.setValue('editid', documentEditID)
	}
	if (reportParams != null) {
		for (var i=0; i<reportParams.allParameters.length; i++) {
			parameters.setValue('cr_' +reportParams.allParameters[i].name, reportParams.allParameters[i].value)
		}
	}
	var crNode = request.addRequest('creport', parameters)
	if (getReportContent) {
		parameters.Clear()
		parameters.setValue('type', 'crystalreport')
		return request.addRequestData(crNode, 'data', parameters).getAttribute("ID")
	} else {
		return crNode.getAttribute("ID")
	}
}

TLinkSession.prototype.UpdateFields2 = function(contextID, dataRowIndex, fieldNames, fieldValues) {
	if (!(isArray(fieldNames)) && !(isArray(fieldValues))) {
		this.UpdateFields(contextID, dataRowIndex, fieldNames, fieldValues)
		return
	}
	if (fieldNames.length != fieldValues.length) {
		throw "SOAP Error: Number of FieldValues <> Number of FieldNames"
	}
	var xmlEdit = request.getNodeByID(contextID)
	parameters.Clear()
	if (dataRowIndex != 0) {
		parameters.setValue('datarow', dataRowIndex)
	}
	var updateNode = request.addRequestData(xmlEdit, 'update', parameters)
	for (var i = 0; i < fieldNames.length; i++) {
		request.addNode(updateNode, fieldNames[i], fieldValues[i])
	}
}

TLinkSession.prototype.SendExternalMail = function(sendFrom, sendTo, sendCc, subject, body, target, IDLinked) {
	var contextID = this.BeginEdit(targets.tgMAIL, 0)
	var names = new Array;
	var values = new Array;
	names.push("KIND");
	values.push(4);
	names.push("TOLIST");
	values.push(sendTo);
	names.push("CCLIST");
	values.push(sendCc);
	names.push("MAILFROM");
	values.push(sendFrom);
	names.push("SUBJECT");
	values.push(subject);
	names.push("MAILBODY");
	values.push(body);
	if (target != 0)
	{
		names.push("IDTABLE");
		values.push(eval('targets.revtg' +target));
		names.push("IDLINKED");
		values.push("MAILBODY");
	}
	this.UpdateFields2(contextID, 0, names, values);
	//_UpdateFields2(contextID, 0, ("KIND", "TOLIST", "CCLIST", "SUBJECT", "MAILBODY"), (4, sendTo, sendCc, subject, body));
	//if (target != 0) {
	//	_UpdateFields2(contextID, 0, ("IDTABLE", "IDLINKED"), (eval('targets.revtg' +target), IDLinked))
	//}
	this.CommitChanges(contextID, false)
	this.EndEdit(contextID)
}

TLinkSession.prototype.SendMailToUsers = function(sendTo, sendCc, subject, body, target, IDLinked) {
	var contextID = this.BeginEdit(targets.tgMAIL, 0)
	this.UpdateFields2(contextID, 0, ["KIND", "TOLIST", "CCLIST", "SUBJECT", "MAILBODY"], [0, sendTo, sendCc, subject, body])
	if (target != 0) {
		this.UpdateFields2(contextID, 0, ["IDTABLE", "IDLINKED"], [eval('targets.revtg' +target), IDLinked])
	}
	this.CommitChanges(contextID, false)
	this.EndEdit(contextID)
}

TLinkSession.prototype.ExecuteSQLQuery = function(sql, queryParams, recordCount) {
	parameters.Clear()	
	var executeSQLQueryNode = request.addRequest('common', parameters)   
	parameters.setValue('type', 'executesqlquery')
	if (recordCount > 0) {
		parameters.setValue('recordcount', recordCount)
	}
	var queryNode = request.addRequestData(executeSQLQueryNode, 'datacontainer', parameters)
	request.addNode(queryNode, 'SQL', sql)
	if (!queryParams) {
		queryParams = ''
	}
	request.addNode(queryNode, 'QueryParams', queryParams)
	return queryNode.getAttribute("ID")
}

TLinkSession.prototype.HandleMeetingInvitation = function(actionID, invitationAction) {
	parameters.Clear()	
	var handleMeetingInvitationNode = request.addRequest('common', parameters)
	parameters.Clear()	
	parameters.setValue('type', 'meetinginvitation')
	parameters.setValue('actionid', actionID)
	parameters.setValue('invitationaction', invitationAction)
	return request.addRequestData(handleMeetingInvitationNode, 'data', parameters).getAttribute("ID")
}

TLinkSession.prototype.SetURLFavorites = function(favorites) {
	parameters.Clear()	
	var setURLFavoritesNode = request.addRequest('common', parameters)
	setURLFavoritesNode = request.addRequestData(setURLFavoritesNode, 'seturlfavorites', parameters)
	setNodeValue(setURLFavoritesNode, encode64(favorites))
	return setURLFavoritesNode.getAttribute("ID")
}

TLinkSession.prototype.AddOrModifyFavorite = function(target, entityKey, text) {
	parameters.Clear()	
	var addOrModifyFavoriteNode = request.addRequest('common', parameters)
	parameters.Clear()	
	parameters.setValue('type', 'addormodifyfavorite')
	parameters.setValue('target', eval('targets.revtg' +target))
	parameters.setValue('entitykey', entityKey)
	parameters.setValue('text', text)
	return request.addRequestData(addOrModifyFavoriteNode, 'data', parameters).getAttribute("ID")
}

TLinkSession.prototype.GetServerFileSize = function(serverPathWithoutRootDir) {
	parameters.Clear()	
	var serverFileSizeNode = request.addRequest('common', parameters)
	parameters.Clear()	
	parameters.setValue('type', 'serverfilesize')
	parameters.setValue('filepath', serverPathWithoutRootDir)
	return request.addRequestData(serverFileSizeNode, 'data', parameters).getAttribute("ID")
}

TLinkSession.prototype.GetStructure = function(IDTable, tableName, IDField, fieldName) {
	parameters.Clear()	
	var fieldStructureNode = request.addRequest('common', parameters)
	parameters.Clear()	
	parameters.setValue('type', 'table_structure')
	parameters.setValue('idtable', IDTable)
	parameters.setValue('tablename', tableName)
	parameters.setValue('idfield', IDField)
	parameters.setValue('fieldname', fieldName)
	return request.addRequestData(fieldStructureNode, 'datacontainer', parameters).getAttribute("ID")
}

//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
//!!!!!!!!!!!!!!! Not functional at this time !!!!!!!!!!!!!!!!//
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
function _TestExecute(functionName, params, addSessionID) {
	parameters.Clear()	
	var testExecuteNode = request.addRequest('common', parameters)
	parameters.Clear()	
	parameters.setValue('type', 'testexecute')
	parameters.setValue('functionname', functionName)
	parameters.setValue('params', params)
	parameters.setValue('addsessionid', (addSessionID?'true':'false'))
	return request.addRequestData(testExecuteNode, 'data', parameters).getAttribute("ID")
}
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//

TLinkSession.prototype.GetDefaultRights = function(target) {
	parameters.Clear()	
	var defaultRightsNode = request.addRequest('common', parameters)
	parameters.Clear()	
	parameters.setValue('type', 'getdefaultrights')
	parameters.setValue('target', eval('targets.revtg' +target))
	return request.addRequestData(defaultRightsNode, 'data', parameters).getAttribute("ID")
}

TLinkSession.prototype.HasRightTo = function(target, accesOperation) {
	parameters.Clear()	
	var hasRightToNode = request.addRequest('common', parameters)
	parameters.Clear()	
	parameters.setValue('type', 'hasrightto')
	parameters.setValue('target', eval('targets.revtg' +target))
	parameters.setValue('operation', accesOperation)
	return request.addRequestData(hasRightToNode, 'data', parameters).getAttribute("ID")
}

TLinkSession.prototype.EditSecurityDataSet = function(contextID) {
	var xmlEdit = request.getNodeByID(contextID)
	parameters.Clear()	
	parameters.setValue('type', 'securitydataset')
	return request.addRequestData(xmlEdit, 'datacontainer', parameters).getAttribute("ID")
}

TLinkSession.prototype.SetOwner = function(contextID, ownerID) {
	var xmlEdit = request.getNodeByID(contextID)
	parameters.Clear()	
	parameters.setValue('type', 'setowner')
	parameters.setValue('ownerid', ownerID)
	return request.addRequestData(xmlEdit, 'data', parameters).getAttribute("ID")
}

TLinkSession.prototype.GetOwner = function(contextID) {
	var xmlEdit = request.getNodeByID(contextID)
	parameters.Clear()	
	parameters.setValue('type', 'getowner')
	return request.addRequestData(xmlEdit, 'data', parameters).getAttribute("ID")
}

TLinkSession.prototype.InitializeSecurityDataSet = function(contextID) {
	var xmlEdit = request.getNodeByID(contextID)
	parameters.Clear()
	parameters.setValue('type', 'initializesecurity')
	return request.addRequestData(xmlEdit, 'data', parameters).getAttribute("ID")   
}

TLinkSession.prototype.GetJoinTableId = function(IDTable1, IDTable2) {
	parameters.Clear()
	var joinTableIDNode = request.addRequest('common', parameters)
	parameters.Clear()
	parameters.setValue('type', 'getjointableid')
	parameters.setValue('idtbl1', IDTable1)
	parameters.setValue('idtbl2', IDTable2)
	return request.addRequestData(joinTableIDNode, 'data', parameters).getAttribute("ID")   
}

TLinkSession.prototype.GetAllTypes = function(tableID) {
	parameters.Clear()
	var allTypesNode = request.addRequest('common', parameters)
	parameters.Clear()
	parameters.setValue('type', 'getalltypes')
	parameters.setValue('tableid', tableID)
	return request.addRequestData(allTypesNode, 'datacontainer', parameters).getAttribute("ID")
}

TLinkSession.prototype.ContactIDsFromEMailAddresses = function(recipients) {
	parameters.Clear()
	var IDsFromEmailNode = request.addRequest('common', parameters)
	parameters.Clear()
	parameters.setValue('type', 'contactidsfromemailaddresses')
	parameters.setValue('recipients', recipients)
	return request.addRequestData(IDsFromEmailNode, 'datacontainer', parameters).getAttribute("ID")
}

TLinkSession.prototype.UsersInGroup = function(groupID) {
	parameters.Clear()
	var usersInGroupNode = request.addRequest('common', parameters)
	parameters.setValue('type', 'useringroup')
	parameters.setValue('idgroup', groupID)
	return request.addRequestData(usersInGroupNode, 'data', parameters).getAttribute("ID")
}

TLinkSession.prototype.GetLookupData = function(target, detail, fieldName) {
	parameters.Clear()
	var lookupDataNode = request.addRequest('common', parameters)
	parameters.setValue('type', 'getlookupdata')
	parameters.setValue('target', eval('targets.revtg' +target))
	parameters.setValue('detail', eval('targets.revtg' +detail))
	parameters.setValue('fieldname', fieldName)
	return request.addRequestData(lookupDataNode, 'datacontainer', parameters).getAttribute("ID")	
}

TLinkSession.prototype.GetFieldMetaData = function(target, detail) {
	parameters.Clear()
	var fieldMetaDataNode = request.addRequest('common', parameters)
	parameters.setValue('type', 'getfieldmetadata')
	parameters.setValue('target', eval('targets.revtg' +target))
	if (!detail) {
		detail = targets.tgNONE
	}
	parameters.setValue('detail', eval('targets.revtg' +detail))
	return request.addRequestData(fieldMetaDataNode, 'datacontainer', parameters).getAttribute("ID")
}

TLinkSession.prototype.GetFieldIDFromFieldName = function(target, detail, fieldName) {
	parameters.Clear()
	var fieldMetaDataNode = request.addRequest('common', parameters)
	parameters.setValue('type', 'linkfldnametofieldid')
	parameters.setValue('target', eval('targets.revtg' +target))
	parameters.setValue('detail', eval('targets.revtg' +detail))
	parameters.setValue('fieldname', fieldName)
	return request.addRequestData(fieldMetaDataNode, 'data', parameters).getAttribute("ID")
}

TLinkSession.prototype.GetTypeMetaData = function(target, detail) {
	parameters.Clear()
	var typeMetaDataNode = request.addRequest('common', parameters)
	parameters.setValue('type', 'gettypemetadata')
	parameters.setValue('target', eval('targets.revtg' +target))
	parameters.setValue('detail', eval('targets.revtg' +detail))
	return request.addRequestData(typeMetaDataNode, 'datacontainer', parameters).getAttribute("ID")
}

TLinkSession.prototype.PrepareMailMerge = function(contextID, editID, templateID, mainContactOnly) {
	if (contextID == 0) {
		contextID = this.ConnectToExistingEdit(editID)
	}
	var xmlEdit = request.getNodeByID(contextID)
	parameters.Clear()
	parameters.setValue('idtemplate', templateID)
	if (mainContactOnly) {
		parameters.setValue('maincontactonly', (mainContactOnly?'true':'false'))
	}
	return request.addRequestData(xmlEdit, 'preparemailmerge', parameters).getAttribute("ID")
}

TLinkSession.prototype.ExecuteDocMailMerge = function(contextID, editID, templateID, mainContactOnly, transferContent) {
	if (contextID == 0) {
		contextID = this.ConnectToExistingEdit(editID)
	}
	var xmlEdit = request.getNodeByID(contextID)
	xmlEdit.setAttribute('apply', 'true')
	parameters.Clear()
	parameters.setValue('idtemplate', templateID)
	if (mainContactOnly) {
		parameters.setValue('maincontactonly', (mainContactOnly?'true':'false'))
	}
	if (transferContent) {
		parameters.setValue('transfercontent', (transferContent?'true':'false'))
	}
	return request.addRequestData(xmlEdit, 'executedocmailmerge', parameters).getAttribute("ID")
}

TLinkSession.prototype.ExecuteMailing = function(contextID, editID, templateID) {
	if (contextID == 0) {
		contextID = this.ConnectToExistingEdit(editID)
	}
	var xmlEdit = request.getNodeByID(contextID)
	xmlEdit.setAttribute('apply', 'true')
	parameters.Clear()
	parameters.setValue('idtemplate', templateID)
	return request.addRequestData(xmlEdit, 'executemailing', parameters).getAttribute("ID")
}

TLinkSession.prototype.ExportMailing = function(contextID, editID, templateID, DatabaseFileName, inEditID) {
	if (contextID == 0) {
		contextID = this.ConnectToExistingEdit(editID)
	}
	var xmlEdit = request.getNodeByID(contextID)
	xmlEdit.setAttribute('apply', 'true')
	parameters.Clear()
	parameters.setValue('idtemplate', templateID)
	parameters.setValue('databasefilename', DatabaseFileName)
	parameters.setValue('ineditid', inEditID)
	return request.addRequestData(xmlEdit, 'exportmailing', parameters).getAttribute("ID")
}

TLinkSession.prototype.ExecuteDatabaseQuery = function(IDQuery, queryParameters, loadBlobs) {
	parameters.Clear()
	var xmlCommon = request.addRequest('common', parameters)
	queryParameters.setValue('type', 'query')
	queryParameters.setValue('idquery', IDQuery)
	if (loadBlobs == true) {
		queryParameters.setValue('includeblobcontent', 'true')
	}
	return request.addRequestData(xmlCommon, 'datacontainer', queryParameters).getAttribute("ID")		
}

//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
//!!!!!!!!!!!!!!! Not functional at this time !!!!!!!!!!!!!!!!//
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
function _WriteQueryTostring(contextID, queryDefinition) {
/*
   DocNode := ComponentToXMLDOMDocument(QueryDefinition);
   ComponentNode.AppendChild(FindChildNode(DocNode, 'DOCUMENT'));
*/
	var xmlEdit = request.getNodeByID(contextID)
	parameters.Clear()
	var componentNode = request.addRequestData(xmlEdit, 'updatequerydefinition', parameters)
	/*var docNode =*/
	return componentNode.getAttribute("ID")
}
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//

//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
//!!!!!!!!!!!!!!! Not functional at this time !!!!!!!!!!!!!!!!//
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
function _WriteDocModelTostring(contextID, docModelDefinition) {
/*
   DocNode := ComponentToXMLDOMDocument(DocModelDefinition);
   ComponentNode.AppendChild(FindChildNode(DocNode, 'DOCUMENT'));
*/
	var xmlEdit = request.getNodeByID(contextID)
	parameters.Clear()
	var componentNode = request.addRequestData(xmlEdit, 'docmodeldefinition', parameters)
	/*var docNode = */
	return componentNode.getAttribute("ID")
}
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//

TLinkSession.prototype.ExecuteEditedQuery = function(contextID, loadBlobs) {
	var xmlEdit = request.getNodeByID(contextID)
	parameters.Clear()
	parameters.setValue('type', 'executequery')
	if (loadBlobs) {
		parameters.setValue('includeblobcontent', 'true')
	}
	return request.addRequestData(xmlEdit, 'datacontainer', parameters).getAttribute("ID")	
}

TLinkSession.prototype.ReadQueryDefinitionFromstring = function(contextID) {
	var xmlEdit = request.getNodeByID(contextID)
	parameters.Clear()
	parameters.setValue('type', 'querydefinition')
	return request.addRequestData(xmlEdit, 'datacontainer', parameters).getAttribute("ID")	
}

//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
//!!!!!!!!!!!!!!! Not functional at this time !!!!!!!!!!!!!!!!//
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
function _CreateDocModelTable(contextID, docModelDefinition, tableType, isProductTable) {
/*
   DocNode := ComponentToXMLDOMDocument(DocModelDefinition);
   ComponentNode.AppendChild(FindChildNode(DocNode, 'DOCUMENT'));
*/	
	var xmlEdit = request.getNodeByID(contextID)
	parameters.Clear()
	parameters.setValue('tabletype', tableType)
	if (isProductTable) {
		parameters.setValue('producttable', 'true')
	}
	var componentNode =  request.addRequestData(xmlEdit, 'docmodeltable', parameters)
	/*var docNode = */
	componentNode.appendChild(findChildNode(docNode, 'DOCUMENT'))
	return componentNode.getAttribute("ID")
}
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//

TLinkSession.prototype.ReadDocModelFromstring = function(contextID) {
	var xmlEdit = request.getNodeByID(contextID)
	parameters.Clear()
	parameters.setValue('type', 'docmodeldefinition')
	return request.addRequestData(xmlEdit, 'datacontainer', parameters).getAttribute("ID")
}

TLinkSession.prototype.ReadDocModelBlob = function(contextID) {
	var xmlEdit = request.getNodeByID(contextID)
	parameters.Clear()
	parameters.setValue('type', 'docmodelblob')
	return request.addRequestData(xmlEdit, 'data', parameters).getAttribute("ID")
}

TLinkSession.prototype.CopyDetails = function(contextID, sourceTarget, key, details, mainLinkOnly) {
	var xmlEdit = request.getNodeByID(contextID)
	parameters.Clear()
	parameters.setValue('target', eval('targets.revtg' +sourceTarget))
	parameters.setValue('key', key)
	parameters.setValue('details', eval('targets.revtg' +details))
	parameters.setValue('mainlinkonly', (mainLinkOnly?'true':'false'))
	return request.addRequestData(xmlEdit, 'copydetails', parameters).getAttribute("ID")
}

TLinkSession.prototype.EventEditInitialized = function(contextID) {
	var xmlEdit = request.getNodeByID(contextID)
	parameters.Clear()
	return request.addRequestData(xmlEdit, 'eventeditinitialized', parameters).getAttribute("ID")
}

TLinkSession.prototype.UnplanAction = function(contextID) {
	var xmlEdit = request.getNodeByID(contextID)
	parameters.Clear()
	return request.addRequestData(xmlEdit, 'unplanaction', parameters).getAttribute("ID")
}
TLinkSession.prototype.PlanAction = function(contextID) {
	var xmlEdit = request.getNodeByID(contextID)
	parameters.Clear()
	return request.addRequestData(xmlEdit, 'planaction', parameters).getAttribute("ID")
}

TLinkSession.prototype.UpdateAttachment = function(contextID, IDBlob, attachmentAsString) {
	var xmlEdit = request.getNodeByID(contextID)
	parameters.Clear()
	parameters.setValue('key', IDBlob)
	var dataSetNode = request.addRequestData(xmlEdit, 'updateattachment', parameters)
	dataSetNode.setAttribute('EncodingKind', 'MIME64')
	setNodeValue(dataSetNode, encode64(attachmentAsString))
	return dataSetNode.getAttribute("ID")
}

TLinkSession.prototype.InsertAttachment = function(contextID, attachmentType, path, fileContent) {
	var xmlEdit = request.getNodeByID(contextID)
	parameters.Clear()
	parameters.setValue('type', attachmentType)
	parameters.setValue('path', path)
	var blobNode = request.addRequestData(xmlEdit, 'insertattachment', parameters)
	if ((fileContent != null) && (fileContent != '')) {
		setNodeValue(blobNode, fileContent)
		blobNode.setAttribute('EncodingKind', 'MIME64')
	}
	return blobNode.getAttribute("ID")
}

TLinkSession.prototype.SetReference = function(contextID, referenceID) {
	var xmlEdit = request.getNodeByID(contextID)
	request.addNode(xmlEdit, 'reference', referenceID)
}

TLinkSession.prototype.GetReferenceListForTarget = function(target) {
	parameters.Clear()
	var referenceListForTargetNode = request.addRequest('common', parameters)
	parameters.Clear()
	parameters.setValue('type', 'referencelistfortarget')
	parameters.setValue('target', eval('targets.revtg' +target))
	return request.addRequestData(referenceListForTargetNode, 'datacontainer', parameters).getAttribute("ID")
}

TLinkSession.prototype.GetReferenceList = function(contextID) {
	var xmlEdit = request.getNodeByID(contextID)
	parameters.Clear()
	parameters.setValue('type', 'reference')
	return request.addRequestData(xmlEdit, 'datacontainer', parameters).getAttribute("ID")		
}

TLinkSession.prototype.GetLookupList = function(contextID, fieldName) {
	var xmlEdit = request.getNodeByID(contextID)
	parameters.Clear()
	parameters.setValue('type', 'lookup')
	parameters.setValue('field', fieldName)
	return request.addRequestData(xmlEdit, 'datacontainer', parameters).getAttribute("ID")
}

TLinkSession.prototype.ClearDetail = function(contextID, detail) {
	var xmlEdit = request.getNodeByID(contextID)
	parameters.Clear()
	parameters.setValue('detail', eval('targets.revtg' +detail))
	return request.addRequestData(xmlEdit, 'cleardetail', parameters).getAttribute("ID")
}

TLinkSession.prototype.UpdateDetail = function(contextID, detail, detailKey, fieldNames, fieldValues) {
	var allfieldNames = fieldNames.split(";")
	var allfieldValues = fieldValues.split(";")
	var xmlEdit = request.getNodeByID(contextID)
	parameters.Clear()
	parameters.setValue('detail', eval('targets.revtg' +detail))
	parameters.setValue('detailkey', detailKey)
	var updateNode = request.addRequestData(xmlEdit, 'updatedetail', parameters)
	for (var i = 0; i < allfieldNames.length; i++) {
		request.addNode(updateNode, allfieldNames[i], allfieldValues[i]);
	}
}

TLinkSession.prototype.DeleteDetail = function(contextID, detail, detailKey) {
	var xmlEdit = request.getNodeByID(contextID)
	parameters.Clear()
	parameters.setValue('detail', eval('targets.revtg' +detail))
	parameters.setValue('detailkey', detailKey)
	return request.addRequestData(xmlEdit, 'deletedetail', parameters).getAttribute("ID")
}

TLinkSession.prototype.InsertDetail = function(contextID, detail, detailKey, linkMainCy) {
	var xmlEdit = request.getNodeByID(contextID)
	parameters.Clear()
	parameters.setValue('detail', eval('targets.revtg' +detail))
	parameters.setValue('detailkey', detailKey)
	if (!linkMainCy) {
		parameters.setValue('maincy', 'false')
	}
	return request.addRequestData(xmlEdit, 'insertdetail', parameters).getAttribute("ID")	
}

TLinkSession.prototype.ConnectToExistingEdit = function(editID) {
	parameters.Clear()
	parameters.setValue('editid', editID)
	return request.addRequest('edit', parameters).getAttribute("ID")
}

TLinkSession.prototype.UpdateFields = function(contextID, dataRowIndex, fieldNames, fieldValues) {
	if (isArray(fieldNames) && isArray(fieldValues)) {
		this.UpdateFields2(contextID, dataRowIndex, fieldNames, fieldValues)
		return
	}
	var allfieldNames = fieldNames.split(";")
	var allfieldValues = fieldValues.toString().split(";")
	if (allfieldNames.length != allfieldValues.length) {
		throw "SOAP Error: Number of FieldValues <> Number of FieldNames"
	}
	var xmlEdit = request.getNodeByID(contextID)
	parameters.Clear()
	if (dataRowIndex != 0) {
		parameters.setValue('datarow', dataRowIndex)
	}
	var updateNode = request.addRequestData(xmlEdit, 'update', parameters)
	for (var i = 0; i < allfieldNames.length; i++) {
		request.addNode(updateNode, allfieldNames[i], allfieldValues[i]);
	}
}

TLinkSession.prototype.EditDetailDataSet = function(contextID, detail, loadBlobs) {
	var xmlEdit = request.getNodeByID(contextID)
	parameters.Clear()
	parameters.setValue('type', eval('targets.revtg' +detail))
	if (loadBlobs == true) {
		parameters.setValue('includeblobcontent', 'true')
	}
	return request.addRequestData(xmlEdit, 'datacontainer', parameters).getAttribute("ID")
}

TLinkSession.prototype.EditMasterDataSet = function(contextID, dataRowIndex) {
	var xmlEdit = request.getNodeByID(contextID)
	parameters.Clear()
	if (dataRowIndex != 0) {
		parameters.setValue('datarow', dataRowIndex)
	}
	return request.addRequestData(xmlEdit, 'datacontainer', parameters).getAttribute("ID")
}

TLinkSession.prototype.BeginEditRelation = function(target, detail, key, detailKey) {
	parameters.Clear()
	parameters.setValue('target', eval('targets.revtg' +target))
	parameters.setValue('key', key)
	parameters.setValue('detail', eval('targets.revtg' +detail))
	parameters.setValue('detailkey', detailKey)
	var contextID = request.addRequest('edit', parameters).getAttribute("ID")
	return contextID
}

TLinkSession.prototype.DeleteLink = function(target, detailTarget, key, detailKey) {
	var delLinkNode = request.addRequest('common', parameters)
	parameters.Clear()
	parameters.setValue('type', 'deletelink')
	parameters.setValue('key', key)
	parameters.setValue('detailkey', detailKey)
	parameters.setValue('laptarget', eval('targets.revtg' +target))
	parameters.setValue('detaillaptarget', eval('targets.revtg' +detailTarget))
	return request.addRequestData(delLinkNode, 'data', parameters).getAttribute("ID")
}

TLinkSession.prototype.AddLink = function(target, detailTarget, key, detailKey, ignoreExisting) {
	var addLinkNode = request.addRequest('common', parameters)
	parameters.Clear()
	parameters.setValue('type', 'addlink')
	parameters.setValue('key', key) 
	parameters.setValue('detailkey', detailKey) 
	parameters.setValue('laptarget', eval('targets.revtg' +target))
	parameters.setValue('detaillaptarget', eval('targets.revtg' +detailTarget))
	parameters.setValue('ignoreexisting', ignoreExisting) 
	return request.addRequestData(addLinkNode, 'data', parameters).getAttribute("ID")	
}

TLinkSession.prototype.ConsultMainCompanyEx = function(contactKey) {
	var mainCompanyExNode = request.addRequest('common', parameters)
	parameters.Clear()
	parameters.setValue('type', 'consultmaincompany')
	parameters.setValue('key', contactKey)
	return request.addRequestData(mainCompanyExNode, 'datacontainer', parameters).getAttribute("ID")	
}

TLinkSession.prototype.Consult2 = function(target, key, detail, detailResponseID) {
	var contextID = this.BeginConsult(target, key)
	var result = this.ConsultDataSet(contextID)
	this.EndConsult(contextID)
	detailResponseID = this.ConsultDetail(contextID, detail)
	return result
}

TLinkSession.prototype.Consult = function(target, key) {
	var contextID = this.BeginConsult(target, key)
	var result = this.ConsultDataSet(contextID)
	this.EndConsult(contextID)
	return result
}

TLinkSession.prototype.Search = function(target, searchField, value, optionsOwn, optionsContains) {
	var contextID = this.BeginSearch(target)
	var result = this.SearchDataSet(contextID, searchField, value, optionsOwn, optionsContains)
	this.EndSearch(contextID)
	return result
}

TLinkSession.prototype.ConsultURLFavorites = function() {
	parameters.Clear()
	var URLFavoritesNode = request.addRequest('common', parameters)
	parameters.Clear()
	parameters.setValue('type', 'urlfavoritelist')
	return request.addRequestData(URLFavoritesNode, 'datacontainer', parameters).getAttribute("ID")
}

TLinkSession.prototype.ConsultFavorites = function() {
	parameters.Clear()
	var favoritesNode = request.addRequest('common', parameters)
	parameters.Clear()
	parameters.setValue('type', 'favoritelist')
	return request.addRequestData(favoritesNode, 'datacontainer', parameters).getAttribute("ID")					
}

//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
//!!!!!!!!!!!!!!! Not functional at this time !!!!!!!!!!!!!!!!//
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
function _ConsultMailList(mailKind, accountID) {
	parameters.Clear()
	parameters.setValue('kind', mailKind)
	parameters.setValue('account', accountID)
	var mailListNode = request.addRequest('mailbox', parameters)
	parameters.Clear()
	return request.addRequestData(mailListNode, 'datacontainer', parameters).getAttribute("ID")				
}
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//

TLinkSession.prototype.ConsultQueryList = function(userIDs) {
	parameters.Clear()
	parameters.setValue('user', userIDs)
	var queryListNode = request.addRequest('querylist', parameters)
	parameters.Clear()
	return request.addRequestData(queryListNode, 'datacontainer', parameters).getAttribute("ID")		
}

TLinkSession.prototype.ConsultDocModelList = function(userIDs) {
	parameters.Clear()
	parameters.setValue('user', userIDs)
	var docModelListNode = request.addRequest('docmodellist', parameters)
	parameters.Clear()
	return request.addRequestData(docModelListNode, 'datacontainer', parameters).getAttribute("ID")
}

TLinkSession.prototype.ConsultDocumentList = function(userIDs, opened, activeUser) {
	parameters.Clear()
	parameters.setValue('user', userIDs)
	parameters.setValue('active', (activeUser?'true':'false'))
	parameters.setValue('opened', (opened?'true':'false'))
	var documentListNode = request.addRequest('documentlist', parameters)
	parameters.Clear()
	return request.addRequestData(documentListNode, 'datacontainer', parameters).getAttribute("ID")
}

TLinkSession.prototype.ConsultToDoList = function(date, userIDs, activeUser) {
	parameters.Clear()
	parameters.setValue('date', date)
	parameters.setValue('user', userIDs)
	parameters.setValue('active', (activeUser?'true':'false'))
	var toDoListNode = request.addRequest('todolist', parameters)
	parameters.Clear()
	return request.addRequestData(toDoListNode, 'datacontainer', parameters).getAttribute("ID")
}

TLinkSession.prototype.ConsultDetail = function(contextID, detailTarget) {
	var xmlConsult = request.getNodeByID(contextID)
	parameters.Clear()
	parameters.setValue('type', eval('targets.revtg' +detailTarget))
	return request.addRequestData(xmlConsult, 'datacontainer', parameters).getAttribute("ID")
}

TLinkSession.prototype.SearchDetail = function(contextID, key, detailTarget) {
	var xmlSearch = request.getNodeByID(contextID)	
	parameters.Clear()
	parameters.setValue('type', eval('targets.revtg' +detailTarget))
	parameters.setValue('key', key)
	return request.addRequestData(xmlSearch, 'datacontainer', parameters).getAttribute("ID")
}

TLinkSession.prototype.SearchDataSet = function(contextID, searchField, value, optionsOwn, optionsContains) {
	var xmlSearch = request.getNodeByID(contextID)
	xmlSearch.setAttribute('searchfield', searchField)
	xmlSearch.setAttribute('value', value)
	xmlSearch.setAttribute('own', (optionsOwn?'true':'false'))
	xmlSearch.setAttribute('contains', (optionsContains?'true':'false'))
	parameters.Clear()
	return request.addRequestData(xmlSearch, 'datacontainer', parameters).getAttribute("ID")
}

TLinkSession.prototype.EndSearch = function(contextID, keepOnServer) {
	if (!keepOnServer) {
		var xmlSearch = request.getNodeByID(contextID)
		xmlSearch.setAttribute('closecontext', 'true')
	}
}

TLinkSession.prototype.BeginSearch = function(target) {
	parameters.Clear()		
	parameters.setValue('target', eval('targets.revtg' +target))
	var contextID = request.addRequest('search', parameters).getAttribute("ID")
	return contextID	
}

TLinkSession.prototype.GetUserID = function(userName) {
	userlist.first()
	while (!userlist.EOF()) {
		if (userlist.fieldByName('NAME') == userName) {
			return userlist.fieldByName('ID')
		}				
		userlist.next()
	}	
}

TLinkSession.prototype.ConsultAgenda = function(dateBegin, dateEnd, userIDs, activeUser, kind) {
	parameters.Clear()
	parameters.setValue('date', dateBegin)
	parameters.setValue('to', dateEnd)
	parameters.setValue('user', userIDs)
	parameters.setValue('active', (activeUser?'true':'false'))
	if (kind) parameters.setValue("kind", kind)
	var agendaNode = request.addRequest('agenda', parameters)
	parameters.Clear()
	return request.addRequestData(agendaNode, 'datacontainer', parameters).getAttribute("ID")
}

TLinkSession.prototype.ConsultInstMsg = function(recordCount, afterID) {
	parameters.Clear()
	var agendaNode = request.addRequest('instmsg', parameters)
	parameters.Clear()
	if (recordCount) parameters.setValue('recordcount', recordCount)
	if (!afterID) afterID=0
	parameters.setValue('filter', 'IDINSTMSG>' +afterID)
	return request.addRequestData(agendaNode, 'datacontainer', parameters).getAttribute("ID")
}

TLinkSession.prototype.GetUserName = function(userID) {
	userlist.first()
	while (!userlist.EOF()) {
		if (userlist.fieldByName('ID') == userID) {
			return userlist.fieldByName('FULLNAME')
		}				
		userlist.next()
	}
}

TLinkSession.prototype.CopyFromExisting = function(contextID, key) {
	parameters.Clear()
	parameters.setValue('key', key)
	var xmlEdit = request.getNodeByID(contextID)
	return request.addRequestData(xmlEdit, 'copyfromexisting', parameters).getAttribute("ID")
}

TLinkSession.prototype.ConsultManyEx = function(target, findFields, orderByFields, findValues){
	parameters.Clear()
	parameters.setValue('type', 'consultmanyex')
	var xmlCommon = request.addRequest('common', parameters)
	parameters.setValue('target', eval('targets.revtg' +target))
	parameters.setValue('findfield', findFields)
	parameters.setValue('orderbyfield', orderByFields)
	parameters.setValue('keys', findValues)
	return request.addRequestData(xmlCommon, 'datacontainer', parameters).getAttribute("ID")
}

TLinkSession.prototype.SaveParameters = function(iniParameters) {
	parameters.Clear()
	var xmlCommon = request.addRequest('common', parameters)
	parameters.setValue('type', 'setoptionsinifile')
	parameters.setValue('text', iniParameters)
	return request.addRequestData(xmlCommon, 'data', parameters).getAttribute("ID")
}

TLinkSession.prototype.GetOptionsIniFile = function() {
	parameters.Clear()
	var xmlCommon = request.addRequest('common', parameters)
	parameters.setValue('type', 'optionsinifile')
	return request.addRequestData(xmlCommon, 'data', parameters).getAttribute("ID")
}

TLinkSession.prototype.GetOptionsValue = function(sectionName, keyName) {
	parameters.Clear()
	var xmlCommon = request.addRequest('common', parameters)
	parameters.setValue('type', 'getoptionsvalue')
	parameters.setValue('section', sectionName)
	parameters.setValue('key', keyName)
	return request.addRequestData(xmlCommon, 'data', parameters).getAttribute("ID")
}

TLinkSession.prototype.UpdateOptions = function(options) {
	parameters.Clear()
	var xmlCommon = request.addRequest('common', parameters)
	var xmlUpdate = request.addRequestData(xmlCommon, 'updateoptions', parameters)
	var xmlRows = request.addNode(xmlUpdate, 'ROWS', '')
	for (var i=0; i<options.sections.length; i++) {
		var xmlRow = request.addNode(xmlRows, 'ROW', '')
		xmlRow.setAttribute('ID', i)
		var xmlName = request.addNode(xmlRow, 'Name', options.sections[i].name)
		var xmlSectionEntries = request.addNode(xmlRow, 'SectionEntries', '')
		xmlSectionEntries.setAttribute('CLASS', 'StringList')
		var xmlValueRows = request.addNode(xmlSectionEntries, 'ROWS', '')
		for (var j=0; j<options.sections[i].values.length; j++) {
			var xmlValueRow = request.addNode(xmlValueRows, 'ROW', options.sections[i].values[j].key +'=' +options.sections[i].values[j].value)
			xmlValueRow.setAttribute('ID', j)
		}
	}
	return xmlUpdate.getAttribute("ID")
}

TLinkSession.prototype.ConsultDataSet = function(contextID) {
	var xmlConsult = request.getNodeByID(contextID)
	parameters.Clear()
	return request.addRequestData(xmlConsult, 'datacontainer', parameters).getAttribute("ID")
}

TLinkSession.prototype.EndConsult = function(contextID) {
	var xmlConsult = request.getNodeByID(contextID)
	xmlConsult.setAttribute('closecontext', 'true')
}

TLinkSession.prototype.BeginConsult = function(target, key) {
	parameters.Clear()
	parameters.setValue('target', eval('targets.revtg' +target))
	parameters.setValue('key', key)
	var contextID = request.addRequest('consult', parameters).getAttribute("ID")
	return contextID
}

TLinkSession.prototype.GetLookupDataFromID = function(TableID, fieldName) {
	parameters.Clear()
	var xmlCommon = request.addRequest('common', parameters)
	parameters.setValue('type', 'getlookupdata')
	parameters.setValue('tableid', TableID)
	parameters.setValue('fieldname', fieldName)
	var SOAPResponseID = request.addRequestData(xmlCommon, 'datacontainer', parameters).getAttribute("ID")
	return SOAPResponseID
}

TLinkSession.prototype.SetUsers = function(contextID, users, clearUsers) {
	var xmlEdit = request.getNodeByID(contextID)
	parameters.Clear()
	parameters.setValue('clear', (clearUsers?'true':'false'))
	var xmlUsers = request.addRequestData(xmlEdit, 'setusers', parameters)
	parameters.Clear()
	for (var i=0; i<users.length; i++)
		request.addNode(xmlUsers, 'user', users[i])
	return xmlUsers.getAttribute("ID")
}

TLinkSession.prototype.getNodeDataByID = function(SOAPResponseID, removePrefix) {
	return response.getNodeDataByID(SOAPResponseID, removePrefix)
}

TLinkSession.prototype.getNodeValueByID = function(SOAPResponseID) {
	return response.getNodeValueByID(SOAPResponseID)
}

TLinkSession.prototype.GetDocModelList = function() {
	parameters.Clear()
	var xmlCommon = request.addRequest('docmodellist', parameters)
	parameters.Clear()
	var SOAPResponseID = request.addRequestData(xmlCommon, 'datacontainer', parameters).getAttribute("ID")
	return SOAPResponseID
}

TLinkSession.prototype.ConsultRecent = function() {
	parameters.Clear()
	var xmlCommon = request.addRequest('common', parameters)
	parameters.Clear()
	parameters.setValue('type', 'recentlist')
	var SOAPResponseID = request.addRequestData(xmlCommon, 'datacontainer', parameters).getAttribute("ID")
	return SOAPResponseID
}

TLinkSession.prototype.GetAttachment = function(contextID, blobID) {
	var xmlEdit = request.getNodeByID(contextID)
	parameters.Clear()
	parameters.setValue('type', 'attachment')
	parameters.setValue('key', blobID)
	var SOAPResponseID = request.addRequestData(xmlEdit, 'data', parameters).getAttribute("ID")
	return SOAPResponseID
}

TLinkSession.prototype.GetEditKey = function(contextID) {
	var key = response.getNodeByID(contextID).getAttribute("key")
	return key
}

TLinkSession.prototype.GetEditID = function(contextID) {
	var editid = response.getNodeByID(contextID).getAttribute("editid")
	return editid
}

TLinkSession.prototype.Delete = function(target, keys) {
	parameters.Clear()
	var xmlCommon = request.addRequest('common', parameters)
	parameters.Clear()
	parameters.setValue('type', 'deleterow')
	parameters.setValue('laptarget', eval('targets.revtg' +target))
	parameters.setValue('keys', keys)
	var SOAPResponseID = request.addRequestData(xmlCommon, 'data', parameters).getAttribute("ID")
	return SOAPResponseID
}

TLinkSession.prototype.BeginEdit = function(target, targetKey) {
	parameters.Clear()
	parameters.setValue('target', eval('targets.revtg' +target))
	parameters.setValue('key', targetKey)
	var contextID = request.addRequest('edit', parameters).getAttribute("ID")
	return contextID
}

TLinkSession.prototype.UpdateField = function(contextID, fieldName, fieldValue, encodeMime64) {
	var xmlEdit = request.getNodeByID(contextID)
	var xmlUpdate = selectSingleNode(xmlEdit, 'update')
	if (xmlUpdate == null) {
		parameters.Clear()
		xmlUpdate = request.addRequestData(xmlEdit, 'update', parameters)
	}
	if (encodeMime64) 
		request.addNode(xmlUpdate, fieldName, encode64(fieldValue)).setAttribute('EncodingKind', 'MIME64')
	else
		request.addNode(xmlUpdate, fieldName, fieldValue)
}

TLinkSession.prototype.CommitChanges = function(contextID, refreshData) {
	var xmlContext = request.getNodeByID(contextID)
	if (refreshData)
		xmlContext.setAttribute('apply', 'keep')
	else
		xmlContext.setAttribute('apply', 'true')
}

TLinkSession.prototype.EndEdit = function(contextID, keepOnServer) {
	if (keepOnServer == null) keepOnServer = false
	if (!keepOnServer) {
		var xmlEdit = request.getNodeByID(contextID)
		xmlEdit.setAttribute('closecontext', 'true')
	}
}

TLinkSession.prototype.logout = function() {
	parameters.Clear()
	var SOAPResponseID = request.addRequest('logout', parameters).getAttribute("ID")
	return SOAPResponseID
}

TLinkSession.prototype.GetTranslatedTableName = function(target) {
	parameters.Clear()
	var xmlCommon = request.addRequest('common', parameters)
	parameters.Clear()
	parameters.setValue('type', 'gettranslatedtablename')
	parameters.setValue('target', eval('targets.revtg' +target))
	var SOAPResponseID = request.addRequestData(xmlCommon, 'data', parameters).getAttribute("ID")
	return SOAPResponseID
}

TLinkSession.prototype.login = function(aLogin, aPassword, aDBPath) {
	parameters.Clear()
	parameters.setValue('login', aLogin)
	parameters.setValue('password', aPassword)
	parameters.setValue('dbpath', aDBPath)
	var SOAPResponseID = request.addRequest('login', parameters).getAttribute("ID")
	return SOAPResponseID
}

TLinkSession.prototype.agenda = function(dateFrom, dateTo, userID, active, kind) {
	parameters.Clear()
	parameters.setValue("date", dateFrom)
	parameters.setValue("to", dateTo)
	parameters.setValue("user", userID)
	parameters.setValue("explodegroup", "true")
	if (active) parameters.setValue("active", "true")
	if (kind) parameters.setValue("kind", kind)
	var xmlCommon = request.addRequest('agenda', parameters)
	parameters.Clear()
	var SOAPResponseID = request.addRequestData(xmlCommon, 'datacontainer', parameters).getAttribute("ID")
	return SOAPResponseID
}

TLinkSession.prototype.executeSProc = function(procName, procParams) {
	parameters.Clear()
	var executeSProcNode = request.addRequest('common', parameters)
	parameters.Clear()
	parameters.setValue('type', 'executesproc')
	parameters.setValue('procname', procName)
	for (var i = 0; i < procParams.length; i++) {
		parameters.setValue('param'+i, procParams[i])
	}
	var SOAPResponseID = request.addRequestData(executeSProcNode, 'data', parameters).getAttribute("ID")
	return SOAPResponseID
}

TLinkSession.prototype.executeMergeProcess = function(idTemplate, pdfConversion, transferContentOrBase, 
		generationMode, editID, masterRef, reportParams, CRFormatType) {
	parameters.Clear()
	parameters.setValue('idtemplate', idTemplate)
	parameters.setValue('pdfconversion', (pdfConversion?'true':'false'))
	parameters.setValue('transfercontentorbase', transferContentOrBase)
	parameters.setValue('generationmode', generationMode)	
	if (editID != null)	{
		parameters.setValue('editid', editID)
		parameters.setValue('master', eval('targets.revtg' +masterRef))
	}
	if (reportParams != null) {
		for (var i=0; i<reportParams.allParameters.length; i++) {
			parameters.setValue('cr_' +reportParams.allParameters[i].name, reportParams.allParameters[i].value)
		}
	}
	if (CRFormatType != null) {
		parameters.setValue('crformattype', CRFormatType)
	}
	var mergeNode = request.addRequest('docmerge', parameters)
    return mergeNode.getAttribute("ID")
}

TLinkSession.prototype.SetUserSecurity = function(contextID, userID, securityValue) {
	var xmlEdit = request.getNodeByID(contextID)
	parameters.Clear()
	parameters.setValue('userid', userID)
	parameters.setValue('securityvalue', securityValue)	
	var xmlSetUserSecurity = request.addRequestData(xmlEdit, 'setusersecurity', parameters)
	return xmlSetUserSecurity.getAttribute("ID")
}

TLinkSession.prototype.isError = function() {
	return response.isError
}

TLinkSession.prototype.lastError = function() {
	return response.lastError
}

TLinkSession.prototype.shortError = function() {
	return response.shortError
}

TLinkSession.prototype.daughterDB = function() {
	return daughterdb
}


/******************* initialization of local variables *********************************/
var currentuserid = null
var currentdatabasealias = null
var daughterdb = null
var userlist = null
var getnormaltablesforqueries = null
var options = null
var targetcollection = null
var aliasList = null
var systemsettings = null
var currentUserName = null
var currentUserFullName = null
var targets = new Object()

TLinkSession.prototype.initSoapSession = function() {
	parameters.Clear()
	var xmlCommon = request.addRequest('common', parameters)

	parameters.Clear()
	parameters.setValue('type', 'currentuserid')
	var currentuseridSOAPResponseID = request.addRequestData(xmlCommon, 'data', parameters).getAttribute("ID")

	parameters.Clear()
	parameters.setValue('type', 'userlist')
	var userlistSOAPResponseID = request.addRequestData(xmlCommon, 'datacontainer', parameters).getAttribute("ID")

	parameters.Clear()
	parameters.setValue('type', 'aliaslist')
    var aliasListID = request.addRequestData(xmlCommon, 'datacontainer', parameters).getAttribute("ID")
    
	parameters.Clear()
	parameters.setValue('type', 'currentdatabasealias')
	var currentdatabasealiasSOAPResponseID = request.addRequestData(xmlCommon, 'data', parameters).getAttribute("ID")

	parameters.Clear()
	parameters.setValue('type', 'getnormaltablesforqueries')
	var getnormaltablesforqueriesSOAPResponseID = request.addRequestData(xmlCommon, 'datacontainer', parameters).getAttribute("ID")

	parameters.Clear()
	parameters.setValue('type', 'options')
	var optionsSOAPResponseID = request.addRequestData(xmlCommon, 'datacontainer', parameters).getAttribute("ID")

	parameters.Clear()
	parameters.setValue('type', 'daughterdb')
	var daughterdbSOAPResponseID = request.addRequestData(xmlCommon, 'data', parameters).getAttribute("ID")

	parameters.Clear()
	parameters.setValue('type', 'targetcollection')
	var targetcollectionSOAPResponseID = request.addRequestData(xmlCommon, 'datacontainer', parameters).getAttribute("ID")

	parameters.Clear()
	parameters.setValue('type', 'systemsettings')
	var systemsettingsID = request.addRequestData(xmlCommon, 'datacontainer', parameters).getAttribute("ID")
         
	//parameters.Clear()
	//parameters.setValue('type', 'reference')
	//var referencelistID = request.addRequestData(xmlCommon, 'datacontainer', parameters).getAttribute("ID")

	this.executeBatch(true)
	if (!response.isError) {
		currentuserid = response.getNodeValueByID(currentuseridSOAPResponseID)
		aliasList = response.getNodeDataByID(aliasListID)
		currentdatabasealias = response.getNodeValueByID(currentdatabasealiasSOAPResponseID)
		daughterdb = response.getNodeValueByID(daughterdbSOAPResponseID)
		userlist = response.getNodeDataByID(userlistSOAPResponseID, 'USERLIST')
		getnormaltablesforqueries = response.getNodeDataByID(getnormaltablesforqueriesSOAPResponseID, 'DICTLIST')
		options = response.getNodeDataByID(optionsSOAPResponseID)
		targetcollection = response.getNodeDataByID(targetcollectionSOAPResponseID)
		systemsettings = response.getNodeDataByID(systemsettingsID)
		//referencelist = response.getNodeDataByID(referencelistID)
		
		targetcollection.first()
		while (!targetcollection.EOF()) {
			eval('targets.tg' +targetcollection.fieldByName('NAME').toUpperCase() +'=' +targetcollection.fieldByName('TARGETINDEX'))
			eval('targets.revtg' +targetcollection.fieldByName('TARGETINDEX') +'="' +targetcollection.fieldByName('NAME').toUpperCase() +'"')
			eval('targets.id' +targetcollection.fieldByName('NAME').toUpperCase() +'=' +targetcollection.fieldByName('TABLEID'))
			eval('targets.tid' +targetcollection.fieldByName('TABLEID') +'=' +targetcollection.fieldByName('TARGETINDEX'))
			eval('targets.revid' +targetcollection.fieldByName('TARGETINDEX') +'=' +targetcollection.fieldByName('TABLEID'))
			eval('targets.kfn' +targetcollection.fieldByName('TARGETINDEX') +'="' +targetcollection.fieldByName('KEYFIELDNAME').toUpperCase() +'"')
			eval('targets.tn' +targetcollection.fieldByName('TABLENAME') +'=' +targetcollection.fieldByName('TARGETINDEX'))
			targetcollection.next()
		}
		
		userlist.first()
		while (!userlist.EOF()) {
			if (userlist.fieldByName('ID') == currentuserid) {
				currentUserName = userlist.fieldByName('NAME')
				currentUserFullName = userlist.fieldByName('FULLNAME')
				break
			}				
			userlist.next()
		}
	} else {
		alert('Error during initSoapSession() : ' +response.lastError);
	}
}