Open-ILS/web/js/dojo/openils/PermaCrud.js

   1 /* ---------------------------------------------------------------------------
   2  * Copyright (C) 2008  Equinox Software, Inc
   3  * Mike Rylander <miker@esilibrary.com>
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License
   7  * as published by the Free Software Foundation; either version 2
   8  * of the License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  * ---------------------------------------------------------------------------
  15  */
  16
  17 if(!dojo._hasResource["openils.PermaCrud"]) {
  18
  19     dojo._hasResource["openils.PermaCrud"] = true;
  20     dojo.provide("openils.PermaCrud");
  21     dojo.require("openils.User");
  22
  23     dojo.declare('openils.PermaCrud', null, {
  24
  25         session : null,
  26         authtoken : null,
  27         connnected : false,
  28
  29         constructor : function ( kwargs ) {
  30             kwargs = kwargs || {};
  31
  32             this.authtoken = kwargs.authtoken;
  33
  34             this.session =
  35                 kwargs.session ||
  36                 new OpenSRF.ClientSession('open-ils.pcrud');
  37
  38             if (
  39                 this.session &&
  40                 this.session.state == OSRF_APP_SESSION_CONNECTED
  41             ) this.connected = true;
  42         },
  43
  44         auth : function (token) {
  45             if (token) this.authtoken = token;
  46             return this.authtoken || openils.User.authtoken;
  47         },
  48
  49         connect : function ( onerror ) {
  50             if (!this.connected && !this.session.connect()) {
  51                 this.connected = false;
  52                 if (onerror) onerror(this.session);
  53                 return false;
  54             }
  55             this.connected = true;
  56             return true;
  57         },
  58
  59         disconnect : function ( onerror ) {
  60             if (!this.session.disconnect()) {
  61                 if (onerror) onerror(this.session);
  62                 return false;
  63             }
  64             return true;
  65         },
  66
  67
  68             retrieve : function ( fm_class /* Fieldmapper class hint */, id /* Fieldmapper object primary key value */,  opts /* Option hash */) {
  69             var req_hash = dojo.mixin(
  70                 opts,
  71                 { method : 'open-ils.pcrud.retrieve.' + fm_class,
  72                   params : [ this.auth(), id ]
  73                 }
  74             );
  75
  76             var _pcrud = this;
  77             var req = this.session.request( req_hash );
  78
  79             if (!req.onerror)
  80                 req.onerror = function (r) { throw js2JSON(r); };
  81
  82             if (!req.oncomplete)
  83                 req.oncomplete = function (r) { r.result = r.recv(); _pcrud.last_result = r.result; };
  84
  85             req.send();
  86
  87             return req;
  88             },
  89
  90             retrieveAll : function ( fm_class /* Fieldmapper class hint */, opts /* Option hash */) {
  91             var pkey = fieldmapper[fm_class].Indentifier;
  92
  93             var order_by = {};
  94             if (opts.order_by) order_by.order_by = opts.order_by;
  95             if (opts.select) order_by.select = opts.select;
  96
  97             var req_hash = dojo.mixin(
  98                 opts,
  99                 { method : 'open-ils.pcrud.search.' + fm_class + '.atomic',
 100                   params : [ this.auth(), { fieldmapper[fm_class].Indentifier : { '!=' : null } }, order_by ]
 101                 }
 102             );
 103
 104             var _pcrud = this;
 105             var req = this.session.request( req_hash );
 106
 107             if (!req.onerror)
 108                 req.onerror = function (r) { throw js2JSON(r); };
 109
 110             if (!req.oncomplete)
 111                 req.oncomplete = function (r) { r.result = r.recv(); _pcrud.last_result = r.result; };
 112
 113             req.send();
 114
 115             return req;
 116             },
 117
 118             search : function ( fm_class /* Fieldmapper class hint */, search /* Fieldmapper query object */, opts /* Option hash */) {
 119             var pkey = fieldmapper[fm_class].Indentifier;
 120
 121             var order_by = {};
 122             if (opts.order_by) order_by.order_by = opts.order_by;
 123             if (opts.select) order_by.select = opts.select;
 124
 125             var req_hash = dojo.mixin(
 126                 opts,
 127                 { method : 'open-ils.pcrud.search.' + fm_class + '.atomic',
 128                   params : [ this.auth(), search, order_by ]
 129                 }
 130             );
 131
 132             var _pcrud = this;
 133             var req = this.session.request( req_hash );
 134
 135             if (!req.onerror)
 136                 req.onerror = function (r) { throw js2JSON(r); };
 137
 138             if (!req.oncomplete)
 139                 req.oncomplete = function (r) { r.result = r.recv(); _pcrud.last_result = r.result; };
 140
 141             req.send();
 142
 143             return req;
 144             },
 145
 146         _CUD : function ( method /* 'create' or 'update' or 'delete' */ list /* Fieldmapper object */, opts /* Option hash */) {
 147
 148             if (dojo.isArray(list)) {
 149                 if (list.classname) list = [ list ];
 150             } else {
 151                 list = [ list ];
 152             }
 153
 154             if (!this.connected) this.connect();
 155
 156             var _pcrud = this;
 157             var final_complete = opts.oncomplete;
 158             var final_error = opts.onerror;
 159
 160             function _CUD_recursive ( obj_list, pos, final_complete ) {
 161                 var obj = obj_list[pos];
 162                 var req_hash = {
 163                     method : 'open-ils.pcrud.' + method + '.' + obj.classname,
 164                     params : [ _pcrud.auth(), obj ],
 165                     onerror : final_error || function (r) { _pcrud.disconnect(); throw '_CUD: Error creating, deleting or updating ' + js2JSON(obj); };
 166                 };
 167
 168                 var req = _pcrud.session.request( req_hash );
 169
 170                 if (++pos == all_objs.length) {
 171                     req.oncomplete = function (r) {
 172                         _pcrud.commit();
 173                         _pcrud.disconnect();
 174                         final_complete(r);
 175                     };
 176
 177                     req.onerror = function (r) {
 178                         _pcrud.disconnect();
 179                         final_error(r);
 180                     };
 181
 182                 } else {
 183                     req._pos = pos;
 184                     req._obj_list = obj_list;
 185                     req._final_complete = final_complete;
 186                     req.oncomplete = function (r) {
 187                         var res = r.recv();
 188                         if ( res && res.content() ) {
 189                             _CUD_recursive( r._obj_list, r._pos, r._final_complete );
 190                         } else {
 191                             _pcrud.disconnect();
 192                             throw '_CUD: Error creating, deleting or updating ' + js2JSON(obj);
 193                         }
 194                     };
 195                 }
 196
 197                 req.send();
 198             }
 199
 200             this.session.request({
 201                 method : 'open-ils.pcrud.transaction.commit',
 202                 timeout : 10,
 203                 params : [ ses, modified_ou ],
 204                 onerror : function (r) {
 205                     _pcrud.disconnect();
 206                     throw 'Transaction begin error';
 207                 },
 208                 oncomplete : function (r) {
 209                     var res = r.recv();
 210                     if ( res && res.content() ) {
 211                         _CUD_recursive( list, 0 );
 212                     } else {
 213                         _pcrud.disconnect();
 214                         throw 'Transaction begin error';
 215                     }
 216                 },
 217                 }).send();
 218         },
 219
 220         create : function ( list, opts ) {
 221             this._CUD( 'create', list, opts );
 222         },
 223
 224         update : function ( list, opts ) {
 225             this._CUD( 'update', list, opts );
 226         },
 227
 228         delete : function ( list, opts ) {
 229             this._CUD( 'delete', list, opts );
 230         },
 231
 232         apply : function ( list, opts ) {
 233             this._auto_CUD( list, opts );
 234         },
 235
 236         _auto_CUD : function ( list /* Fieldmapper object */, opts /* Option hash */) {
 237
 238             if (dojo.isArray(list)) {
 239                 if (list.classname) list = [ list ];
 240             } else {
 241                 list = [ list ];
 242             }
 243
 244             if (!this.connected) this.connect();
 245
 246             var _pcrud = this;
 247             var final_complete = opts.oncomplete;
 248             var final_error = opts.onerror;
 249
 250             function _auto_CUD_recursive ( obj_list, pos, final_complete ) {
 251                 var obj = obj_list[pos];
 252
 253                 var method;
 254                 if (obj.isnew)     method = 'create';
 255                 if (obj.ischanged) method = 'update';
 256                 if (obj.isdeleted) method = 'delete';
 257                 if (!method) throw 'No action detected';
 258
 259                 var req_hash = {
 260                     method : 'open-ils.pcrud.' + method + '.' + obj.classname,
 261                     params : [ _pcrud.auth(), obj ],
 262                     onerror : final_error || function (r) { _pcrud.disconnect(); throw '_auto_CUD: Error creating, deleting or updating ' + js2JSON(obj); };
 263                 };
 264
 265                 var req = _pcrud.session.request( req_hash );
 266
 267                 if (++pos == all_objs.length) {
 268                     req.oncomplete = function (r) {
 269                         _pcrud.commit();
 270                         _pcrud.disconnect();
 271                         final_complete(r);
 272                     };
 273
 274                     req.onerror = function (r) {
 275                         _pcrud.disconnect();
 276                         final_error(r);
 277                     };
 278
 279                 } else {
 280                     req._pos = pos;
 281                     req._obj_list = obj_list;
 282                     req._final_complete = final_complete;
 283                     req.oncomplete = function (r) {
 284                         var res = r.recv();
 285                         if ( res && res.content() ) {
 286                             _auto_CUD_recursive( r._obj_list, r._pos, r._final_complete );
 287                         } else {
 288                             _pcrud.disconnect();
 289                             throw '_auto_CUD: Error creating, deleting or updating ' + js2JSON(obj);
 290                         }
 291                     };
 292                 }
 293
 294                 req.send();
 295             }
 296
 297             this.session.request({
 298                 method : 'open-ils.pcrud.transaction.commit',
 299                 timeout : 10,
 300                 params : [ ses, modified_ou ],
 301                 onerror : function (r) {
 302                     _pcrud.disconnect();
 303                     throw 'Transaction begin error';
 304                 },
 305                 oncomplete : function (r) {
 306                     var res = r.recv();
 307                     if ( res && res.content() ) {
 308                         _auto_CUD_recursive( list, 0 );
 309                     } else {
 310                         _pcrud.disconnect();
 311                         throw 'Transaction begin error';
 312                     }
 313                 },
 314                 }).send();
 315         }
 316
 317     });
 318 }
 319
 320