js/pz2.js

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