e76bab08704dba72df1bde24b6ef0ff7f9e7e653
[Evergreen.git] / Open-ILS / src / perlmods / OpenILS / Application / AppUtils.pm
1 package OpenILS::Application::AppUtils;
2 # vim:noet:ts=4
3 use strict; use warnings;
4 use OpenILS::Application;
5 use base qw/OpenILS::Application/;
6 use OpenSRF::Utils::Cache;
7 use OpenSRF::Utils::Logger qw/$logger/;
8 use OpenILS::Utils::ModsParser;
9 use OpenSRF::EX qw(:try);
10 use OpenILS::Event;
11 use Data::Dumper;
12 use OpenILS::Utils::CStoreEditor;
13 use OpenILS::Const qw/:const/;
14
15 # ---------------------------------------------------------------------------
16 # Pile of utilty methods used accross applications.
17 # ---------------------------------------------------------------------------
18 my $cache_client = "OpenSRF::Utils::Cache";
19
20
21 # ---------------------------------------------------------------------------
22 # on sucess, returns the created session, on failure throws ERROR exception
23 # ---------------------------------------------------------------------------
24 sub start_db_session {
25
26         my $self = shift;
27         my $session = OpenSRF::AppSession->connect( "open-ils.storage" );
28         my $trans_req = $session->request( "open-ils.storage.transaction.begin" );
29
30         my $trans_resp = $trans_req->recv();
31         if(ref($trans_resp) and UNIVERSAL::isa($trans_resp,"Error")) { throw $trans_resp; }
32         if( ! $trans_resp->content() ) {
33                 throw OpenSRF::ERROR 
34                         ("Unable to Begin Transaction with database" );
35         }
36         $trans_req->finish();
37
38         $logger->debug("Setting global storage session to ".
39                 "session: " . $session->session_id . " : " . $session->app );
40
41         return $session;
42 }
43
44 my $PERM_QUERY = {
45     select => {
46         au => [ {
47             transform => 'permission.usr_has_perm',
48             alias => 'has_perm',
49             column => 'id',
50             params => []
51         } ]
52     },
53     from => 'au',
54     where => {},
55 };
56
57
58 # returns undef if user has all of the perms provided
59 # returns the first failed perm on failure
60 sub check_user_perms {
61         my($self, $user_id, $org_id, @perm_types ) = @_;
62         $logger->debug("Checking perms with user : $user_id , org: $org_id, @perm_types");
63
64         for my $type (@perm_types) {
65             $PERM_QUERY->{select}->{au}->[0]->{params} = [$type, $org_id];
66                 $PERM_QUERY->{where}->{id} = $user_id;
67                 return $type unless $self->is_true(OpenILS::Utils::CStoreEditor->new->json_query($PERM_QUERY)->[0]->{has_perm});
68         }
69         return undef;
70 }
71
72 # checks the list of user perms.  The first one that fails returns a new
73 sub check_perms {
74         my( $self, $user_id, $org_id, @perm_types ) = @_;
75         my $t = $self->check_user_perms( $user_id, $org_id, @perm_types );
76         return OpenILS::Event->new('PERM_FAILURE', ilsperm => $t, ilspermloc => $org_id ) if $t;
77         return undef;
78 }
79
80
81
82 # ---------------------------------------------------------------------------
83 # commits and destroys the session
84 # ---------------------------------------------------------------------------
85 sub commit_db_session {
86         my( $self, $session ) = @_;
87
88         my $req = $session->request( "open-ils.storage.transaction.commit" );
89         my $resp = $req->recv();
90
91         if(!$resp) {
92                 throw OpenSRF::EX::ERROR ("Unable to commit db session");
93         }
94
95         if(UNIVERSAL::isa($resp,"Error")) { 
96                 throw $resp ($resp->stringify); 
97         }
98
99         if(!$resp->content) {
100                 throw OpenSRF::EX::ERROR ("Unable to commit db session");
101         }
102
103         $session->finish();
104         $session->disconnect();
105         $session->kill_me();
106 }
107
108 sub rollback_db_session {
109         my( $self, $session ) = @_;
110
111         my $req = $session->request("open-ils.storage.transaction.rollback");
112         my $resp = $req->recv();
113         if(UNIVERSAL::isa($resp,"Error")) { throw $resp;  }
114
115         $session->finish();
116         $session->disconnect();
117         $session->kill_me();
118 }
119
120
121 # returns undef it the event is not an ILS event
122 # returns the event code otherwise
123 sub event_code {
124         my( $self, $evt ) = @_;
125         return $evt->{ilsevent} if( ref($evt) eq 'HASH' and defined($evt->{ilsevent})) ;
126         return undef;
127 }
128
129 # ---------------------------------------------------------------------------
130 # Checks to see if a user is logged in.  Returns the user record on success,
131 # throws an exception on error.
132 # ---------------------------------------------------------------------------
133 sub check_user_session {
134
135         my( $self, $user_session ) = @_;
136
137         my $content = $self->simplereq( 
138                 'open-ils.auth', 
139                 'open-ils.auth.session.retrieve', $user_session );
140
141         if(! $content or $self->event_code($content)) {
142                 throw OpenSRF::EX::ERROR 
143                         ("Session [$user_session] cannot be authenticated" );
144         }
145
146         $logger->debug("Fetch user session $user_session found user " . $content->id );
147
148         return $content;
149 }
150
151 # generic simple request returning a scalar value
152 sub simplereq {
153         my($self, $service, $method, @params) = @_;
154         return $self->simple_scalar_request($service, $method, @params);
155 }
156
157
158 sub simple_scalar_request {
159         my($self, $service, $method, @params) = @_;
160
161         my $session = OpenSRF::AppSession->create( $service );
162
163         my $request = $session->request( $method, @params );
164
165         my $val;
166         my $err;
167         try  {
168
169                 $val = $request->gather(1);     
170
171         } catch Error with {
172                 $err = shift;
173         };
174
175         if( $err ) {
176                 warn "received error : service=$service : method=$method : params=".Dumper(\@params) . "\n $err";
177                 throw $err ("Call to $service for method $method \n failed with exception: $err : " );
178         }
179
180         return $val;
181 }
182
183
184
185
186
187 my $tree                                                = undef;
188 my $orglist                                     = undef;
189 my $org_typelist                        = undef;
190 my $org_typelist_hash   = {};
191
192 sub __get_org_tree {
193         
194         # can we throw this version away??
195
196         my $self = shift;
197         if($tree) { return $tree; }
198
199         # see if it's in the cache
200         $tree = $cache_client->new()->get_cache('_orgtree');
201         if($tree) { return $tree; }
202
203         if(!$orglist) {
204                 warn "Retrieving Org Tree\n";
205                 $orglist = $self->simple_scalar_request( 
206                         "open-ils.cstore", 
207                         "open-ils.cstore.direct.actor.org_unit.search.atomic",
208                         { id => { '!=' => undef } }
209                 );
210         }
211
212         if( ! $org_typelist ) {
213                 warn "Retrieving org types\n";
214                 $org_typelist = $self->simple_scalar_request( 
215                         "open-ils.cstore", 
216                         "open-ils.cstore.direct.actor.org_unit_type.search.atomic",
217                         { id => { '!=' => undef } }
218                 );
219                 $self->build_org_type($org_typelist);
220         }
221
222         $tree = $self->build_org_tree($orglist,1);
223         $cache_client->new()->put_cache('_orgtree', $tree);
224         return $tree;
225
226 }
227
228 my $slimtree = undef;
229 sub get_slim_org_tree {
230
231         my $self = shift;
232         if($slimtree) { return $slimtree; }
233
234         # see if it's in the cache
235         $slimtree = $cache_client->new()->get_cache('slimorgtree');
236         if($slimtree) { return $slimtree; }
237
238         if(!$orglist) {
239                 warn "Retrieving Org Tree\n";
240                 $orglist = $self->simple_scalar_request( 
241                         "open-ils.cstore", 
242                         "open-ils.cstore.direct.actor.org_unit.search.atomic",
243                         { id => { '!=' => undef } }
244                 );
245         }
246
247         $slimtree = $self->build_org_tree($orglist);
248         $cache_client->new->put_cache('slimorgtree', $slimtree);
249         return $slimtree;
250
251 }
252
253
254 sub build_org_type { 
255         my($self, $org_typelist)  = @_;
256         for my $type (@$org_typelist) {
257                 $org_typelist_hash->{$type->id()} = $type;
258         }
259 }
260
261
262
263 sub build_org_tree {
264
265         my( $self, $orglist, $add_types ) = @_;
266
267         return $orglist unless ref $orglist; 
268     return $$orglist[0] if @$orglist == 1;
269
270         my @list = sort { 
271                 $a->ou_type <=> $b->ou_type ||
272                 $a->name cmp $b->name } @$orglist;
273
274         for my $org (@list) {
275
276                 next unless ($org);
277
278                 if(!ref($org->ou_type()) and $add_types) {
279                         $org->ou_type( $org_typelist_hash->{$org->ou_type()});
280                 }
281
282                 next unless (defined($org->parent_ou));
283
284                 my ($parent) = grep { $_->id == $org->parent_ou } @list;
285                 next unless $parent;
286                 $parent->children([]) unless defined($parent->children); 
287                 push( @{$parent->children}, $org );
288         }
289
290         return $list[0];
291 }
292
293 sub fetch_closed_date {
294         my( $self, $cd ) = @_;
295         my $evt;
296         
297         $logger->debug("Fetching closed_date $cd from cstore");
298
299         my $cd_obj = $self->simplereq(
300                 'open-ils.cstore',
301                 'open-ils.cstore.direct.actor.org_unit.closed_date.retrieve', $cd );
302
303         if(!$cd_obj) {
304                 $logger->info("closed_date $cd not found in the db");
305                 $evt = OpenILS::Event->new('ACTOR_USER_NOT_FOUND');
306         }
307
308         return ($cd_obj, $evt);
309 }
310
311 sub fetch_user {
312         my( $self, $userid ) = @_;
313         my( $user, $evt );
314         
315         $logger->debug("Fetching user $userid from cstore");
316
317         $user = $self->simplereq(
318                 'open-ils.cstore',
319                 'open-ils.cstore.direct.actor.user.retrieve', $userid );
320
321         if(!$user) {
322                 $logger->info("User $userid not found in the db");
323                 $evt = OpenILS::Event->new('ACTOR_USER_NOT_FOUND');
324         }
325
326         return ($user, $evt);
327 }
328
329 sub checkses {
330         my( $self, $session ) = @_;
331         my $user; my $evt; my $e; 
332
333         $logger->debug("Checking user session $session");
334
335         try {
336                 $user = $self->check_user_session($session);
337         } catch Error with { $e = 1; };
338
339         $logger->debug("Done checking user session $session " . (($e) ? "error = $e" : "") );
340
341         if( $e or !$user ) { $evt = OpenILS::Event->new('NO_SESSION'); }
342         return ( $user, $evt );
343 }
344
345
346 # verifiese the session and checks the permissions agains the
347 # session user and the user's home_ou as the org id
348 sub checksesperm {
349         my( $self, $session, @perms ) = @_;
350         my $user; my $evt; my $e; 
351         $logger->debug("Checking user session $session and perms @perms");
352         ($user, $evt) = $self->checkses($session);
353         return (undef, $evt) if $evt;
354         $evt = $self->check_perms($user->id, $user->home_ou, @perms);
355         return ($user, $evt);
356 }
357
358
359 sub checkrequestor {
360         my( $self, $staffobj, $userid, @perms ) = @_;
361         my $user; my $evt;
362         $userid = $staffobj->id unless defined $userid;
363
364         $logger->debug("checkrequestor(): requestor => " . $staffobj->id . ", target => $userid");
365
366         if( $userid ne $staffobj->id ) {
367                 ($user, $evt) = $self->fetch_user($userid);
368                 return (undef, $evt) if $evt;
369                 $evt = $self->check_perms( $staffobj->id, $user->home_ou, @perms );
370
371         } else {
372                 $user = $staffobj;
373         }
374
375         return ($user, $evt);
376 }
377
378 sub checkses_requestor {
379         my( $self, $authtoken, $targetid, @perms ) = @_;
380         my( $requestor, $target, $evt );
381
382         ($requestor, $evt) = $self->checkses($authtoken);
383         return (undef, undef, $evt) if $evt;
384
385         ($target, $evt) = $self->checkrequestor( $requestor, $targetid, @perms );
386         return( $requestor, $target, $evt);
387 }
388
389 sub fetch_copy {
390         my( $self, $copyid ) = @_;
391         my( $copy, $evt );
392
393         $logger->debug("Fetching copy $copyid from cstore");
394
395         $copy = $self->simplereq(
396                 'open-ils.cstore',
397                 'open-ils.cstore.direct.asset.copy.retrieve', $copyid );
398
399         if(!$copy) { $evt = OpenILS::Event->new('ASSET_COPY_NOT_FOUND'); }
400
401         return( $copy, $evt );
402 }
403
404
405 # retrieves a circ object by id
406 sub fetch_circulation {
407         my( $self, $circid ) = @_;
408         my $circ; my $evt;
409         
410         $logger->debug("Fetching circ $circid from cstore");
411
412         $circ = $self->simplereq(
413                 'open-ils.cstore',
414                 "open-ils.cstore.direct.action.circulation.retrieve", $circid );
415
416         if(!$circ) {
417                 $evt = OpenILS::Event->new('ACTION_CIRCULATION_NOT_FOUND', circid => $circid );
418         }
419
420         return ( $circ, $evt );
421 }
422
423 sub fetch_record_by_copy {
424         my( $self, $copyid ) = @_;
425         my( $record, $evt );
426
427         $logger->debug("Fetching record by copy $copyid from cstore");
428
429         $record = $self->simplereq(
430                 'open-ils.cstore',
431                 'open-ils.cstore.direct.asset.copy.retrieve', $copyid,
432                 { flesh => 3,
433                   flesh_fields => {     bre => [ 'fixed_fields' ],
434                                         acn => [ 'record' ],
435                                         acp => [ 'call_number' ],
436                                   }
437                 }
438         );
439
440         if(!$record) {
441                 $evt = OpenILS::Event->new('BIBLIO_RECORD_ENTRY_NOT_FOUND');
442         } else {
443                 $record = $record->call_number->record;
444         }
445
446         return ($record, $evt);
447 }
448
449 # turns a record object into an mvr (mods) object
450 sub record_to_mvr {
451         my( $self, $record ) = @_;
452         return undef unless $record and $record->marc;
453         my $u = OpenILS::Utils::ModsParser->new();
454         $u->start_mods_batch( $record->marc );
455         my $mods = $u->finish_mods_batch();
456         $mods->doc_id($record->id);
457    $mods->tcn($record->tcn_value);
458         return $mods;
459 }
460
461 sub fetch_hold {
462         my( $self, $holdid ) = @_;
463         my( $hold, $evt );
464
465         $logger->debug("Fetching hold $holdid from cstore");
466
467         $hold = $self->simplereq(
468                 'open-ils.cstore',
469                 'open-ils.cstore.direct.action.hold_request.retrieve', $holdid);
470
471         $evt = OpenILS::Event->new('ACTION_HOLD_REQUEST_NOT_FOUND', holdid => $holdid) unless $hold;
472
473         return ($hold, $evt);
474 }
475
476
477 sub fetch_hold_transit_by_hold {
478         my( $self, $holdid ) = @_;
479         my( $transit, $evt );
480
481         $logger->debug("Fetching transit by hold $holdid from cstore");
482
483         $transit = $self->simplereq(
484                 'open-ils.cstore',
485                 'open-ils.cstore.direct.action.hold_transit_copy.search', { hold => $holdid } );
486
487         $evt = OpenILS::Event->new('ACTION_HOLD_TRANSIT_COPY_NOT_FOUND', holdid => $holdid) unless $transit;
488
489         return ($transit, $evt );
490 }
491
492 # fetches the captured, but not fulfilled hold attached to a given copy
493 sub fetch_open_hold_by_copy {
494         my( $self, $copyid ) = @_;
495         $logger->debug("Searching for active hold for copy $copyid");
496         my( $hold, $evt );
497
498         $hold = $self->cstorereq(
499                 'open-ils.cstore.direct.action.hold_request.search',
500                 { 
501                         current_copy            => $copyid , 
502                         capture_time            => { "!=" => undef }, 
503                         fulfillment_time        => undef,
504                         cancel_time                     => undef,
505                 } );
506
507         $evt = OpenILS::Event->new('ACTION_HOLD_REQUEST_NOT_FOUND', copyid => $copyid) unless $hold;
508         return ($hold, $evt);
509 }
510
511 sub fetch_hold_transit {
512         my( $self, $transid ) = @_;
513         my( $htransit, $evt );
514         $logger->debug("Fetching hold transit with hold id $transid");
515         $htransit = $self->cstorereq(
516                 'open-ils.cstore.direct.action.hold_transit_copy.retrieve', $transid );
517         $evt = OpenILS::Event->new('ACTION_HOLD_TRANSIT_COPY_NOT_FOUND', id => $transid) unless $htransit;
518         return ($htransit, $evt);
519 }
520
521 sub fetch_copy_by_barcode {
522         my( $self, $barcode ) = @_;
523         my( $copy, $evt );
524
525         $logger->debug("Fetching copy by barcode $barcode from cstore");
526
527         $copy = $self->simplereq( 'open-ils.cstore',
528                 'open-ils.cstore.direct.asset.copy.search', { barcode => $barcode, deleted => 'f'} );
529                 #'open-ils.storage.direct.asset.copy.search.barcode', $barcode );
530
531         $evt = OpenILS::Event->new('ASSET_COPY_NOT_FOUND', barcode => $barcode) unless $copy;
532
533         return ($copy, $evt);
534 }
535
536 sub fetch_open_billable_transaction {
537         my( $self, $transid ) = @_;
538         my( $transaction, $evt );
539
540         $logger->debug("Fetching open billable transaction $transid from cstore");
541
542         $transaction = $self->simplereq(
543                 'open-ils.cstore',
544                 'open-ils.cstore.direct.money.open_billable_transaction_summary.retrieve',  $transid);
545
546         $evt = OpenILS::Event->new(
547                 'MONEY_OPEN_BILLABLE_TRANSACTION_SUMMARY_NOT_FOUND', transid => $transid ) unless $transaction;
548
549         return ($transaction, $evt);
550 }
551
552
553
554 my %buckets;
555 $buckets{'biblio'} = 'biblio_record_entry_bucket';
556 $buckets{'callnumber'} = 'call_number_bucket';
557 $buckets{'copy'} = 'copy_bucket';
558 $buckets{'user'} = 'user_bucket';
559
560 sub fetch_container {
561         my( $self, $id, $type ) = @_;
562         my( $bucket, $evt );
563
564         $logger->debug("Fetching container $id with type $type");
565
566         my $e = 'CONTAINER_CALL_NUMBER_BUCKET_NOT_FOUND';
567         $e = 'CONTAINER_BIBLIO_RECORD_ENTRY_BUCKET_NOT_FOUND' if $type eq 'biblio';
568         $e = 'CONTAINER_USER_BUCKET_NOT_FOUND' if $type eq 'user';
569         $e = 'CONTAINER_COPY_BUCKET_NOT_FOUND' if $type eq 'copy';
570
571         my $meth = $buckets{$type};
572         $bucket = $self->simplereq(
573                 'open-ils.cstore',
574                 "open-ils.cstore.direct.container.$meth.retrieve", $id );
575
576         $evt = OpenILS::Event->new(
577                 $e, container => $id, container_type => $type ) unless $bucket;
578
579         return ($bucket, $evt);
580 }
581
582
583 sub fetch_container_e {
584         my( $self, $editor, $id, $type ) = @_;
585
586         my( $bucket, $evt );
587         $bucket = $editor->retrieve_container_copy_bucket($id) if $type eq 'copy';
588         $bucket = $editor->retrieve_container_call_number_bucket($id) if $type eq 'callnumber';
589         $bucket = $editor->retrieve_container_biblio_record_entry_bucket($id) if $type eq 'biblio';
590         $bucket = $editor->retrieve_container_user_bucket($id) if $type eq 'user';
591
592         $evt = $editor->event unless $bucket;
593         return ($bucket, $evt);
594 }
595
596 sub fetch_container_item_e {
597         my( $self, $editor, $id, $type ) = @_;
598
599         my( $bucket, $evt );
600         $bucket = $editor->retrieve_container_copy_bucket_item($id) if $type eq 'copy';
601         $bucket = $editor->retrieve_container_call_number_bucket_item($id) if $type eq 'callnumber';
602         $bucket = $editor->retrieve_container_biblio_record_entry_bucket_item($id) if $type eq 'biblio';
603         $bucket = $editor->retrieve_container_user_bucket_item($id) if $type eq 'user';
604
605         $evt = $editor->event unless $bucket;
606         return ($bucket, $evt);
607 }
608
609
610
611
612
613 sub fetch_container_item {
614         my( $self, $id, $type ) = @_;
615         my( $bucket, $evt );
616
617         $logger->debug("Fetching container item $id with type $type");
618
619         my $meth = $buckets{$type} . "_item";
620
621         $bucket = $self->simplereq(
622                 'open-ils.cstore',
623                 "open-ils.cstore.direct.container.$meth.retrieve", $id );
624
625
626         my $e = 'CONTAINER_CALL_NUMBER_BUCKET_ITEM_NOT_FOUND';
627         $e = 'CONTAINER_BIBLIO_RECORD_ENTRY_BUCKET_ITEM_NOT_FOUND' if $type eq 'biblio';
628         $e = 'CONTAINER_USER_BUCKET_ITEM_NOT_FOUND' if $type eq 'user';
629         $e = 'CONTAINER_COPY_BUCKET_ITEM_NOT_FOUND' if $type eq 'copy';
630
631         $evt = OpenILS::Event->new(
632                 $e, itemid => $id, container_type => $type ) unless $bucket;
633
634         return ($bucket, $evt);
635 }
636
637
638 sub fetch_patron_standings {
639         my $self = shift;
640         $logger->debug("Fetching patron standings");    
641         return $self->simplereq(
642                 'open-ils.cstore', 
643                 'open-ils.cstore.direct.config.standing.search.atomic', { id => { '!=' => undef } });
644 }
645
646
647 sub fetch_permission_group_tree {
648         my $self = shift;
649         $logger->debug("Fetching patron profiles");     
650         return $self->simplereq(
651                 'open-ils.actor', 
652                 'open-ils.actor.groups.tree.retrieve' );
653 }
654
655
656 sub fetch_patron_circ_summary {
657         my( $self, $userid ) = @_;
658         $logger->debug("Fetching patron summary for $userid");
659         my $summary = $self->simplereq(
660                 'open-ils.storage', 
661                 "open-ils.storage.action.circulation.patron_summary", $userid );
662
663         if( $summary ) {
664                 $summary->[0] ||= 0;
665                 $summary->[1] ||= 0.0;
666                 return $summary;
667         }
668         return undef;
669 }
670
671
672 sub fetch_copy_statuses {
673         my( $self ) = @_;
674         $logger->debug("Fetching copy statuses");
675         return $self->simplereq(
676                 'open-ils.cstore', 
677                 'open-ils.cstore.direct.config.copy_status.search.atomic', { id => { '!=' => undef } });
678 }
679
680 sub fetch_copy_location {
681         my( $self, $id ) = @_;
682         my $evt;
683         my $cl = $self->cstorereq(
684                 'open-ils.cstore.direct.asset.copy_location.retrieve', $id );
685         $evt = OpenILS::Event->new('ASSET_COPY_LOCATION_NOT_FOUND') unless $cl;
686         return ($cl, $evt);
687 }
688
689 sub fetch_copy_locations {
690         my $self = shift; 
691         return $self->simplereq(
692                 'open-ils.cstore', 
693                 'open-ils.cstore.direct.asset.copy_location.search.atomic', { id => { '!=' => undef } });
694 }
695
696 sub fetch_copy_location_by_name {
697         my( $self, $name, $org ) = @_;
698         my $evt;
699         my $cl = $self->cstorereq(
700                 'open-ils.cstore.direct.asset.copy_location.search',
701                         { name => $name, owning_lib => $org } );
702         $evt = OpenILS::Event->new('ASSET_COPY_LOCATION_NOT_FOUND') unless $cl;
703         return ($cl, $evt);
704 }
705
706 sub fetch_callnumber {
707         my( $self, $id ) = @_;
708         my $evt = undef;
709
710         my $e = OpenILS::Event->new( 'ASSET_CALL_NUMBER_NOT_FOUND', id => $id );
711         return( undef, $e ) unless $id;
712
713         $logger->debug("Fetching callnumber $id");
714
715         my $cn = $self->simplereq(
716                 'open-ils.cstore',
717                 'open-ils.cstore.direct.asset.call_number.retrieve', $id );
718         $evt = $e  unless $cn;
719
720         return ( $cn, $evt );
721 }
722
723 my %ORG_CACHE; # - these rarely change, so cache them..
724 sub fetch_org_unit {
725         my( $self, $id ) = @_;
726         return undef unless $id;
727         return $id if( ref($id) eq 'Fieldmapper::actor::org_unit' );
728         return $ORG_CACHE{$id} if $ORG_CACHE{$id};
729         $logger->debug("Fetching org unit $id");
730         my $evt = undef;
731
732         my $org = $self->simplereq(
733                 'open-ils.cstore', 
734                 'open-ils.cstore.direct.actor.org_unit.retrieve', $id );
735         $evt = OpenILS::Event->new( 'ACTOR_ORG_UNIT_NOT_FOUND', id => $id ) unless $org;
736         $ORG_CACHE{$id}  = $org;
737
738         return ($org, $evt);
739 }
740
741 sub fetch_stat_cat {
742         my( $self, $type, $id ) = @_;
743         my( $cat, $evt );
744         $logger->debug("Fetching $type stat cat: $id");
745         $cat = $self->simplereq(
746                 'open-ils.cstore', 
747                 "open-ils.cstore.direct.$type.stat_cat.retrieve", $id );
748
749         my $e = 'ASSET_STAT_CAT_NOT_FOUND';
750         $e = 'ACTOR_STAT_CAT_NOT_FOUND' if $type eq 'actor';
751
752         $evt = OpenILS::Event->new( $e, id => $id ) unless $cat;
753         return ( $cat, $evt );
754 }
755
756 sub fetch_stat_cat_entry {
757         my( $self, $type, $id ) = @_;
758         my( $entry, $evt );
759         $logger->debug("Fetching $type stat cat entry: $id");
760         $entry = $self->simplereq(
761                 'open-ils.cstore', 
762                 "open-ils.cstore.direct.$type.stat_cat_entry.retrieve", $id );
763
764         my $e = 'ASSET_STAT_CAT_ENTRY_NOT_FOUND';
765         $e = 'ACTOR_STAT_CAT_ENTRY_NOT_FOUND' if $type eq 'actor';
766
767         $evt = OpenILS::Event->new( $e, id => $id ) unless $entry;
768         return ( $entry, $evt );
769 }
770
771
772 sub find_org {
773         my( $self, $org_tree, $orgid )  = @_;
774         if (!$org_tree) {
775                 $logger->warn("find_org() did not receive a value for \$org_tree");
776                 return undef;
777         } elsif (!$orgid) {
778                 $logger->warn("find_org() did not receive a value for \$orgid");
779                 return undef;
780     }
781         return $org_tree if ( $org_tree->id eq $orgid );
782         return undef unless ref($org_tree->children);
783         for my $c (@{$org_tree->children}) {
784                 my $o = $self->find_org($c, $orgid);
785                 return $o if $o;
786         }
787         return undef;
788 }
789
790 sub fetch_non_cat_type_by_name_and_org {
791         my( $self, $name, $orgId ) = @_;
792         $logger->debug("Fetching non cat type $name at org $orgId");
793         my $types = $self->simplereq(
794                 'open-ils.cstore',
795                 'open-ils.cstore.direct.config.non_cataloged_type.search.atomic',
796                 { name => $name, owning_lib => $orgId } );
797         return ($types->[0], undef) if($types and @$types);
798         return (undef, OpenILS::Event->new('CONFIG_NON_CATALOGED_TYPE_NOT_FOUND') );
799 }
800
801 sub fetch_non_cat_type {
802         my( $self, $id ) = @_;
803         $logger->debug("Fetching non cat type $id");
804         my( $type, $evt );
805         $type = $self->simplereq(
806                 'open-ils.cstore', 
807                 'open-ils.cstore.direct.config.non_cataloged_type.retrieve', $id );
808         $evt = OpenILS::Event->new('CONFIG_NON_CATALOGED_TYPE_NOT_FOUND') unless $type;
809         return ($type, $evt);
810 }
811
812 sub DB_UPDATE_FAILED { 
813         my( $self, $payload ) = @_;
814         return OpenILS::Event->new('DATABASE_UPDATE_FAILED', 
815                 payload => ($payload) ? $payload : undef ); 
816 }
817
818 sub fetch_circ_duration_by_name {
819         my( $self, $name ) = @_;
820         my( $dur, $evt );
821         $dur = $self->simplereq(
822                 'open-ils.cstore', 
823                 'open-ils.cstore.direct.config.rules.circ_duration.search.atomic', { name => $name } );
824         $dur = $dur->[0];
825         $evt = OpenILS::Event->new('CONFIG_RULES_CIRC_DURATION_NOT_FOUND') unless $dur;
826         return ($dur, $evt);
827 }
828
829 sub fetch_recurring_fine_by_name {
830         my( $self, $name ) = @_;
831         my( $obj, $evt );
832         $obj = $self->simplereq(
833                 'open-ils.cstore', 
834                 'open-ils.cstore.direct.config.rules.recuring_fine.search.atomic', { name => $name } );
835         $obj = $obj->[0];
836         $evt = OpenILS::Event->new('CONFIG_RULES_RECURING_FINE_NOT_FOUND') unless $obj;
837         return ($obj, $evt);
838 }
839
840 sub fetch_max_fine_by_name {
841         my( $self, $name ) = @_;
842         my( $obj, $evt );
843         $obj = $self->simplereq(
844                 'open-ils.cstore', 
845                 'open-ils.cstore.direct.config.rules.max_fine.search.atomic', { name => $name } );
846         $obj = $obj->[0];
847         $evt = OpenILS::Event->new('CONFIG_RULES_MAX_FINE_NOT_FOUND') unless $obj;
848         return ($obj, $evt);
849 }
850
851 sub storagereq {
852         my( $self, $method, @params ) = @_;
853         return $self->simplereq(
854                 'open-ils.storage', $method, @params );
855 }
856
857 sub cstorereq {
858         my( $self, $method, @params ) = @_;
859         return $self->simplereq(
860                 'open-ils.cstore', $method, @params );
861 }
862
863 sub event_equals {
864         my( $self, $e, $name ) =  @_;
865         if( $e and ref($e) eq 'HASH' and 
866                 defined($e->{textcode}) and $e->{textcode} eq $name ) {
867                 return 1 ;
868         }
869         return 0;
870 }
871
872 sub logmark {
873         my( undef, $f, $l ) = caller(0);
874         my( undef, undef, undef, $s ) = caller(1);
875         $s =~ s/.*:://g;
876         $f =~ s/.*\///g;
877         $logger->debug("LOGMARK: $f:$l:$s");
878 }
879
880 # takes a copy id 
881 sub fetch_open_circulation {
882         my( $self, $cid ) = @_;
883         my $evt;
884         $self->logmark;
885         my $circ = $self->cstorereq(
886                 'open-ils.cstore.direct.action.open_circulation.search',
887                 { target_copy => $cid, stop_fines_time => undef } );
888         $evt = OpenILS::Event->new('ACTION_CIRCULATION_NOT_FOUND') unless $circ;        
889         return ($circ, $evt);
890 }
891
892 sub fetch_all_open_circulation {
893         my( $self, $cid ) = @_;
894         my $evt;
895         $self->logmark;
896         my $circ = $self->cstorereq(
897                 'open-ils.cstore.direct.action.open_circulation.search',
898                 { target_copy => $cid, xact_finish => undef } );
899         $evt = OpenILS::Event->new('ACTION_CIRCULATION_NOT_FOUND') unless $circ;        
900         return ($circ, $evt);
901 }
902
903 my $copy_statuses;
904 sub copy_status_from_name {
905         my( $self, $name ) = @_;
906         $copy_statuses = $self->fetch_copy_statuses unless $copy_statuses;
907         for my $status (@$copy_statuses) { 
908                 return $status if( $status->name =~ /$name/i );
909         }
910         return undef;
911 }
912
913 sub copy_status_to_name {
914         my( $self, $sid ) = @_;
915         $copy_statuses = $self->fetch_copy_statuses unless $copy_statuses;
916         for my $status (@$copy_statuses) { 
917                 return $status->name if( $status->id == $sid );
918         }
919         return undef;
920 }
921
922
923 sub copy_status {
924         my( $self, $arg ) = @_;
925         return $arg if ref $arg;
926         $copy_statuses = $self->fetch_copy_statuses unless $copy_statuses;
927         my ($stat) = grep { $_->id == $arg } @$copy_statuses;
928         return $stat;
929 }
930
931 sub fetch_open_transit_by_copy {
932         my( $self, $copyid ) = @_;
933         my($transit, $evt);
934         $transit = $self->cstorereq(
935                 'open-ils.cstore.direct.action.transit_copy.search',
936                 { target_copy => $copyid, dest_recv_time => undef });
937         $evt = OpenILS::Event->new('ACTION_TRANSIT_COPY_NOT_FOUND') unless $transit;
938         return ($transit, $evt);
939 }
940
941 sub unflesh_copy {
942         my( $self, $copy ) = @_;
943         return undef unless $copy;
944         $copy->status( $copy->status->id ) if ref($copy->status);
945         $copy->location( $copy->location->id ) if ref($copy->location);
946         $copy->circ_lib( $copy->circ_lib->id ) if ref($copy->circ_lib);
947         return $copy;
948 }
949
950 # un-fleshes a copy and updates it in the DB
951 # returns a DB_UPDATE_FAILED event on error
952 # returns undef on success
953 sub update_copy {
954         my( $self, %params ) = @_;
955
956         my $copy                = $params{copy} || die "update_copy(): copy required";
957         my $editor      = $params{editor} || die "update_copy(): copy editor required";
958         my $session = $params{session};
959
960         $logger->debug("Updating copy in the database: " . $copy->id);
961
962         $self->unflesh_copy($copy);
963         $copy->editor( $editor );
964         $copy->edit_date( 'now' );
965
966         my $s;
967         my $meth = 'open-ils.storage.direct.asset.copy.update';
968
969         $s = $session->request( $meth, $copy )->gather(1) if $session;
970         $s = $self->storagereq( $meth, $copy ) unless $session;
971
972         $logger->debug("Update of copy ".$copy->id." returned: $s");
973
974         return $self->DB_UPDATE_FAILED($copy) unless $s;
975         return undef;
976 }
977
978 sub fetch_billable_xact {
979         my( $self, $id ) = @_;
980         my($xact, $evt);
981         $logger->debug("Fetching billable transaction %id");
982         $xact = $self->cstorereq(
983                 'open-ils.cstore.direct.money.billable_transaction.retrieve', $id );
984         $evt = OpenILS::Event->new('MONEY_BILLABLE_TRANSACTION_NOT_FOUND') unless $xact;
985         return ($xact, $evt);
986 }
987
988 sub fetch_billable_xact_summary {
989         my( $self, $id ) = @_;
990         my($xact, $evt);
991         $logger->debug("Fetching billable transaction summary %id");
992         $xact = $self->cstorereq(
993                 'open-ils.cstore.direct.money.billable_transaction_summary.retrieve', $id );
994         $evt = OpenILS::Event->new('MONEY_BILLABLE_TRANSACTION_NOT_FOUND') unless $xact;
995         return ($xact, $evt);
996 }
997
998 sub fetch_fleshed_copy {
999         my( $self, $id ) = @_;
1000         my( $copy, $evt );
1001         $logger->info("Fetching fleshed copy $id");
1002         $copy = $self->cstorereq(
1003                 "open-ils.cstore.direct.asset.copy.retrieve", $id,
1004                 { flesh => 1,
1005                   flesh_fields => { acp => [ qw/ circ_lib location status stat_cat_entries / ] }
1006                 }
1007         );
1008         $evt = OpenILS::Event->new('ASSET_COPY_NOT_FOUND', id => $id) unless $copy;
1009         return ($copy, $evt);
1010 }
1011
1012
1013 # returns the org that owns the callnumber that the copy
1014 # is attached to
1015 sub fetch_copy_owner {
1016         my( $self, $copyid ) = @_;
1017         my( $copy, $cn, $evt );
1018         $logger->debug("Fetching copy owner $copyid");
1019         ($copy, $evt) = $self->fetch_copy($copyid);
1020         return (undef,$evt) if $evt;
1021         ($cn, $evt) = $self->fetch_callnumber($copy->call_number);
1022         return (undef,$evt) if $evt;
1023         return ($cn->owning_lib);
1024 }
1025
1026 sub fetch_copy_note {
1027         my( $self, $id ) = @_;
1028         my( $note, $evt );
1029         $logger->debug("Fetching copy note $id");
1030         $note = $self->cstorereq(
1031                 'open-ils.cstore.direct.asset.copy_note.retrieve', $id );
1032         $evt = OpenILS::Event->new('ASSET_COPY_NOTE_NOT_FOUND', id => $id ) unless $note;
1033         return ($note, $evt);
1034 }
1035
1036 sub fetch_call_numbers_by_title {
1037         my( $self, $titleid ) = @_;
1038         $logger->info("Fetching call numbers by title $titleid");
1039         return $self->cstorereq(
1040                 'open-ils.cstore.direct.asset.call_number.search.atomic', 
1041                 { record => $titleid, deleted => 'f' });
1042                 #'open-ils.storage.direct.asset.call_number.search.record.atomic', $titleid);
1043 }
1044
1045 sub fetch_copies_by_call_number {
1046         my( $self, $cnid ) = @_;
1047         $logger->info("Fetching copies by call number $cnid");
1048         return $self->cstorereq(
1049                 'open-ils.cstore.direct.asset.copy.search.atomic', { call_number => $cnid, deleted => 'f' } );
1050                 #'open-ils.storage.direct.asset.copy.search.call_number.atomic', $cnid );
1051 }
1052
1053 sub fetch_user_by_barcode {
1054         my( $self, $bc ) = @_;
1055         my $cardid = $self->cstorereq(
1056                 'open-ils.cstore.direct.actor.card.id_list', { barcode => $bc } );
1057         return (undef, OpenILS::Event->new('ACTOR_CARD_NOT_FOUND', barcode => $bc)) unless $cardid;
1058         my $user = $self->cstorereq(
1059                 'open-ils.cstore.direct.actor.user.search', { card => $cardid } );
1060         return (undef, OpenILS::Event->new('ACTOR_USER_NOT_FOUND', card => $cardid)) unless $user;
1061         return ($user);
1062         
1063 }
1064
1065
1066 # ---------------------------------------------------------------------
1067 # Updates and returns the patron penalties
1068 # ---------------------------------------------------------------------
1069 sub update_patron_penalties {
1070         my( $self, %args ) = @_;
1071         return $self->simplereq(
1072                 'open-ils.penalty',
1073                 'open-ils.penalty.patron_penalty.calculate', 
1074                 { update => 1, %args }
1075         );
1076 }
1077
1078 sub fetch_bill {
1079         my( $self, $billid ) = @_;
1080         $logger->debug("Fetching billing $billid");
1081         my $bill = $self->cstorereq(
1082                 'open-ils.cstore.direct.money.billing.retrieve', $billid );
1083         my $evt = OpenILS::Event->new('MONEY_BILLING_NOT_FOUND') unless $bill;
1084         return($bill, $evt);
1085 }
1086
1087
1088
1089 my $ORG_TREE;
1090 sub fetch_org_tree {
1091         my $self = shift;
1092         return $ORG_TREE if $ORG_TREE;
1093         return $ORG_TREE = OpenILS::Utils::CStoreEditor->new->search_actor_org_unit( 
1094                 [
1095                         {"parent_ou" => undef },
1096                         {
1097                                 flesh                           => 2,
1098                                 flesh_fields    => { aou =>  ['children'] },
1099                                 order_by       => { aou => 'name'}
1100                         }
1101                 ]
1102         )->[0];
1103 }
1104
1105 sub walk_org_tree {
1106         my( $self, $node, $callback ) = @_;
1107         return unless $node;
1108         $callback->($node);
1109         if( $node->children ) {
1110                 $self->walk_org_tree($_, $callback) for @{$node->children};
1111         }
1112 }
1113
1114 sub is_true {
1115         my( $self, $item ) = @_;
1116         return 1 if $item and $item !~ /^f$/i;
1117         return 0;
1118 }
1119
1120
1121 # This logic now lives in storage
1122 sub __patron_money_owed {
1123         my( $self, $patronid ) = @_;
1124         my $ses = OpenSRF::AppSession->create('open-ils.storage');
1125         my $req = $ses->request(
1126                 'open-ils.storage.money.billable_transaction.summary.search',
1127                 { usr => $patronid, xact_finish => undef } );
1128
1129         my $total = 0;
1130         my $data;
1131         while( $data = $req->recv ) {
1132                 $data = $data->content;
1133                 $total += $data->balance_owed;
1134         }
1135         return $total;
1136 }
1137
1138 sub patron_money_owed {
1139         my( $self, $userid ) = @_;
1140         return $self->storagereq(
1141                 'open-ils.storage.actor.user.total_owed', $userid);
1142 }
1143
1144 sub patron_total_items_out {
1145         my( $self, $userid ) = @_;
1146         return $self->storagereq(
1147                 'open-ils.storage.actor.user.total_out', $userid);
1148 }
1149
1150
1151
1152
1153 #---------------------------------------------------------------------
1154 # Returns  ($summary, $event) 
1155 #---------------------------------------------------------------------
1156 sub fetch_mbts {
1157         my $self = shift;
1158         my $id  = shift;
1159         my $editor = shift || OpenILS::Utils::CStoreEditor->new;
1160
1161         $id = $id->id if (ref($id));
1162
1163         my $xact = $editor->retrieve_money_billable_transaction(
1164                 [
1165                         $id, {  
1166                                 flesh => 1, 
1167                                 flesh_fields => { mbt => [ qw/billings payments grocery circulation/ ] } 
1168                         }
1169                 ]
1170         ) or return (undef, $editor->event);
1171
1172         return $self->make_mbts($xact);
1173 }
1174
1175
1176 #---------------------------------------------------------------------
1177 # Given a list of money.billable_transaction objects, this creates
1178 # transaction summary objects for each
1179 #--------------------------------------------------------------------
1180 sub make_mbts {
1181         my $self = shift;
1182         my @xacts = @_;
1183
1184         my @mbts;
1185         for my $x (@xacts) {
1186
1187                 my $s = new Fieldmapper::money::billable_transaction_summary;
1188
1189                 $s->id( $x->id );
1190                 $s->usr( $x->usr );
1191                 $s->xact_start( $x->xact_start );
1192                 $s->xact_finish( $x->xact_finish );
1193                 
1194                 my $to = 0;
1195                 my $lb = undef;
1196                 for my $b (@{ $x->billings }) {
1197                         next if ($self->is_true($b->voided));
1198                         $to += ($b->amount * 100);
1199                         $lb ||= $b->billing_ts;
1200                         if ($b->billing_ts ge $lb) {
1201                                 $lb = $b->billing_ts;
1202                                 $s->last_billing_note($b->note);
1203                                 $s->last_billing_ts($b->billing_ts);
1204                                 $s->last_billing_type($b->billing_type);
1205                         }
1206                 }
1207
1208                 $s->total_owed( sprintf('%0.2f', $to / 100 ) );
1209                 
1210                 my $tp = 0;
1211                 my $lp = undef;
1212                 for my $p (@{ $x->payments }) {
1213                         next if ($self->is_true($p->voided));
1214                         $tp += ($p->amount * 100);
1215                         $lp ||= $p->payment_ts;
1216                         if ($p->payment_ts ge $lp) {
1217                                 $lp = $p->payment_ts;
1218                                 $s->last_payment_note($p->note);
1219                                 $s->last_payment_ts($p->payment_ts);
1220                                 $s->last_payment_type($p->payment_type);
1221                         }
1222                 }
1223
1224                 $s->total_paid( sprintf('%0.2f', $tp / 100 ) );
1225                 $s->balance_owed( sprintf('%0.2f', ($to - $tp) / 100) );
1226                 $s->xact_type('grocery') if ($x->grocery);
1227                 $s->xact_type('circulation') if ($x->circulation);
1228
1229                 $logger->debug("Created mbts with balance_owed = ". $s->balance_owed);
1230                 
1231                 push @mbts, $s;
1232         }
1233                 
1234         return @mbts;
1235 }
1236                 
1237                 
1238 sub ou_ancestor_setting_value {
1239     my $obj = ou_ancestor_setting(@_);
1240     return ($obj) ? $obj->{value} : undef;
1241 }
1242
1243 sub ou_ancestor_setting {
1244     my( $self, $orgid, $name, $e ) = @_;
1245     $e = $e || OpenILS::Utils::CStoreEditor->new;
1246
1247     do {
1248         my $setting = $e->search_actor_org_unit_setting({org_unit=>$orgid, name=>$name})->[0];
1249
1250         if( $setting ) {
1251             $logger->info("found org_setting $name at org $orgid : " . $setting->value);
1252             return { org => $orgid, value => OpenSRF::Utils::JSON->JSON2perl($setting->value) };
1253         }
1254
1255         my $org = $e->retrieve_actor_org_unit($orgid) or return $e->event;
1256         $orgid = $org->parent_ou or return undef;
1257
1258     } while(1);
1259
1260     return undef;
1261 }       
1262                 
1263
1264 # returns the ISO8601 string representation of the requested epoch in GMT
1265 sub epoch2ISO8601 {
1266     my( $self, $epoch ) = @_;
1267     my ($sec,$min,$hour,$mday,$mon,$year) = gmtime($epoch);
1268     $year += 1900; $mon += 1;
1269     my $date = sprintf(
1270         '%s-%0.2d-%0.2dT%0.2d:%0.2d:%0.2d-00',
1271         $year, $mon, $mday, $hour, $min, $sec);
1272     return $date;
1273 }
1274                         
1275 sub find_highest_perm_org {
1276         my ( $self, $perm, $userid, $start_org, $org_tree ) = @_;
1277         my $org = $self->find_org($org_tree, $start_org );
1278
1279         my $lastid = -1;
1280         while( $org ) {
1281                 last if ($self->check_perms( $userid, $org->id, $perm )); # perm failed
1282                 $lastid = $org->id;
1283                 $org = $self->find_org( $org_tree, $org->parent_ou() );
1284         }
1285
1286         return $lastid;
1287 }
1288
1289
1290 sub find_highest_work_orgs {
1291     my($self, $e, $perm, $options) = @_;
1292     my $work_orgs = $self->get_user_work_ou_ids($e, $e->requestor->id);
1293     $logger->debug("found work orgs @$work_orgs");
1294         $options ||= {};
1295
1296     my @allowed_orgs;
1297         my $org_tree = $self->get_org_tree();
1298     my $org_types = $self->get_org_types();
1299
1300     # use the first work org to determine the highest depth at which 
1301     # the user has the requested permission
1302     my $first_org = shift @$work_orgs;
1303     my $high_org_id = $self->find_highest_perm_org($perm, $e->requestor->id, $first_org, $org_tree);
1304     $logger->debug("found highest work org $high_org_id");
1305
1306     
1307     return [] if $high_org_id == -1; # not allowed anywhere
1308
1309     my $high_org = $self->find_org($org_tree, $high_org_id);
1310     my ($high_org_type) = grep { $_->id == $high_org->ou_type } @$org_types;
1311     my $org_depth = $high_org_type->depth;
1312
1313         if($$options{descendants}) {
1314                 push(@allowed_orgs, @{$self->get_org_descendants($high_org_id, $org_depth)});
1315         } else {
1316                 push(@allowed_orgs, $high_org_id);
1317         }
1318
1319         return \@allowed_orgs if $org_depth == 0;
1320
1321     for my $org (@$work_orgs) {
1322
1323         $logger->debug("work org looking at $org");
1324                 my $org_list = $self->get_org_full_path($org, $org_depth);
1325
1326                 my $found = 0;
1327         for my $sub_org (@$org_list) {
1328                         if(not $found) {
1329                                 $logger->debug("work org looking at sub-org $sub_org");
1330                                 my $org_unit = $self->find_org($org_tree, $sub_org);
1331                                 my ($ou_type) = grep { $_->id == $org_unit->ou_type } @$org_types;
1332                                 if($ou_type->depth >= $org_depth) {
1333                                         push(@allowed_orgs, $sub_org);
1334                                         $found = 1;
1335                                 }
1336                         } else {
1337                                 last unless $$options{descendants}; 
1338                                 push(@allowed_orgs, $sub_org);
1339                         }
1340         }
1341     }
1342
1343     my %de_dupe;
1344     $de_dupe{$_} = 1 for @allowed_orgs;
1345     return [keys %de_dupe];
1346 }
1347
1348
1349 sub get_user_work_ou_ids {
1350     my($self, $e, $userid) = @_;
1351     my $work_orgs = $e->json_query({
1352         select => {puwoum => ['work_ou']},
1353         from => 'puwoum',
1354         where => {usr => $e->requestor->id}});
1355
1356     return [] unless @$work_orgs;
1357     my @work_orgs;
1358     push(@work_orgs, $_->{work_ou}) for @$work_orgs;
1359
1360     return \@work_orgs;
1361 }
1362
1363
1364 my $org_types;
1365 sub get_org_types {
1366         my($self, $client) = @_;
1367         return $org_types if $org_types;
1368         return $org_types = OpenILS::Utils::CStoreEditor->new->retrieve_all_actor_org_unit_type();
1369 }
1370
1371 sub get_org_tree {
1372         my $cache_diff = shift || '';
1373         my $cache = OpenSRF::Utils::Cache->new("global", 0);
1374         my $tree = $cache->get_cache("orgtree.$cache_diff");
1375         return $tree if $tree;
1376
1377         $tree = OpenILS::Utils::CStoreEditor->new->search_actor_org_unit( 
1378                 [
1379                         {"parent_ou" => undef },
1380                         {
1381                                 flesh                           => -1,
1382                                 flesh_fields    => { aou =>  ['children'] },
1383                                 order_by                        => { aou => 'name'}
1384                         }
1385                 ]
1386         )->[0];
1387
1388         $cache->put_cache("orgtree.$cache_diff", $tree);
1389         return $tree;
1390 }
1391
1392 sub get_org_descendants {
1393         my($self, $org_id, $depth) = @_;
1394
1395         my $select = {
1396                 transform => 'actor.org_unit_descendants',
1397                 column => 'id',
1398                 result_field => 'id',
1399         };
1400         $select->{params} = [$depth] if defined $depth;
1401
1402         my $org_list = OpenILS::Utils::CStoreEditor->new->json_query({
1403                 select => {aou => [$select]},
1404         from => 'aou',
1405                 where => {id => $org_id}
1406         });
1407         my @orgs;
1408         push(@orgs, $_->{id}) for @$org_list;
1409         return \@orgs;
1410 }
1411
1412 sub get_org_ancestors {
1413         my($self, $org_id, $depth) = @_;
1414         $depth ||= 0;
1415
1416         my $org_list = OpenILS::Utils::CStoreEditor->new->json_query({
1417                 select => {
1418                         aou => [{
1419                                 transform => 'actor.org_unit_ancestors',
1420                                 column => 'id',
1421                                 result_field => 'id',
1422                                 params => [$depth]
1423                         }],
1424                 },
1425                 from => 'aou',
1426                 where => {id => $org_id}
1427         });
1428
1429         my @orgs;
1430         push(@orgs, $_->{id}) for @$org_list;
1431         return \@orgs;
1432 }
1433
1434 sub get_org_full_path {
1435         my($self, $org_id, $depth) = @_;
1436         $depth ||= 0;
1437
1438         my $org_list = OpenILS::Utils::CStoreEditor->new->json_query({
1439                 select => {
1440                         aou => [{
1441                                 transform => 'actor.org_unit_full_path',
1442                                 column => 'id',
1443                                 result_field => 'id',
1444                                 params => [$depth]
1445                         }],
1446                 },
1447                 from => 'aou',
1448                 where => {id => $org_id}
1449         });
1450
1451         my @orgs;
1452         push(@orgs, $_->{id}) for @$org_list;
1453         return \@orgs;
1454 }
1455
1456 # returns the user's configured locale as a string.  Defaults to en-US if none is configured.
1457 sub get_user_locale {
1458         my($self, $user_id, $e) = @_;
1459         $e ||=OpenILS::Utils::CStoreEditor->new;
1460
1461         # first, see if the user has an explicit locale set
1462         my $setting = $e->search_actor_user_setting(
1463                 {usr => $user_id, name => 'global.locale'})->[0];
1464         return OpenSRF::Utils::JSON->JSON2perl($setting->value) if $setting;
1465
1466         my $user = $e->retrieve_actor_user($user_id) or return $e->event;
1467
1468         # next see if their home org specifies a default locale
1469         $setting = $e->search_actor_org_unit_setting(
1470                 {org_unit => $user->home_ou, name => 'global.default_locale'})->[0];
1471         return OpenSRF::Utils::JSON->JSON2perl($setting->value) if $setting;
1472
1473         # if nothing else, fallback to locale=cowboy
1474         return 'en-US';
1475 }
1476
1477 1;
1478