js/pz2.js

   1 /*
   2 ** $Id: pz2.js,v 1.46 2007-07-12 11:49:20 sondberg 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( {}, 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)
 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         var searchParams = { "command": "search", "query": __myself.currQuery, "session": __myself.sessionID };
 205
 206         if (filter !== undefined)
 207             searchParams["filter"] = filter;
 208
 209         var request = new pzHttpRequest(__myself.pz2String, __myself.errorHandler);
 210         request.get(
 211             searchParams,
 212             function(data) {
 213                 if ( data.getElementsByTagName("status")[0].childNodes[0].nodeValue == "OK" ) {
 214                     __myself.searchStatusOK = true;
 215                     //piggyback search
 216                     __myself.show(0, num, sort);
 217                     if ( __myself.statCallback )
 218                         __myself.stat();
 219                         //__myself.statTimer = setTimeout("__myself.stat()", __myself.statTime / 4);
 220                     if ( __myself.termlistCallback )
 221                         __myself.termlist();
 222                         //__myself.termTimer = setTimeout("__myself.termlist()", __myself.termTime / 4);
 223                     if ( __myself.bytargetCallback )
 224                         __myself.bytarget();
 225                         //__myself.bytargetTimer = setTimeout("__myself.bytarget()", __myself.bytargetTime / 4);
 226                 }
 227                 else
 228                     // if it gets here the http return code was 200 (pz2 errors are 417)
 229                     // but the response was invalid, it should never occur
 230                     setTimeout("__myself.search(__myself.currQuery)", 500);
 231             }
 232         );
 233     },
 234     stat: function()
 235     {
 236         if( !__myself.initStatusOK )
 237             return;
 238         // if called explicitly takes precedence
 239         clearTimeout(__myself.statTimer);
 240         var request = new pzHttpRequest(__myself.pz2String, __myself.errorHandler);
 241         request.get(
 242             { "command": "stat", "session": __myself.sessionID },
 243             function(data) {
 244                 if ( data.getElementsByTagName("stat") ) {
 245                     var activeClients = Number( data.getElementsByTagName("activeclients")[0].childNodes[0].nodeValue );
 246                     __myself.activeClients = activeClients;
 247                     var stat = {
 248                     "activeclients": activeClients,
 249                     "hits": Number( data.getElementsByTagName("hits")[0].childNodes[0].nodeValue ),
 250                     "records": Number( data.getElementsByTagName("records")[0].childNodes[0].nodeValue ),
 251                     "clients": Number( data.getElementsByTagName("clients")[0].childNodes[0].nodeValue ),
 252                     "initializing": Number( data.getElementsByTagName("initializing")[0].childNodes[0].nodeValue ),
 253                     "searching": Number( data.getElementsByTagName("searching")[0].childNodes[0].nodeValue ),
 254                     "presenting": Number( data.getElementsByTagName("presenting")[0].childNodes[0].nodeValue ),
 255                     "idle": Number( data.getElementsByTagName("idle")[0].childNodes[0].nodeValue ),
 256                     "failed": Number( data.getElementsByTagName("failed")[0].childNodes[0].nodeValue ),
 257                     "error": Number( data.getElementsByTagName("error")[0].childNodes[0].nodeValue )
 258                     };
 259
 260                     __myself.statCounter++;
 261                     var delay = __myself.statTime + __myself.statCounter * __myself.dumpFactor;
 262                     if ( activeClients > 0 )
 263                         __myself.statTimer = setTimeout("__myself.stat()", delay);
 264
 265                     __myself.statCallback(stat);
 266                 }
 267                 else
 268                     // if it gets here the http return code was 200 (pz2 errors are 417)
 269                     // but the response was invalid, it should never occur
 270                     __myself.statTimer = setTimeout("__myself.stat()", __myself.statTime / 4);
 271             }
 272         );
 273     },
 274     show: function(start, num, sort)
 275     {
 276         if( !__myself.searchStatusOK )
 277             return;
 278         // if called explicitly takes precedence
 279         clearTimeout(__myself.showTimer);
 280
 281         if( sort !== undefined )
 282             __myself.currentSort = sort;
 283         if( start !== undefined )
 284             __myself.currentStart = Number( start );
 285         if( num !== undefined )
 286             __myself.currentNum = Number( num );
 287         var request = new pzHttpRequest(__myself.pz2String, __myself.errorHandler);
 288         var context = this;
 289         request.get(
 290             { "command": "show", "session": __myself.sessionID, "start": __myself.currentStart,
 291               "num": __myself.currentNum, "sort": __myself.currentSort, "block": 1 },
 292             function(data) {
 293                 if ( data.getElementsByTagName("status")[0].childNodes[0].nodeValue == "OK" ) {
 294                     // first parse the status data send along with records
 295                     // this is strictly bound to the format
 296                     var activeClients = Number( data.getElementsByTagName("activeclients")[0].childNodes[0].nodeValue );
 297                     __myself.activeClients = activeClients;
 298                     var show = {
 299                     "activeclients": activeClients,
 300                     "merged": Number( data.getElementsByTagName("merged")[0].childNodes[0].nodeValue ),
 301                     "total": Number( data.getElementsByTagName("total")[0].childNodes[0].nodeValue ),
 302                     "start": Number( data.getElementsByTagName("start")[0].childNodes[0].nodeValue ),
 303                     "num": Number( data.getElementsByTagName("num")[0].childNodes[0].nodeValue ),
 304                     "hits": []
 305                     };
 306                     // parse all the first-level nodes for all <hit> tags
 307                     var hits = data.getElementsByTagName("hit");
 308                     var hit = new Array();
 309                     for (i = 0; i < hits.length; i++) {
 310                         show.hits[i] = new Array();
 311                         show.hits[i]['location'] = new Array();
 312                         for ( j = 0; j < hits[i].childNodes.length; j++) {
 313                             var locCount = 0;
 314                             if ( hits[i].childNodes[j].nodeType == Node.ELEMENT_NODE ) {
 315                                 if (hits[i].childNodes[j].nodeName == 'location') {
 316                                     var locNode = hits[i].childNodes[j];
 317                                     var id = locNode.getAttribute('id');
 318                                     show.hits[i]['location'][id] = {
 319                                         "id": locNode.getAttribute("id"),
 320                                         "name": locNode.getAttribute("name")
 321                                     };
 322                                 }
 323                                 else {
 324                                     var nodeName = hits[i].childNodes[j].nodeName;
 325                                     var nodeText = 'ERROR'
 326                                     if ( hits[i].childNodes[j].firstChild )
 327                                         nodeText = hits[i].childNodes[j].firstChild.nodeValue;
 328                                     show.hits[i][nodeName] = nodeText;
 329                                 }
 330                             }
 331                         }
 332                     }
 333                     __myself.showCounter++;
 334                     var delay = __myself.showTime;
 335                     if (__myself.showCounter > __myself.showFastCount)
 336                             delay += __myself.showCounter * __myself.dumpFactor;
 337                     if ( activeClients > 0 )
 338                         __myself.showTimer = setTimeout("__myself.show()", delay);
 339
 340                     __myself.showCallback(show);
 341                 }
 342                 else
 343                     // if it gets here the http return code was 200 (pz2 errors are 417)
 344                     // but the response was invalid, it should never occur
 345                     __myself.showTimer = setTimeout("__myself.show()", __myself.showTime / 4);
 346             }
 347         );
 348     },
 349     record: function(id,offset, params)
 350     {
 351         if ( params == undefined )
 352             params = {};
 353
 354         if ( params.callback != undefined ) {
 355             callback = params.callback;
 356         } else {
 357             callback = __myself.recordCallback;
 358         }
 359
 360         if( !__myself.searchStatusOK && __myself.useSessions)
 361             return;
 362
 363         if( id !== undefined )
 364             __myself.currRecID = id;
 365         var request = new pzHttpRequest(__myself.pz2String, __myself.errorHandler);
 366
 367         var recordParams = { "command": "record", "session": __myself.sessionID, "id": __myself.currRecID };
 368         if (offset !== undefined) {
 369                 recordParams["offset"] = offset;
 370         }
 371
 372         if (params.syntax != undefined) {
 373             recordParams['syntax'] = params.syntax;
 374         }
 375
 376         __myself.currRecOffset = offset;
 377         request.get(
 378             recordParams,
 379             function(data) {
 380                 var recordNode;
 381                 var record = new Array();
 382                 record['xmlDoc'] = data;
 383                 if (__myself.currRecOffset !== undefined) {
 384                     record['offset'] = __myself.currRecOffset;
 385                     callback(record);
 386                 } else if ( recordNode = data.getElementsByTagName("record")[0] ) {
 387                     // if stylesheet was fetched do not parse the response
 388                     if ( __myself.xslDoc ) {
 389                         record['recid'] = recordNode.getElementsByTagName("recid")[0].firstChild.nodeValue;
 390                         record['xslDoc'] = __myself.xslDoc;
 391                     } else {
 392                         for ( i = 0; i < recordNode.childNodes.length; i++) {
 393                             if ( recordNode.childNodes[i].nodeType == Node.ELEMENT_NODE
 394                                     && recordNode.childNodes[i].nodeName != 'location' ) {
 395                                 var nodeName = recordNode.childNodes[i].nodeName;
 396                                 var nodeText = recordNode.childNodes[i].firstChild.nodeValue;
 397                                 record[nodeName] = nodeText;
 398                             }
 399                         }
 400                         // the location might be empty!!
 401                         var locationNodes = recordNode.getElementsByTagName("location");
 402                         record["location"] = new Array();
 403                         for ( i = 0; i < locationNodes.length; i++ ) {
 404                             record["location"][i] = {
 405                                 "id": locationNodes[i].getAttribute("id"),
 406                                 "name": locationNodes[i].getAttribute("name")
 407                             };
 408
 409                             for ( j = 0; j < locationNodes[i].childNodes.length; j++) {
 410                                 if ( locationNodes[i].childNodes[j].nodeType == Node.ELEMENT_NODE ) {
 411                                     var nodeName = locationNodes[i].childNodes[j].nodeName;
 412                                     var nodeText = '';
 413                                     if (locationNodes[i].childNodes[j].firstChild)
 414                                             nodeText = locationNodes[i].childNodes[j].firstChild.nodeValue;
 415                                     record["location"][i][nodeName] = nodeText;
 416                                 }
 417                             }
 418                         }
 419                     }
 420
 421                     callback(record);
 422                 }
 423                 else
 424                     // if it gets here the http return code was 200 (pz2 errors are 417)
 425                     // but the response was invalid, it should never occur
 426                     setTimeout("__myself.record(__myself.currRecID)", 500);
 427             }
 428         );
 429     },
 430     termlist: function()
 431     {
 432         if( !__myself.searchStatusOK )
 433             return;
 434         // if called explicitly takes precedence
 435         clearTimeout(__myself.termTimer);
 436         var request = new pzHttpRequest(__myself.pz2String, __myself.errorHandler);
 437         request.get(
 438             { "command": "termlist", "session": __myself.sessionID, "name": __myself.termKeys },
 439             function(data) {
 440                 if ( data.getElementsByTagName("termlist") ) {
 441                     var activeClients = Number( data.getElementsByTagName("activeclients")[0].childNodes[0].nodeValue );
 442                     __myself.activeClients = activeClients;
 443                     var termList = { "activeclients":  activeClients };
 444                     var termLists = data.getElementsByTagName("list");
 445                     //for each termlist
 446                     for (i = 0; i < termLists.length; i++) {
 447                         var listName = termLists[i].getAttribute('name');
 448                         termList[listName] = new Array();
 449                         var terms = termLists[i].getElementsByTagName('term');
 450                         //for each term in the list
 451                         for (j = 0; j < terms.length; j++) {
 452                             var term = {
 453                                 "name": (terms[j].getElementsByTagName("name")[0].childNodes.length
 454                                                 ? terms[j].getElementsByTagName("name")[0].childNodes[0].nodeValue
 455                                                 : 'ERROR'),
 456                                 "freq": terms[j].getElementsByTagName("frequency")[0].childNodes[0].nodeValue || 'ERROR'
 457                             };
 458
 459                             var termIdNode = terms[j].getElementsByTagName("id");
 460                             if(terms[j].getElementsByTagName("id").length)
 461                                 term["id"] = termIdNode[0].childNodes[0].nodeValue;
 462
 463                             termList[listName][j] = term;
 464                         }
 465                     }
 466
 467                     __myself.termCounter++;
 468                     var delay = __myself.termTime + __myself.termCounter * __myself.dumpFactor;
 469                     if ( activeClients > 0 )
 470                         __myself.termTimer = setTimeout("__myself.termlist()", delay);
 471
 472                    __myself.termlistCallback(termList);
 473                 }
 474                 else
 475                     // if it gets here the http return code was 200 (pz2 errors are 417)
 476                     // but the response was invalid, it should never occur
 477                     __myself.termTimer = setTimeout("__myself.termlist()", __myself.termTime / 4);
 478             }
 479         );
 480
 481     },
 482     bytarget: function()
 483     {
 484         if( !__myself.searchStatusOK )
 485             return;
 486         // if called explicitly takes precedence
 487         clearTimeout(__myself.bytargetTimer);
 488         var request = new pzHttpRequest(__myself.pz2String, __myself.errorHandler);
 489         request.get(
 490             { "command": "bytarget", "session": __myself.sessionID },
 491             function(data) {
 492                 if ( data.getElementsByTagName("status")[0].childNodes[0].nodeValue == "OK" ) {
 493                     var targetNodes = data.getElementsByTagName("target");
 494                     var bytarget = new Array();
 495                     for ( i = 0; i < targetNodes.length; i++) {
 496                         bytarget[i] = new Array();
 497                         for( j = 0; j < targetNodes[i].childNodes.length; j++ ) {
 498                             if ( targetNodes[i].childNodes[j].nodeType == Node.ELEMENT_NODE ) {
 499                                 var nodeName = targetNodes[i].childNodes[j].nodeName;
 500                                 var nodeText = targetNodes[i].childNodes[j].firstChild.nodeValue;
 501                                 bytarget[i][nodeName] = nodeText;
 502                             }
 503                         }
 504                     }
 505
 506                     __myself.bytargetCounter++;
 507                     var delay = __myself.bytargetTime + __myself.bytargetCounter * __myself.dumpFactor;
 508                     if ( __myself.activeClients > 0 )
 509                         __myself.bytargetTimer = setTimeout("__myself.bytarget()", delay);
 510
 511                     __myself.bytargetCallback(bytarget);
 512                 }
 513                 else
 514                     // if it gets here the http return code was 200 (pz2 errors are 417)
 515                     // but the response was invalid, it should never occur
 516                     __myself.bytargetTimer = setTimeout("__myself.bytarget()", __myself.bytargetTime / 4);
 517             }
 518         );
 519     },
 520     // just for testing, probably shouldn't be here
 521     showNext: function(page)
 522     {
 523         var step = page || 1;
 524         __myself.show( ( step * __myself.currentNum ) + __myself.currentStart );
 525     },
 526     showPrev: function(page)
 527     {
 528         if (__myself.currentStart == 0 )
 529             return false;
 530         var step = page || 1;
 531         var newStart = __myself.currentStart - (step * __myself.currentNum );
 532         __myself.show( newStart > 0 ? newStart : 0 );
 533     },
 534     showPage: function(pageNum)
 535     {
 536         //var page = pageNum || 1;
 537         __myself.show(pageNum * __myself.currentNum);
 538     }
 539 };
 540
 541 /*
 542 *********************************************************************************
 543 ** AJAX HELPER CLASS ************************************************************
 544 *********************************************************************************
 545 */
 546 var pzHttpRequest = function ( url, errorHandler ) {
 547         this.request = null;
 548         this.url = url;
 549         this.errorHandler = errorHandler || null;
 550         this.async = true;
 551
 552         if ( window.XMLHttpRequest ) {
 553             this.request = new XMLHttpRequest();
 554         } else if ( window.ActiveXObject ) {
 555             try {
 556                 this.request = new ActiveXObject( 'Msxml2.XMLHTTP' );
 557             } catch (err) {
 558                 this.request = new ActiveXObject( 'Microsoft.XMLHTTP' );
 559             }
 560         }
 561 };
 562
 563 pzHttpRequest.prototype =
 564 {
 565     get: function ( params, callback )
 566     {
 567         this._send( 'GET', params, '', callback );
 568     },
 569
 570     post: function ( params, data, callback )
 571     {
 572         this._send( 'POST', params, data, callback );
 573     },
 574
 575     load: function ()
 576     {
 577         this.async = false;
 578         this.request.open( 'GET', this.url, this.async );
 579         this.request.send('');
 580         if ( this.request.status == 200 )
 581             return this.request.responseXML;
 582     },
 583
 584     _send: function ( type, params, data, callback )
 585     {
 586         this.callback = callback;
 587         var context = this;
 588         this.async = true;
 589         this.request.open( type, this._urlAppendParams(params), this.async );
 590         this.request.onreadystatechange = function () {
 591             context._handleResponse();
 592         }
 593         this.request.send(data);
 594     },
 595
 596     _urlAppendParams: function (params)
 597     {
 598         var getUrl = this.url;
 599
 600         var sep = '?';
 601         var el = params;
 602         for (var key in el) {
 603             if (el[key] != null) {
 604                 getUrl += sep + key + '=' + encodeURI(el[key]);
 605                 sep = '&';
 606             }
 607         }
 608         return getUrl;
 609     },
 610
 611     _handleResponse: function ()
 612     {
 613         if ( this.request.readyState == 4 ) {
 614             if ( this.request.status == 200 ) {
 615                 this.callback( this.request.responseXML );
 616             }
 617             // pz errors
 618             else if ( this.request.status == 417 ) {
 619                 var errMsg = this.request.responseXML.getElementsByTagName("error")[0].childNodes[0].nodeValue;
 620                 var errCode = this.request.responseXML.getElementsByTagName("error")[0].getAttribute("code");
 621
 622                 var err = new Error(errMsg);
 623                 err.code = errCode;
 624
 625                 if (this.errorHandler) {
 626                     this.errorHandler(err);
 627                 }
 628                 else {
 629                     throw err;
 630                 }
 631             }
 632             else {
 633                 var err = new Error("XMLHttpRequest error. STATUS: "
 634                             + this.request.status + " STATUS TEXT: "
 635                             + this.request.statusText );
 636                 err.code = 'HTTP';
 637
 638                 if (this.errorHandler) {
 639                     this.errorHandler(err);
 640                 }
 641                 else {
 642                     throw err;
 643                 }
 644             }
 645         }
 646     }
 647 };
 648
 649 /*
 650 *********************************************************************************
 651 ** QUERY CLASS ******************************************************************
 652 *********************************************************************************
 653 */
 654 var pzQuery = function()
 655 {
 656     this.simpleQuery = '';
 657     this.singleFilter = null;
 658     this.advTerms = new Array();
 659     this.filterHash = new Array();
 660     this.numTerms = 0;
 661     this.filterNums = 0;
 662 };
 663 pzQuery.prototype = {
 664     reset: function()
 665     {
 666         this.simpleQuery = '';
 667         this.advTerms = new Array();
 668         this.simpleFilter = null;
 669         this.numTerms = 0;
 670     },
 671     clearSimpleQuery: function()
 672     {
 673         this.simpleQuery = '';
 674     },
 675     addTerm: function(field, value)
 676     {
 677         var term = {"field": field, "value": value};
 678         this.advTerms[this.numTerms] = term;
 679         this.numTerms++;
 680     },
 681     getTermValueByIdx: function(index)
 682     {
 683         return this.advTerms[index].value;
 684     },
 685     getTermFieldByIdx: function(index)
 686     {
 687         return this.advTerms[index].field;
 688     },
 689     /* semicolon separated list of terms for given field*/
 690     getTermsByField: function(field)
 691     {
 692         var terms = '';
 693         for(var i = 0; i < this.advTerms.length; i++)
 694         {
 695             if( this.advTerms[i].field == field )
 696                 terms = terms + this.queryHas[i].value + ';';
 697         }
 698         return terms;
 699     },
 700     addTermsFromList: function(inputString, field)
 701     {
 702         var inputArr = inputString.split(';');
 703         for(var i=0; i < inputArr.length; i++)
 704         {
 705             if(inputArr[i].length < 3) continue;
 706             this.advTerms[this.numTerms] = {"field": field, "value": inputArr[i] };
 707             this.numTerms++;
 708         }
 709     },
 710     removeTermByIdx: function(index)
 711     {
 712         this.advTerms.splice(index, 1);
 713         this.numTerms--;
 714     },
 715     toCCL: function()
 716     {
 717         var ccl = '';
 718         if( this.simpleQuery != '')
 719             ccl = this.simpleQuery;
 720         for(var i = 0; i < this.advTerms.length; i++)
 721         {
 722             if (ccl != '') ccl = ccl + ' and ';
 723             ccl = ccl + this.advTerms[i].field+'="'+this.advTerms[i].value+'"';
 724         }
 725         return ccl;
 726     },
 727     addFilter: function(name, value)
 728     {
 729         var filter = {"name": name, "id": value };
 730         this.filterHash[this.filterHash.length] = filter;
 731         this.filterNums++
 732         return  this.filterHash.length - 1;
 733     },
 734     setFilter: function(name, value)
 735     {
 736         this.filterHash = new Array();
 737         this.filterNums = 0;
 738         this.addFilter(name, value);
 739     },
 740     getFilter: function(index)
 741     {
 742         return this.filterHash[index].id;
 743     },
 744     getFilterName: function(index)
 745     {
 746         return this.filterHash[index].name;
 747     },
 748     removeFilter: function(index)
 749     {
 750         delete this.filterHash[index];
 751         this.filterNums--;
 752     },
 753     clearFilter: function()
 754     {
 755         this.filterHash = new Array();
 756         this.filterNums = 0;
 757     },
 758     getFilterString: function()
 759     {
 760         //temporary
 761         if( this.singleFilter != null ) {
 762             return 'pz:id='+this.singleFilter.id;
 763         }
 764         else if( this.filterNums <= 0 ) {
 765             return undefined;
 766         }
 767
 768         var filter = 'pz:id=';
 769         for(var i = 0; i < this.filterHash.length; i++)
 770         {
 771             if (this.filterHash[i] == undefined) continue;
 772             if (filter > 'pz:id=') filter = filter + '|';
 773             filter += this.filterHash[i].id;
 774         }
 775         return filter;
 776     },
 777     totalLength: function()
 778     {
 779         var simpleLength = this.simpleQuery != '' ? 1 : 0;
 780         return this.advTerms.length + simpleLength;
 781     },
 782     clearSingleFilter: function()
 783     {
 784         this.singleFilter = null;
 785     },
 786     setSingleFilter: function(name, value)
 787     {
 788         this.singleFilter = {"name": name, "id": value };
 789     },
 790     getSingleFilterName: function()
 791     {
 792         return this.singleFilter.name;
 793     }
 794 }
 795
 796 }