js/pz2.js

   1 /*
   2 ** $Id: pz2.js,v 1.50 2007-08-14 14:23:32 jakub Exp $
   3 ** pz2.js - pazpar2's javascript client library.
   4 */
   5
   6 //since explorer is flawed
   7 if (!window['Node']) {
   8     window.Node = new Object();
   9     Node.ELEMENT_NODE = 1;
  10     Node.ATTRIBUTE_NODE = 2;
  11     Node.TEXT_NODE = 3;
  12     Node.CDATA_SECTION_NODE = 4;
  13     Node.ENTITY_REFERENCE_NODE = 5;
  14     Node.ENTITY_NODE = 6;
  15     Node.PROCESSING_INSTRUCTION_NODE = 7;
  16     Node.COMMENT_NODE = 8;
  17     Node.DOCUMENT_NODE = 9;
  18     Node.DOCUMENT_TYPE_NODE = 10;
  19     Node.DOCUMENT_FRAGMENT_NODE = 11;
  20     Node.NOTATION_NODE = 12;
  21 }
  22
  23 // prevent execution of more than once
  24 if(typeof window.pz2 == "undefined") {
  25 window.undefined = window.undefined;
  26
  27 var pz2 = function(paramArray) {
  28     //for convenience
  29     __myself = this;
  30
  31     //supported pazpar2's protocol version
  32     __myself.suppProtoVer = '1';
  33     __myself.pz2String = paramArray.pazpar2path || "/pazpar2/search.pz2";
  34     __myself.stylesheet = paramArray.detailstylesheet || null;
  35     __myself.useSessions = true;
  36     if (paramArray.usesessions != undefined) {
  37          __myself.useSessions = paramArray.usesessions;
  38     }
  39
  40     //load stylesheet if required in async mode
  41     if( __myself.stylesheet ) {
  42         var request = new pzHttpRequest( __myself.stylesheet );
  43         request.get( {}, function ( doc ) { __myself.xslDoc = doc; } );
  44     }
  45
  46     // at least one callback required
  47     if ( !paramArray )
  48         throw new Error("An array with parameters has to be suplied when instantiating a class");
  49
  50     __myself.errorHandler = paramArray.errorhandler || null;
  51
  52     // function callbacks
  53     __myself.statCallback = paramArray.onstat || null;
  54     __myself.showCallback = paramArray.onshow || null;
  55     __myself.termlistCallback = paramArray.onterm || null;
  56     __myself.recordCallback = paramArray.onrecord || null;
  57     __myself.bytargetCallback = paramArray.onbytarget || null;
  58     __myself.resetCallback = paramArray.onreset || null;
  59
  60     // termlist keys
  61     __myself.termKeys = paramArray.termlist || "subject";
  62
  63     // some configurational stuff
  64     __myself.keepAlive = 50000;
  65
  66     __myself.sessionID = null;
  67     __myself.initStatusOK = false;
  68     __myself.pingStatusOK = false;
  69     __myself.searchStatusOK = false;
  70
  71     if ( paramArray.keepAlive < __myself.keepAlive )
  72         __myself.keepAlive = paramArray.keepAlive;
  73
  74     // for sorting
  75     __myself.currentSort = "relevance";
  76     // where are we?
  77     __myself.currentStart = 0;
  78     __myself.currentNum = 20;
  79
  80     // last full record retrieved
  81     __myself.currRecID = null;
  82     // current query
  83     __myself.currQuery = null;
  84
  85     //timers
  86     __myself.statTime = paramArray.stattime || 1000;
  87     __myself.statTimer = null;
  88     __myself.termTime = paramArray.termtime || 1000;
  89     __myself.termTimer = null;
  90     __myself.showTime = paramArray.showtime || 1000;
  91     __myself.showTimer = null;
  92     __myself.showFastCount = 4;
  93     __myself.bytargetTime = paramArray.bytargettime || 1000;
  94     __myself.bytargetTimer = null;
  95
  96     // counters for each command and applied delay
  97     __myself.dumpFactor = 500;
  98     __myself.showCounter = 0;
  99     __myself.termCounter = 0;
 100     __myself.statCounter = 0;
 101     __myself.bytargetCounter = 0;
 102
 103     // active clients, updated by stat and show
 104     // might be an issue since bytarget will poll accordingly
 105     __myself.activeClients = 1;
 106
 107     // auto init session?
 108     if (paramArray.autoInit !== false)
 109         __myself.init();
 110 };
 111 pz2.prototype =
 112 {
 113    stop: function ()
 114    {
 115        clearTimeout(__myself.statTimer);
 116        clearTimeout(__myself.showTimer);
 117        clearTimeout(__myself.termTimer);
 118        clearTimeout(__myself.bytargetTimer);
 119     },
 120
 121     reset: function ()
 122     {
 123         __myself.sessionID = null;
 124         __myself.initStatusOK = false;
 125         __myself.pingStatusOK = false;
 126         __myself.searchStatusOK = false;
 127
 128         __myself.stop();
 129
 130         if ( __myself.resetCallback )
 131                 __myself.resetCallback();
 132     },
 133     init: function ( sessionId )
 134     {
 135         __myself.reset();
 136
 137         if ( sessionId != undefined ) {
 138             __myself.initStatusOK = true;
 139             __myself.sessionID = sessionId;
 140             __myself.ping();
 141         } else if (__myself.useSessions) {
 142             var request = new pzHttpRequest(__myself.pz2String, __myself.errorHandler);
 143             request.get(
 144                 { "command": "init" },
 145                 function(data) {
 146                     if ( data.getElementsByTagName("status")[0].childNodes[0].nodeValue == "OK" ) {
 147                         if ( data.getElementsByTagName("protocol")[0].childNodes[0].nodeValue != __myself.suppProtoVer )
 148                             throw new Error("Server's protocol not supported by the client");
 149                         __myself.initStatusOK = true;
 150                         __myself.sessionID = data.getElementsByTagName("session")[0].childNodes[0].nodeValue;
 151                         setTimeout("__myself.ping()", __myself.keepAlive);
 152                     }
 153                     else
 154                         // if it gets here the http return code was 200 (pz2 errors are 417)
 155                         // but the response was invalid, it should never occur
 156                         setTimeout("__myself.init()", 1000);
 157                 }
 158             );
 159         } else {
 160             __myself.initStatusOK = true;
 161         }
 162     },
 163     // no need to ping explicitly
 164     ping: function ()
 165     {
 166         if( !__myself.initStatusOK )
 167             return;
 168             // session is not initialized code here
 169         var request = new pzHttpRequest(__myself.pz2String, __myself.errorHandler);
 170         request.get(
 171             { "command": "ping", "session": __myself.sessionID },
 172             function(data) {
 173                 if ( data.getElementsByTagName("status")[0].childNodes[0].nodeValue == "OK" ) {
 174                     __myself.pingStatusOK = true;
 175                     setTimeout("__myself.ping()", __myself.keepAlive);
 176                 }
 177                 else
 178                     // if it gets here the http return code was 200 (pz2 errors are 417)
 179                     // but the response was invalid, it should never occur
 180                     setTimeout("__myself.ping()", 1000);
 181             }
 182         );
 183     },
 184     search: function (query, num, sort, filter, showfrom)
 185     {
 186         clearTimeout(__myself.statTimer);
 187         clearTimeout(__myself.showTimer);
 188         clearTimeout(__myself.termTimer);
 189         clearTimeout(__myself.bytargetTimer);
 190
 191         __myself.showCounter = 0;
 192         __myself.termCounter = 0;
 193         __myself.bytargetCounter = 0;
 194         __myself.statCounter = 0;
 195
 196         if( !__myself.initStatusOK )
 197             return;
 198
 199         if( query !== undefined )
 200             __myself.currQuery = query;
 201         else
 202             throw new Error("You need to supply query to the search command");
 203
 204         if ( showfrom !== undefined )
 205             var start = showfrom;
 206         else
 207             var start = 0;
 208
 209         var searchParams = { "command": "search", "query": __myself.currQuery, "session": __myself.sessionID };
 210
 211         if (filter !== undefined)
 212             searchParams["filter"] = filter;
 213
 214         var request = new pzHttpRequest(__myself.pz2String, __myself.errorHandler);
 215         request.get(
 216             searchParams,
 217             function(data) {
 218                 if ( data.getElementsByTagName("status")[0].childNodes[0].nodeValue == "OK" ) {
 219                     __myself.searchStatusOK = true;
 220                     //piggyback search
 221                     __myself.show(start, num, sort);
 222                     if ( __myself.statCallback )
 223                         __myself.stat();
 224                         //__myself.statTimer = setTimeout("__myself.stat()", __myself.statTime / 4);
 225                     if ( __myself.termlistCallback )
 226                         __myself.termlist();
 227                         //__myself.termTimer = setTimeout("__myself.termlist()", __myself.termTime / 4);
 228                     if ( __myself.bytargetCallback )
 229                         __myself.bytarget();
 230                         //__myself.bytargetTimer = setTimeout("__myself.bytarget()", __myself.bytargetTime / 4);
 231                 }
 232                 else
 233                     // if it gets here the http return code was 200 (pz2 errors are 417)
 234                     // but the response was invalid, it should never occur
 235                     setTimeout("__myself.search(__myself.currQuery)", 500);
 236             }
 237         );
 238     },
 239     stat: function()
 240     {
 241         if( !__myself.initStatusOK )
 242             return;
 243         // if called explicitly takes precedence
 244         clearTimeout(__myself.statTimer);
 245         var request = new pzHttpRequest(__myself.pz2String, __myself.errorHandler);
 246         request.get(
 247             { "command": "stat", "session": __myself.sessionID },
 248             function(data) {
 249                 if ( data.getElementsByTagName("stat") ) {
 250                     var activeClients = Number( data.getElementsByTagName("activeclients")[0].childNodes[0].nodeValue );
 251                     __myself.activeClients = activeClients;
 252                     var stat = {
 253                     "activeclients": activeClients,
 254                     "hits": Number( data.getElementsByTagName("hits")[0].childNodes[0].nodeValue ),
 255                     "records": Number( data.getElementsByTagName("records")[0].childNodes[0].nodeValue ),
 256                     "clients": Number( data.getElementsByTagName("clients")[0].childNodes[0].nodeValue ),
 257                     "initializing": Number( data.getElementsByTagName("initializing")[0].childNodes[0].nodeValue ),
 258                     "searching": Number( data.getElementsByTagName("searching")[0].childNodes[0].nodeValue ),
 259                     "presenting": Number( data.getElementsByTagName("presenting")[0].childNodes[0].nodeValue ),
 260                     "idle": Number( data.getElementsByTagName("idle")[0].childNodes[0].nodeValue ),
 261                     "failed": Number( data.getElementsByTagName("failed")[0].childNodes[0].nodeValue ),
 262                     "error": Number( data.getElementsByTagName("error")[0].childNodes[0].nodeValue )
 263                     };
 264
 265                     __myself.statCounter++;
 266                     var delay = __myself.statTime + __myself.statCounter * __myself.dumpFactor;
 267                     if ( activeClients > 0 )
 268                         __myself.statTimer = setTimeout("__myself.stat()", delay);
 269
 270                     __myself.statCallback(stat);
 271                 }
 272                 else
 273                     // if it gets here the http return code was 200 (pz2 errors are 417)
 274                     // but the response was invalid, it should never occur
 275                     __myself.statTimer = setTimeout("__myself.stat()", __myself.statTime / 4);
 276             }
 277         );
 278     },
 279     show: function(start, num, sort)
 280     {
 281         if( !__myself.searchStatusOK )
 282             return;
 283         // if called explicitly takes precedence
 284         clearTimeout(__myself.showTimer);
 285
 286         if( sort !== undefined )
 287             __myself.currentSort = sort;
 288         if( start !== undefined )
 289             __myself.currentStart = Number( start );
 290         if( num !== undefined )
 291             __myself.currentNum = Number( num );
 292         var request = new pzHttpRequest(__myself.pz2String, __myself.errorHandler);
 293         var context = this;
 294         request.get(
 295             { "command": "show", "session": __myself.sessionID, "start": __myself.currentStart,
 296               "num": __myself.currentNum, "sort": __myself.currentSort, "block": 1 },
 297             function(data) {
 298                 if ( data.getElementsByTagName("status")[0].childNodes[0].nodeValue == "OK" ) {
 299                     // first parse the status data send along with records
 300                     // this is strictly bound to the format
 301                     var activeClients = Number( data.getElementsByTagName("activeclients")[0].childNodes[0].nodeValue );
 302                     __myself.activeClients = activeClients;
 303                     var show = {
 304                     "activeclients": activeClients,
 305                     "merged": Number( data.getElementsByTagName("merged")[0].childNodes[0].nodeValue ),
 306                     "total": Number( data.getElementsByTagName("total")[0].childNodes[0].nodeValue ),
 307                     "start": Number( data.getElementsByTagName("start")[0].childNodes[0].nodeValue ),
 308                     "num": Number( data.getElementsByTagName("num")[0].childNodes[0].nodeValue ),
 309                     "hits": []
 310                     };
 311                     // parse all the first-level nodes for all <hit> tags
 312                     var hits = data.getElementsByTagName("hit");
 313                     var hit = new Array();
 314                     for (i = 0; i < hits.length; i++) {
 315                         show.hits[i] = new Array();
 316                         show.hits[i]['location'] = new Array();
 317                         for ( j = 0; j < hits[i].childNodes.length; j++) {
 318                             var locCount = 0;
 319                             if ( hits[i].childNodes[j].nodeType == Node.ELEMENT_NODE ) {
 320                                 if (hits[i].childNodes[j].nodeName == 'location') {
 321                                     var locNode = hits[i].childNodes[j];
 322                                     var id = locNode.getAttribute('id');
 323                                     show.hits[i]['location'][id] = {
 324                                         "id": locNode.getAttribute("id"),
 325                                         "name": locNode.getAttribute("name")
 326                                     };
 327                                 }
 328                                 else {
 329                                     var nodeName = hits[i].childNodes[j].nodeName;
 330                                     var nodeText = 'ERROR'
 331                                     if ( hits[i].childNodes[j].firstChild )
 332                                         nodeText = hits[i].childNodes[j].firstChild.nodeValue;
 333                                     show.hits[i][nodeName] = nodeText;
 334                                 }
 335                             }
 336                         }
 337                     }
 338                     __myself.showCounter++;
 339                     var delay = __myself.showTime;
 340                     if (__myself.showCounter > __myself.showFastCount)
 341                             delay += __myself.showCounter * __myself.dumpFactor;
 342                     if ( activeClients > 0 )
 343                         __myself.showTimer = setTimeout("__myself.show()", delay);
 344
 345                     __myself.showCallback(show);
 346                 }
 347                 else
 348                     // if it gets here the http return code was 200 (pz2 errors are 417)
 349                     // but the response was invalid, it should never occur
 350                     __myself.showTimer = setTimeout("__myself.show()", __myself.showTime / 4);
 351             }
 352         );
 353     },
 354     record: function(id,offset, params)
 355     {
 356         if ( params == undefined )
 357             params = {};
 358
 359         if ( params.callback != undefined ) {
 360             callback = params.callback;
 361         } else {
 362             callback = __myself.recordCallback;
 363         }
 364
 365         if ( params['handle'] == undefined )
 366             handle = {};
 367         else
 368             handle = params['handle'];
 369
 370         if( !__myself.searchStatusOK && __myself.useSessions)
 371             return;
 372
 373         if( id !== undefined )
 374             __myself.currRecID = id;
 375         var request = new pzHttpRequest(__myself.pz2String, __myself.errorHandler);
 376
 377         var recordParams = { "command": "record", "session": __myself.sessionID, "id": __myself.currRecID };
 378         if (offset !== undefined) {
 379                 recordParams["offset"] = offset;
 380         }
 381
 382         if (params.syntax != undefined) {
 383             recordParams['syntax'] = params.syntax;
 384         }
 385
 386         __myself.currRecOffset = offset;
 387         request.get(
 388             recordParams,
 389             function(data) {
 390                 var recordNode;
 391                 var record = new Array();
 392                 record['xmlDoc'] = data;
 393                 if (__myself.currRecOffset !== undefined) {
 394                     record['offset'] = __myself.currRecOffset;
 395                     callback(record, handle);
 396                 } else if ( recordNode = data.getElementsByTagName("record")[0] ) {
 397                     // if stylesheet was fetched do not parse the response
 398                     if ( __myself.xslDoc ) {
 399                         record['recid'] = recordNode.getElementsByTagName("recid")[0].firstChild.nodeValue;
 400                         record['xslDoc'] = __myself.xslDoc;
 401                     } else {
 402                         for ( i = 0; i < recordNode.childNodes.length; i++) {
 403                             if ( recordNode.childNodes[i].nodeType == Node.ELEMENT_NODE
 404                                     && recordNode.childNodes[i].nodeName != 'location' ) {
 405                                 var nodeName = recordNode.childNodes[i].nodeName;
 406                                 var nodeText = recordNode.childNodes[i].firstChild.nodeValue;
 407                                 record[nodeName] = nodeText;
 408                             }
 409                         }
 410                         // the location might be empty!!
 411                         var locationNodes = recordNode.getElementsByTagName("location");
 412                         record["location"] = new Array();
 413                         for ( i = 0; i < locationNodes.length; i++ ) {
 414                             record["location"][i] = {
 415                                 "id": locationNodes[i].getAttribute("id"),
 416                                 "name": locationNodes[i].getAttribute("name")
 417                             };
 418
 419                             for ( j = 0; j < locationNodes[i].childNodes.length; j++) {
 420                                 if ( locationNodes[i].childNodes[j].nodeType == Node.ELEMENT_NODE ) {
 421                                     var nodeName = locationNodes[i].childNodes[j].nodeName;
 422                                     var nodeText = '';
 423                                     if (locationNodes[i].childNodes[j].firstChild)
 424                                             nodeText = locationNodes[i].childNodes[j].firstChild.nodeValue;
 425                                     record["location"][i][nodeName] = nodeText;
 426                                 }
 427                             }
 428                         }
 429                     }
 430
 431                     callback(record, handle);
 432                 }
 433                 else
 434                     // if it gets here the http return code was 200 (pz2 errors are 417)
 435                     // but the response was invalid, it should never occur
 436                     setTimeout("__myself.record(__myself.currRecID)", 500);
 437             }
 438         );
 439     },
 440     termlist: function()
 441     {
 442         if( !__myself.searchStatusOK )
 443             return;
 444         // if called explicitly takes precedence
 445         clearTimeout(__myself.termTimer);
 446         var request = new pzHttpRequest(__myself.pz2String, __myself.errorHandler);
 447         request.get(
 448             { "command": "termlist", "session": __myself.sessionID, "name": __myself.termKeys },
 449             function(data) {
 450                 if ( data.getElementsByTagName("termlist") ) {
 451                     var activeClients = Number( data.getElementsByTagName("activeclients")[0].childNodes[0].nodeValue );
 452                     __myself.activeClients = activeClients;
 453                     var termList = { "activeclients":  activeClients };
 454                     var termLists = data.getElementsByTagName("list");
 455                     //for each termlist
 456                     for (i = 0; i < termLists.length; i++) {
 457                         var listName = termLists[i].getAttribute('name');
 458                         termList[listName] = new Array();
 459                         var terms = termLists[i].getElementsByTagName('term');
 460                         //for each term in the list
 461                         for (j = 0; j < terms.length; j++) {
 462                             var term = {
 463                                 "name": (terms[j].getElementsByTagName("name")[0].childNodes.length
 464                                                 ? terms[j].getElementsByTagName("name")[0].childNodes[0].nodeValue
 465                                                 : 'ERROR'),
 466                                 "freq": terms[j].getElementsByTagName("frequency")[0].childNodes[0].nodeValue || 'ERROR'
 467                             };
 468
 469                             var termIdNode = terms[j].getElementsByTagName("id");
 470                             if(terms[j].getElementsByTagName("id").length)
 471                                 term["id"] = termIdNode[0].childNodes[0].nodeValue;
 472
 473                             termList[listName][j] = term;
 474                         }
 475                     }
 476
 477                     __myself.termCounter++;
 478                     var delay = __myself.termTime + __myself.termCounter * __myself.dumpFactor;
 479                     if ( activeClients > 0 )
 480                         __myself.termTimer = setTimeout("__myself.termlist()", delay);
 481
 482                    __myself.termlistCallback(termList);
 483                 }
 484                 else
 485                     // if it gets here the http return code was 200 (pz2 errors are 417)
 486                     // but the response was invalid, it should never occur
 487                     __myself.termTimer = setTimeout("__myself.termlist()", __myself.termTime / 4);
 488             }
 489         );
 490
 491     },
 492     bytarget: function()
 493     {
 494         if( !__myself.searchStatusOK )
 495             return;
 496         // if called explicitly takes precedence
 497         clearTimeout(__myself.bytargetTimer);
 498         var request = new pzHttpRequest(__myself.pz2String, __myself.errorHandler);
 499         request.get(
 500             { "command": "bytarget", "session": __myself.sessionID },
 501             function(data) {
 502                 if ( data.getElementsByTagName("status")[0].childNodes[0].nodeValue == "OK" ) {
 503                     var targetNodes = data.getElementsByTagName("target");
 504                     var bytarget = new Array();
 505                     for ( i = 0; i < targetNodes.length; i++) {
 506                         bytarget[i] = new Array();
 507                         for( j = 0; j < targetNodes[i].childNodes.length; j++ ) {
 508                             if ( targetNodes[i].childNodes[j].nodeType == Node.ELEMENT_NODE ) {
 509                                 var nodeName = targetNodes[i].childNodes[j].nodeName;
 510                                 var nodeText = targetNodes[i].childNodes[j].firstChild.nodeValue;
 511                                 bytarget[i][nodeName] = nodeText;
 512                             }
 513                         }
 514                     }
 515
 516                     __myself.bytargetCounter++;
 517                     var delay = __myself.bytargetTime + __myself.bytargetCounter * __myself.dumpFactor;
 518                     if ( __myself.activeClients > 0 )
 519                         __myself.bytargetTimer = setTimeout("__myself.bytarget()", delay);
 520
 521                     __myself.bytargetCallback(bytarget);
 522                 }
 523                 else
 524                     // if it gets here the http return code was 200 (pz2 errors are 417)
 525                     // but the response was invalid, it should never occur
 526                     __myself.bytargetTimer = setTimeout("__myself.bytarget()", __myself.bytargetTime / 4);
 527             }
 528         );
 529     },
 530     // just for testing, probably shouldn't be here
 531     showNext: function(page)
 532     {
 533         var step = page || 1;
 534         __myself.show( ( step * __myself.currentNum ) + __myself.currentStart );
 535     },
 536     showPrev: function(page)
 537     {
 538         if (__myself.currentStart == 0 )
 539             return false;
 540         var step = page || 1;
 541         var newStart = __myself.currentStart - (step * __myself.currentNum );
 542         __myself.show( newStart > 0 ? newStart : 0 );
 543     },
 544     showPage: function(pageNum)
 545     {
 546         //var page = pageNum || 1;
 547         __myself.show(pageNum * __myself.currentNum);
 548     }
 549 };
 550
 551 /*
 552 *********************************************************************************
 553 ** AJAX HELPER CLASS ************************************************************
 554 *********************************************************************************
 555 */
 556 var pzHttpRequest = function ( url, errorHandler ) {
 557         this.request = null;
 558         this.url = url;
 559         this.errorHandler = errorHandler || null;
 560         this.async = true;
 561
 562         if ( window.XMLHttpRequest ) {
 563             this.request = new XMLHttpRequest();
 564         } else if ( window.ActiveXObject ) {
 565             try {
 566                 this.request = new ActiveXObject( 'Msxml2.XMLHTTP' );
 567             } catch (err) {
 568                 this.request = new ActiveXObject( 'Microsoft.XMLHTTP' );
 569             }
 570         }
 571 };
 572
 573 pzHttpRequest.prototype =
 574 {
 575     get: function ( params, callback )
 576     {
 577         this._send( 'GET', params, '', callback );
 578     },
 579
 580     post: function ( params, data, callback )
 581     {
 582         this._send( 'POST', params, data, callback );
 583     },
 584
 585     load: function ()
 586     {
 587         this.async = false;
 588         this.request.open( 'GET', this.url, this.async );
 589         this.request.send('');
 590         if ( this.request.status == 200 )
 591             return this.request.responseXML;
 592     },
 593
 594     _send: function ( type, params, data, callback )
 595     {
 596         this.callback = callback;
 597         var context = this;
 598         this.async = true;
 599         this.request.open( type, this._urlAppendParams(params), this.async );
 600         this.request.onreadystatechange = function () {
 601             context._handleResponse();
 602         }
 603         this.request.send(data);
 604     },
 605
 606     _urlAppendParams: function (params)
 607     {
 608         var getUrl = this.url;
 609
 610         var sep = '?';
 611         var el = params;
 612         for (var key in el) {
 613             if (el[key] != null) {
 614                 getUrl += sep + key + '=' + encodeURI(el[key]);
 615                 sep = '&';
 616             }
 617         }
 618         return getUrl;
 619     },
 620
 621     _handleResponse: function ()
 622     {
 623         if ( this.request.readyState == 4 ) {
 624             if ( this.request.status == 200 ) {
 625                 this.callback( this.request.responseXML );
 626             }
 627             // pz errors
 628             else if ( this.request.status == 417 ) {
 629                 var errMsg = this.request.responseXML.getElementsByTagName("error")[0].childNodes[0].nodeValue;
 630                 var errCode = this.request.responseXML.getElementsByTagName("error")[0].getAttribute("code");
 631
 632                 var err = new Error(errMsg);
 633                 err.code = errCode;
 634
 635                 if (this.errorHandler) {
 636                     this.errorHandler(err);
 637                 }
 638                 else {
 639                     throw err;
 640                 }
 641             }
 642             else {
 643                 var err = new Error("XMLHttpRequest error. STATUS: "
 644                             + this.request.status + " STATUS TEXT: "
 645                             + this.request.statusText );
 646                 err.code = 'HTTP';
 647
 648                 if (this.errorHandler) {
 649                     this.errorHandler(err);
 650                 }
 651                 else {
 652                     throw err;
 653                 }
 654             }
 655         }
 656     }
 657 };
 658
 659 /*
 660 *********************************************************************************
 661 ** XML HELPER CLASS ************************************************************
 662 *********************************************************************************
 663 */
 664
 665 // DOMDocument
 666
 667 if ( window.ActiveXObject) {
 668     var DOMDoc = document;
 669 } else {
 670     var DOMDoc = Document.prototype;
 671 }
 672
 673 DOMDoc.newXmlDoc = function ( root )
 674 {
 675     var doc;
 676
 677     if (document.implementation && document.implementation.createDocument) {
 678         doc = document.implementation.createDocument('', root, null);
 679     } else if ( window.ActiveXObject ) {
 680         doc = new ActiveXObject("MSXML2.DOMDocument");
 681         doc.loadXML('<' + root + '/>');
 682     } else {
 683         throw new Error ('No XML support in this browser');
 684     }
 685
 686     return doc;
 687 }
 688
 689
 690 DOMDoc.parseXmlFromString = function ( xmlString )
 691 {
 692     var doc;
 693
 694     if ( window.DOMParser ) {
 695         var parser = new DOMParser();
 696         doc = parser.parseFromString( xmlString, "text/xml");
 697     } else if ( window.ActiveXObject ) {
 698         doc = new ActiveXObject("MSXML2.DOMDocument");
 699         doc.loadXML( xmlString );
 700     } else {
 701         throw new Error ("No XML parsing support in this browser.");
 702     }
 703
 704     return doc;
 705 }
 706
 707 // DOMElement
 708
 709 Element_removeFromDoc = function (DOM_Element)
 710 {
 711     DOM_Element.parentNode.removeChild(DOM_Element);
 712 }
 713
 714 Element_emptyChildren = function (DOM_Element)
 715 {
 716     while( DOM_Element.firstChild ) {
 717         DOM_Element.removeChild( DOM_Element.firstChild )
 718     }
 719 }
 720
 721 Element_appendTransformResult = function ( DOM_Element, xmlDoc, xslDoc )
 722 {
 723     if ( window.XSLTProcessor ) {
 724         var proc = new XSLTProcessor();
 725         proc.importStylesheet( xslDoc );
 726         var docFrag = false;
 727         docFrag = proc.transformToFragment( xmlDoc, DOM_Element.ownerDocument );
 728         DOM_Element.appendChild(docFrag);
 729     } else if ( window.ActiveXObject ) {
 730         DOM_Element.innerHTML = xmlDoc.transformNode( xslDoc );
 731     } else {
 732         alert( 'Unable to perform XSLT transformation in this browser' );
 733     }
 734 }
 735
 736 Element_appendTextNode = function (DOM_Element, tagName, textContent )
 737 {
 738     var node = DOM_Element.ownerDocument.createElement(tagName);
 739     var text = DOM_Element.ownerDocument.createTextNode(textContent);
 740
 741     DOM_Element.appendChild(node);
 742     node.appendChild(text);
 743
 744     return node;
 745 }
 746
 747 Element_setTextContent = function ( DOM_Element, textContent )
 748 {
 749     if (typeof DOM_Element.textContent !== "undefined") {
 750         DOM_Element.textContent = textContent;
 751     } else if (typeof DOM_Element.innerText !== "undefined" ) {
 752         DOM_Element.innerText = textContent;
 753     } else {
 754         throw new Error("Cannot set text content of the node, no such method.");
 755     }
 756 }
 757
 758 Element_getTextContent = function (DOM_Element)
 759 {
 760     if (DOM_Element.textContent) {
 761         return DOM_Element.textContent;
 762     } else if (DOM_Element.text ) {
 763         return DOM_Element.text;
 764     } else {
 765         throw new Error("Cannot get text content of the node, no such method.");
 766     }
 767 }
 768
 769 /*
 770 *********************************************************************************
 771 ** QUERY CLASS ******************************************************************
 772 *********************************************************************************
 773 */
 774 var pzQuery = function()
 775 {
 776     this.simpleQuery = '';
 777     this.singleFilter = null;
 778     this.advTerms = new Array();
 779     this.filterHash = new Array();
 780     this.numTerms = 0;
 781     this.filterNums = 0;
 782 };
 783 pzQuery.prototype = {
 784     reset: function()
 785     {
 786         this.simpleQuery = '';
 787         this.advTerms = new Array();
 788         this.simpleFilter = null;
 789         this.numTerms = 0;
 790     },
 791     clearSimpleQuery: function()
 792     {
 793         this.simpleQuery = '';
 794     },
 795     addTerm: function(field, value)
 796     {
 797         var term = {"field": field, "value": value};
 798         this.advTerms[this.numTerms] = term;
 799         this.numTerms++;
 800     },
 801     getTermValueByIdx: function(index)
 802     {
 803         return this.advTerms[index].value;
 804     },
 805     getTermFieldByIdx: function(index)
 806     {
 807         return this.advTerms[index].field;
 808     },
 809     /* semicolon separated list of terms for given field*/
 810     getTermsByField: function(field)
 811     {
 812         var terms = '';
 813         for(var i = 0; i < this.advTerms.length; i++)
 814         {
 815             if( this.advTerms[i].field == field )
 816                 terms = terms + this.queryHas[i].value + ';';
 817         }
 818         return terms;
 819     },
 820     addTermsFromList: function(inputString, field)
 821     {
 822         var inputArr = inputString.split(';');
 823         for(var i=0; i < inputArr.length; i++)
 824         {
 825             if(inputArr[i].length < 3) continue;
 826             this.advTerms[this.numTerms] = {"field": field, "value": inputArr[i] };
 827             this.numTerms++;
 828         }
 829     },
 830     removeTermByIdx: function(index)
 831     {
 832         this.advTerms.splice(index, 1);
 833         this.numTerms--;
 834     },
 835     toCCL: function()
 836     {
 837         var ccl = '';
 838         if( this.simpleQuery != '')
 839             ccl = this.simpleQuery;
 840         for(var i = 0; i < this.advTerms.length; i++)
 841         {
 842             if (ccl != '') ccl = ccl + ' and ';
 843             ccl = ccl + this.advTerms[i].field+'="'+this.advTerms[i].value+'"';
 844         }
 845         return ccl;
 846     },
 847     addFilter: function(name, value)
 848     {
 849         var filter = {"name": name, "id": value };
 850         this.filterHash[this.filterHash.length] = filter;
 851         this.filterNums++
 852         return  this.filterHash.length - 1;
 853     },
 854     setFilter: function(name, value)
 855     {
 856         this.filterHash = new Array();
 857         this.filterNums = 0;
 858         this.addFilter(name, value);
 859     },
 860     getFilter: function(index)
 861     {
 862         return this.filterHash[index].id;
 863     },
 864     getFilterName: function(index)
 865     {
 866         return this.filterHash[index].name;
 867     },
 868     removeFilter: function(index)
 869     {
 870         delete this.filterHash[index];
 871         this.filterNums--;
 872     },
 873     clearFilter: function()
 874     {
 875         this.filterHash = new Array();
 876         this.filterNums = 0;
 877     },
 878     getFilterString: function()
 879     {
 880         //temporary
 881         if( this.singleFilter != null ) {
 882             return 'pz:id='+this.singleFilter.id;
 883         }
 884         else if( this.filterNums <= 0 ) {
 885             return undefined;
 886         }
 887
 888         var filter = 'pz:id=';
 889         for(var i = 0; i < this.filterHash.length; i++)
 890         {
 891             if (this.filterHash[i] == undefined) continue;
 892             if (filter > 'pz:id=') filter = filter + '|';
 893             filter += this.filterHash[i].id;
 894         }
 895         return filter;
 896     },
 897     totalLength: function()
 898     {
 899         var simpleLength = this.simpleQuery != '' ? 1 : 0;
 900         return this.advTerms.length + simpleLength;
 901     },
 902     clearSingleFilter: function()
 903     {
 904         this.singleFilter = null;
 905     },
 906     setSingleFilter: function(name, value)
 907     {
 908         this.singleFilter = {"name": name, "id": value };
 909     },
 910     getSingleFilterName: function()
 911     {
 912         return this.singleFilter.name;
 913     }
 914 }
 915
 916 }