src/javascript/opensrf_domain_object.js

   1 // -----------------------------------------------------------------------------
   2 // This houses all of the domain object code.
   3 // -----------------------------------------------------------------------------
   4
   5
   6
   7
   8 // -----------------------------------------------------------------------------
   9 // DomainObject
  10
  11 DomainObject.prototype                                  = new domainObject();
  12 DomainObject.prototype.constructor      = DomainObject;
  13 DomainObject.prototype.baseClass                = domainObject.prototype.constructor;
  14
  15 /** Top level DomainObject class.  This most provides convience methods
  16   * and a shared superclass
  17   */
  18 function DomainObject( name ) {
  19         if( name ) { this._init_domainObject( name ); }
  20 }
  21
  22 /** Returns the actual element of the given domainObjectAttr. */
  23 DomainObject.prototype._findAttr = function ( name ) {
  24
  25         var nodes = this.element.childNodes;
  26
  27         if( ! nodes || nodes.length < 1 ) {
  28                 throw new oils_ex_dom( "Invalid xml object in _findAttr: " + this.toString() );
  29         }
  30
  31         var i=0;
  32         var node = nodes.item(i);
  33
  34         while( node != null ) {
  35
  36                 if( node.nodeName == "oils:domainObjectAttr" &&
  37                                 node.getAttribute("name") == name ) {
  38                         return node;
  39                 }
  40
  41                 node = nodes.item(++i);
  42         }
  43
  44         return null;
  45 }
  46
  47
  48
  49
  50 /** Returns the value stored in the given attribute */
  51 DomainObject.prototype.getAttr = function ( name ) {
  52
  53         var node = this._findAttr( name );
  54         if( node ) { return node.getAttribute( "value" ); }
  55         else {
  56                 throw new oils_ex_dom( "getAttr(); Getting nonexistent attribute: " + name );
  57         }
  58 }
  59
  60 /** Updates the value held by the given attribute */
  61 DomainObject.prototype.setAttr = function ( name, value ) {
  62
  63         var node = this._findAttr( name );
  64         if( node ) {
  65                 node.setAttribute( "value", value );
  66         } else {
  67                 throw new oils_ex_dom( "setAttr(); Setting nonexistent attribute: " + name );
  68         }
  69 }
  70
  71 /** This takes a raw DOM Element node and creates the DomainObject that the node
  72   * embodies and returns the object.  All new DomainObjects should be added to
  73   * this list if they require this type of dynamic functionality.
  74   * NOTE Much of this will be deprecated as move to a more JSON-centric wire protocol
  75   */
  76 DomainObject.newFromNode = function( node ) {
  77
  78         switch( node.getAttribute("name") ) {
  79
  80                 case "oilsMethod":
  81                         return new oilsMethod().replaceNode( node );
  82
  83                 case "oilsMessage":
  84                         return new oilsMessage().replaceNode( node );
  85
  86                 case "oilsResponse":
  87                         return new oilsResponse().replaceNode( node );
  88
  89                 case "oilsResult":
  90                         return new oilsResult().replaceNode( node );
  91
  92                 case "oilsConnectStatus":
  93                         return new oilsConnectStatus().replaceNode( node );
  94
  95                 case "oilsException":
  96                         return new oilsException().replaceNode( node );
  97
  98                 case "oilsMethodException":
  99                         return new oilsMethodException().replaceNode( node );
 100
 101                 case "oilsBrokenSession":
 102                         return new oilsBrokenSession().replaceNode( node );
 103
 104                 case "oilsScalar":
 105                         return new oilsScalar().replaceNode( node );
 106
 107                 case "oilsPair":
 108                         return new oilsPair().replaceNode( node );
 109
 110                 case "oilsArray":
 111                         return new oilsArray().replaceNode( node );
 112
 113                 case "oilsHash":
 114                         return new oilsHash().replaceNode( node );
 115
 116
 117         }
 118
 119 }
 120
 121
 122
 123 // -----------------------------------------------------------------------------
 124 // oilsMethod
 125
 126 oilsMethod.prototype = new DomainObject();
 127 oilsMethod.prototype.constructor = oilsMethod;
 128 oilsMethod.prototype.baseClass = DomainObject.prototype.constructor;
 129
 130 /**
 131   * oilsMethod Constructor
 132   *
 133   * @param method_name The name of the method your are sending
 134   * to the remote server
 135   * @param params_array A Javascript array of the params (any
 136   * Javascript data type)
 137   */
 138
 139 function oilsMethod( method_name, params_array ) {
 140         this._init_domainObject( "oilsMethod" );
 141         this.add( new domainObjectAttr( "method", method_name ) );
 142
 143         if( params_array ) {
 144                 var params = this.doc.createElement( "oils:params" );
 145                 this.element.appendChild( params );
 146                 params.appendChild( this.doc.createTextNode(
 147                                 js2JSON( params_array ) ) );
 148         }
 149 }
 150
 151
 152 /** Locates the params node of this method */
 153 oilsMethod.prototype._getParamsNode = function() {
 154
 155         var nodes = this.element.childNodes;
 156         if( ! nodes || nodes.length < 1 ) { return null; }
 157         var x=0;
 158         var node = nodes.item(x);
 159         while( node != null ) {
 160                 if( node.nodeName == "oils:params" ) {
 161                         return node;
 162                 }
 163                 node = nodes.item(++x);
 164         }
 165
 166         return null;
 167 }
 168
 169
 170 /** Returns an array of param objects  */
 171 oilsMethod.prototype.getParams = function() {
 172         var node = this._getParamsNode();
 173         if(node != null ) {
 174                 return JSON2js( node.textContent );
 175         }
 176 }
 177
 178
 179
 180 // -----------------------------------------------------------------------------
 181 // oilsMessage
 182
 183 // -----------------------------------------------------------------------------
 184 // oilsMessage message types
 185 // -----------------------------------------------------------------------------
 186 /** CONNECT Message type */
 187 oilsMessage.CONNECT             = 'CONNECT';
 188 /** DISCONNECT Message type */
 189 oilsMessage.DISCONNECT  = 'DISCONNECT';
 190 /** STATUS Message type */
 191 oilsMessage.STATUS              = 'STATUS';
 192 /** REQUEST Message type */
 193 oilsMessage.REQUEST             = 'REQUEST';
 194 /** RESULT Message type */
 195 oilsMessage.RESULT              = 'RESULT';
 196
 197
 198 oilsMessage.prototype = new DomainObject();
 199 oilsMessage.prototype.constructor = oilsMessage;
 200 oilsMessage.prototype.baseClass = DomainObject.prototype.constructor;
 201
 202 /** Core XML object for message passing */
 203 function oilsMessage( type, protocol ) {
 204
 205         if( !( type && protocol) ) {
 206                 type = oilsMessage.CONNECT;
 207                 protocol = "1";
 208         }
 209
 210         if( ! ( type == oilsMessage.CONNECT             ||
 211                                 type == oilsMessage.DISCONNECT  ||
 212                                 type == oilsMessage.STATUS                      ||
 213                                 type == oilsMessage.REQUEST             ||
 214                                 type == oilsMessage.RESULT      ) ) {
 215                 throw new oils_ex_message( "Attempt to create oilsMessage with incorrect type: " + type );
 216         }
 217
 218         this._init_domainObject( "oilsMessage" );
 219
 220         this.add( new domainObjectAttr( "type", type ) );
 221         this.add( new domainObjectAttr( "threadTrace", 0 ) );
 222         this.add( new domainObjectAttr( "protocol", protocol ) );
 223
 224         // user_auth used to be a parameter for oilsMessage
 225         //if( user_auth ) { this.add( user_auth ); }
 226
 227 }
 228
 229 /** Builds a new oilsMessage from raw xml.
 230   * Checks are taken to make sure the xml is supposed to be an oilsMessage.
 231   * If not, an oils_ex_dom exception is throw.
 232   */
 233 oilsMessage.newFromXML = function( xml ) {
 234
 235         try {
 236
 237                 if( ! xml || xml == "" ) { throw 1; }
 238
 239                 var doc = new DOMParser().parseFromString( xml, "text/xml" );
 240                 if( ! doc ) { throw 1; }
 241
 242                 var root = doc.documentElement;
 243                 if( ! root ) { throw 1; }
 244
 245                 // -----------------------------------------------------------------------------
 246                 // There are two options here.  One is that we were provided the full message
 247                 // xml (i.e. contains the <oils:root> tag.  The other option is that we were
 248                 // provided just the message xml portion (top level element is the
 249                 // <oils:domainObject>
 250                 // -----------------------------------------------------------------------------
 251
 252                 var element;
 253                 if( root.nodeName == "oils:root"  ) {
 254
 255                         element = root.firstChild;
 256                         if( ! element ) { throw 1; }
 257
 258                 } else {
 259
 260                         if( root.nodeName == "oils:domainObject" ) {
 261                                 element = root;
 262
 263                         } else { throw 1; }
 264
 265                 }
 266
 267
 268                 if( element.nodeName != "oils:domainObject" ) { throw 1; }
 269                 if( element.getAttribute( "name" ) != "oilsMessage" ) { throw 1; }
 270
 271                 return new oilsMessage().replaceNode( element );
 272
 273         } catch( E ) {
 274
 275                 if( E && E.message ) {
 276                         throw new oils_ex_dom( "Bogus XML for creating oilsMessage: " + E.message + "\n" + xml );
 277
 278                 } else {
 279                         throw new oils_ex_dom( "Bogus XML for creating oilsMessage:\n" + xml );
 280                 }
 281         }
 282
 283         return msg;
 284 }
 285
 286
 287
 288 /** Adds a copy of the given DomainObject to the message */
 289 oilsMessage.prototype.addPayload = function( new_DomainObject ) {
 290         this.add( new_DomainObject );
 291 }
 292
 293
 294 /** Returns the top level DomainObject contained in this message
 295   *
 296   * Note:  The object retuturned will be the actual object, not just a
 297   * generic DomainObject - e.g. oilsException.
 298   */
 299 oilsMessage.prototype.getPayload = function() {
 300
 301         var nodes = this.element.childNodes;
 302         var x=0;
 303         var node = nodes.item(0);
 304
 305         while( node != null ) {
 306
 307                 if( node.nodeName == "oils:domainObject" ) {
 308
 309                         new Logger().debug( "Building oilsMessage payload from\n" +
 310                                 new XMLSerializer().serializeToString( node ), Logger.DEBUG );
 311                         return DomainObject.newFromNode( node );
 312                 }
 313                 node = nodes.item(++x);
 314         }
 315
 316         return null;
 317 }
 318
 319 oilsMessage.prototype.getUserAuth = function() {
 320
 321         var nodes = this.element.getElementsByTagName( "oils:userAuth" );
 322         if( ! nodes ) { return null; }
 323
 324         var auth_elem = nodes.item(0); // should only be one
 325         if ( ! auth_elem ) { return null; }
 326
 327         return new userAuth().replaceNode( auth_elem );
 328
 329 }
 330
 331 /** Returns the type of the message */
 332 oilsMessage.prototype.getType = function() {
 333         return this.getAttr( "type" );
 334 }
 335
 336 /** Returns the message protocol */
 337 oilsMessage.prototype.getProtocol = function() {
 338         return this.getAttr( "protocol" );
 339 }
 340
 341 /** Returns the threadTrace */
 342 oilsMessage.prototype.getThreadTrace = function() {
 343         return this.getAttr( "threadTrace" );
 344 }
 345
 346 /** Sets the thread trace - MUST be an integer */
 347 oilsMessage.prototype.setThreadTrace = function( trace ) {
 348         this.setAttr( "threadTrace", trace );
 349 }
 350
 351 /** Increments the thread trace by 1 */
 352 oilsMessage.prototype.updateThreadTrace = function() {
 353         var tt = this.getThreadTrace();
 354         return this.setThreadTrace( ++tt );
 355 }
 356
 357
 358
 359
 360
 361 // -----------------------------------------------------------------------------
 362 // oilsResponse
 363
 364
 365 // -----------------------------------------------------------------------------
 366 // Response codes
 367 // -----------------------------------------------------------------------------
 368
 369 /**
 370   * Below are the various response statuses
 371   */
 372 oilsResponse.STATUS_CONTINUE                                            = 100
 373
 374 oilsResponse.STATUS_OK                                                          = 200
 375 oilsResponse.STATUS_ACCEPTED                                            = 202
 376 oilsResponse.STATUS_COMPLETE                                            = 205
 377
 378 oilsResponse.STATUS_REDIRECTED                                  = 307
 379
 380 oilsResponse.STATUS_BADREQUEST                                  = 400
 381 oilsResponse.STATUS_UNAUTHORIZED                                        = 401
 382 oilsResponse.STATUS_FORBIDDEN                                           = 403
 383 oilsResponse.STATUS_NOTFOUND                                            = 404
 384 oilsResponse.STATUS_NOTALLOWED                                  = 405
 385 oilsResponse.STATUS_TIMEOUT                                             = 408
 386 oilsResponse.STATUS_EXPFAILED                                           = 417
 387 oilsResponse.STATUS_INTERNALSERVERERROR         = 500
 388 oilsResponse.STATUS_NOTIMPLEMENTED                              = 501
 389 oilsResponse.STATUS_VERSIONNOTSUPPORTED         = 505
 390
 391
 392 oilsResponse.prototype = new DomainObject();
 393 oilsResponse.prototype.constructor = oilsResponse;
 394 oilsResponse.prototype.baseClass = DomainObject.prototype.constructor;
 395
 396 /** Constructor.  status is the text describing the message status and
 397   * statusCode must correspond to one of the oilsResponse status code numbers
 398   */
 399 function oilsResponse( name, status, statusCode ) {
 400         if( name && status && statusCode ) {
 401                 this._initResponse( name, status, statusCode );
 402         }
 403 }
 404
 405 /** Initializes the reponse XML */
 406 oilsResponse.prototype._initResponse = function( name, status, statusCode ) {
 407
 408         this._init_domainObject( name );
 409         this.add( new domainObjectAttr( "status", status ));
 410         this.add( new domainObjectAttr( "statusCode", statusCode ) );
 411 }
 412
 413
 414
 415 /** Returns the status of the response */
 416 oilsResponse.prototype.getStatus = function() {
 417         return this.getAttr( "status" );
 418 }
 419
 420 /** Returns the statusCode of the response */
 421 oilsResponse.prototype.getStatusCode = function() {
 422         return this.getAttr("statusCode");
 423 }
 424
 425
 426 oilsConnectStatus.prototype = new oilsResponse();
 427 oilsConnectStatus.prototype.constructor = oilsConnectStatus;
 428 oilsConnectStatus.prototype.baseClass = oilsResponse.prototype.constructor;
 429
 430 /** Constructor.  These give us info on our connection attempts **/
 431 function oilsConnectStatus( status, statusCode ) {
 432         this._initResponse( "oilsConnectStatus", status, statusCode );
 433 }
 434
 435
 436 oilsResult.prototype = new oilsResponse();
 437 oilsResult.prototype.constructor = oilsResult;
 438 oilsResult.prototype.baseClass = oilsResponse.prototype.constructor;
 439
 440
 441 /** Constructor.  These usually carry REQUEST responses */
 442 function oilsResult( status, statusCode ) {
 443         if( status && statusCode ) {
 444                 this._initResponse( "oilsResult", status, statusCode );
 445         }
 446 }
 447
 448 /** Returns the top level DomainObject within this result message.
 449   * Note:  The object retuturned will be the actual object, not just a
 450   * generic DomainObject - e.g. oilsException.
 451   */
 452 oilsResult.prototype.getContent = function() {
 453
 454         var nodes = this.element.childNodes;
 455         if( ! nodes || nodes.length < 1 ) {
 456                 throw new oils_ex_dom("Content node for oilsResult is invalid\n" + this.toString() );
 457         }
 458         var x = 0;
 459         var node = nodes.item(x);
 460         while( node != null ) {
 461
 462                 if( node.nodeName == "oils:domainObject"                                        ||
 463                                 node.nodeName == "oils:domainObjectCollection" ) {
 464
 465                         return DomainObject.newFromNode( node );
 466                 }
 467                 node = nodes.item(++x);
 468         }
 469
 470         throw new oils_ex_dom("Content node for oilsResult is invalid\n" + this.toString() );
 471 }
 472
 473
 474 oilsException.prototype = new oilsResponse();
 475 oilsException.prototype.constructor = oilsException;
 476 oilsException.prototype.baseClass = oilsResponse.prototype.constructor;
 477
 478 /** Top level exception */
 479 function oilsException( status, statusCode ) {
 480         if( status && statusCode ) {
 481                 this._initResponse( "oilsException", status, statusCode );
 482         }
 483 }
 484
 485
 486 oilsMethodException.prototype = new oilsException();
 487 oilsMethodException.prototype.constructor = oilsMethodException;
 488 oilsMethodException.prototype.baseClass = oilsException.prototype.constructor;
 489
 490 /** Method exception */
 491 function oilsMethodException( status, statusCode ) {
 492         if( status && statusCode ) {
 493                 this._initResponse( "oilsMethodException", status, statusCode );
 494         }
 495 }
 496
 497 oilsBrokenSession.prototype = new oilsException();
 498 oilsBrokenSession.prototype.constructor = oilsBrokenSession;
 499 oilsBrokenSession.prototype.baseClass = oilsException.prototype.constructor;
 500
 501 /** broken session exception */
 502 function oilsBrokenSession( status, statusCode ) {
 503         if( status && statusCode ) {
 504                 this._initResponse( "oilsBrokenSession", status, statusCode );
 505         }
 506 }
 507
 508
 509 // -----------------------------------------------------------------------------
 510 // oilsScalar
 511
 512
 513 oilsScalar.prototype = new DomainObject();
 514 oilsScalar.prototype.constructor = oilsScalar;
 515 oilsScalar.prototype.baseClass = DomainObject.prototype.constructor;
 516
 517 /** Contains a single JSON item as its text content */
 518 function oilsScalar( value ) {
 519         this._init_domainObject( "oilsScalar" );
 520         this.element.appendChild( this.doc.createTextNode( value ) );
 521 }
 522
 523 /** Returns the contained item as a Javascript object */
 524 oilsScalar.prototype.getValue = function() {
 525         return JSON2js( this.element.textContent );
 526 }
 527
 528
 529 // -----------------------------------------------------------------------------
 530 // oilsPair
 531
 532
 533 oilsPair.prototype = new DomainObject()
 534 oilsPair.prototype.constructor = oilsPair;
 535 oilsPair.prototype.baseClass = DomainObject.prototype.constructor;
 536
 537 function oilsPair( key, value ) {
 538
 539         this._init_domainObject( "oilsPair" );
 540         this.element.appendChild( this.doc.createTextNode( value ) );
 541         this.element.setAttribute( "key", key );
 542 }
 543
 544 oilsPair.prototype.getKey = function() {
 545         return this.element.getAttribute( "key" );
 546 }
 547
 548 oilsPair.prototype.getValue = function() {
 549         return this.element.textContent;
 550 }
 551
 552
 553
 554 // -----------------------------------------------------------------------------
 555 // oilsArray - is a domainObjectCollection that stores a list of domainObject's
 556 // or domainObjectCollections.
 557 // -----------------------------------------------------------------------------
 558
 559 oilsArray.prototype = new domainObjectCollection()
 560 oilsArray.prototype.constructor = oilsArray;
 561 oilsArray.prototype.baseClass = domainObjectCollection.prototype.constructor;
 562
 563 function oilsArray( obj_list ) {
 564         this._initCollection( "oilsArray" );
 565         if(obj_list) { this.initArray( obj_list ); }
 566 }
 567
 568 // -----------------------------------------------------------------------------
 569 // Adds the array of objects to the array, these should be actual objects, not
 570 // DOM nodes/elements, etc.
 571 // -----------------------------------------------------------------------------
 572 oilsArray.prototype.initArray = function( obj_list ) {
 573         if( obj_array != null && obj_array.length > 0 ) {
 574                 for( var i= 0; i!= obj_array.length; i++ ) {
 575                         this.add( obj_array[i] );
 576                 }
 577         }
 578 }
 579
 580 // -----------------------------------------------------------------------------
 581 // Returns an array of DomainObjects or domainObjectCollections.  The objects
 582 // returned will already be 'cast' into the correct object. i.e. you will not
 583 // receieve an array of DomainObjects, but instead an array of oilsScalar's or
 584 // an array of oilsHashe's, etc.
 585 // -----------------------------------------------------------------------------
 586 oilsArray.prototype.getObjects = function() {
 587
 588         var obj_list = new Array();
 589         var nodes = this.element.childNodes;
 590         var i=0;
 591         var node = nodes.item(i);
 592
 593         while( node != null ) {
 594
 595                 if( node.nodeName == "oils:domainObject"                                        ||
 596                                 node.nodeName == "oils:domainObjectCollection" ) {
 597                         obj_list[i++] = DomainObject.newFromNode( node );
 598                 }
 599                 node = nodes.item(i);
 600         }
 601
 602         return obj_list;
 603 }
 604
 605
 606 // -----------------------------------------------------------------------------
 607 // oilsHash - an oilsHash is an oilsArray except it only stores oilsPair's
 608 // -----------------------------------------------------------------------------
 609
 610 oilsHash.prototype = new oilsArray();
 611 oilsHash.prototype.constructor = oilsHash;
 612 oilsHash.prototype.baseClass = oilsArray.prototype.constructor;
 613
 614 function oilsHash( pair_array ) {
 615         this._initCollection("oilsHash");
 616         if(pair_array) { this.initArray( pair_array ); }
 617 }
 618
 619 // -----------------------------------------------------------------------------
 620 // Returns the array of oilsPairs objects that this hash contains
 621 // -----------------------------------------------------------------------------
 622 oilsHash.prototype.getPairs = function() {
 623         return this.getObjects();
 624 }
 625
 626