js/pz2.js

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