18093d42ff1a5d9b2edf29b499cb5d43593520a5
[Evergreen.git] / Open-ILS / src / perlmods / OpenILS / Application / Actor.pm
1 package OpenILS::Application::Actor;
2 use base qw/OpenSRF::Application/;
3 use strict; use warnings;
4 use Data::Dumper;
5 $Data::Dumper::Indent = 0;
6 use OpenILS::Event;
7
8 use Digest::MD5 qw(md5_hex);
9
10 use OpenSRF::EX qw(:try);
11 use OpenILS::Perm;
12
13 use OpenILS::Application::AppUtils;
14
15 use OpenILS::Utils::Fieldmapper;
16 use OpenILS::Utils::ModsParser;
17 use OpenSRF::Utils::Logger qw/$logger/;
18 use OpenSRF::Utils qw/:datetime/;
19
20 use OpenSRF::Utils::Cache;
21
22 use JSON;
23 use DateTime;
24 use DateTime::Format::ISO8601;
25 use OpenILS::Const qw/:const/;
26
27 use OpenILS::Application::Actor::Container;
28 use OpenILS::Application::Actor::ClosedDates;
29
30 use OpenILS::Utils::CStoreEditor qw/:funcs/;
31
32 use OpenILS::Application::Actor::UserGroups;
33 sub initialize {
34         OpenILS::Application::Actor::Container->initialize();
35         OpenILS::Application::Actor::UserGroups->initialize();
36         OpenILS::Application::Actor::ClosedDates->initialize();
37 }
38
39 my $apputils = "OpenILS::Application::AppUtils";
40 my $U = $apputils;
41
42 sub _d { warn "Patron:\n" . Dumper(shift()); }
43
44 my $cache;
45
46
47 my $set_user_settings;
48 my $set_ou_settings;
49
50 __PACKAGE__->register_method(
51         method  => "set_user_settings",
52         api_name        => "open-ils.actor.patron.settings.update",
53 );
54 sub set_user_settings {
55         my( $self, $client, $user_session, $uid, $settings ) = @_;
56         
57         $logger->debug("Setting user settings: $user_session, $uid, " . Dumper($settings));
58
59         my( $staff, $user, $evt ) = 
60                 $apputils->checkses_requestor( $user_session, $uid, 'UPDATE_USER' );    
61         return $evt if $evt;
62         
63         my @params = map { 
64                 [{ usr => $user->id, name => $_}, {value => $$settings{$_}}] } keys %$settings;
65                 
66         $_->[1]->{value} = JSON->perl2JSON($_->[1]->{value}) for @params;
67
68         $logger->activity("User " . $staff->id . " updating user $uid settings with: " . Dumper(\@params));
69
70         my $ses = $U->start_db_session();
71         my $stat = $ses->request(
72                 'open-ils.storage.direct.actor.user_setting.batch.merge', @params )->gather(1);
73         $U->commit_db_session($ses);
74
75         return $stat;
76 }
77
78
79
80 __PACKAGE__->register_method(
81         method  => "set_ou_settings",
82         api_name        => "open-ils.actor.org_unit.settings.update",
83 );
84 sub set_ou_settings {
85         my( $self, $client, $user_session, $ouid, $settings ) = @_;
86         
87         my( $staff, $evt ) = $apputils->checkses( $user_session );
88         return $evt if $evt;
89         $evt = $apputils->check_perms( $staff->id, $ouid, 'UPDATE_ORG_SETTING' );
90         return $evt if $evt;
91
92         my @params;
93         for my $set (keys %$settings) {
94
95                 my $json = JSON->perl2JSON($$settings{$set});
96                 $logger->activity("updating org_unit.setting: $ouid : $set : $json");
97
98                 push( @params, 
99                         { org_unit => $ouid, name => $set }, 
100                         { value => $json } );
101         }
102
103         my $ses = $U->start_db_session();
104         my $stat = $ses->request(
105                 'open-ils.storage.direct.actor.org_unit_setting.merge', @params )->gather(1);
106         $U->commit_db_session($ses);
107
108         return $stat;
109 }
110
111
112 my $fetch_user_settings;
113 my $fetch_ou_settings;
114
115 __PACKAGE__->register_method(
116         method  => "user_settings",
117         api_name        => "open-ils.actor.patron.settings.retrieve",
118 );
119 sub user_settings {
120         my( $self, $client, $user_session, $uid ) = @_;
121         
122         my( $staff, $user, $evt ) = 
123                 $apputils->checkses_requestor( $user_session, $uid, 'VIEW_USER' );
124         return $evt if $evt;
125
126         $logger->debug("User " . $staff->id . " fetching user $uid\n");
127         my $s = $apputils->simplereq(
128                 'open-ils.cstore',
129                 'open-ils.cstore.direct.actor.user_setting.search.atomic', { usr => $uid } );
130
131         return { map { ( $_->name => JSON->JSON2perl($_->value) ) } @$s };
132 }
133
134
135
136 __PACKAGE__->register_method(
137         method  => "ou_settings",
138         api_name        => "open-ils.actor.org_unit.settings.retrieve",
139 );
140 sub ou_settings {
141         my( $self, $client, $ouid ) = @_;
142         
143         $logger->info("Fetching org unit settings for org $ouid");
144
145         my $s = $apputils->simplereq(
146                 'open-ils.cstore',
147                 'open-ils.cstore.direct.actor.org_unit_setting.search.atomic', {org_unit => $ouid});
148
149         return { map { ( $_->name => JSON->JSON2perl($_->value) ) } @$s };
150 }
151
152 __PACKAGE__->register_method (
153         method          => "ou_setting_delete",
154         api_name                => 'open-ils.actor.org_setting.delete',
155         signature       => q/
156                 Deletes a specific org unit setting for a specific location
157                 @param authtoken The login session key
158                 @param orgid The org unit whose setting we're changing
159                 @param setting The name of the setting to delete
160                 @return True value on success.
161         /
162 );
163
164 sub ou_setting_delete {
165         my( $self, $conn, $authtoken, $orgid, $setting ) = @_;
166         my( $reqr, $evt) = $U->checkses($authtoken);
167         return $evt if $evt;
168         $evt = $U->check_perms($reqr->id, $orgid, 'UPDATE_ORG_SETTING');
169         return $evt if $evt;
170
171         my $id = $U->cstorereq(
172                 'open-ils.cstore.direct.actor.org_unit_setting.id_list', 
173                 { name => $setting, org_unit => $orgid } );
174
175         $logger->debug("Retrieved setting $id in org unit setting delete");
176
177         my $s = $U->cstorereq(
178                 'open-ils.cstore.direct.actor.org_unit_setting.delete', $id );
179
180         $logger->activity("User ".$reqr->id." deleted org unit setting $id") if $s;
181         return $s;
182 }
183
184
185
186 __PACKAGE__->register_method(
187         method  => "update_patron",
188         api_name        => "open-ils.actor.patron.update",);
189
190 sub update_patron {
191         my( $self, $client, $user_session, $patron ) = @_;
192
193         my $session = $apputils->start_db_session();
194         my $err = undef;
195
196         $logger->info("Creating new patron...") if $patron->isnew; 
197         $logger->info("Updating Patron: " . $patron->id) unless $patron->isnew;
198
199         my( $user_obj, $evt ) = $U->checkses($user_session);
200         return $evt if $evt;
201
202         # XXX does this user have permission to add/create users.  Granularity?
203         # $new_patron is the patron in progress.  $patron is the original patron
204         # passed in with the method.  new_patron will change as the components
205         # of patron are added/updated.
206
207         my $new_patron;
208
209         # unflesh the real items on the patron
210         $patron->card( $patron->card->id ) if(ref($patron->card));
211         $patron->billing_address( $patron->billing_address->id ) 
212                 if(ref($patron->billing_address));
213         $patron->mailing_address( $patron->mailing_address->id ) 
214                 if(ref($patron->mailing_address));
215
216         # create/update the patron first so we can use his id
217         if($patron->isnew()) {
218                 ( $new_patron, $evt ) = _add_patron($session, _clone_patron($patron), $user_obj);
219                 return $evt if $evt;
220         } else { $new_patron = $patron; }
221
222         ( $new_patron, $evt ) = _add_update_addresses($session, $patron, $new_patron, $user_obj);
223         return $evt if $evt;
224
225         ( $new_patron, $evt ) = _add_update_cards($session, $patron, $new_patron, $user_obj);
226         return $evt if $evt;
227
228         ( $new_patron, $evt ) = _add_survey_responses($session, $patron, $new_patron, $user_obj);
229         return $evt if $evt;
230
231         # re-update the patron if anything has happened to him during this process
232         if($new_patron->ischanged()) {
233                 ( $new_patron, $evt ) = _update_patron($session, $new_patron, $user_obj);
234                 return $evt if $evt;
235         }
236
237         #$session = OpenSRF::AppSession->create("open-ils.storage");  # why did i put this here?
238
239         ($new_patron, $evt) = _create_stat_maps($session, $user_session, $patron, $new_patron, $user_obj);
240         return $evt if $evt;
241
242         ($new_patron, $evt) = _create_perm_maps($session, $user_session, $patron, $new_patron, $user_obj);
243         return $evt if $evt;
244
245         ($new_patron, $evt) = _create_standing_penalties($session, $user_session, $patron, $new_patron, $user_obj);
246         return $evt if $evt;
247
248         $logger->activity("user ".$user_obj->id." updating/creating  user ".$new_patron->id);
249
250         my $opatron;
251         if(!$patron->isnew) {
252                 $opatron = new_editor()->retrieve_actor_user($new_patron->id);
253         }
254
255         $apputils->commit_db_session($session);
256         my $fuser =  flesh_user($new_patron->id());
257
258         if( $opatron ) {
259                 # Log the new and old patron for investigation
260                 $logger->info("$user_session updating patron object. orig patron object = ".
261                         JSON->perl2JSON($opatron). " |||| new patron = ".JSON->perl2JSON($fuser));
262         }
263
264
265         return $fuser;
266 }
267
268
269 sub flesh_user {
270         my $id = shift;
271         return new_flesh_user($id, [
272                 "cards",
273                 "card",
274                 "standing_penalties",
275                 "addresses",
276                 "billing_address",
277                 "mailing_address",
278                 "stat_cat_entries" ] );
279 }
280
281
282
283
284
285
286 # clone and clear stuff that would break the database
287 sub _clone_patron {
288         my $patron = shift;
289
290         my $new_patron = $patron->clone;
291         # clear these
292         $new_patron->clear_billing_address();
293         $new_patron->clear_mailing_address();
294         $new_patron->clear_addresses();
295         $new_patron->clear_card();
296         $new_patron->clear_cards();
297         $new_patron->clear_id();
298         $new_patron->clear_isnew();
299         $new_patron->clear_ischanged();
300         $new_patron->clear_isdeleted();
301         $new_patron->clear_stat_cat_entries();
302         $new_patron->clear_permissions();
303         $new_patron->clear_standing_penalties();
304
305         return $new_patron;
306 }
307
308
309 sub _add_patron {
310
311         my $session             = shift;
312         my $patron              = shift;
313         my $user_obj    = shift;
314
315         my $evt = $U->check_perms($user_obj->id, $patron->home_ou, 'CREATE_USER');
316         return (undef, $evt) if $evt;
317
318         my $ex = $session->request(
319                 'open-ils.storage.direct.actor.user.search.usrname', $patron->usrname())->gather(1);
320         if( $ex and @$ex ) {
321                 return (undef, OpenILS::Event->new('USERNAME_EXISTS'));
322         }
323
324         $logger->info("Creating new user in the DB with username: ".$patron->usrname());
325
326         my $id = $session->request(
327                 "open-ils.storage.direct.actor.user.create", $patron)->gather(1);
328         return (undef, $U->DB_UPDATE_FAILED($patron)) unless $id;
329
330         $logger->info("Successfully created new user [$id] in DB");
331
332         return ( $session->request( 
333                 "open-ils.storage.direct.actor.user.retrieve", $id)->gather(1), undef );
334 }
335
336
337 sub _update_patron {
338         my( $session, $patron, $user_obj, $noperm) = @_;
339
340         $logger->info("Updating patron ".$patron->id." in DB");
341
342         my $evt;
343
344         if(!$noperm) {
345                 $evt = $U->check_perms($user_obj->id, $patron->home_ou, 'UPDATE_USER');
346                 return (undef, $evt) if $evt;
347         }
348
349         # update the password by itself to avoid the password protection magic
350         if( $patron->passwd ) {
351                 my $s = $session->request(
352                         'open-ils.storage.direct.actor.user.remote_update',
353                         {id => $patron->id}, {passwd => $patron->passwd})->gather(1);
354                 return (undef, $U->DB_UPDATE_FAILED($patron)) unless defined($s);
355                 $patron->clear_passwd;
356         }
357
358         if(!$patron->ident_type) {
359                 $patron->clear_ident_type;
360                 $patron->clear_ident_value;
361         }
362
363         my $stat = $session->request(
364                 "open-ils.storage.direct.actor.user.update",$patron )->gather(1);
365         return (undef, $U->DB_UPDATE_FAILED($patron)) unless defined($stat);
366
367         return ($patron);
368 }
369
370 sub _check_dup_ident {
371         my( $session, $patron ) = @_;
372
373         return undef unless $patron->ident_value;
374
375         my $search = {
376                 ident_type      => $patron->ident_type, 
377                 ident_value => $patron->ident_value,
378         };
379
380         $logger->debug("patron update searching for dup ident values: " . 
381                 $patron->ident_type . ':' . $patron->ident_value);
382
383         $search->{id} = {'!=' => $patron->id} if $patron->id and $patron->id > 0;
384
385         my $dups = $session->request(
386                 'open-ils.storage.direct.actor.user.search_where.atomic', $search )->gather(1);
387
388
389         return OpenILS::Event->new('PATRON_DUP_IDENT1', payload => $patron )
390                 if $dups and @$dups;
391
392         return undef;
393 }
394
395
396 sub _add_update_addresses {
397
398         my $session = shift;
399         my $patron = shift;
400         my $new_patron = shift;
401
402         my $evt;
403
404         my $current_id; # id of the address before creation
405
406         for my $address (@{$patron->addresses()}) {
407
408                 next unless ref $address;
409                 $current_id = $address->id();
410
411                 if( $patron->billing_address() and
412                         $patron->billing_address() == $current_id ) {
413                         $logger->info("setting billing addr to $current_id");
414                         $new_patron->billing_address($address->id());
415                         $new_patron->ischanged(1);
416                 }
417         
418                 if( $patron->mailing_address() and
419                         $patron->mailing_address() == $current_id ) {
420                         $new_patron->mailing_address($address->id());
421                         $logger->info("setting mailing addr to $current_id");
422                         $new_patron->ischanged(1);
423                 }
424
425
426                 if($address->isnew()) {
427
428                         $address->usr($new_patron->id());
429
430                         ($address, $evt) = _add_address($session,$address);
431                         return (undef, $evt) if $evt;
432
433                         # we need to get the new id
434                         if( $patron->billing_address() and 
435                                         $patron->billing_address() == $current_id ) {
436                                 $new_patron->billing_address($address->id());
437                                 $logger->info("setting billing addr to $current_id");
438                                 $new_patron->ischanged(1);
439                         }
440
441                         if( $patron->mailing_address() and
442                                         $patron->mailing_address() == $current_id ) {
443                                 $new_patron->mailing_address($address->id());
444                                 $logger->info("setting mailing addr to $current_id");
445                                 $new_patron->ischanged(1);
446                         }
447
448                 } elsif($address->ischanged() ) {
449
450                         ($address, $evt) = _update_address($session, $address);
451                         return (undef, $evt) if $evt;
452
453                 } elsif($address->isdeleted() ) {
454
455                         if( $address->id() == $new_patron->mailing_address() ) {
456                                 $new_patron->clear_mailing_address();
457                                 ($new_patron, $evt) = _update_patron($session, $new_patron);
458                                 return (undef, $evt) if $evt;
459                         }
460
461                         if( $address->id() == $new_patron->billing_address() ) {
462                                 $new_patron->clear_billing_address();
463                                 ($new_patron, $evt) = _update_patron($session, $new_patron);
464                                 return (undef, $evt) if $evt;
465                         }
466
467                         $evt = _delete_address($session, $address);
468                         return (undef, $evt) if $evt;
469                 } 
470         }
471
472         return ( $new_patron, undef );
473 }
474
475
476 # adds an address to the db and returns the address with new id
477 sub _add_address {
478         my($session, $address) = @_;
479         $address->clear_id();
480
481         $logger->info("Creating new address at street ".$address->street1);
482
483         # put the address into the database
484         my $id = $session->request(
485                 "open-ils.storage.direct.actor.user_address.create", $address )->gather(1);
486         return (undef, $U->DB_UPDATE_FAILED($address)) unless $id;
487
488         $address->id( $id );
489         return ($address, undef);
490 }
491
492
493 sub _update_address {
494         my( $session, $address ) = @_;
495
496         $logger->info("Updating address ".$address->id." in the DB");
497
498         my $stat = $session->request(
499                 "open-ils.storage.direct.actor.user_address.update", $address )->gather(1);
500
501         return (undef, $U->DB_UPDATE_FAILED($address)) unless defined($stat);
502         return ($address, undef);
503 }
504
505
506
507 sub _add_update_cards {
508
509         my $session = shift;
510         my $patron = shift;
511         my $new_patron = shift;
512
513         my $evt;
514
515         my $virtual_id; #id of the card before creation
516         for my $card (@{$patron->cards()}) {
517
518                 $card->usr($new_patron->id());
519
520                 if(ref($card) and $card->isnew()) {
521
522                         $virtual_id = $card->id();
523                         ( $card, $evt ) = _add_card($session,$card);
524                         return (undef, $evt) if $evt;
525
526                         #if(ref($patron->card)) { $patron->card($patron->card->id); }
527                         if($patron->card() == $virtual_id) {
528                                 $new_patron->card($card->id());
529                                 $new_patron->ischanged(1);
530                         }
531
532                 } elsif( ref($card) and $card->ischanged() ) {
533                         $evt = _update_card($session, $card);
534                         return (undef, $evt) if $evt;
535                 }
536         }
537
538         return ( $new_patron, undef );
539 }
540
541
542 # adds an card to the db and returns the card with new id
543 sub _add_card {
544         my( $session, $card ) = @_;
545         $card->clear_id();
546
547         $logger->info("Adding new patron card ".$card->barcode);
548
549         my $id = $session->request(
550                 "open-ils.storage.direct.actor.card.create", $card )->gather(1);
551         return (undef, $U->DB_UPDATE_FAILED($card)) unless $id;
552         $logger->info("Successfully created patron card $id");
553
554         $card->id($id);
555         return ( $card, undef );
556 }
557
558
559 # returns event on error.  returns undef otherwise
560 sub _update_card {
561         my( $session, $card ) = @_;
562         $logger->info("Updating patron card ".$card->id);
563
564         my $stat = $session->request(
565                 "open-ils.storage.direct.actor.card.update", $card )->gather(1);
566         return $U->DB_UPDATE_FAILED($card) unless defined($stat);
567         return undef;
568 }
569
570
571
572
573 # returns event on error.  returns undef otherwise
574 sub _delete_address {
575         my( $session, $address ) = @_;
576
577         $logger->info("Deleting address ".$address->id." from DB");
578
579         my $stat = $session->request(
580                 "open-ils.storage.direct.actor.user_address.delete", $address )->gather(1);
581
582         return $U->DB_UPDATE_FAILED($address) unless defined($stat);
583         return undef;
584 }
585
586
587
588 sub _add_survey_responses {
589         my ($session, $patron, $new_patron) = @_;
590
591         $logger->info( "Updating survey responses for patron ".$new_patron->id );
592
593         my $responses = $patron->survey_responses;
594
595         if($responses) {
596
597                 $_->usr($new_patron->id) for (@$responses);
598
599                 my $evt = $U->simplereq( "open-ils.circ", 
600                         "open-ils.circ.survey.submit.user_id", $responses );
601
602                 return (undef, $evt) if defined($U->event_code($evt));
603
604         }
605
606         return ( $new_patron, undef );
607 }
608
609
610 sub _create_stat_maps {
611
612         my($session, $user_session, $patron, $new_patron) = @_;
613
614         my $maps = $patron->stat_cat_entries();
615
616         for my $map (@$maps) {
617
618                 my $method = "open-ils.storage.direct.actor.stat_cat_entry_user_map.update";
619
620                 if ($map->isdeleted()) {
621                         $method = "open-ils.storage.direct.actor.stat_cat_entry_user_map.delete";
622
623                 } elsif ($map->isnew()) {
624                         $method = "open-ils.storage.direct.actor.stat_cat_entry_user_map.create";
625                         $map->clear_id;
626                 }
627
628
629                 $map->target_usr($new_patron->id);
630
631                 #warn "
632                 $logger->info("Updating stat entry with method $method and map $map");
633
634                 my $stat = $session->request($method, $map)->gather(1);
635                 return (undef, $U->DB_UPDATE_FAILED($map)) unless defined($stat);
636
637         }
638
639         return ($new_patron, undef);
640 }
641
642 sub _create_perm_maps {
643
644         my($session, $user_session, $patron, $new_patron) = @_;
645
646         my $maps = $patron->permissions;
647
648         for my $map (@$maps) {
649
650                 my $method = "open-ils.storage.direct.permission.usr_perm_map.update";
651                 if ($map->isdeleted()) {
652                         $method = "open-ils.storage.direct.permission.usr_perm_map.delete";
653                 } elsif ($map->isnew()) {
654                         $method = "open-ils.storage.direct.permission.usr_perm_map.create";
655                         $map->clear_id;
656                 }
657
658
659                 $map->usr($new_patron->id);
660
661                 #warn( "Updating permissions with method $method and session $user_session and map $map" );
662                 $logger->info( "Updating permissions with method $method and map $map" );
663
664                 my $stat = $session->request($method, $map)->gather(1);
665                 return (undef, $U->DB_UPDATE_FAILED($map)) unless defined($stat);
666
667         }
668
669         return ($new_patron, undef);
670 }
671
672
673 sub _create_standing_penalties {
674
675         my($session, $user_session, $patron, $new_patron) = @_;
676
677         my $maps = $patron->standing_penalties;
678         my $method;
679
680         for my $map (@$maps) {
681
682                 if ($map->isdeleted()) {
683                         $method = "open-ils.storage.direct.actor.user_standing_penalty.delete";
684                 } elsif ($map->isnew()) {
685                         $method = "open-ils.storage.direct.actor.user_standing_penalty.create";
686                         $map->clear_id;
687                 } else {
688                         next;
689                 }
690
691                 $map->usr($new_patron->id);
692
693                 $logger->debug( "Updating standing penalty with method $method and session $user_session and map $map" );
694
695                 my $stat = $session->request($method, $map)->gather(1);
696                 return (undef, $U->DB_UPDATE_FAILED($map)) unless $stat;
697         }
698
699         return ($new_patron, undef);
700 }
701
702
703
704 __PACKAGE__->register_method(
705         method  => "search_username",
706         api_name        => "open-ils.actor.user.search.username",
707 );
708
709 sub search_username {
710         my($self, $client, $username) = @_;
711         my $users = OpenILS::Application::AppUtils->simple_scalar_request(
712                         "open-ils.cstore", 
713                         "open-ils.cstore.direct.actor.user.search.atomic",
714                         { usrname => $username }
715         );
716         return $users;
717 }
718
719
720
721
722 __PACKAGE__->register_method(
723         method  => "user_retrieve_by_barcode",
724         api_name        => "open-ils.actor.user.fleshed.retrieve_by_barcode",);
725
726 sub user_retrieve_by_barcode {
727         my($self, $client, $user_session, $barcode) = @_;
728
729         $logger->debug("Searching for user with barcode $barcode");
730         my ($user_obj, $evt) = $apputils->checkses($user_session);
731         return $evt if $evt;
732
733         my $card = OpenILS::Application::AppUtils->simple_scalar_request(
734                         "open-ils.cstore", 
735                         "open-ils.cstore.direct.actor.card.search.atomic",
736                         { barcode => $barcode }
737         );
738
739         if(!$card || !$card->[0]) {
740                 return OpenILS::Event->new( 'ACTOR_USER_NOT_FOUND' );
741         }
742
743         $card = $card->[0];
744         my $user = flesh_user($card->usr());
745
746         $evt = $U->check_perms($user_obj->id, $user->home_ou, 'VIEW_USER');
747         return $evt if $evt;
748
749         if(!$user) { return OpenILS::Event->new( 'ACTOR_USER_NOT_FOUND' ); }
750         return $user;
751
752 }
753
754
755
756 __PACKAGE__->register_method(
757         method  => "get_user_by_id",
758         api_name        => "open-ils.actor.user.retrieve",);
759
760 sub get_user_by_id {
761         my ($self, $client, $auth, $id) = @_;
762         my $e = new_editor(authtoken=>$auth);
763         return $e->event unless $e->checkauth;
764         my $user = $e->retrieve_actor_user($id)
765                 or return $e->event;
766         return $e->event unless $e->allowed('VIEW_USER', $user->home_ou);       
767         return $user;
768 }
769
770
771
772 __PACKAGE__->register_method(
773         method  => "get_org_types",
774         api_name        => "open-ils.actor.org_types.retrieve",);
775
776 my $org_types;
777 sub get_org_types {
778         my($self, $client) = @_;
779         return $org_types if $org_types;
780         return $org_types = new_editor()->retrieve_all_actor_org_unit_type();
781 }
782
783
784
785 __PACKAGE__->register_method(
786         method  => "get_user_ident_types",
787         api_name        => "open-ils.actor.user.ident_types.retrieve",
788 );
789 my $ident_types;
790 sub get_user_ident_types {
791         return $ident_types if $ident_types;
792         return $ident_types = 
793                 new_editor()->retrieve_all_config_identification_type();
794 }
795
796
797
798
799 __PACKAGE__->register_method(
800         method  => "get_org_unit",
801         api_name        => "open-ils.actor.org_unit.retrieve",
802 );
803
804 sub get_org_unit {
805         my( $self, $client, $user_session, $org_id ) = @_;
806         my $e = new_editor(authtoken => $user_session);
807         if(!$org_id) {
808                 return $e->event unless $e->checkauth;
809                 $org_id = $e->requestor->ws_ou;
810         }
811         my $o = $e->retrieve_actor_org_unit($org_id)
812                 or return $e->event;
813         return $o;
814 }
815
816 __PACKAGE__->register_method(
817         method  => "search_org_unit",
818         api_name        => "open-ils.actor.org_unit_list.search",
819 );
820
821 sub search_org_unit {
822
823         my( $self, $client, $field, $value ) = @_;
824
825         my $list = OpenILS::Application::AppUtils->simple_scalar_request(
826                 "open-ils.cstore",
827                 "open-ils.cstore.direct.actor.org_unit.search.atomic", 
828                 { $field => $value } );
829
830         return $list;
831 }
832
833
834 # build the org tree
835
836 __PACKAGE__->register_method(
837         method  => "get_org_tree",
838         api_name        => "open-ils.actor.org_tree.retrieve",
839         argc            => 0, 
840         note            => "Returns the entire org tree structure",
841 );
842
843 sub get_org_tree {
844         my( $self, $client) = @_;
845
846         $cache  = OpenSRF::Utils::Cache->new("global", 0) unless $cache;
847         my $tree = $cache->get_cache('orgtree');
848         return $tree if $tree;
849
850         $tree = new_editor()->search_actor_org_unit( 
851                 [
852                         {"parent_ou" => undef },
853                         {
854                                 flesh                           => 2,
855                                 flesh_fields    => { aou =>  ['children'] },
856                                 order_by                        => { aou => 'name'}
857                         }
858                 ]
859         )->[0];
860
861         $cache->put_cache('orgtree', $tree);
862         return $tree;
863 }
864
865
866 # turns an org list into an org tree
867 sub build_org_tree {
868
869         my( $self, $orglist) = @_;
870
871         return $orglist unless ( 
872                         ref($orglist) and @$orglist > 1 );
873
874         my @list = sort { 
875                 $a->ou_type <=> $b->ou_type ||
876                 $a->name cmp $b->name } @$orglist;
877
878         for my $org (@list) {
879
880                 next unless ($org and defined($org->parent_ou));
881                 my ($parent) = grep { $_->id == $org->parent_ou } @list;
882                 next unless $parent;
883
884                 $parent->children([]) unless defined($parent->children); 
885                 push( @{$parent->children}, $org );
886         }
887
888         return $list[0];
889
890 }
891
892
893 __PACKAGE__->register_method(
894         method  => "get_org_descendants",
895         api_name        => "open-ils.actor.org_tree.descendants.retrieve"
896 );
897
898 # depth is optional.  org_unit is the id
899 sub get_org_descendants {
900         my( $self, $client, $org_unit, $depth ) = @_;
901         my $orglist = $apputils->simple_scalar_request(
902                         "open-ils.storage", 
903                         "open-ils.storage.actor.org_unit.descendants.atomic",
904                         $org_unit, $depth );
905         return $self->build_org_tree($orglist);
906 }
907
908
909 __PACKAGE__->register_method(
910         method  => "get_org_ancestors",
911         api_name        => "open-ils.actor.org_tree.ancestors.retrieve"
912 );
913
914 # depth is optional.  org_unit is the id
915 sub get_org_ancestors {
916         my( $self, $client, $org_unit, $depth ) = @_;
917         my $orglist = $apputils->simple_scalar_request(
918                         "open-ils.storage", 
919                         "open-ils.storage.actor.org_unit.ancestors.atomic",
920                         $org_unit, $depth );
921         return $self->build_org_tree($orglist);
922 }
923
924
925 __PACKAGE__->register_method(
926         method  => "get_standings",
927         api_name        => "open-ils.actor.standings.retrieve"
928 );
929
930 my $user_standings;
931 sub get_standings {
932         return $user_standings if $user_standings;
933         return $user_standings = 
934                 $apputils->simple_scalar_request(
935                         "open-ils.cstore",
936                         "open-ils.cstore.direct.config.standing.search.atomic",
937                         { id => { "!=" => undef } }
938                 );
939 }
940
941
942
943 __PACKAGE__->register_method(
944         method  => "get_my_org_path",
945         api_name        => "open-ils.actor.org_unit.full_path.retrieve"
946 );
947
948 sub get_my_org_path {
949         my( $self, $client, $user_session, $org_id ) = @_;
950         my $user_obj = $apputils->check_user_session($user_session); 
951         if(!defined($org_id)) { $org_id = $user_obj->home_ou; }
952
953         return $apputils->simple_scalar_request(
954                 "open-ils.storage",
955                 "open-ils.storage.actor.org_unit.full_path.atomic",
956                 $org_id );
957 }
958
959
960 __PACKAGE__->register_method(
961         method  => "patron_adv_search",
962         api_name        => "open-ils.actor.patron.search.advanced" );
963 sub patron_adv_search {
964         my( $self, $client, $auth, $search_hash, $search_limit, $search_sort, $include_inactive ) = @_;
965         my $e = new_editor(authtoken=>$auth);
966         return $e->event unless $e->checkauth;
967         return $e->event unless $e->allowed('VIEW_USER');
968         return $U->storagereq(
969                 "open-ils.storage.actor.user.crazy_search", 
970                 $search_hash, $search_limit, $search_sort, $include_inactive);
971 }
972
973
974
975 sub _verify_password {
976         my($user_session, $password) = @_;
977         my $user_obj = $apputils->check_user_session($user_session); 
978
979         #grab the user with password
980         $user_obj = $apputils->simple_scalar_request(
981                 "open-ils.cstore", 
982                 "open-ils.cstore.direct.actor.user.retrieve",
983                 $user_obj->id );
984
985         if($user_obj->passwd eq $password) {
986                 return 1;
987         }
988
989         return 0;
990 }
991
992
993 __PACKAGE__->register_method(
994         method  => "update_password",
995         api_name        => "open-ils.actor.user.password.update");
996
997 __PACKAGE__->register_method(
998         method  => "update_password",
999         api_name        => "open-ils.actor.user.username.update");
1000
1001 __PACKAGE__->register_method(
1002         method  => "update_password",
1003         api_name        => "open-ils.actor.user.email.update");
1004
1005 sub update_password {
1006         my( $self, $client, $user_session, $new_value, $current_password ) = @_;
1007
1008         my $evt;
1009
1010         my $user_obj = $apputils->check_user_session($user_session); 
1011
1012         if($self->api_name =~ /password/o) {
1013
1014                 #make sure they know the current password
1015                 if(!_verify_password($user_session, md5_hex($current_password))) {
1016                         return OpenILS::Event->new('INCORRECT_PASSWORD');
1017                 }
1018
1019                 $logger->debug("update_password setting new password $new_value");
1020                 $user_obj->passwd($new_value);
1021
1022         } elsif($self->api_name =~ /username/o) {
1023                 my $users = search_username(undef, undef, $new_value); 
1024                 if( $users and $users->[0] ) {
1025                         return OpenILS::Event->new('USERNAME_EXISTS');
1026                 }
1027                 $user_obj->usrname($new_value);
1028
1029         } elsif($self->api_name =~ /email/o) {
1030                 #warn "Updating email to $new_value\n";
1031                 $user_obj->email($new_value);
1032         }
1033
1034         my $session = $apputils->start_db_session();
1035
1036         ( $user_obj, $evt ) = _update_patron($session, $user_obj, $user_obj, 1);
1037         return $evt if $evt;
1038
1039         $apputils->commit_db_session($session);
1040
1041         if($user_obj) { return 1; }
1042         return undef;
1043 }
1044
1045
1046 __PACKAGE__->register_method(
1047         method  => "check_user_perms",
1048         api_name        => "open-ils.actor.user.perm.check",
1049         notes           => <<"  NOTES");
1050         Takes a login session, user id, an org id, and an array of perm type strings.  For each
1051         perm type, if the user does *not* have the given permission it is added
1052         to a list which is returned from the method.  If all permissions
1053         are allowed, an empty list is returned
1054         if the logged in user does not match 'user_id', then the logged in user must
1055         have VIEW_PERMISSION priveleges.
1056         NOTES
1057
1058 sub check_user_perms {
1059         my( $self, $client, $login_session, $user_id, $org_id, $perm_types ) = @_;
1060
1061         my( $staff, $evt ) = $apputils->checkses($login_session);
1062         return $evt if $evt;
1063
1064         if($staff->id ne $user_id) {
1065                 if( $evt = $apputils->check_perms(
1066                         $staff->id, $org_id, 'VIEW_PERMISSION') ) {
1067                         return $evt;
1068                 }
1069         }
1070
1071         my @not_allowed;
1072         for my $perm (@$perm_types) {
1073                 if($apputils->check_perms($user_id, $org_id, $perm)) {
1074                         push @not_allowed, $perm;
1075                 }
1076         }
1077
1078         return \@not_allowed
1079 }
1080
1081 __PACKAGE__->register_method(
1082         method  => "check_user_perms2",
1083         api_name        => "open-ils.actor.user.perm.check.multi_org",
1084         notes           => q/
1085                 Checks the permissions on a list of perms and orgs for a user
1086                 @param authtoken The login session key
1087                 @param user_id The id of the user to check
1088                 @param orgs The array of org ids
1089                 @param perms The array of permission names
1090                 @return An array of  [ orgId, permissionName ] arrays that FAILED the check
1091                 if the logged in user does not match 'user_id', then the logged in user must
1092                 have VIEW_PERMISSION priveleges.
1093         /);
1094
1095 sub check_user_perms2 {
1096         my( $self, $client, $authtoken, $user_id, $orgs, $perms ) = @_;
1097
1098         my( $staff, $target, $evt ) = $apputils->checkses_requestor(
1099                 $authtoken, $user_id, 'VIEW_PERMISSION' );
1100         return $evt if $evt;
1101
1102         my @not_allowed;
1103         for my $org (@$orgs) {
1104                 for my $perm (@$perms) {
1105                         if($apputils->check_perms($user_id, $org, $perm)) {
1106                                 push @not_allowed, [ $org, $perm ];
1107                         }
1108                 }
1109         }
1110
1111         return \@not_allowed
1112 }
1113
1114
1115 __PACKAGE__->register_method(
1116         method => 'check_user_perms3',
1117         api_name        => 'open-ils.actor.user.perm.highest_org',
1118         notes           => q/
1119                 Returns the highest org unit id at which a user has a given permission
1120                 If the requestor does not match the target user, the requestor must have
1121                 'VIEW_PERMISSION' rights at the home org unit of the target user
1122                 @param authtoken The login session key
1123                 @param userid The id of the user in question
1124                 @param perm The permission to check
1125                 @return The org unit highest in the org tree within which the user has
1126                 the requested permission
1127         /);
1128
1129 sub check_user_perms3 {
1130         my( $self, $client, $authtoken, $userid, $perm ) = @_;
1131
1132         my( $staff, $target, $org, $evt );
1133
1134         ( $staff, $target, $evt ) = $apputils->checkses_requestor(
1135                 $authtoken, $userid, 'VIEW_PERMISSION' );
1136         return $evt if $evt;
1137
1138         my $tree = $self->get_org_tree();
1139         return _find_highest_perm_org( $perm, $userid, $target->ws_ou, $tree );
1140 }
1141
1142
1143 sub _find_highest_perm_org {
1144         my ( $perm, $userid, $start_org, $org_tree ) = @_;
1145         my $org = $apputils->find_org($org_tree, $start_org );
1146
1147         my $lastid = undef;
1148         while( $org ) {
1149                 last if ($apputils->check_perms( $userid, $org->id, $perm )); # perm failed
1150                 $lastid = $org->id;
1151                 $org = $apputils->find_org( $org_tree, $org->parent_ou() );
1152         }
1153
1154         return $lastid;
1155 }
1156
1157 __PACKAGE__->register_method(
1158         method => 'check_user_perms4',
1159         api_name        => 'open-ils.actor.user.perm.highest_org.batch',
1160         notes           => q/
1161                 Returns the highest org unit id at which a user has a given permission
1162                 If the requestor does not match the target user, the requestor must have
1163                 'VIEW_PERMISSION' rights at the home org unit of the target user
1164                 @param authtoken The login session key
1165                 @param userid The id of the user in question
1166                 @param perms An array of perm names to check 
1167                 @return An array of orgId's  representing the org unit 
1168                 highest in the org tree within which the user has the requested permission
1169                 The arrah of orgId's has matches the order of the perms array
1170         /);
1171
1172 sub check_user_perms4 {
1173         my( $self, $client, $authtoken, $userid, $perms ) = @_;
1174         
1175         my( $staff, $target, $org, $evt );
1176
1177         ( $staff, $target, $evt ) = $apputils->checkses_requestor(
1178                 $authtoken, $userid, 'VIEW_PERMISSION' );
1179         return $evt if $evt;
1180
1181         my @arr;
1182         return [] unless ref($perms);
1183         my $tree = $self->get_org_tree();
1184
1185         for my $p (@$perms) {
1186                 push( @arr, _find_highest_perm_org( $p, $userid, $target->home_ou, $tree ) );
1187         }
1188         return \@arr;
1189 }
1190
1191
1192
1193
1194 __PACKAGE__->register_method(
1195         method  => "user_fines_summary",
1196         api_name        => "open-ils.actor.user.fines.summary",
1197         notes           => <<"  NOTES");
1198         Returns a short summary of the users total open fines, excluding voided fines
1199         Params are login_session, user_id
1200         Returns a 'mous' object.
1201         NOTES
1202
1203 sub user_fines_summary {
1204         my( $self, $client, $login_session, $user_id ) = @_;
1205
1206         my $user_obj = $apputils->check_user_session($login_session); 
1207         if($user_obj->id ne $user_id) {
1208                 if($apputils->check_user_perms($user_obj->id, $user_obj->home_ou, "VIEW_USER_FINES_SUMMARY")) {
1209                         return OpenILS::Perm->new("VIEW_USER_FINES_SUMMARY"); 
1210                 }
1211         }
1212
1213         return $apputils->simple_scalar_request( 
1214                 "open-ils.cstore",
1215                 "open-ils.cstore.direct.money.open_user_summary.search",
1216                 { usr => $user_id } );
1217
1218 }
1219
1220
1221
1222
1223 __PACKAGE__->register_method(
1224         method  => "user_transactions",
1225         api_name        => "open-ils.actor.user.transactions",
1226         notes           => <<"  NOTES");
1227         Returns a list of open user transactions (mbts objects);
1228         Params are login_session, user_id
1229         Optional third parameter is the transactions type.  defaults to all
1230         NOTES
1231
1232 __PACKAGE__->register_method(
1233         method  => "user_transactions",
1234         api_name        => "open-ils.actor.user.transactions.have_charge",
1235         notes           => <<"  NOTES");
1236         Returns a list of all open user transactions (mbts objects) that have an initial charge
1237         Params are login_session, user_id
1238         Optional third parameter is the transactions type.  defaults to all
1239         NOTES
1240
1241 __PACKAGE__->register_method(
1242         method  => "user_transactions",
1243         api_name        => "open-ils.actor.user.transactions.have_balance",
1244         notes           => <<"  NOTES");
1245         Returns a list of all open user transactions (mbts objects) that have a balance
1246         Params are login_session, user_id
1247         Optional third parameter is the transactions type.  defaults to all
1248         NOTES
1249
1250 __PACKAGE__->register_method(
1251         method  => "user_transactions",
1252         api_name        => "open-ils.actor.user.transactions.fleshed",
1253         notes           => <<"  NOTES");
1254         Returns an object/hash of transaction, circ, title where transaction = an open 
1255         user transactions (mbts objects), circ is the attached circluation, and title
1256         is the title the circ points to
1257         Params are login_session, user_id
1258         Optional third parameter is the transactions type.  defaults to all
1259         NOTES
1260
1261 __PACKAGE__->register_method(
1262         method  => "user_transactions",
1263         api_name        => "open-ils.actor.user.transactions.have_charge.fleshed",
1264         notes           => <<"  NOTES");
1265         Returns an object/hash of transaction, circ, title where transaction = an open 
1266         user transactions that has an initial charge (mbts objects), circ is the 
1267         attached circluation, and title is the title the circ points to
1268         Params are login_session, user_id
1269         Optional third parameter is the transactions type.  defaults to all
1270         NOTES
1271
1272 __PACKAGE__->register_method(
1273         method  => "user_transactions",
1274         api_name        => "open-ils.actor.user.transactions.have_balance.fleshed",
1275         notes           => <<"  NOTES");
1276         Returns an object/hash of transaction, circ, title where transaction = an open 
1277         user transaction that has a balance (mbts objects), circ is the attached 
1278         circluation, and title is the title the circ points to
1279         Params are login_session, user_id
1280         Optional third parameter is the transaction type.  defaults to all
1281         NOTES
1282
1283 __PACKAGE__->register_method(
1284         method  => "user_transactions",
1285         api_name        => "open-ils.actor.user.transactions.count",
1286         notes           => <<"  NOTES");
1287         Returns an object/hash of transaction, circ, title where transaction = an open 
1288         user transactions (mbts objects), circ is the attached circluation, and title
1289         is the title the circ points to
1290         Params are login_session, user_id
1291         Optional third parameter is the transactions type.  defaults to all
1292         NOTES
1293
1294 __PACKAGE__->register_method(
1295         method  => "user_transactions",
1296         api_name        => "open-ils.actor.user.transactions.have_charge.count",
1297         notes           => <<"  NOTES");
1298         Returns an object/hash of transaction, circ, title where transaction = an open 
1299         user transactions that has an initial charge (mbts objects), circ is the 
1300         attached circluation, and title is the title the circ points to
1301         Params are login_session, user_id
1302         Optional third parameter is the transactions type.  defaults to all
1303         NOTES
1304
1305 __PACKAGE__->register_method(
1306         method  => "user_transactions",
1307         api_name        => "open-ils.actor.user.transactions.have_balance.count",
1308         notes           => <<"  NOTES");
1309         Returns an object/hash of transaction, circ, title where transaction = an open 
1310         user transaction that has a balance (mbts objects), circ is the attached 
1311         circluation, and title is the title the circ points to
1312         Params are login_session, user_id
1313         Optional third parameter is the transaction type.  defaults to all
1314         NOTES
1315
1316 __PACKAGE__->register_method(
1317         method  => "user_transactions",
1318         api_name        => "open-ils.actor.user.transactions.have_balance.total",
1319         notes           => <<"  NOTES");
1320         Returns an object/hash of transaction, circ, title where transaction = an open 
1321         user transaction that has a balance (mbts objects), circ is the attached 
1322         circluation, and title is the title the circ points to
1323         Params are login_session, user_id
1324         Optional third parameter is the transaction type.  defaults to all
1325         NOTES
1326
1327
1328
1329 sub user_transactions {
1330         my( $self, $client, $login_session, $user_id, $type ) = @_;
1331
1332         my( $user_obj, $target, $evt ) = $apputils->checkses_requestor(
1333                 $login_session, $user_id, 'VIEW_USER_TRANSACTIONS' );
1334         return $evt if $evt;
1335         
1336         my $api = $self->api_name();
1337         my $trans;
1338         my @xact;
1339
1340         if(defined($type)) { @xact = (xact_type =>  $type); 
1341
1342         } else { @xact = (); }
1343
1344         if($api =~ /have_charge/o) {
1345
1346                 $trans = $apputils->simple_scalar_request( 
1347                         "open-ils.cstore",
1348                         "open-ils.cstore.direct.money.open_billable_transaction_summary.search.atomic",
1349                         { usr => $user_id, total_owed => { ">" => 0 }, @xact });
1350
1351         } elsif($api =~ /have_balance/o) {
1352
1353                 $trans =  $apputils->simple_scalar_request( 
1354                         "open-ils.cstore",
1355                         "open-ils.cstore.direct.money.open_billable_transaction_summary.search.atomic",
1356                         { usr => $user_id, balance_owed => { "<>" => 0 }, @xact });
1357
1358         } else {
1359
1360                 $trans =  $apputils->simple_scalar_request( 
1361                         "open-ils.cstore",
1362                         "open-ils.cstore.direct.money.open_billable_transaction_summary.search.atomic",
1363                         { usr => $user_id, @xact });
1364         }
1365
1366         if($api =~ /total/o) { 
1367                 my $total = 0.0;
1368                 for my $t (@$trans) {
1369                         $total += $t->balance_owed;
1370                 }
1371
1372                 $logger->debug("Total balance owed by user $user_id: $total");
1373                 return $total;
1374         }
1375
1376         if($api =~ /count/o) { return scalar @$trans; }
1377         if($api !~ /fleshed/o) { return $trans; }
1378
1379         my @resp;
1380         for my $t (@$trans) {
1381                         
1382                 if( $t->xact_type ne 'circulation' ) {
1383                         push @resp, {transaction => $t};
1384                         next;
1385                 }
1386
1387                 my $circ = $apputils->simple_scalar_request(
1388                                 "open-ils.cstore",
1389                                 "open-ils.cstore.direct.action.circulation.retrieve",
1390                                 $t->id );
1391
1392                 next unless $circ;
1393
1394                 my $title = $apputils->simple_scalar_request(
1395                         "open-ils.storage", 
1396                         "open-ils.storage.fleshed.biblio.record_entry.retrieve_by_copy",
1397                         $circ->target_copy );
1398
1399                 next unless $title;
1400
1401                 my $u = OpenILS::Utils::ModsParser->new();
1402                 $u->start_mods_batch($title->marc());
1403                 my $mods = $u->finish_mods_batch();
1404                 $mods->doc_id($title->id) if $mods;
1405
1406                 push @resp, {transaction => $t, circ => $circ, record => $mods };
1407
1408         }
1409
1410         return \@resp; 
1411
1412
1413
1414 __PACKAGE__->register_method(
1415         method  => "user_transaction_retrieve",
1416         api_name        => "open-ils.actor.user.transaction.fleshed.retrieve",
1417         argc            => 1,
1418         notes           => <<"  NOTES");
1419         Returns a fleshedtransaction record
1420         NOTES
1421 __PACKAGE__->register_method(
1422         method  => "user_transaction_retrieve",
1423         api_name        => "open-ils.actor.user.transaction.retrieve",
1424         argc            => 1,
1425         notes           => <<"  NOTES");
1426         Returns a transaction record
1427         NOTES
1428 sub user_transaction_retrieve {
1429         my( $self, $client, $login_session, $bill_id ) = @_;
1430
1431         my $trans = $apputils->simple_scalar_request( 
1432                 "open-ils.cstore",
1433                 "open-ils.cstore.direct.money.billable_transaction_summary.retrieve",
1434                 $bill_id
1435         );
1436
1437         my( $user_obj, $target, $evt ) = $apputils->checkses_requestor(
1438                 $login_session, $trans->usr, 'VIEW_USER_TRANSACTIONS' );
1439         return $evt if $evt;
1440         
1441         my $api = $self->api_name();
1442         if($api !~ /fleshed/o) { return $trans; }
1443
1444         if( $trans->xact_type ne 'circulation' ) {
1445                 $logger->debug("Returning non-circ transaction");
1446                 return {transaction => $trans};
1447         }
1448
1449         my $circ = $apputils->simple_scalar_request(
1450                         "open-ils.cstore",
1451                         "open-ils..direct.action.circulation.retrieve",
1452                         $trans->id );
1453
1454         return {transaction => $trans} unless $circ;
1455         $logger->debug("Found the circ transaction");
1456
1457         my $title = $apputils->simple_scalar_request(
1458                 "open-ils.storage", 
1459                 "open-ils.storage.fleshed.biblio.record_entry.retrieve_by_copy",
1460                 $circ->target_copy );
1461
1462         return {transaction => $trans, circ => $circ } unless $title;
1463         $logger->debug("Found the circ title");
1464
1465         my $mods;
1466         try {
1467                 my $u = OpenILS::Utils::ModsParser->new();
1468                 $u->start_mods_batch($title->marc());
1469                 $mods = $u->finish_mods_batch();
1470         } otherwise {
1471                 if ($title->id == OILS_PRECAT_RECORD) {
1472                         my $copy = $apputils->simple_scalar_request(
1473                                 "open-ils.cstore",
1474                                 "open-ils.cstore.direct.asset.copy.retrieve",
1475                                 $circ->target_copy );
1476
1477                         $mods = new Fieldmapper::metabib::virtual_record;
1478                         $mods->doc_id(OILS_PRECAT_RECORD);
1479                         $mods->title($copy->dummy_title);
1480                         $mods->author($copy->dummy_author);
1481                 }
1482         };
1483
1484         $logger->debug("MODSized the circ title");
1485
1486         return {transaction => $trans, circ => $circ, record => $mods };
1487 }
1488
1489
1490 __PACKAGE__->register_method(
1491         method  => "hold_request_count",
1492         api_name        => "open-ils.actor.user.hold_requests.count",
1493         argc            => 1,
1494         notes           => <<"  NOTES");
1495         Returns hold ready/total counts
1496         NOTES
1497 sub hold_request_count {
1498         my( $self, $client, $login_session, $userid ) = @_;
1499
1500         my( $user_obj, $target, $evt ) = $apputils->checkses_requestor(
1501                 $login_session, $userid, 'VIEW_HOLD' );
1502         return $evt if $evt;
1503         
1504
1505         my $holds = $apputils->simple_scalar_request(
1506                         "open-ils.cstore",
1507                         "open-ils.cstore.direct.action.hold_request.search.atomic",
1508                         { 
1509                                 usr => $userid,
1510                                 fulfillment_time => {"=" => undef },
1511                                 cancel_time => undef,
1512                         }
1513         );
1514
1515         my @ready;
1516         for my $h (@$holds) {
1517                 next unless $h->capture_time and $h->current_copy;
1518
1519                 my $copy = $apputils->simple_scalar_request(
1520                         "open-ils.cstore",
1521                         "open-ils.cstore.direct.asset.copy.retrieve",
1522                         $h->current_copy
1523                 );
1524
1525                 if ($copy and $copy->status == 8) {
1526                         push @ready, $h;
1527                 }
1528         }
1529
1530         return { total => scalar(@$holds), ready => scalar(@ready) };
1531 }
1532
1533
1534 __PACKAGE__->register_method(
1535         method  => "checkedout_count",
1536         api_name        => "open-ils.actor.user.checked_out.count__",
1537         argc            => 1,
1538         notes           => <<"  NOTES");
1539         Returns a transaction record
1540         NOTES
1541
1542 # XXX Deprecate Me
1543 sub checkedout_count {
1544         my( $self, $client, $login_session, $userid ) = @_;
1545
1546         my( $user_obj, $target, $evt ) = $apputils->checkses_requestor(
1547                 $login_session, $userid, 'VIEW_CIRCULATIONS' );
1548         return $evt if $evt;
1549         
1550         my $circs = $apputils->simple_scalar_request(
1551                         "open-ils.cstore",
1552                         "open-ils.cstore.direct.action.circulation.search.atomic",
1553                         { usr => $userid, stop_fines => undef }
1554                         #{ usr => $userid, checkin_time => {"=" => undef } }
1555         );
1556
1557         my $parser = DateTime::Format::ISO8601->new;
1558
1559         my (@out,@overdue);
1560         for my $c (@$circs) {
1561                 my $due_dt = $parser->parse_datetime( clense_ISO8601( $c->due_date ) );
1562                 my $due = $due_dt->epoch;
1563
1564                 if ($due < DateTime->today->epoch) {
1565                         push @overdue, $c;
1566                 }
1567         }
1568
1569         return { total => scalar(@$circs), overdue => scalar(@overdue) };
1570 }
1571
1572
1573 __PACKAGE__->register_method(
1574         method          => "checked_out",
1575         api_name                => "open-ils.actor.user.checked_out",
1576         argc                    => 2,
1577         signature       => q/
1578                 Returns a structure of circulations objects sorted by
1579                 out, overdue, lost, claims_returned, long_overdue.
1580                 A list of IDs are returned of each type.
1581                 lost, long_overdue, and claims_returned circ will not
1582                 be "finished" (there is an outstanding balance or some 
1583                 other pending action on the circ). 
1584
1585                 The .count method also includes a 'total' field which 
1586                 sums all "open" circs
1587         /
1588 );
1589
1590 __PACKAGE__->register_method(
1591         method          => "checked_out",
1592         api_name                => "open-ils.actor.user.checked_out.count",
1593         argc                    => 2,
1594         signature       => q/@see open-ils.actor.user.checked_out/
1595 );
1596
1597 sub checked_out {
1598         my( $self, $conn, $auth, $userid ) = @_;
1599
1600         my $e = new_editor(authtoken=>$auth);
1601         return $e->event unless $e->checkauth;
1602
1603         if( $userid ne $e->requestor->id ) {
1604                 return $e->event unless $e->allowed('VIEW_CIRCULATIONS');
1605         }
1606
1607         my $count = $self->api_name =~ /count/;
1608         return _checked_out( $count, $e, $userid );
1609 }
1610
1611 sub _checked_out {
1612         my( $iscount, $e, $userid ) = @_;
1613
1614         my $circs = $e->search_action_circulation( 
1615                 { usr => $userid, stop_fines => undef });
1616
1617         my $parser = DateTime::Format::ISO8601->new;
1618
1619         # split the circs up into overdue and not-overdue circs
1620         my (@out,@overdue);
1621         for my $c (@$circs) {
1622                 if( $c->due_date ) {
1623                         my $due_dt = $parser->parse_datetime( clense_ISO8601( $c->due_date ) );
1624                         my $due = $due_dt->epoch;
1625                         if ($due < DateTime->today->epoch) {
1626                                 push @overdue, $c->id;
1627                         } else {
1628                                 push @out, $c->id;
1629                         }
1630                 } else {
1631                         push @out, $c->id;
1632                 }
1633         }
1634
1635         # grab all of the lost, claims-returned, and longoverdue circs
1636         #my $open = $e->search_action_circulation(
1637         #       {usr => $userid, stop_fines => { '!=' => undef }, xact_finish => undef });
1638
1639
1640         # these items have stop_fines, but no xact_finish, so money
1641         # is owed on them and they have not been checked in
1642         my $open = $e->search_action_circulation(
1643                 {
1644                         usr                             => $userid, 
1645                         stop_fines              => { '!=' => undef }, 
1646                         xact_finish             => undef,
1647                         checkin_time    => undef,
1648                 }
1649         );
1650
1651
1652         my( @lost, @cr, @lo );
1653         for my $c (@$open) {
1654                 push( @lost, $c->id ) if $c->stop_fines eq 'LOST';
1655                 push( @cr, $c->id ) if $c->stop_fines eq 'CLAIMSRETURNED';
1656                 push( @lo, $c->id ) if $c->stop_fines eq 'LONGOVERDUE';
1657         }
1658
1659
1660         if( $iscount ) {
1661                 return {
1662                         total           => @$circs + @lost + @cr + @lo,
1663                         out             => scalar(@out),
1664                         overdue => scalar(@overdue),
1665                         lost            => scalar(@lost),
1666                         claims_returned => scalar(@cr),
1667                         long_overdue            => scalar(@lo)
1668                 };
1669         }
1670
1671         return {
1672                 out             => \@out,
1673                 overdue => \@overdue,
1674                 lost            => \@lost,
1675                 claims_returned => \@cr,
1676                 long_overdue            => \@lo
1677         };
1678 }
1679
1680
1681
1682 __PACKAGE__->register_method(
1683         method          => "checked_in_with_fines",
1684         api_name                => "open-ils.actor.user.checked_in_with_fines",
1685         argc                    => 2,
1686         signature       => q/@see open-ils.actor.user.checked_out/
1687 );
1688 sub checked_in_with_fines {
1689         my( $self, $conn, $auth, $userid ) = @_;
1690
1691         my $e = new_editor(authtoken=>$auth);
1692         return $e->event unless $e->checkauth;
1693
1694         if( $userid ne $e->requestor->id ) {
1695                 return $e->event unless $e->allowed('VIEW_CIRCULATIONS');
1696         }
1697
1698         # money is owed on these items and they are checked in
1699         my $open = $e->search_action_circulation(
1700                 {
1701                         usr                             => $userid, 
1702                         xact_finish             => undef,
1703                         checkin_time    => { "!=" => undef },
1704                 }
1705         );
1706
1707
1708         my( @lost, @cr, @lo );
1709         for my $c (@$open) {
1710                 push( @lost, $c->id ) if $c->stop_fines eq 'LOST';
1711                 push( @cr, $c->id ) if $c->stop_fines eq 'CLAIMSRETURNED';
1712                 push( @lo, $c->id ) if $c->stop_fines eq 'LONGOVERDUE';
1713         }
1714
1715         return {
1716                 lost            => \@lost,
1717                 claims_returned => \@cr,
1718                 long_overdue            => \@lo
1719         };
1720 }
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730 __PACKAGE__->register_method(
1731         method  => "user_transaction_history",
1732         api_name        => "open-ils.actor.user.transactions.history",
1733         argc            => 1,
1734         notes           => <<"  NOTES");
1735         Returns a list of billable transaction ids for a user, optionally by type
1736         NOTES
1737 __PACKAGE__->register_method(
1738         method  => "user_transaction_history",
1739         api_name        => "open-ils.actor.user.transactions.history.have_charge",
1740         argc            => 1,
1741         notes           => <<"  NOTES");
1742         Returns a list of billable transaction ids for a user that have an initial charge, optionally by type
1743         NOTES
1744 __PACKAGE__->register_method(
1745         method  => "user_transaction_history",
1746         api_name        => "open-ils.actor.user.transactions.history.have_balance",
1747         argc            => 1,
1748         notes           => <<"  NOTES");
1749         Returns a list of billable transaction ids for a user that have a balance, optionally by type
1750         NOTES
1751
1752 =head old
1753 sub _user_transaction_history {
1754         my( $self, $client, $login_session, $user_id, $type ) = @_;
1755
1756         my( $user_obj, $target, $evt ) = $apputils->checkses_requestor(
1757                 $login_session, $user_id, 'VIEW_USER_TRANSACTIONS' );
1758         return $evt if $evt;
1759
1760         my $api = $self->api_name();
1761         my @xact;
1762         my @charge;
1763         my @balance;
1764
1765         @xact = (xact_type =>  $type) if(defined($type));
1766         @balance = (balance_owed => { "!=" => 0}) if($api =~ /have_balance/);
1767         @charge  = (last_billing_ts => { "<>" => undef }) if $api =~ /have_charge/;
1768
1769         $logger->debug("searching for transaction history: @xact : @balance, @charge");
1770
1771         my $trans = $apputils->simple_scalar_request( 
1772                 "open-ils.cstore",
1773                 "open-ils.cstore.direct.money.billable_transaction_summary.search.atomic",
1774                 { usr => $user_id, @xact, @charge, @balance }, { order_by => { mbts => 'xact_start DESC' } });
1775
1776         return [ map { $_->id } @$trans ];
1777 }
1778 =cut
1779
1780
1781 sub user_transaction_history {
1782         my( $self, $conn, $auth, $userid, $type ) = @_;
1783         my $e = new_editor(authtoken=>$auth);
1784         return $e->event unless $e->checkauth;
1785         return $e->event unless $e->allowed('VIEW_USER_TRANSACTIONS');
1786
1787         my $api = $self->api_name;
1788         my @xact = (xact_type =>  $type) if(defined($type));
1789         my @balance = (balance_owed => { "!=" => 0}) if($api =~ /have_balance/);
1790         my @charge  = (last_billing_ts => { "!=" => undef }) if $api =~ /have_charge/;
1791
1792         return $e->search_money_billable_transaction_summary(
1793                 [
1794                         { usr => $userid, @xact, @charge, @balance }, 
1795                         { order_by => 'xact_start DESC' }
1796                 ], {idlist => 1});
1797 }
1798
1799
1800
1801 __PACKAGE__->register_method(
1802         method  => "user_perms",
1803         api_name        => "open-ils.actor.permissions.user_perms.retrieve",
1804         argc            => 1,
1805         notes           => <<"  NOTES");
1806         Returns a list of permissions
1807         NOTES
1808 sub user_perms {
1809         my( $self, $client, $authtoken, $user ) = @_;
1810
1811         my( $staff, $evt ) = $apputils->checkses($authtoken);
1812         return $evt if $evt;
1813
1814         $user ||= $staff->id;
1815
1816         if( $user != $staff->id and $evt = $apputils->check_perms( $staff->id, $staff->home_ou, 'VIEW_PERMISSION') ) {
1817                 return $evt;
1818         }
1819
1820         return $apputils->simple_scalar_request(
1821                 "open-ils.storage",
1822                 "open-ils.storage.permission.user_perms.atomic",
1823                 $user);
1824 }
1825
1826 __PACKAGE__->register_method(
1827         method  => "retrieve_perms",
1828         api_name        => "open-ils.actor.permissions.retrieve",
1829         notes           => <<"  NOTES");
1830         Returns a list of permissions
1831         NOTES
1832 sub retrieve_perms {
1833         my( $self, $client ) = @_;
1834         return $apputils->simple_scalar_request(
1835                 "open-ils.cstore",
1836                 "open-ils.cstore.direct.permission.perm_list.search.atomic",
1837                 { id => { '!=' => undef } }
1838         );
1839 }
1840
1841 __PACKAGE__->register_method(
1842         method  => "retrieve_groups",
1843         api_name        => "open-ils.actor.groups.retrieve",
1844         notes           => <<"  NOTES");
1845         Returns a list of user groupss
1846         NOTES
1847 sub retrieve_groups {
1848         my( $self, $client ) = @_;
1849         return new_editor()->retrieve_all_permission_grp_tree();
1850 }
1851
1852 __PACKAGE__->register_method(
1853         method  => "retrieve_org_address",
1854         api_name        => "open-ils.actor.org_unit.address.retrieve",
1855         notes           => <<'  NOTES');
1856         Returns an org_unit address by ID
1857         @param An org_address ID
1858         NOTES
1859 sub retrieve_org_address {
1860         my( $self, $client, $id ) = @_;
1861         return $apputils->simple_scalar_request(
1862                 "open-ils.cstore",
1863                 "open-ils.cstore.direct.actor.org_address.retrieve",
1864                 $id
1865         );
1866 }
1867
1868 __PACKAGE__->register_method(
1869         method  => "retrieve_groups_tree",
1870         api_name        => "open-ils.actor.groups.tree.retrieve",
1871         notes           => <<"  NOTES");
1872         Returns a list of user groups
1873         NOTES
1874 sub retrieve_groups_tree {
1875         my( $self, $client ) = @_;
1876         return new_editor()->search_permission_grp_tree(
1877                 [
1878                         { parent => undef},
1879                         {       
1880                                 flesh                           => 10, 
1881                                 flesh_fields    => { pgt => ["children"] }, 
1882                                 order_by                        => { pgt => 'name'}
1883                         }
1884                 ]
1885         )->[0];
1886 }
1887
1888
1889 # turns an org list into an org tree
1890 =head old code
1891 sub build_group_tree {
1892
1893         my( $self, $grplist) = @_;
1894
1895         return $grplist unless ( 
1896                         ref($grplist) and @$grplist > 1 );
1897
1898         my @list = sort { $a->name cmp $b->name } @$grplist;
1899
1900         my $root;
1901         for my $grp (@list) {
1902
1903                 if ($grp and !defined($grp->parent)) {
1904                         $root = $grp;
1905                         next;
1906                 }
1907                 my ($parent) = grep { $_->id == $grp->parent} @list;
1908
1909                 $parent->children([]) unless defined($parent->children); 
1910                 push( @{$parent->children}, $grp );
1911         }
1912
1913         return $root;
1914 }
1915 =cut
1916
1917
1918 __PACKAGE__->register_method(
1919         method  => "add_user_to_groups",
1920         api_name        => "open-ils.actor.user.set_groups",
1921         notes           => <<"  NOTES");
1922         Adds a user to one or more permission groups
1923         NOTES
1924
1925 sub add_user_to_groups {
1926         my( $self, $client, $authtoken, $userid, $groups ) = @_;
1927
1928         my( $requestor, $target, $evt ) = $apputils->checkses_requestor(
1929                 $authtoken, $userid, 'CREATE_USER_GROUP_LINK' );
1930         return $evt if $evt;
1931
1932         ( $requestor, $target, $evt ) = $apputils->checkses_requestor(
1933                 $authtoken, $userid, 'REMOVE_USER_GROUP_LINK' );
1934         return $evt if $evt;
1935
1936         $apputils->simplereq(
1937                 'open-ils.storage',
1938                 'open-ils.storage.direct.permission.usr_grp_map.mass_delete', { usr => $userid } );
1939                 
1940         for my $group (@$groups) {
1941                 my $link = Fieldmapper::permission::usr_grp_map->new;
1942                 $link->grp($group);
1943                 $link->usr($userid);
1944
1945                 my $id = $apputils->simplereq(
1946                         'open-ils.storage',
1947                         'open-ils.storage.direct.permission.usr_grp_map.create', $link );
1948         }
1949
1950         return 1;
1951 }
1952
1953 __PACKAGE__->register_method(
1954         method  => "get_user_perm_groups",
1955         api_name        => "open-ils.actor.user.get_groups",
1956         notes           => <<"  NOTES");
1957         Retrieve a user's permission groups.
1958         NOTES
1959
1960
1961 sub get_user_perm_groups {
1962         my( $self, $client, $authtoken, $userid ) = @_;
1963
1964         my( $requestor, $target, $evt ) = $apputils->checkses_requestor(
1965                 $authtoken, $userid, 'VIEW_PERM_GROUPS' );
1966         return $evt if $evt;
1967
1968         return $apputils->simplereq(
1969                 'open-ils.cstore',
1970                 'open-ils.cstore.direct.permission.usr_grp_map.search.atomic', { usr => $userid } );
1971 }       
1972
1973
1974
1975 __PACKAGE__->register_method (
1976         method          => 'register_workstation',
1977         api_name                => 'open-ils.actor.workstation.register.override',
1978         signature       => q/@see open-ils.actor.workstation.register/);
1979
1980 __PACKAGE__->register_method (
1981         method          => 'register_workstation',
1982         api_name                => 'open-ils.actor.workstation.register',
1983         signature       => q/
1984                 Registers a new workstion in the system
1985                 @param authtoken The login session key
1986                 @param name The name of the workstation id
1987                 @param owner The org unit that owns this workstation
1988                 @return The workstation id on success, WORKSTATION_NAME_EXISTS
1989                 if the name is already in use.
1990         /);
1991
1992 sub _register_workstation {
1993         my( $self, $connection, $authtoken, $name, $owner ) = @_;
1994         my( $requestor, $evt ) = $U->checkses($authtoken);
1995         return $evt if $evt;
1996         $evt = $U->check_perms($requestor->id, $owner, 'REGISTER_WORKSTATION');
1997         return $evt if $evt;
1998
1999         my $ws = $U->cstorereq(
2000                 'open-ils.cstore.direct.actor.workstation.search', { name => $name } );
2001         return OpenILS::Event->new('WORKSTATION_NAME_EXISTS') if $ws;
2002
2003         $ws = Fieldmapper::actor::workstation->new;
2004         $ws->owning_lib($owner);
2005         $ws->name($name);
2006
2007         my $id = $U->storagereq(
2008                 'open-ils.storage.direct.actor.workstation.create', $ws );
2009         return $U->DB_UPDATE_FAILED($ws) unless $id;
2010
2011         $ws->id($id);
2012         return $ws->id();
2013 }
2014
2015 sub register_workstation {
2016         my( $self, $conn, $authtoken, $name, $owner ) = @_;
2017
2018         my $e = new_editor(authtoken=>$authtoken, xact=>1);
2019         return $e->event unless $e->checkauth;
2020         return $e->event unless $e->allowed('REGISTER_WORKSTATION'); # XXX rely on editor perms
2021         my $existing = $e->search_actor_workstation({name => $name});
2022
2023         if( @$existing ) {
2024                 if( $self->api_name =~ /override/o ) {
2025                         return $e->event unless $e->allowed('DELETE_WORKSTATION'); # XXX rely on editor perms
2026                         return $e->event unless $e->delete_actor_workstation($$existing[0]);
2027                 } else {
2028                         return OpenILS::Event->new('WORKSTATION_NAME_EXISTS')
2029                 }
2030         }
2031
2032         my $ws = Fieldmapper::actor::workstation->new;
2033         $ws->owning_lib($owner);
2034         $ws->name($name);
2035         $e->create_actor_workstation($ws) or return $e->event;
2036         $e->commit;
2037         return $ws->id; # note: editor sets the id on the new object for us
2038 }
2039
2040
2041 __PACKAGE__->register_method (
2042         method          => 'fetch_patron_note',
2043         api_name                => 'open-ils.actor.note.retrieve.all',
2044         signature       => q/
2045                 Returns a list of notes for a given user
2046                 Requestor must have VIEW_USER permission if pub==false and
2047                 @param authtoken The login session key
2048                 @param args Hash of params including
2049                         patronid : the patron's id
2050                         pub : true if retrieving only public notes
2051         /
2052 );
2053
2054 sub fetch_patron_note {
2055         my( $self, $conn, $authtoken, $args ) = @_;
2056         my $patronid = $$args{patronid};
2057
2058         my($reqr, $evt) = $U->checkses($authtoken);
2059
2060         my $patron;
2061         ($patron, $evt) = $U->fetch_user($patronid);
2062         return $evt if $evt;
2063
2064         if($$args{pub}) {
2065                 if( $patronid ne $reqr->id ) {
2066                         $evt = $U->check_perms($reqr->id, $patron->home_ou, 'VIEW_USER');
2067                         return $evt if $evt;
2068                 }
2069                 return $U->cstorereq(
2070                         'open-ils.cstore.direct.actor.usr_note.search.atomic', 
2071                         { usr => $patronid, pub => 't' } );
2072         }
2073
2074         $evt = $U->check_perms($reqr->id, $patron->home_ou, 'VIEW_USER');
2075         return $evt if $evt;
2076
2077         return $U->cstorereq(
2078                 'open-ils.cstore.direct.actor.usr_note.search.atomic', { usr => $patronid } );
2079 }
2080
2081 __PACKAGE__->register_method (
2082         method          => 'create_user_note',
2083         api_name                => 'open-ils.actor.note.create',
2084         signature       => q/
2085                 Creates a new note for the given user
2086                 @param authtoken The login session key
2087                 @param note The note object
2088         /
2089 );
2090 sub create_user_note {
2091         my( $self, $conn, $authtoken, $note ) = @_;
2092         my( $reqr, $patron, $evt ) = 
2093                 $U->checkses_requestor($authtoken, $note->usr, 'UPDATE_USER');
2094         return $evt if $evt;
2095         $logger->activity("user ".$reqr->id." creating note for user ".$note->usr);
2096
2097         $note->creator($reqr->id);
2098         my $id = $U->storagereq(
2099                 'open-ils.storage.direct.actor.usr_note.create', $note );
2100         return $U->DB_UPDATE_FAILED($note) unless $id;
2101         return $id;
2102 }
2103
2104
2105 __PACKAGE__->register_method (
2106         method          => 'delete_user_note',
2107         api_name                => 'open-ils.actor.note.delete',
2108         signature       => q/
2109                 Deletes a note for the given user
2110                 @param authtoken The login session key
2111                 @param noteid The note id
2112         /
2113 );
2114 sub delete_user_note {
2115         my( $self, $conn, $authtoken, $noteid ) = @_;
2116
2117         my $note = $U->cstorereq(
2118                 'open-ils.cstore.direct.actor.usr_note.retrieve', $noteid);
2119         return OpenILS::Event->new('ACTOR_USER_NOTE_NOT_FOUND') unless $note;
2120
2121         my( $reqr, $patron, $evt ) = 
2122                 $U->checkses_requestor($authtoken, $note->usr, 'UPDATE_USER');
2123         return $evt if $evt;
2124         $logger->activity("user ".$reqr->id." deleting note [$noteid] for user ".$note->usr);
2125
2126         my $stat = $U->storagereq(
2127                 'open-ils.storage.direct.actor.usr_note.delete', $noteid );
2128         return $U->DB_UPDATE_FAILED($note) unless defined $stat;
2129         return $stat;
2130 }
2131
2132
2133 __PACKAGE__->register_method (
2134         method          => 'update_user_note',
2135         api_name                => 'open-ils.actor.note.update',
2136         signature       => q/
2137                 @param authtoken The login session key
2138                 @param note The note
2139         /
2140 );
2141
2142 sub update_user_note {
2143         my( $self, $conn, $auth, $note ) = @_;
2144         my $e = new_editor(authtoken=>$auth, xact=>1);
2145         return $e->event unless $e->checkauth;
2146         my $patron = $e->retrieve_actor_user($note->usr)
2147                 or return $e->event;
2148         return $e->event unless 
2149                 $e->allowed('UPDATE_USER', $patron->home_ou);
2150         $e->update_actor_user_note($note)
2151                 or return $e->event;
2152         $e->commit;
2153         return 1;
2154 }
2155
2156
2157
2158
2159 __PACKAGE__->register_method (
2160         method          => 'create_closed_date',
2161         api_name        => 'open-ils.actor.org_unit.closed_date.create',
2162         signature       => q/
2163                 Creates a new closing entry for the given org_unit
2164                 @param authtoken The login session key
2165                 @param note The closed_date object
2166         /
2167 );
2168 sub create_closed_date {
2169         my( $self, $conn, $authtoken, $cd ) = @_;
2170
2171         my( $user, $evt ) = $U->checkses($authtoken);
2172         return $evt if $evt;
2173
2174         $evt = $U->check_perms($user->id, $cd->org_unit, 'CREATE_CLOSEING');
2175         return $evt if $evt;
2176
2177         $logger->activity("user ".$user->id." creating library closing for ".$cd->org_unit);
2178
2179         my $id = $U->storagereq(
2180                 'open-ils.storage.direct.actor.org_unit.closed_date.create', $cd );
2181         return $U->DB_UPDATE_FAILED($cd) unless $id;
2182         return $id;
2183 }
2184
2185
2186 __PACKAGE__->register_method (
2187         method          => 'delete_closed_date',
2188         api_name        => 'open-ils.actor.org_unit.closed_date.delete',
2189         signature       => q/
2190                 Deletes a closing entry for the given org_unit
2191                 @param authtoken The login session key
2192                 @param noteid The close_date id
2193         /
2194 );
2195 sub delete_closed_date {
2196         my( $self, $conn, $authtoken, $cd ) = @_;
2197
2198         my( $user, $evt ) = $U->checkses($authtoken);
2199         return $evt if $evt;
2200
2201         my $cd_obj;
2202         ($cd_obj, $evt) = fetch_closed_date($cd);
2203         return $evt if $evt;
2204
2205         $evt = $U->check_perms($user->id, $cd->org_unit, 'DELETE_CLOSEING');
2206         return $evt if $evt;
2207
2208         $logger->activity("user ".$user->id." deleting library closing for ".$cd->org_unit);
2209
2210         my $stat = $U->storagereq(
2211                 'open-ils.storage.direct.actor.org_unit.closed_date.delete', $cd );
2212         return $U->DB_UPDATE_FAILED($cd) unless $stat;
2213         return $stat;
2214 }
2215
2216
2217 __PACKAGE__->register_method(
2218         method => 'usrname_exists',
2219         api_name        => 'open-ils.actor.username.exists',
2220         signature => q/
2221                 Returns 1 if the requested username exists, returns 0 otherwise
2222         /
2223 );
2224
2225 sub usrname_exists {
2226         my( $self, $conn, $auth, $usrname ) = @_;
2227         my $e = new_editor(authtoken=>$auth);
2228         return $e->event unless $e->checkauth;
2229         my $a = $e->search_actor_user({usrname => $usrname, deleted=>'f'}, {idlist=>1});
2230         return $$a[0] if $a and @$a;
2231         return 0;
2232 }
2233
2234 __PACKAGE__->register_method(
2235         method => 'barcode_exists',
2236         api_name        => 'open-ils.actor.barcode.exists',
2237         signature => q/
2238                 Returns 1 if the requested barcode exists, returns 0 otherwise
2239         /
2240 );
2241
2242 sub barcode_exists {
2243         my( $self, $conn, $auth, $barcode ) = @_;
2244         my $e = new_editor(authtoken=>$auth);
2245         return $e->event unless $e->checkauth;
2246         my $a = $e->search_actor_card({barcode => $barcode}, {idlist=>1});
2247         return $$a[0] if $a and @$a;
2248         return 0;
2249 }
2250
2251
2252 __PACKAGE__->register_method(
2253         method => 'retrieve_net_levels',
2254         api_name        => 'open-ils.actor.net_access_level.retrieve.all',
2255 );
2256
2257 sub retrieve_net_levels {
2258         my( $self, $conn, $auth ) = @_;
2259         my $e = new_editor(authtoken=>$auth);
2260         return $e->event unless $e->checkauth;
2261         return $e->retrieve_all_config_net_access_level();
2262 }
2263
2264
2265 __PACKAGE__->register_method(
2266         method => 'fetch_org_by_shortname',
2267         api_name => 'open-ils.actor.org_unit.retrieve_by_shorname',
2268 );
2269 sub fetch_org_by_shortname {
2270         my( $self, $conn, $sname ) = @_;
2271         my $e = new_editor();
2272         my $org = $e->search_actor_org_unit({ shortname => uc($sname)})->[0];
2273         return $e->event unless $org;
2274         return $org;
2275 }
2276
2277
2278 __PACKAGE__->register_method(
2279         method => 'session_home_lib',
2280         api_name => 'open-ils.actor.session.home_lib',
2281 );
2282
2283 sub session_home_lib {
2284         my( $self, $conn, $auth ) = @_;
2285         my $e = new_editor(authtoken=>$auth);
2286         return undef unless $e->checkauth;
2287         my $org = $e->retrieve_actor_org_unit($e->requestor->home_ou);
2288         return $org->shortname;
2289 }
2290
2291
2292
2293 __PACKAGE__->register_method(
2294         method => 'slim_tree',
2295         api_name        => "open-ils.actor.org_tree.slim_hash.retrieve",
2296 );
2297 sub slim_tree {
2298         my $tree = new_editor()->search_actor_org_unit( 
2299                 [
2300                         {"parent_ou" => undef },
2301                         {
2302                                 flesh                           => 2,
2303                                 flesh_fields    => { aou =>  ['children'] },
2304                                 order_by                        => { aou => 'name'},
2305                                 select                  => { aou => ["id","shortname", "name"]},
2306                         }
2307                 ]
2308         )->[0];
2309
2310         return trim_tree($tree);
2311 }
2312
2313
2314 sub trim_tree {
2315         my $tree = shift;
2316         return undef unless $tree;
2317         my $htree = {
2318                 code => $tree->shortname,
2319                 name => $tree->name,
2320         };
2321         if( $tree->children and @{$tree->children} ) {
2322                 $htree->{children} = [];
2323                 for my $c (@{$tree->children}) {
2324                         push( @{$htree->{children}}, trim_tree($c) );
2325                 }
2326         }
2327
2328         return $htree;
2329 }
2330
2331
2332
2333 __PACKAGE__->register_method(
2334         method  => "user_retrieve_fleshed_by_id",
2335         api_name        => "open-ils.actor.user.fleshed.retrieve",);
2336
2337 sub user_retrieve_fleshed_by_id {
2338         my( $self, $client, $auth, $user_id, $fields ) = @_;
2339         my $e = new_editor(authtoken => $auth);
2340         return $e->event unless $e->checkauth;
2341         if( $e->requestor->id != $user_id ) {
2342                 return $e->event unless $e->allowed('VIEW_USER');
2343         }
2344         $fields ||= [
2345                 "cards",
2346                 "card",
2347                 "standing_penalties",
2348                 "addresses",
2349                 "billing_address",
2350                 "mailing_address",
2351                 "stat_cat_entries" ];
2352         return new_flesh_user($user_id, $fields, $e);
2353 }
2354
2355
2356 sub new_flesh_user {
2357
2358         my $id = shift;
2359         my $fields = shift || [];
2360         my $e   = shift || new_editor(xact=>1);
2361
2362         my $user = $e->retrieve_actor_user(
2363         [
2364         $id,
2365         {
2366                 "flesh"                         => 1,
2367                 "flesh_fields" =>  { "au" => $fields }
2368         }
2369         ]
2370         ) or return $e->event;
2371
2372
2373         if( grep { $_ eq 'addresses' } @$fields ) {
2374
2375                 $user->addresses([]) unless @{$user->addresses};
2376         
2377                 if( ref $user->billing_address ) {
2378                         unless( grep { $user->billing_address->id == $_->id } @{$user->addresses} ) {
2379                                 push( @{$user->addresses}, $user->billing_address );
2380                         }
2381                 }
2382         
2383                 if( ref $user->mailing_address ) {
2384                         unless( grep { $user->mailing_address->id == $_->id } @{$user->addresses} ) {
2385                                 push( @{$user->addresses}, $user->mailing_address );
2386                         }
2387                 }
2388         }
2389
2390         $e->disconnect;
2391         $user->clear_passwd();
2392         return $user;
2393 }
2394
2395
2396
2397
2398 __PACKAGE__->register_method(
2399         method  => "user_retrieve_parts",
2400         api_name        => "open-ils.actor.user.retrieve.parts",);
2401
2402 sub user_retrieve_parts {
2403         my( $self, $client, $auth, $user_id, $fields ) = @_;
2404         my $e = new_editor(authtoken => $auth);
2405         return $e->event unless $e->checkauth;
2406         if( $e->requestor->id != $user_id ) {
2407                 return $e->event unless $e->allowed('VIEW_USER');
2408         }
2409         my @resp;
2410         my $user = $e->retrieve_actor_user($user_id) or return $e->event;
2411         push(@resp, $user->$_()) for(@$fields);
2412         return \@resp;
2413 }
2414
2415
2416
2417
2418
2419
2420 1;
2421