js/pz2.js

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