Open-ILS/xul/staff_client/server/patron/ue_config.js

   1 /* -----------------------------------------------------------------------
   2         ----------------------------------------------------------------------- */
   3 const SC_FETCH_ALL              = 'open-ils.circ:open-ils.circ.stat_cat.actor.retrieve.all';
   4 const SC_CREATE_MAP             = 'open-ils.circ:open-ils.circ.stat_cat.actor.user_map.create';
   5 const SV_FETCH_ALL              = 'open-ils.circ:open-ils.circ.survey.retrieve.all';
   6 const FETCH_ID_TYPES            = 'open-ils.actor:open-ils.actor.user.ident_types.retrieve';
   7 const FETCH_GROUPS              = 'open-ils.actor:open-ils.actor.groups.tree.retrieve';
   8 const UPDATE_PATRON             = 'open-ils.actor:open-ils.actor.patron.update';
   9 const PATRON_SEARCH             = 'open-ils.actor:open-ils.actor.patron.search.advanced';
  10 const ZIP_SEARCH                        = 'open-ils.search:open-ils.search.zip';
  11 const FETCH_ADDR_MEMS   = 'open-ils.actor:open-ils.actor.address.members';
  12 const FETCH_GRP_MEMS            = 'open-ils.actor:open-ils.actor.usergroup.members.retrieve';
  13 const defaultState              = 'GA';
  14 const defaultCountry            = 'USA';
  15 const CSS_INVALID_DATA  = 'invalid_value';
  16
  17 /* if they don't have these perms, they shouldn't be here */
  18 var myPerms = [ 'CREATE_USER', 'UPDATE_USER', 'CREATE_PATRON_STAT_CAT_ENTRY_MAP' ];
  19
  20 var dataFields;
  21 const numRegex          = /^\d+$/;
  22 const wordRegex = /^\w+$/;
  23 const ssnRegex          = /^\d{3}-\d{2}-\d{4}$/;
  24 const dlRegex           = /^[a-zA-Z]{2}-\w+/; /* driver's license */
  25 const phoneRegex        = /\d{3}-\d{3}-\d{4}/;
  26 const nonumRegex        = /^[a-zA-Z]\D*$/; /* no numbers, no beginning whitespace */
  27 const dateRegex = /^\d{4}-\d{2}-\d{2}/;
  28
  29
  30
  31 function uEditDefineData(patron) {
  32
  33         var fields = [
  34                 {
  35                         required : true,
  36                         object  : patron.card(),
  37                         key             : 'barcode',
  38                         errkey  : 'ue_bad_barcode',
  39                         widget  : {
  40                                 id              : 'ue_barcode',
  41                                 regex   : wordRegex,
  42                                 type    : 'input'
  43                         }
  44                 },
  45                 {
  46                         required : true,
  47                         object  : patron,
  48                         key             : 'usrname',
  49                         errkey  : 'ue_bad_username',
  50                         widget  : {
  51                                 id              : 'ue_username',
  52                                 regex   : wordRegex,
  53                                 type    : 'input'
  54                         }
  55                 },
  56                 {
  57                         required : (patron.isnew()) ? true : false,
  58                         object  : patron,
  59                         key             : 'passwd',
  60                         errkey  : 'ue_bad_password',
  61                         widget  : {
  62                                 id              : 'ue_password1',
  63                                 type    : 'input',
  64                                 onpostchange : function(field, newval) {
  65                                         var pw2 = uEditFindFieldByWId('ue_password2');
  66                                         /* tell the second passsword input to re-validate */
  67                                         pw2.widget.node.onchange();
  68                                 }
  69
  70                         }
  71                 },
  72                 {
  73                         required : (patron.isnew()) ? true : false,
  74                         object  : patron,
  75                         key             : 'passwd',
  76                         errkey  : 'ue_bad_password',
  77                         widget  : {
  78                                 id              : 'ue_password2',
  79                                 type    : 'input',
  80                                 onpostchange : function(field, newval) {
  81                                         var pw1f = uEditFindFieldByWId('ue_password1');
  82                                         var pw1 = uEditNodeVal(pw1f);
  83                                         if( pw1 == newval )
  84                                                 removeCSSClass(field.widget.node, CSS_INVALID_DATA);
  85                                         else
  86                                                 addCSSClass(field.widget.node, CSS_INVALID_DATA);
  87                                 }
  88                         }
  89                 },
  90                 {
  91                         required : true,
  92                         object  : patron,
  93                         key             : 'first_given_name',
  94                         errkey  : 'ue_bad_firstname',
  95                         widget  : {
  96                                 id              : 'ue_firstname',
  97                                 regex   : nonumRegex,
  98                                 type    : 'input',
  99                                 onblur : function(field) {
 100                                         uEditCheckNamesDup('first', field );
 101                                 }
 102                         }
 103                 },
 104
 105                 {
 106                         required : false,
 107                         object  : patron,
 108                         key             : 'second_given_name',
 109                         errkey  : 'ue_bad_middlename',
 110                         widget  : {
 111                                 id              : 'ue_middlename',
 112                                 regex   : nonumRegex,
 113                                 type    : 'input'
 114                         }
 115                 },
 116                 {
 117                         required : true,
 118                         object  : patron,
 119                         key             : 'family_name',
 120                         errkey  : 'ue_bad_lastname',
 121                         widget  : {
 122                                 id              : 'ue_lastname',
 123                                 regex   : nonumRegex,
 124                                 type    : 'input',
 125                                 onblur : function(field) {
 126                                         uEditCheckNamesDup('last', field );
 127                                 }
 128                         }
 129                 },
 130                 {
 131                         required : false,
 132                         object  : patron,
 133                         key             : 'suffix',
 134                         widget  : {
 135                                 id                      : 'ue_suffix',
 136                                 type            : 'input',
 137                                 onload  : function(val) {
 138                                         setSelector($('ue_suffix_selector'), val);
 139                                 }
 140                         }
 141                 },
 142                 {
 143                         required : true,
 144                         object  : patron,
 145                         key             : 'dob',
 146                         errkey  : 'ue_bad_dob',
 147                         widget  : {
 148                                 id                      : 'ue_dob',
 149                                 regex           : dateRegex,
 150                                 type            : 'input',
 151                         }
 152                 },
 153                 {
 154                         required : true,
 155                         object  : patron,
 156                         key             : 'ident_type',
 157                         errkey  : 'ue_no_ident',
 158                         widget  : {
 159                                 id              : 'ue_primary_ident_type',
 160                                 regex   : numRegex,
 161                                 type    : 'select',
 162                                 onpostchange : function(field, newval)
 163                                         { _uEditIdentPostchange('primary', field, newval); }
 164                         }
 165                 },
 166                 {
 167                         required : false,
 168                         object  : patron,
 169                         key             : 'ident_value',
 170                         widget  : {
 171                                 id                      : 'ue_primary_ident',
 172                                 type            : 'input',
 173                                 onblur : function(field) {
 174                                         uEditCheckIdentDup(field);
 175                                 }
 176                         }
 177                 },
 178                 {
 179                         required : false,
 180                         object  : patron,
 181                         key             : 'ident_type2',
 182                         widget  : {
 183                                 id              : 'ue_secondary_ident_type',
 184                                 regex   : numRegex,
 185                                 type    : 'select',
 186                                 onpostchange : function(field, newval)
 187                                         { _uEditIdentPostchange('secondary', field, newval); }
 188                         }
 189                 },
 190                 {
 191                         required : false,
 192                         object  : patron,
 193                         key             : 'ident_value2',
 194                         widget  : {
 195                                 id                      : 'ue_secondary_ident',
 196                                 type            : 'input',
 197                                 onblur : function(field) {
 198                                         uEditCheckIdentDup(field);
 199                                 }
 200                         }
 201                 },
 202                 {
 203                         required : false,
 204                         object  : patron,
 205                         key             : 'email',
 206                         errkey  : 'ue_bad_email',
 207                         widget  : {
 208                                 id                      : 'ue_email',
 209                                 type            : 'input',
 210                                 regex           :  /.+\@.+\..+/,  /* make me better */
 211                                 onblur  : function(field) {
 212                                         var val = uEditNodeVal(field);
 213                                         if( val && val != field.oldemail ) {
 214                                                 uEditRunDupeSearch('email',
 215                                                         { email : { value : val, group : 0 } });
 216                                                 field.oldemail = val;
 217                                         }
 218                                 }
 219                         }
 220                 },
 221                 {
 222                         required : false,
 223                         object  : patron,
 224                         key             : 'day_phone',
 225                         errkey  : 'ue_bad_phone',
 226                         widget  : {
 227                                 id                      : 'ue_day_phone',
 228                                 type            : 'input',
 229                                 regex           :  phoneRegex,
 230                         }
 231                 },
 232                 {
 233                         required : false,
 234                         object  : patron,
 235                         key             : 'evening_phone',
 236                         errkey  : 'ue_bad_phone',
 237                         widget  : {
 238                                 id                      : 'ue_night_phone',
 239                                 type            : 'input',
 240                                 regex           :  phoneRegex,
 241                         }
 242                 },
 243                 {
 244                         required : false,
 245                         object  : patron,
 246                         key             : 'other_phone',
 247                         errkey  : 'ue_bad_phone',
 248                         widget  : {
 249                                 id                      : 'ue_other_phone',
 250                                 type            : 'input',
 251                                 regex           :  phoneRegex,
 252                         }
 253                 },
 254                 {
 255                         required : true,
 256                         object  : patron,
 257                         key             : 'home_ou',
 258                         widget  : {
 259                                 id                      : 'ue_org_selector',
 260                                 type            : 'select',
 261                                 regex           :  numRegex,
 262                         }
 263                 },
 264                 {
 265                         required : true,
 266                         object  : patron,
 267                         key             : 'expire_date',
 268                         errkey  : 'ue_bad_expire',
 269                         widget  : {
 270                                 id                      : 'ue_expire',
 271                                 type            : 'input',
 272                                 regex           :  dateRegex,
 273                         }
 274                 },
 275                 {
 276                         required : false,
 277                         object  : patron,
 278                         key             : 'active',
 279                         widget  : {
 280                                 id                      : 'ue_active',
 281                                 type            : 'checkbox',
 282                         }
 283                 },
 284                 {
 285                         required : false,
 286                         object  : patron,
 287                         key             : 'barred',
 288                         widget  : {
 289                                 id                      : 'ue_barred',
 290                                 type            : 'checkbox',
 291                         }
 292                 },
 293                 {
 294                         required : true,
 295                         object  : patron,
 296                         key             : 'profile',
 297                         errkey  : 'ue_no_profile',
 298                         widget  : {
 299                                 id                      : 'ue_profile',
 300                                 type            : 'select',
 301                                 regex           : numRegex,
 302                                 onpostchange : function(field, value) {
 303                                         var type                        = groupsCache[value];
 304                                         var interval    = type.perm_interval();
 305                                         var intsecs             = parseInt(util.date.interval_to_seconds(interval));
 306
 307                                         var expdate             = new Date();
 308                                         var exptime             = expdate.getTime();
 309                                         exptime                 += intsecs * 1000;
 310                                         expdate.setTime(exptime);
 311
 312                                         var year                        = expdate.getYear() + 1900;
 313                                         var month               = (expdate.getMonth() + 1) + '';
 314                                         var day                 = (expdate.getDate() + 1) + '';
 315
 316                                         if(!month.match(/\d{2}/)) month = '0' + month;
 317                                         if(!day.match(/\d{2}/)) day = '0' + day;
 318
 319                                         var node = $('ue_expire');
 320                                         node.value = year+'-'+month+'-'+day;
 321                                 }
 322                         }
 323                 },
 324                 {
 325                         required : false,
 326                         object  : patron,
 327                         key             : 'master_account',
 328                         widget  : {
 329                                 id                      : 'ue_group_lead',
 330                                 type            : 'checkbox',
 331                         }
 332                 },
 333                 {
 334                         required : true,
 335                         object  : patron,
 336                         key             : 'claims_returned_count',
 337                         widget  : {
 338                                 id                      : 'ue_claims_returned',
 339                                 type            : 'input',
 340                                 regex           : numRegex,
 341                         }
 342                 },
 343                 {
 344                         required : false,
 345                         object  : patron,
 346                         key             : 'alert_message',
 347                         widget  : {
 348                                 id                      : 'ue_alert_message',
 349                                 type            : 'input',
 350                         }
 351                 }
 352         ];
 353
 354         for( var f in fields )
 355                 dataFields.push(fields[f]);
 356
 357         uEditBuildAddrs(patron);
 358         uEditBuildPatronSCM(patron);
 359 }
 360
 361 var uEditOldFirstName;
 362 var uEditOldMiddleName; /* future */
 363 var uEditOldLastName;
 364 function uEditCheckNamesDup(type, field) {
 365         var newval = uEditNodeVal(field);
 366         if(!newval) return;
 367
 368         var dosearch = false;
 369
 370         if(type =='first') {
 371                 if( newval != uEditOldFirstName )
 372                         dosearch = true;
 373                 uEditOldFirstName = newval;
 374         }
 375
 376         if(type =='last') {
 377                 if( newval != uEditOldLastName )
 378                         dosearch = true;
 379                 uEditOldLastName = newval;
 380         }
 381
 382         if( dosearch && uEditOldFirstName && uEditOldLastName ) {
 383                 var search_hash = {};
 384                 search_hash['first_given_name'] = { value : uEditOldFirstName, group : 0 };
 385                 search_hash['family_name'] = { value : uEditOldLastName, group : 0 };
 386                 uEditRunDupeSearch('names', search_hash);
 387         }
 388 }
 389
 390 var uEditOldIdentValue;
 391 function uEditCheckIdentDup(field) {
 392         var newval = uEditNodeVal(field);
 393         if( newval && newval != uEditOldIdentValue ) {
 394                 /* searches all ident_value fields */
 395                 var search_hash  = { ident : { value : newval, group : 2 } };
 396                 uEditRunDupeSearch('ident', search_hash);
 397                 uEditOldIdentValue = newval;
 398         }
 399 }
 400
 401
 402 /* Adds all of the addresses attached to the patron object
 403         to the fields array */
 404 var uEditAddrTemplate;
 405 function uEditBuildAddrs(patron) {
 406         var tbody = $('ue_address_tbody');
 407         /*
 408         uEditAddrTemplate =
 409                 tbody.removeChild($('ue_address_template'));
 410                 */
 411         for( var a in patron.addresses() ) {
 412                 if(!uEditAddrTemplate)
 413                         uEditAddrTemplate = tbody.removeChild($('ue_address_template'));
 414                 uEditBuildAddrFields( patron, patron.addresses()[a]);
 415         }
 416 }
 417
 418
 419 function uEditDeleteAddr( tbody, row, address, detach ) {
 420         if(!confirm($('ue_delete_addr_warn').innerHTML)) return;
 421         if(address.isnew()) {
 422                 patron.addresses(
 423                         grep( patron.addresses(),
 424                                 function(i) {
 425                                         return (i.id() != address.id());
 426                                 }
 427                         )
 428                 );
 429         } else {
 430                 if(!detach) address.isdeleted(1);
 431         }
 432         tbody.removeChild(row);
 433
 434         var bid = patron.billing_address();
 435         bid = (typeof bid == 'object') ? bid.id() : bid;
 436
 437         var mid = patron.mailing_address();
 438         mid = (typeof mid == 'object') ? mid.id() : mid;
 439
 440
 441         /* -----------------------------------------------------------------------
 442                 if we're deleting a billing or mailing address
 443                 make sure some other address is automatically
 444                 assigned as the billing or mailng address
 445                 ----------------------------------------------------------------------- */
 446
 447         if( bid == address.id() ) {
 448                 for( var a in patron.addresses() ) {
 449                         var addr = patron.addresses()[a];
 450                         if(!addr.isdeleted() && addr.id() != address.id()) {
 451                                 var node = uEditFindAddrInput('billing', addr.id());
 452                                 node.checked = true;
 453                                 uEditAddrTypeClick(node, 'billing');
 454                                 break;
 455                         }
 456                 }
 457         }
 458
 459         if( mid == address.id() ) {
 460                 for( var a in patron.addresses() ) {
 461                         var addr = patron.addresses()[a];
 462                         if(!addr.isdeleted() && addr.id() != address.id()) {
 463                                 var node = uEditFindAddrInput('mailing', addr.id());
 464                                 node.checked = true;
 465                                 uEditAddrTypeClick(node, 'mailing');
 466                                 break;
 467                         }
 468                 }
 469         }
 470 }
 471
 472
 473 function uEditFindAddrInput(type, id) {
 474         var tbody = $('ue_address_tbody');
 475         var rows = tbody.getElementsByTagName('tr');
 476         for( var r in rows ) {
 477                 var row = rows[r];
 478                 if(row.parentNode != tbody) continue;
 479                 var node = $n(row, 'ue_addr_'+type+'_yes');
 480                 if( node.getAttribute('address') == id )
 481                         return node;
 482         }
 483 }
 484
 485
 486 function uEditAddrTypeClick(input, type) {
 487         var tbody = $('ue_address_tbody');
 488         var rows = tbody.getElementsByTagName('tr');
 489         for( var r in rows ) {
 490                 var row = rows[r];
 491                 if(row.parentNode != tbody) continue;
 492                 var node = $n(row, 'ue_addr_'+type+'_yes');
 493                 removeCSSClass(node.parentNode,'addr_info_checked');
 494         }
 495
 496         addCSSClass(input.parentNode,'addr_info_checked');
 497         patron[type+'_address'](input.getAttribute('address'));
 498         patron.ischanged(1);
 499 }
 500
 501
 502
 503
 504 /* Creates the field entries for an address object. */
 505 function uEditBuildAddrFields(patron, address) {
 506
 507         var tbody = $('ue_address_tbody');
 508
 509
 510
 511         var row = tbody.appendChild(
 512                 uEditAddrTemplate.cloneNode(true));
 513
 514         uEditCheckSharedAddr(patron, address, tbody, row);
 515
 516         $n(row, 'ue_addr_delete').onclick =
 517                 function() { uEditDeleteAddr(tbody, row, address); }
 518
 519         if( address.id() == patron.billing_address().id() )
 520                 $n(row, 'ue_addr_billing_yes').checked = true;
 521
 522         if( address.id() == patron.mailing_address().id() )
 523                 $n(row, 'ue_addr_mailing_yes').checked = true;
 524
 525         $n(row, 'ue_addr_billing_yes').setAttribute('address', address.id());
 526         $n(row, 'ue_addr_mailing_yes').setAttribute('address', address.id());
 527
 528         var fields = [
 529                 {
 530                         required : false,
 531                         object  : address,
 532                         key             : 'address_type',
 533                         widget  : {
 534                                 base    : row,
 535                                 name    : 'ue_addr_label',
 536                                 type    : 'input',
 537                         }
 538                 },
 539                 {
 540                         required : true,
 541                         object  : address,
 542                         key             : 'street1',
 543                         errkey  : 'ue_bad_addr_street',
 544                         widget  : {
 545                                 base    : row,
 546                                 name    : 'ue_addr_street1',
 547                                 type    : 'input',
 548                         }
 549                 },
 550                 {
 551                         required : false,
 552                         object  : address,
 553                         key             : 'street2',
 554                         errkey  : 'ue_bad_addr_street',
 555                         widget  : {
 556                                 base    : row,
 557                                 name    : 'ue_addr_street2',
 558                                 type    : 'input',
 559                         }
 560                 },
 561                 {
 562                         required : true,
 563                         object  : address,
 564                         key             : 'city',
 565                         errkey  : 'ue_bad_addr_city',
 566                         widget  : {
 567                                 base    : row,
 568                                 name    : 'ue_addr_city',
 569                                 type    : 'input',
 570                         }
 571                 },
 572                 {
 573                         required : false,
 574                         object  : address,
 575                         key             : 'county',
 576                         widget  : {
 577                                 base    : row,
 578                                 name    : 'ue_addr_county',
 579                                 type    : 'input',
 580                         }
 581                 },
 582                 {
 583                         required : true,
 584                         object  : address,
 585                         key             : 'state',
 586                         errkey  : 'ue_bad_addr_state',
 587                         widget  : {
 588                                 base    : row,
 589                                 name    : 'ue_addr_state',
 590                                 type    : 'input',
 591                         }
 592                 },
 593                 {
 594                         required : true,
 595                         object  : address,
 596                         key             : 'country',
 597                         errkey  : 'ue_bad_addr_country',
 598                         widget  : {
 599                                 base    : row,
 600                                 name    : 'ue_addr_country',
 601                                 type    : 'input',
 602                         }
 603                 },
 604                 {
 605                         required : true,
 606                         object  : address,
 607                         key             : 'post_code',
 608                         errkey  : 'ue_bad_addr_zip',
 609                         widget  : {
 610                                 base    : row,
 611                                 name    : 'ue_addr_zip',
 612                                 type    : 'input',
 613                                 regex   : /^\d{5}$/,
 614                                 onblur : function(f) {
 615                                         var v = uEditNodeVal(f);
 616                                         var req = new Request(ZIP_SEARCH, v);
 617                                         req.callback(
 618                                                 function(r) {
 619                                                         var info = r.getResultObject();
 620                                                         if(!info) return;
 621                                                         var state = $n(f.widget.base, 'ue_addr_state');
 622                                                         var county = $n(f.widget.base, 'ue_addr_county');
 623                                                         var city = $n(f.widget.base, 'ue_addr_city');
 624                                                         if(!state.value) state.value = info.state;
 625                                                         if(!county.value) county.value = info.county;
 626                                                         if(!city.value) city.value = info.city;
 627                                                 }
 628                                         );
 629                                         req.send();
 630                                 }
 631                         }
 632                 },
 633                 {
 634                         required : false,
 635                         object  : address,
 636                         key             : 'within_city_limits',
 637                         widget  : {
 638                                 base    : row,
 639                                 name    : 'ue_addr_inc_yes',
 640                                 type    : 'checkbox',
 641                         }
 642                 },
 643                 {
 644                         required : false,
 645                         object  : address,
 646                         key             : 'valid',
 647                         widget  : {
 648                                 base    : row,
 649                                 name    : 'ue_addr_valid_yes',
 650                                 type    : 'checkbox',
 651                         }
 652                 }
 653         ];
 654
 655         for( var f in fields ) {
 656                 dataFields.push(fields[f]);
 657                 uEditActivateField(fields[f]);
 658         }
 659 }
 660
 661 function uEditBuildPatronSCM(patron) {
 662         /* get the list of pre-defined maps */
 663         var fields = uEditFindFieldsByKey('stat_cat_entry');
 664         var map;
 665         var newmaps = [];
 666
 667         /* for each user stat cat, pop it off the list,
 668         updated the existing stat map field to match
 669         the popped map and shove the existing stat
 670         map field onto the user's list of stat maps */
 671         while( (map = patron.stat_cat_entries().pop()) ) {
 672
 673                 var field = grep(fields,
 674                         function(item) {
 675                                 return (item.object.stat_cat() == map.stat_cat());
 676                         }
 677                 );
 678
 679                 if(field) {
 680                         var val = map.stat_cat_entry();
 681                         field = field[0];
 682                         $n(field.widget.base, field.widget.name).value = val;
 683                         setSelector($n(field.widget.base, 'ue_stat_cat_selector'), val );
 684                         field.object.stat_cat_entry(val);
 685                         field.object.id(map.id());
 686                         newmaps.push(field.object);
 687                 }
 688         }
 689
 690         for( var m in newmaps )
 691                 patron.stat_cat_entries().push(newmaps[m]);
 692 }
 693
 694
 695 function uEditBuildSCMField(statcat, row) {
 696
 697         var map = new actscecm();
 698         map.stat_cat(statcat.id());
 699         map.target_usr(patron.id());
 700
 701         var field = {
 702                 required : false,
 703                 object  : map,
 704                 key             : 'stat_cat_entry',
 705                 widget  : {
 706                         base    : row,
 707                         name    : 'ue_stat_cat_newval',
 708                         type    : 'input',
 709
 710                         onpostchange : function( field, newval ) {
 711
 712                                 /* see if the current map already resides in
 713                                         the patron entry list */
 714                                 var exists = grep( patron.stat_cat_entries(),
 715                                         function(item) {
 716                                                 return (item.stat_cat() == statcat.id());
 717                                         }
 718                                 );
 719
 720                                 if(newval) {
 721                                         map.isdeleted(0);
 722                                         setSelector($n(row, 'ue_stat_cat_selector'), newval);
 723                                 }
 724
 725                                 if(exists) {
 726                                         if(!newval) {
 727
 728                                                 /* if the map is new but currently contains no value
 729                                                         remove it from the set of new maps */
 730                                                 if(map.isnew()) {
 731                                                         patron.stat_cat_entries(
 732                                                                 grep( patron.stat_cat_entries(),
 733                                                                         function(item) {
 734                                                                                 return (item.stat_cat() != map.stat_cat());
 735                                                                         }
 736                                                                 )
 737                                                         );
 738
 739                                                 } else {
 740                                                         map.isdeleted(1);
 741                                                         map.ischanged(0);
 742                                                 }
 743                                         }
 744
 745                                 } else {
 746
 747                                         /* map does not exist in the map array but now has data */
 748                                         if(newval) {
 749                                                 map.isnew(1);
 750                                                 patron.stat_cat_entries().push(map);
 751                                         }
 752                                 }
 753                         }
 754                 }
 755         }
 756
 757         dataFields.push(field);
 758 }
 759
 760
 761
 762 /** Run this after a new ident type is selected */
 763 function _uEditIdentPostchange(type, field, newval) {
 764
 765         if(!newval) return;
 766
 767         /* When the ident type is changed, we change the
 768         regex on the ident_value to match the selected type */
 769         var vfname = 'ident_value';
 770         if(type == 'secondary') vfname = 'ident_value2';
 771         var vfield = uEditFindFieldByKey(vfname);
 772         var name = identTypesCache[uEditNodeVal(field)].name();
 773
 774         hideMe($(type+'_ident_ssn_help'));
 775         hideMe($(type+'_ident_dl_help'));
 776
 777         if(name.match(/ssn/i)) {
 778                 vfield.widget.regex = ssnRegex;
 779                 vfield.errkey = 'ue_bad_ident_ssn';
 780                 unHideMe($(type+'_ident_ssn_help'));
 781
 782         } else {
 783
 784                 if(name.match(/driver/i)) {
 785                         vfield.widget.regex = dlRegex;
 786                         vfield.errkey = 'ue_bad_ident_dl';
 787                         unHideMe($(type+'_ident_dl_help'));
 788                         if(!uEditNodeVal(vfield))
 789                                 vfield.widget.node.value = defaultState + '-';
 790
 791                 } else {
 792                         vfield.widget.regex = null;
 793                         vfield.errkey = null;
 794                 }
 795         }
 796
 797         /* focus then valdate the value field */
 798         vfield.widget.node.onchange();
 799         vfield.widget.node.focus();
 800 }
 801
 802
 803 /* checks to see if the given address is shared by others.
 804  * if so, the address row is styled and ...
 805  */
 806 function uEditCheckSharedAddr(patron, address, tbody, row) {
 807         var req = new Request(FETCH_ADDR_MEMS, SESSION, address.id());
 808         req.callback(
 809                 function(r) {
 810                         var members = r.getResultObject();
 811                         for( var m in members ) {
 812                                 var id = members[m];
 813
 814                                 if( id != patron.id() ) {
 815
 816                                         addCSSClass(row, 'shared_address');
 817                                         unHideMe($n(row, 'shared_row'));
 818                                         $n(row, 'ue_addr_delete').disabled = true;
 819
 820                                         if( address.usr() != patron.id() ) {
 821                                                 var button = $n(row, 'ue_addr_detach');
 822                                                 unHideMe(button);
 823                                                 button.onclick =
 824                                                         function() { uEditDeleteAddr( tbody, row, address, true ); }
 825                                         }
 826
 827                                         break;
 828                                 }
 829                         }
 830                 }
 831         );
 832         req.send();
 833 }
 834
 835
 836
 837
 838
 839