js/pz2.js

   1 /*
   2 ** $Id: pz2.js,v 1.43 2007-07-02 20:55:07 adam 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 || "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.async = false;
  44         request.get(
  45                 [],
  46                 function ( doc ) {
  47                     __myself.xslDoc = doc;
  48                 }
  49         );
  50     }
  51
  52     // at least one callback required
  53     if ( !paramArray )
  54         throw new Error("An array with parameters has to be suplied when instantiating a class");
  55
  56     __myself.errorHandler = paramArray.errorhandler || null;
  57
  58     // function callbacks
  59     __myself.statCallback = paramArray.onstat || null;
  60     __myself.showCallback = paramArray.onshow || null;
  61     __myself.termlistCallback = paramArray.onterm || null;
  62     __myself.recordCallback = paramArray.onrecord || null;
  63     __myself.bytargetCallback = paramArray.onbytarget || null;
  64     __myself.resetCallback = paramArray.onreset || null;
  65
  66     // termlist keys
  67     __myself.termKeys = paramArray.termlist || "subject";
  68
  69     // some configurational stuff
  70     __myself.keepAlive = 50000;
  71
  72     __myself.sessionID = null;
  73     __myself.initStatusOK = false;
  74     __myself.pingStatusOK = false;
  75     __myself.searchStatusOK = false;
  76
  77     if ( paramArray.keepAlive < __myself.keepAlive )
  78         __myself.keepAlive = paramArray.keepAlive;
  79
  80     // for sorting
  81     __myself.currentSort = "relevance";
  82     // where are we?
  83     __myself.currentStart = 0;
  84     __myself.currentNum = 20;
  85
  86     // last full record retrieved
  87     __myself.currRecID = null;
  88     // current query
  89     __myself.currQuery = null;
  90
  91     //timers
  92     __myself.statTime = paramArray.stattime || 1000;
  93     __myself.statTimer = null;
  94     __myself.termTime = paramArray.termtime || 1000;
  95     __myself.termTimer = null;
  96     __myself.showTime = paramArray.showtime || 1000;
  97     __myself.showTimer = null;
  98     __myself.showFastCount = 4;
  99     __myself.bytargetTime = paramArray.bytargettime || 1000;
 100     __myself.bytargetTimer = null;
 101
 102     // counters for each command and applied delay
 103     __myself.dumpFactor = 500;
 104     __myself.showCounter = 0;
 105     __myself.termCounter = 0;
 106     __myself.statCounter = 0;
 107     __myself.bytargetCounter = 0;
 108
 109     // active clients, updated by stat and show
 110     // might be an issue since bytarget will poll accordingly
 111     __myself.activeClients = 1;
 112
 113     // auto init session?
 114     if (paramArray.autoInit !== false)
 115         __myself.init();
 116 };
 117 pz2.prototype =
 118 {
 119    stop: function ()
 120    {
 121        clearTimeout(__myself.statTimer);
 122        clearTimeout(__myself.showTimer);
 123        clearTimeout(__myself.termTimer);
 124        clearTimeout(__myself.bytargetTimer);
 125     },
 126
 127     reset: function ()
 128     {
 129         __myself.sessionID = null;
 130         __myself.initStatusOK = false;
 131         __myself.pingStatusOK = false;
 132         __myself.searchStatusOK = false;
 133
 134         __myself.stop();
 135
 136         if ( __myself.resetCallback )
 137                 __myself.resetCallback();
 138     },
 139     init: function ( sessionId )
 140     {
 141         __myself.reset();
 142
 143         if ( sessionId != undefined ) {
 144             __myself.initStatusOK = true;
 145             __myself.sessionID = sessionId;
 146             __myself.ping();
 147         } else if (__myself.useSessions) {
 148             var request = new pzHttpRequest(__myself.pz2String, __myself.errorHandler);
 149             request.get(
 150                 { "command": "init" },
 151                 function(data) {
 152                     if ( data.getElementsByTagName("status")[0].childNodes[0].nodeValue == "OK" ) {
 153                         if ( data.getElementsByTagName("protocol")[0].childNodes[0].nodeValue != __myself.suppProtoVer )
 154                             throw new Error("Server's protocol not supported by the client");
 155                         __myself.initStatusOK = true;
 156                         __myself.sessionID = data.getElementsByTagName("session")[0].childNodes[0].nodeValue;
 157                         setTimeout("__myself.ping()", __myself.keepAlive);
 158                     }
 159                     else
 160                         // if it gets here the http return code was 200 (pz2 errors are 417)
 161                         // but the response was invalid, it should never occur
 162                         setTimeout("__myself.init()", 1000);
 163                 }
 164             );
 165         } else {
 166             __myself.initStatusOK = true;
 167         }
 168     },
 169     // no need to ping explicitly
 170     ping: function ()
 171     {
 172         if( !__myself.initStatusOK )
 173             return;
 174             // session is not initialized code here
 175         var request = new pzHttpRequest(__myself.pz2String, __myself.errorHandler);
 176         request.get(
 177             { "command": "ping", "session": __myself.sessionID },
 178             function(data) {
 179                 if ( data.getElementsByTagName("status")[0].childNodes[0].nodeValue == "OK" ) {
 180                     __myself.pingStatusOK = true;
 181                     setTimeout("__myself.ping()", __myself.keepAlive);
 182                 }
 183                 else
 184                     // if it gets here the http return code was 200 (pz2 errors are 417)
 185                     // but the response was invalid, it should never occur
 186                     setTimeout("__myself.ping()", 1000);
 187             }
 188         );
 189     },
 190     search: function (query, num, sort, filter)
 191     {
 192         clearTimeout(__myself.statTimer);
 193         clearTimeout(__myself.showTimer);
 194         clearTimeout(__myself.termTimer);
 195         clearTimeout(__myself.bytargetTimer);
 196
 197         __myself.showCounter = 0;
 198         __myself.termCounter = 0;
 199         __myself.bytargetCounter = 0;
 200         __myself.statCounter = 0;
 201
 202         if( !__myself.initStatusOK )
 203             return;
 204
 205         if( query !== undefined )
 206             __myself.currQuery = query;
 207         else
 208             throw new Error("You need to supply query to the search command");
 209
 210         var searchParams = { "command": "search", "query": __myself.currQuery, "session": __myself.sessionID };
 211
 212         if (filter !== undefined)
 213             searchParams["filter"] = filter;
 214
 215         var request = new pzHttpRequest(__myself.pz2String, __myself.errorHandler);
 216         request.get(
 217             searchParams,
 218             function(data) {
 219                 if ( data.getElementsByTagName("status")[0].childNodes[0].nodeValue == "OK" ) {
 220                     __myself.searchStatusOK = true;
 221                     //piggyback search
 222                     __myself.show(0, num, sort);
 223                     if ( __myself.statCallback )
 224                         __myself.stat();
 225                         //__myself.statTimer = setTimeout("__myself.stat()", __myself.statTime / 4);
 226                     if ( __myself.termlistCallback )
 227                         __myself.termlist();
 228                         //__myself.termTimer = setTimeout("__myself.termlist()", __myself.termTime / 4);
 229                     if ( __myself.bytargetCallback )
 230                         __myself.bytarget();
 231                         //__myself.bytargetTimer = setTimeout("__myself.bytarget()", __myself.bytargetTime / 4);
 232                 }
 233                 else
 234                     // if it gets here the http return code was 200 (pz2 errors are 417)
 235                     // but the response was invalid, it should never occur
 236                     setTimeout("__myself.search(__myself.currQuery)", 500);
 237             }
 238         );
 239     },
 240     stat: function()
 241     {
 242         if( !__myself.initStatusOK )
 243             return;
 244         // if called explicitly takes precedence
 245         clearTimeout(__myself.statTimer);
 246         var request = new pzHttpRequest(__myself.pz2String, __myself.errorHandler);
 247         request.get(
 248             { "command": "stat", "session": __myself.sessionID },
 249             function(data) {
 250                 if ( data.getElementsByTagName("stat") ) {
 251                     var activeClients = Number( data.getElementsByTagName("activeclients")[0].childNodes[0].nodeValue );
 252                     __myself.activeClients = activeClients;
 253                     var stat = {
 254                     "activeclients": activeClients,
 255                     "hits": Number( data.getElementsByTagName("hits")[0].childNodes[0].nodeValue ),
 256                     "records": Number( data.getElementsByTagName("records")[0].childNodes[0].nodeValue ),
 257                     "clients": Number( data.getElementsByTagName("clients")[0].childNodes[0].nodeValue ),
 258                     "initializing": Number( data.getElementsByTagName("initializing")[0].childNodes[0].nodeValue ),
 259                     "searching": Number( data.getElementsByTagName("searching")[0].childNodes[0].nodeValue ),
 260                     "presenting": Number( data.getElementsByTagName("presenting")[0].childNodes[0].nodeValue ),
 261                     "idle": Number( data.getElementsByTagName("idle")[0].childNodes[0].nodeValue ),
 262                     "failed": Number( data.getElementsByTagName("failed")[0].childNodes[0].nodeValue ),
 263                     "error": Number( data.getElementsByTagName("error")[0].childNodes[0].nodeValue )
 264                     };
 265
 266                     __myself.statCounter++;
 267                     var delay = __myself.statTime + __myself.statCounter * __myself.dumpFactor;
 268                     if ( activeClients > 0 )
 269                         __myself.statTimer = setTimeout("__myself.stat()", delay);
 270
 271                     __myself.statCallback(stat);
 272                 }
 273                 else
 274                     // if it gets here the http return code was 200 (pz2 errors are 417)
 275                     // but the response was invalid, it should never occur
 276                     __myself.statTimer = setTimeout("__myself.stat()", __myself.statTime / 4);
 277             }
 278         );
 279     },
 280     show: function(start, num, sort)
 281     {
 282         if( !__myself.searchStatusOK )
 283             return;
 284         // if called explicitly takes precedence
 285         clearTimeout(__myself.showTimer);
 286
 287         if( sort !== undefined )
 288             __myself.currentSort = sort;
 289         if( start !== undefined )
 290             __myself.currentStart = Number( start );
 291         if( num !== undefined )
 292             __myself.currentNum = Number( num );
 293         var request = new pzHttpRequest(__myself.pz2String, __myself.errorHandler);
 294         var context = this;
 295         request.get(
 296             { "command": "show", "session": __myself.sessionID, "start": __myself.currentStart,
 297               "num": __myself.currentNum, "sort": __myself.currentSort, "block": 1 },
 298             function(data) {
 299                 if ( data.getElementsByTagName("status")[0].childNodes[0].nodeValue == "OK" ) {
 300                     // first parse the status data send along with records
 301                     // this is strictly bound to the format
 302                     var activeClients = Number( data.getElementsByTagName("activeclients")[0].childNodes[0].nodeValue );
 303                     __myself.activeClients = activeClients;
 304                     var show = {
 305                     "activeclients": activeClients,
 306                     "merged": Number( data.getElementsByTagName("merged")[0].childNodes[0].nodeValue ),
 307                     "total": Number( data.getElementsByTagName("total")[0].childNodes[0].nodeValue ),
 308                     "start": Number( data.getElementsByTagName("start")[0].childNodes[0].nodeValue ),
 309                     "num": Number( data.getElementsByTagName("num")[0].childNodes[0].nodeValue ),
 310                     "hits": []
 311                     };
 312                     // parse all the first-level nodes for all <hit> tags
 313                     var hits = data.getElementsByTagName("hit");
 314                     var hit = new Array();
 315                     for (i = 0; i < hits.length; i++) {
 316                         show.hits[i] = new Array();
 317                         show.hits[i]['location'] = new Array();
 318                         for ( j = 0; j < hits[i].childNodes.length; j++) {
 319                             var locCount = 0;
 320                             if ( hits[i].childNodes[j].nodeType == Node.ELEMENT_NODE ) {
 321                                 if (hits[i].childNodes[j].nodeName == 'location') {
 322                                     var locNode = hits[i].childNodes[j];
 323                                     var id = locNode.getAttribute('id');
 324                                     show.hits[i]['location'][id] = {
 325                                         "id": locNode.getAttribute("id"),
 326                                         "name": locNode.getAttribute("name")
 327                                     };
 328                                 }
 329                                 else {
 330                                     var nodeName = hits[i].childNodes[j].nodeName;
 331                                     var nodeText = 'ERROR'
 332                                     if ( hits[i].childNodes[j].firstChild )
 333                                         nodeText = hits[i].childNodes[j].firstChild.nodeValue;
 334                                     show.hits[i][nodeName] = nodeText;
 335                                 }
 336                             }
 337                         }
 338                     }
 339                     __myself.showCounter++;
 340                     var delay = __myself.showTime;
 341                     if (__myself.showCounter > __myself.showFastCount)
 342                             delay += __myself.showCounter * __myself.dumpFactor;
 343                     if ( activeClients > 0 )
 344                         __myself.showTimer = setTimeout("__myself.show()", delay);
 345
 346                     __myself.showCallback(show);
 347                 }
 348                 else
 349                     // if it gets here the http return code was 200 (pz2 errors are 417)
 350                     // but the response was invalid, it should never occur
 351                     __myself.showTimer = setTimeout("__myself.show()", __myself.showTime / 4);
 352             }
 353         );
 354     },
 355     record: function(id,offset)
 356     {
 357         if( !__myself.searchStatusOK && __myself.useSessions)
 358             return;
 359
 360         if( id !== undefined )
 361             __myself.currRecID = id;
 362         var request = new pzHttpRequest(__myself.pz2String, __myself.errorHandler);
 363
 364         var recordParams = { "command": "record", "session": __myself.sessionID, "id": __myself.currRecID };
 365         if (offset !== undefined) {
 366                 recordParams["offset"] = offset;
 367                 recordParams["syntax"] = "usmarc";
 368                 recordParams["esn"] = "F";
 369         }
 370         __myself.currRecOffset = offset;
 371         request.get(
 372             recordParams,
 373             function(data) {
 374                 var recordNode;
 375                 var record = new Array();
 376                 record['xmlDoc'] = data;
 377                 if (__myself.currRecOffset !== undefined) {
 378                     record['offset'] = __myself.currRecOffset;
 379                     __myself.recordCallback(record);
 380                 } else if ( recordNode = data.getElementsByTagName("record")[0] ) {
 381                     // if stylesheet was fetched do not parse the response
 382                     if ( __myself.xslDoc ) {
 383                         record['recid'] = recordNode.getElementsByTagName("recid")[0].firstChild.nodeValue;
 384                         record['xslDoc'] = __myself.xslDoc;
 385                     } else {
 386                         for ( i = 0; i < recordNode.childNodes.length; i++) {
 387                             if ( recordNode.childNodes[i].nodeType == Node.ELEMENT_NODE
 388                                     && recordNode.childNodes[i].nodeName != 'location' ) {
 389                                 var nodeName = recordNode.childNodes[i].nodeName;
 390                                 var nodeText = recordNode.childNodes[i].firstChild.nodeValue;
 391                                 record[nodeName] = nodeText;
 392                             }
 393                         }
 394                         // the location might be empty!!
 395                         var locationNodes = recordNode.getElementsByTagName("location");
 396                         record["location"] = new Array();
 397                         for ( i = 0; i < locationNodes.length; i++ ) {
 398                             record["location"][i] = {
 399                                 "id": locationNodes[i].getAttribute("id"),
 400                                 "name": locationNodes[i].getAttribute("name")
 401                             };
 402
 403                             for ( j = 0; j < locationNodes[i].childNodes.length; j++) {
 404                                 if ( locationNodes[i].childNodes[j].nodeType == Node.ELEMENT_NODE ) {
 405                                     var nodeName = locationNodes[i].childNodes[j].nodeName;
 406                                     var nodeText = '';
 407                                     if (locationNodes[i].childNodes[j].firstChild)
 408                                             nodeText = locationNodes[i].childNodes[j].firstChild.nodeValue;
 409                                     record["location"][i][nodeName] = nodeText;
 410                                 }
 411                             }
 412                         }
 413                     }
 414
 415                     __myself.recordCallback(record);
 416                 }
 417                 else
 418                     // if it gets here the http return code was 200 (pz2 errors are 417)
 419                     // but the response was invalid, it should never occur
 420                     setTimeout("__myself.record(__myself.currRecID)", 500);
 421             }
 422         );
 423     },
 424     termlist: function()
 425     {
 426         if( !__myself.searchStatusOK )
 427             return;
 428         // if called explicitly takes precedence
 429         clearTimeout(__myself.termTimer);
 430         var request = new pzHttpRequest(__myself.pz2String, __myself.errorHandler);
 431         request.get(
 432             { "command": "termlist", "session": __myself.sessionID, "name": __myself.termKeys },
 433             function(data) {
 434                 if ( data.getElementsByTagName("termlist") ) {
 435                     var activeClients = Number( data.getElementsByTagName("activeclients")[0].childNodes[0].nodeValue );
 436                     __myself.activeClients = activeClients;
 437                     var termList = { "activeclients":  activeClients };
 438                     var termLists = data.getElementsByTagName("list");
 439                     //for each termlist
 440                     for (i = 0; i < termLists.length; i++) {
 441                         var listName = termLists[i].getAttribute('name');
 442                         termList[listName] = new Array();
 443                         var terms = termLists[i].getElementsByTagName('term');
 444                         //for each term in the list
 445                         for (j = 0; j < terms.length; j++) {
 446                             var term = {
 447                                 "name": (terms[j].getElementsByTagName("name")[0].childNodes.length
 448                                                 ? terms[j].getElementsByTagName("name")[0].childNodes[0].nodeValue
 449                                                 : 'ERROR'),
 450                                 "freq": terms[j].getElementsByTagName("frequency")[0].childNodes[0].nodeValue || 'ERROR'
 451                             };
 452
 453                             var termIdNode = terms[j].getElementsByTagName("id");
 454                             if(terms[j].getElementsByTagName("id").length)
 455                                 term["id"] = termIdNode[0].childNodes[0].nodeValue;
 456
 457                             termList[listName][j] = term;
 458                         }
 459                     }
 460
 461                     __myself.termCounter++;
 462                     var delay = __myself.termTime + __myself.termCounter * __myself.dumpFactor;
 463                     if ( activeClients > 0 )
 464                         __myself.termTimer = setTimeout("__myself.termlist()", delay);
 465
 466                    __myself.termlistCallback(termList);
 467                 }
 468                 else
 469                     // if it gets here the http return code was 200 (pz2 errors are 417)
 470                     // but the response was invalid, it should never occur
 471                     __myself.termTimer = setTimeout("__myself.termlist()", __myself.termTime / 4);
 472             }
 473         );
 474
 475     },
 476     bytarget: function()
 477     {
 478         if( !__myself.searchStatusOK )
 479             return;
 480         // if called explicitly takes precedence
 481         clearTimeout(__myself.bytargetTimer);
 482         var request = new pzHttpRequest(__myself.pz2String, __myself.errorHandler);
 483         request.get(
 484             { "command": "bytarget", "session": __myself.sessionID },
 485             function(data) {
 486                 if ( data.getElementsByTagName("status")[0].childNodes[0].nodeValue == "OK" ) {
 487                     var targetNodes = data.getElementsByTagName("target");
 488                     var bytarget = new Array();
 489                     for ( i = 0; i < targetNodes.length; i++) {
 490                         bytarget[i] = new Array();
 491                         for( j = 0; j < targetNodes[i].childNodes.length; j++ ) {
 492                             if ( targetNodes[i].childNodes[j].nodeType == Node.ELEMENT_NODE ) {
 493                                 var nodeName = targetNodes[i].childNodes[j].nodeName;
 494                                 var nodeText = targetNodes[i].childNodes[j].firstChild.nodeValue;
 495                                 bytarget[i][nodeName] = nodeText;
 496                             }
 497                         }
 498                     }
 499
 500                     __myself.bytargetCounter++;
 501                     var delay = __myself.bytargetTime + __myself.bytargetCounter * __myself.dumpFactor;
 502                     if ( __myself.activeClients > 0 )
 503                         __myself.bytargetTimer = setTimeout("__myself.bytarget()", delay);
 504
 505                     __myself.bytargetCallback(bytarget);
 506                 }
 507                 else
 508                     // if it gets here the http return code was 200 (pz2 errors are 417)
 509                     // but the response was invalid, it should never occur
 510                     __myself.bytargetTimer = setTimeout("__myself.bytarget()", __myself.bytargetTime / 4);
 511             }
 512         );
 513     },
 514     // just for testing, probably shouldn't be here
 515     showNext: function(page)
 516     {
 517         var step = page || 1;
 518         __myself.show( ( step * __myself.currentNum ) + __myself.currentStart );
 519     },
 520     showPrev: function(page)
 521     {
 522         if (__myself.currentStart == 0 )
 523             return false;
 524         var step = page || 1;
 525         var newStart = __myself.currentStart - (step * __myself.currentNum );
 526         __myself.show( newStart > 0 ? newStart : 0 );
 527     },
 528     showPage: function(pageNum)
 529     {
 530         //var page = pageNum || 1;
 531         __myself.show(pageNum * __myself.currentNum);
 532     }
 533 };
 534
 535 /*
 536 *********************************************************************************
 537 ** AJAX HELPER CLASS ************************************************************
 538 *********************************************************************************
 539 */
 540 var pzHttpRequest = function ( url, errorHandler ) {
 541         this.request = null;
 542         this.url = url;
 543         this.errorHandler = errorHandler || null;
 544         this.async = true;
 545
 546         if ( window.XMLHttpRequest ) {
 547             this.request = new XMLHttpRequest();
 548         } else if ( window.ActiveXObject ) {
 549             try {
 550                 this.request = new ActiveXObject( 'Msxml2.XMLHTTP' );
 551             } catch (err) {
 552                 this.request = new ActiveXObject( 'Microsoft.XMLHTTP' );
 553             }
 554         }
 555 };
 556
 557 pzHttpRequest.prototype =
 558 {
 559     get: function ( params, callback )
 560     {
 561         this._send( 'GET', params, null, callback );
 562     },
 563
 564     post: function ( params, data, callback )
 565     {
 566         this._send( 'POST', params, data, callback );
 567     },
 568
 569     _send: function ( type, params, data, callback )
 570     {
 571         this.callback = callback;
 572         var context = this;
 573         this.request.open( type, this._urlAppendParams(params), this.async );
 574         //this.request.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
 575         this.request.onreadystatechange = function () {
 576             context._handleResponse();
 577         }
 578         this.request.send(data);
 579     },
 580
 581     _urlAppendParams: function (params)
 582     {
 583         var getUrl = this.url;
 584
 585         var sep = '?';
 586         var el = params;
 587         for (var key in el) {
 588             if (el[key] != null) {
 589                 getUrl += sep + key + '=' + encodeURI(el[key]);
 590                 sep = '&';
 591             }
 592         }
 593         return getUrl;
 594     },
 595
 596     _handleResponse: function ()
 597     {
 598         if ( this.request.readyState == 4 ) {
 599             if ( this.request.status == 200 ) {
 600                 this.callback( this.request.responseXML );
 601             }
 602             // pz errors
 603             else if ( this.request.status == 417 ) {
 604                 var errMsg = this.request.responseXML.getElementsByTagName("error")[0].childNodes[0].nodeValue;
 605                 var errCode = this.request.responseXML.getElementsByTagName("error")[0].getAttribute("code");
 606
 607                 var err = new Error(errMsg);
 608                 err.code = errCode;
 609
 610                 if (this.errorHandler) {
 611                     this.errorHandler(err);
 612                 }
 613                 else {
 614                     throw err;
 615                 }
 616             }
 617             else {
 618                 var err = new Error("XMLHttpRequest error. STATUS: "
 619                             + this.request.status + " STATUS TEXT: "
 620                             + this.request.statusText );
 621                 err.code = 'HTTP';
 622
 623                 if (this.errorHandler) {
 624                     this.errorHandler(err);
 625                 }
 626                 else {
 627                     throw err;
 628                 }
 629             }
 630         }
 631     }
 632 };
 633
 634 /*
 635 *********************************************************************************
 636 ** QUERY CLASS ******************************************************************
 637 *********************************************************************************
 638 */
 639 var pzQuery = function()
 640 {
 641     this.simpleQuery = '';
 642     this.singleFilter = null;
 643     this.advTerms = new Array();
 644     this.filterHash = new Array();
 645     this.numTerms = 0;
 646     this.filterNums = 0;
 647 };
 648 pzQuery.prototype = {
 649     reset: function()
 650     {
 651         this.simpleQuery = '';
 652         this.advTerms = new Array();
 653         this.simpleFilter = null;
 654         this.numTerms = 0;
 655     },
 656     clearSimpleQuery: function()
 657     {
 658         this.simpleQuery = '';
 659     },
 660     addTerm: function(field, value)
 661     {
 662         var term = {"field": field, "value": value};
 663         this.advTerms[this.numTerms] = term;
 664         this.numTerms++;
 665     },
 666     getTermValueByIdx: function(index)
 667     {
 668         return this.advTerms[index].value;
 669     },
 670     getTermFieldByIdx: function(index)
 671     {
 672         return this.advTerms[index].field;
 673     },
 674     /* semicolon separated list of terms for given field*/
 675     getTermsByField: function(field)
 676     {
 677         var terms = '';
 678         for(var i = 0; i < this.advTerms.length; i++)
 679         {
 680             if( this.advTerms[i].field == field )
 681                 terms = terms + this.queryHas[i].value + ';';
 682         }
 683         return terms;
 684     },
 685     addTermsFromList: function(inputString, field)
 686     {
 687         var inputArr = inputString.split(';');
 688         for(var i=0; i < inputArr.length; i++)
 689         {
 690             if(inputArr[i].length < 3) continue;
 691             this.advTerms[this.numTerms] = {"field": field, "value": inputArr[i] };
 692             this.numTerms++;
 693         }
 694     },
 695     removeTermByIdx: function(index)
 696     {
 697         this.advTerms.splice(index, 1);
 698         this.numTerms--;
 699     },
 700     toCCL: function()
 701     {
 702         var ccl = '';
 703         if( this.simpleQuery != '')
 704             ccl = this.simpleQuery;
 705         for(var i = 0; i < this.advTerms.length; i++)
 706         {
 707             if (ccl != '') ccl = ccl + ' and ';
 708             ccl = ccl + this.advTerms[i].field+'="'+this.advTerms[i].value+'"';
 709         }
 710         return ccl;
 711     },
 712     addFilter: function(name, value)
 713     {
 714         var filter = {"name": name, "id": value };
 715         this.filterHash[this.filterHash.length] = filter;
 716         this.filterNums++
 717         return  this.filterHash.length - 1;
 718     },
 719     setFilter: function(name, value)
 720     {
 721         this.filterHash = new Array();
 722         this.filterNums = 0;
 723         this.addFilter(name, value);
 724     },
 725     getFilter: function(index)
 726     {
 727         return this.filterHash[index].id;
 728     },
 729     getFilterName: function(index)
 730     {
 731         return this.filterHash[index].name;
 732     },
 733     removeFilter: function(index)
 734     {
 735         delete this.filterHash[index];
 736         this.filterNums--;
 737     },
 738     clearFilter: function()
 739     {
 740         this.filterHash = new Array();
 741         this.filterNums = 0;
 742     },
 743     getFilterString: function()
 744     {
 745         //temporary
 746         if( this.singleFilter != null ) {
 747             return 'pz:id='+this.singleFilter.id;
 748         }
 749         else if( this.filterNums <= 0 ) {
 750             return undefined;
 751         }
 752
 753         var filter = 'pz:id=';
 754         for(var i = 0; i < this.filterHash.length; i++)
 755         {
 756             if (this.filterHash[i] == undefined) continue;
 757             if (filter > 'pz:id=') filter = filter + '|';
 758             filter += this.filterHash[i].id;
 759         }
 760         return filter;
 761     },
 762     totalLength: function()
 763     {
 764         var simpleLength = this.simpleQuery != '' ? 1 : 0;
 765         return this.advTerms.length + simpleLength;
 766     },
 767     clearSingleFilter: function()
 768     {
 769         this.singleFilter = null;
 770     },
 771     setSingleFilter: function(name, value)
 772     {
 773         this.singleFilter = {"name": name, "id": value };
 774     },
 775     getSingleFilterName: function()
 776     {
 777         return this.singleFilter.name;
 778     }
 779 }
 780
 781 }