Merge branch 'master' of git.evergreen-ils.org:Evergreen into template-toolkit-opac
[working/Evergreen.git] / Open-ILS / src / perlmods / lib / OpenILS / Application / Circ / StatCat.pm
1 # ---------------------------------------------------------------
2 # Copyright (C) 2006  Georgia Public Library Service 
3 # Bill Erickson <billserickson@gmail.com>
4
5 # This program is free software; you can redistribute it and/or
6 # modify it under the terms of the GNU General Public License
7 # as published by the Free Software Foundation; either version 2
8 # of the License, or (at your option) any later version.
9
10 # This program is distributed in the hope that it will be useful,
11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 # GNU General Public License for more details.
14 # ---------------------------------------------------------------
15
16 package OpenILS::Application::Circ::StatCat;
17 use base qw/OpenILS::Application/;
18 use strict; use warnings;
19
20 use OpenSRF::Utils::Logger qw($logger);
21 use OpenSRF::EX qw/:try/;
22 use OpenILS::Application::AppUtils;
23 my $apputils = "OpenILS::Application::AppUtils";
24 my $U = $apputils;
25
26
27
28 __PACKAGE__->register_method(
29         method  => "retrieve_stat_cat_list",
30         argc    => 1,
31         api_name        => "open-ils.circ.stat_cat.actor.retrieve.batch");
32
33 __PACKAGE__->register_method(
34         method  => "retrieve_stat_cat_list",
35         argc    => 1,
36         api_name        => "open-ils.circ.stat_cat.asset.retrieve.batch");
37
38 # retrieves all of the stat cats for a given org unit
39 # if no orgid, user_session->home_ou is used
40
41 sub retrieve_stat_cat_list {
42         my( $self, $client, $user_session, @sc ) = @_;
43
44         if (ref($sc[0])) {
45                 @sc = @{$sc[0]};
46         }
47
48         my $method = "open-ils.storage.fleshed.actor.stat_cat.retrieve.batch.atomic"; 
49         if( $self->api_name =~ /asset/ ) {
50                 $method = "open-ils.storage.fleshed.asset.stat_cat.retrieve.batch.atomic"; 
51         }
52
53         my($user_obj, $evt) = $apputils->checkses($user_session); 
54     return $evt if $evt;
55
56         my $cats = $apputils->simple_scalar_request(
57                                 "open-ils.storage", $method, @sc);
58
59         return [ sort { $a->name cmp $b->name } @$cats ];
60 }
61
62 __PACKAGE__->register_method(
63         method  => "retrieve_stat_cats",
64         api_name        => "open-ils.circ.stat_cat.actor.retrieve.all");
65
66 __PACKAGE__->register_method(
67         method  => "retrieve_stat_cats",
68         api_name        => "open-ils.circ.stat_cat.asset.retrieve.all");
69
70 # retrieves all of the stat cats for a given org unit
71 # if no orgid, user_session->home_ou is used
72
73 sub retrieve_stat_cats {
74         my( $self, $client, $user_session, $orgid ) = @_;
75
76         my $method = "open-ils.storage.ranged.fleshed.actor.stat_cat.all.atomic"; 
77         if( $self->api_name =~ /asset/ ) {
78                 $method = "open-ils.storage.ranged.fleshed.asset.stat_cat.all.atomic"; 
79         }
80
81         my($user_obj, $evt) = $apputils->checkses($user_session); 
82     return $evt if $evt;
83
84         if(!$orgid) { $orgid = $user_obj->home_ou; }
85         my $cats = $apputils->simple_scalar_request(
86                                 "open-ils.storage", $method, $orgid );
87
88         return [ sort { $a->name cmp $b->name } @$cats ];
89 }
90
91
92 __PACKAGE__->register_method(
93         method  => "retrieve_ranged_intersect_stat_cats",
94         api_name        => "open-ils.circ.stat_cat.asset.multirange.intersect.retrieve");
95
96 sub retrieve_ranged_intersect_stat_cats {
97         my( $self, $client, $user_session, $orglist ) = @_;
98
99         my($user_obj, $evt) = $apputils->checkses($user_session); 
100     return $evt if $evt;
101
102         if(!$orglist) { $orglist = [ $user_obj->home_ou ]; }
103
104         # uniquify, yay!
105         my %hash = map { ($_ => 1) } @$orglist;
106         $orglist = [ keys %hash ];
107
108         warn "range: @$orglist\n";
109
110         my      $method = "open-ils.storage.multiranged.intersect.fleshed.asset.stat_cat.all.atomic";
111         return $apputils->simple_scalar_request(
112                                 "open-ils.storage", $method, $orglist );
113 }
114
115
116 __PACKAGE__->register_method(
117         method  => "retrieve_ranged_union_stat_cats",
118         api_name        => "open-ils.circ.stat_cat.asset.multirange.union.retrieve");
119
120 sub retrieve_ranged_union_stat_cats {
121         my( $self, $client, $user_session, $orglist ) = @_;
122
123         my      $method = "open-ils.storage.multiranged.union.fleshed.asset.stat_cat.all.atomic";
124         use Data::Dumper;
125         warn "Retrieving stat_cats with method $method and orgs " . Dumper($orglist) . "\n";
126
127         my($user_obj, $evt) = $apputils->checkses($user_session); 
128     return $evt if $evt;
129
130         if(!$orglist) { $orglist = [ $user_obj->home_ou ]; }
131
132         # uniquify, yay!
133         my %hash = map { ($_ => 1) } @$orglist;
134         $orglist = [ keys %hash ];
135
136         warn "range: @$orglist\n";
137
138         return $apputils->simple_scalar_request(
139                                 "open-ils.storage", $method, $orglist );
140 }
141
142
143
144 __PACKAGE__->register_method(
145         method  => "stat_cat_create",
146         api_name        => "open-ils.circ.stat_cat.asset.create");
147
148 __PACKAGE__->register_method(
149         method  => "stat_cat_create",
150         api_name        => "open-ils.circ.stat_cat.actor.create");
151
152 sub stat_cat_create {
153         my( $self, $client, $user_session, $stat_cat ) = @_;
154
155         my $method = "open-ils.storage.direct.actor.stat_cat.create";
156         my $entry_create = "open-ils.storage.direct.actor.stat_cat_entry.create";
157         my $perm = 'CREATE_PATRON_STAT_CAT';
158         my $eperm = 'CREATE_PATRON_STAT_CAT_ENTRY';
159
160         if($self->api_name =~ /asset/) {
161                 $method = "open-ils.storage.direct.asset.stat_cat.create";
162                 $entry_create = "open-ils.storage.direct.asset.stat_cat_entry.create";
163                 $perm = 'CREATE_COPY_STAT_CAT_ENTRY';
164         }
165
166         #my $user_obj = $apputils->check_user_session($user_session); 
167         #my $orgid = $user_obj->home_ou();
168         my( $user_obj, $evt ) = $apputils->checkses($user_session);
169         return $evt if $evt;
170         $evt = $apputils->check_perms($user_obj->id, $stat_cat->owner, $perm);
171         return $evt if $evt;
172
173         if($stat_cat->entries) {
174                 $evt = $apputils->check_perms($user_obj->id, $stat_cat->owner, $eperm);
175                 return $evt if $evt;
176         }
177
178
179         my $session = $apputils->start_db_session();
180         my $newid = _create_stat_cat($session, $stat_cat, $method);
181
182         if( ref($stat_cat->entries) ) {
183                 for my $entry (@{$stat_cat->entries}) {
184                         $entry->stat_cat($newid);
185                         _create_stat_entry($session, $entry, $entry_create);
186                 }
187         }
188
189         $apputils->commit_db_session($session);
190
191         $logger->debug("Stat cat creation successful with id $newid");
192
193         my $orgid = $user_obj->home_ou;
194         if( $self->api_name =~ /asset/ ) {
195                 return _flesh_asset_cat($newid, $orgid);
196         } else {
197                 return _flesh_user_cat($newid, $orgid);
198         }
199 }
200
201
202 sub _flesh_user_cat {
203         my $id = shift;
204         my $orgid = shift;
205
206         my $session = OpenSRF::AppSession->create("open-ils.storage");
207         my $cat = $session->request(
208                 "open-ils.storage.direct.actor.stat_cat.retrieve",
209                 $id )->gather(1);
210
211         $cat->entries( 
212                 $session->request(
213                         "open-ils.storage.ranged.actor.stat_cat_entry.search.stat_cat.atomic",
214                         $orgid, $id )->gather(1) );
215
216         return $cat;
217 }
218
219
220 sub _flesh_asset_cat {
221         my $id = shift;
222         my $orgid = shift;
223
224         my $session = OpenSRF::AppSession->create("open-ils.storage");
225         my $cat = $session->request(
226                 "open-ils.storage.direct.asset.stat_cat.retrieve",
227                 $id )->gather(1);
228
229         $cat->entries( 
230                 $session->request(
231                         "open-ils.storage.ranged.asset.stat_cat_entry.search.stat_cat.atomic",
232                         $orgid,  $id )->gather(1) );
233
234         return $cat;
235
236 }
237
238
239 sub _create_stat_cat {
240         my( $session, $stat_cat, $method) = @_;
241         warn "Creating new stat cat with name " . $stat_cat->name . "\n";
242         $stat_cat->clear_id();
243         my $req = $session->request( $method, $stat_cat );
244         my $id = $req->gather(1);
245         if(!$id) {
246                 throw OpenSRF::EX::ERROR 
247                 ("Error creating new statistical category"); }
248
249         warn "Stat cat create returned id $id\n";
250         return $id;
251 }
252
253
254 sub _create_stat_entry {
255         my( $session, $stat_entry, $method) = @_;
256
257         warn "Creating new stat entry with value " . $stat_entry->value . "\n";
258         $stat_entry->clear_id();
259
260         my $req = $session->request($method, $stat_entry);
261         my $id = $req->gather(1);
262
263         warn "Stat entry " . Dumper($stat_entry) . "\n";        
264         
265         if(!$id) {
266                 throw OpenSRF::EX::ERROR 
267                 ("Error creating new stat cat entry"); }
268
269         warn "Stat cat entry create returned id $id\n";
270         return $id;
271 }
272
273
274 __PACKAGE__->register_method(
275         method  => "update_stat_entry",
276         api_name        => "open-ils.circ.stat_cat.actor.entry.update");
277
278 __PACKAGE__->register_method(
279         method  => "update_stat_entry",
280         api_name        => "open-ils.circ.stat_cat.asset.entry.update");
281
282 sub update_stat_entry {
283         my( $self, $client, $user_session, $entry ) = @_;
284
285
286         my $method = "open-ils.storage.direct.actor.stat_cat_entry.update";
287         my $perm = 'UPDATE_PATRON_STAT_CAT_ENTRY';
288         if($self->api_name =~ /asset/) {
289                 $method = "open-ils.storage.direct.asset.stat_cat_entry.update";
290                 $perm = 'UPDATE_COPY_STAT_CAT_ENTRY';
291         }
292
293         my( $user_obj, $evt )  = $apputils->checkses($user_session); 
294         return $evt if $evt;
295         $evt = $apputils->check_perms( $user_obj->id, $entry->owner, $perm );
296         return $evt if $evt;
297
298         my $session = $apputils->start_db_session();
299         my $req = $session->request($method, $entry); 
300         my $status = $req->gather(1);
301         $apputils->commit_db_session($session);
302         warn "stat cat entry with value " . $entry->value . " updated with status $status\n";
303         return 1;
304 }
305
306
307 __PACKAGE__->register_method(
308         method  => "update_stat",
309         api_name        => "open-ils.circ.stat_cat.actor.update");
310
311 __PACKAGE__->register_method(
312         method  => "update_stat",
313         api_name        => "open-ils.circ.stat_cat.asset.update");
314
315 sub update_stat {
316         my( $self, $client, $user_session, $cat ) = @_;
317
318         my $method = "open-ils.storage.direct.actor.stat_cat.update";
319         my $perm = 'UPDATE_PATRON_STAT_CAT';
320         if($self->api_name =~ /asset/) {
321                 $method = "open-ils.storage.direct.asset.stat_cat.update";
322                 $perm = 'UPDATE_COPY_STAT_CAT';
323         }
324
325         my( $user_obj, $evt )  = $apputils->checkses($user_session); 
326         return $evt if $evt;
327         $evt = $apputils->check_perms( $user_obj->id, $cat->owner, $perm );
328         return $evt if $evt;
329
330         my $session = $apputils->start_db_session();
331         my $req = $session->request($method, $cat); 
332         my $status = $req->gather(1);
333         $apputils->commit_db_session($session);
334         warn "stat cat with id " . $cat->id . " updated with status $status\n";
335         return 1;
336 }
337
338
339 __PACKAGE__->register_method(
340         method  => "create_stat_entry",
341         api_name        => "open-ils.circ.stat_cat.actor.entry.create");
342
343 __PACKAGE__->register_method(
344         method  => "create_stat_entry",
345         api_name        => "open-ils.circ.stat_cat.asset.entry.create");
346
347 sub create_stat_entry {
348         my( $self, $client, $user_session, $entry ) = @_;
349
350         my $method = "open-ils.storage.direct.actor.stat_cat_entry.create";
351         my $perm = 'CREATE_PATRON_STAT_CAT_ENTRY';
352         if($self->api_name =~ /asset/) {
353                 $method = "open-ils.storage.direct.asset.stat_cat_entry.create";
354                 $perm = 'CREATE_COPY_STAT_CAT_ENTRY';
355         }
356
357         my( $user_obj, $evt )  = $apputils->checkses($user_session); 
358         return $evt if $evt;
359         $evt = $apputils->check_perms( $user_obj->id, $entry->owner, $perm );
360         return $evt if $evt;
361
362         $entry->clear_id();
363         my $session = $apputils->start_db_session();
364         my $req = $session->request($method, $entry); 
365         my $status = $req->gather(1);
366         $apputils->commit_db_session($session);
367
368         $logger->info("created stat cat entry $status");
369         return $status;
370 }
371
372
373
374 __PACKAGE__->register_method(
375         method  => "create_stat_map",
376         api_name        => "open-ils.circ.stat_cat.actor.user_map.create");
377
378 __PACKAGE__->register_method(
379         method  => "create_stat_map",
380         api_name        => "open-ils.circ.stat_cat.asset.copy_map.create");
381
382 sub create_stat_map {
383         my( $self, $client, $user_session, $map ) = @_;
384
385
386         my ( $evt, $copy, $volume, $patron, $user_obj );
387
388         my $method = "open-ils.storage.direct.actor.stat_cat_entry_user_map.create";
389         my $ret = "open-ils.storage.direct.actor.stat_cat_entry_user_map.retrieve";
390         my $perm = 'CREATE_PATRON_STAT_CAT_ENTRY_MAP';
391         my $perm_org;
392
393         if($self->api_name =~ /asset/) {
394                 $method = "open-ils.storage.direct.asset.stat_cat_entry_copy_map.create";
395                 $ret = "open-ils.storage.direct.asset.stat_cat_entry_copy_map.retrieve";
396                 $perm = 'CREATE_COPY_STAT_CAT_ENTRY_MAP';
397                 ( $copy, $evt ) = $apputils->fetch_copy($map->owning_copy);
398                 return $evt if $evt;
399                 ( $volume, $evt ) = $apputils->fetch_callnumber($copy->call_number);
400                 return $evt if $evt;
401                 $perm_org = $volume->owning_lib;
402
403         } else {
404                 ($patron, $evt) = $apputils->fetch_user($map->target_usr);
405                 return $evt if $evt;
406                 $perm_org = $patron->home_ou;
407         }
408
409         ( $user_obj, $evt )  = $apputils->checkses($user_session); 
410         return $evt if $evt;
411         $evt = $apputils->check_perms( $user_obj->id, $perm_org, $perm );
412         return $evt if $evt;
413
414         $logger->debug( $user_obj->id . " creating new stat cat map" );
415
416         $map->clear_id();
417
418         my $session = $apputils->start_db_session();
419         my $req = $session->request($method, $map); 
420         my $newid = $req->gather(1);
421         warn "Created new stat cat map with id $newid\n";
422         $apputils->commit_db_session($session);
423
424         return $apputils->simple_scalar_request( "open-ils.storage", $ret, $newid );
425
426 }
427
428
429 __PACKAGE__->register_method(
430         method  => "update_stat_map",
431         api_name        => "open-ils.circ.stat_cat.actor.user_map.update");
432
433 __PACKAGE__->register_method(
434         method  => "update_stat_map",
435         api_name        => "open-ils.circ.stat_cat.asset.copy_map.update");
436
437 sub update_stat_map {
438         my( $self, $client, $user_session, $map ) = @_;
439
440         my ( $evt, $copy, $volume, $patron, $user_obj );
441
442         my $method = "open-ils.storage.direct.actor.stat_cat_entry_user_map.update";
443         my $perm = 'UPDATE_PATRON_STAT_ENTRY_MAP';
444         my $perm_org;
445
446         if($self->api_name =~ /asset/) {
447                 $method = "open-ils.storage.direct.asset.stat_cat_entry_copy_map.update";
448                 $perm = 'UPDATE_COPY_STAT_ENTRY_MAP';
449                 ( $copy, $evt ) = $apputils->fetch_copy($map->owning_copy);
450                 return $evt if $evt;
451                 ( $volume, $evt ) = $apputils->fetch_callnumber($copy->call_number);
452                 return $evt if $evt;
453                 $perm_org = $volume->owning_lib;
454
455         } else {
456                 ($patron, $evt) = $apputils->fetch_user($map->target_usr);
457                 return $evt if $evt;
458                 $perm_org = $patron->home_ou;
459         }
460
461
462         ( $user_obj, $evt )  = $apputils->checkses($user_session); 
463         return $evt if $evt;
464         $evt = $apputils->check_perms( $user_obj->id, $perm_org, $perm );
465         return $evt if $evt;
466
467
468         my $session = $apputils->start_db_session();
469         my $req = $session->request($method, $map); 
470         my $newid = $req->gather(1);
471         warn "Updated new stat cat map with id $newid\n";
472         $apputils->commit_db_session($session);
473
474         return $newid;
475 }
476
477
478
479 __PACKAGE__->register_method(
480         method  => "retrieve_maps",
481         api_name        => "open-ils.circ.stat_cat.actor.user_map.retrieve");
482
483 __PACKAGE__->register_method(
484         method  => "retrieve_maps",
485         api_name        => "open-ils.circ.stat_cat.asset.copy_map.retrieve");
486
487 sub retrieve_maps {
488         my( $self, $client, $user_session, $target ) = @_;
489
490
491         my( $user_obj, $evt ) = $apputils->checkses($user_session); 
492         return $evt if $evt;
493
494         my      $method = "open-ils.storage.direct.asset.stat_cat_entry_copy_map.search.owning_copy.atomic";
495         if($self->api_name =~ /actor/ ) {
496                 if(!$target) { $target = $user_obj->id; }
497                 $method = "open-ils.storage.direct.actor.stat_cat_entry_user_map.search.target_usr.atomic";
498         }
499
500         return $apputils->simple_scalar_request("open-ils.storage", $method, $target);
501 }
502
503
504
505
506 __PACKAGE__->register_method(
507         method  => "delete_stats",
508         api_name        => "open-ils.circ.stat_cat.actor.delete");
509
510 __PACKAGE__->register_method(
511         method  => "delete_stats",
512         api_name        => "open-ils.circ.stat_cat.asset.delete");
513
514 sub delete_stats {
515         my( $self, $client, $user_session, $target ) = @_;
516         
517         my $cat;
518
519         my $type = "actor";
520         my $perm = 'DELETE_PATRON_STAT_CAT';
521         if($self->api_name =~ /asset/) { 
522                 $type = "asset"; 
523                 $perm = 'DELETE_COPY_STAT_CAT';
524         }
525
526         my( $user_obj, $evt )  = $apputils->checkses($user_session); 
527         return $evt if $evt;
528
529         ( $cat, $evt ) = $apputils->fetch_stat_cat( $type, $target );
530         return $evt if $evt;
531
532         $evt = $apputils->check_perms( $user_obj->id, $cat->owner, $perm );
533         return $evt if $evt;
534
535         my $session = OpenSRF::AppSession->create("open-ils.storage");
536         return _delete_stats($session, $target, $type);
537 }
538
539 sub _delete_stats {
540         my( $session, $stat, $type) = @_;
541
542         my      $method = "open-ils.storage.direct.asset.stat_cat.delete";
543         if($type =~ /actor/ ) {
544                 $method = "open-ils.storage.direct.actor.stat_cat.delete";
545         }
546         return $session->request($method, $stat)->gather(1);
547 }
548
549
550
551 __PACKAGE__->register_method(
552         method  => "delete_entry",
553         api_name        => "open-ils.circ.stat_cat.actor.entry.delete");
554
555 __PACKAGE__->register_method(
556         method  => "delete_entry",
557         api_name        => "open-ils.circ.stat_cat.asset.entry.delete");
558
559 sub delete_entry {
560         my( $self, $client, $user_session, $target ) = @_;
561
562         my $type = "actor";
563         my $perm = 'DELETE_PATRON_STAT_CAT_ENTRY';
564         if($self->api_name =~ /asset/) { 
565                 $type = "asset"; 
566                 $perm = 'DELETE_COPY_STAT_CAT_ENTRY';
567         }
568
569         my $entry;
570         my( $user_obj, $evt )  = $apputils->checkses($user_session); 
571         return $evt if $evt;
572
573         ( $entry, $evt ) = $apputils->fetch_stat_cat_entry( $type, $target );
574         return $evt if $evt;
575
576         $evt = $apputils->check_perms( $user_obj->id, $entry->owner, $perm );
577         return $evt if $evt;
578
579         my $session = OpenSRF::AppSession->create("open-ils.storage");
580         return _delete_entry($session, $target, $type);
581 }
582
583 sub _delete_entry {
584         my( $session, $stat_entry, $type) = @_;
585
586         my      $method = "open-ils.storage.direct.asset.stat_cat_entry.delete";
587         if($type =~ /actor/ ) {
588                 $method = "open-ils.storage.direct.actor.stat_cat_entry.delete";
589         }
590
591         return $session->request($method, $stat_entry)->gather(1);
592 }
593
594
595 __PACKAGE__->register_method(
596         method => 'fetch_stats_by_copy',
597         api_name        => 'open-ils.circ.asset.stat_cat_entries.fleshed.retrieve_by_copy',
598 );
599
600
601 sub fetch_stats_by_copy {
602         my( $self, $conn, $args ) = @_;
603
604         my @entries;
605
606         if( $$args{public} ) {
607                 my $maps = $U->cstorereq(
608                         'open-ils.cstore.direct.asset.stat_cat_entry_copy_map.search.atomic', { owning_copy => $$args{copyid} });
609
610
611                 warn "here\n";
612                 for my $map (@$maps) {
613
614                         warn "map ".$map->id."\n";
615                         warn "map ".$map->stat_cat_entry."\n";
616
617                         my $entry = $U->cstorereq(
618                                 'open-ils.cstore.direct.asset.stat_cat_entry.retrieve', $map->stat_cat_entry);
619
620                         warn "Found entry ".$entry->id."\n";
621
622                         my $cat = $U->cstorereq(
623                                 'open-ils.cstore.direct.asset.stat_cat.retrieve', $entry->stat_cat );
624                         $entry->stat_cat( $cat );
625                         push( @entries, $entry );
626                 }
627         }
628
629         return \@entries;
630 }
631
632
633
634 1;