Open-ILS/src/perlmods/lib/OpenILS/Application/Reporter.pm

   1 package OpenILS::Application::Reporter;
   2 use OpenILS::Application;
   3 use base qw/OpenILS::Application/;
   4 use strict; use warnings;
   5 use OpenSRF::Utils::Logger qw/$logger/;
   6 use OpenILS::Utils::CStoreEditor qw/:funcs/;
   7 use OpenILS::Utils::Fieldmapper;
   8 use OpenILS::Application::AppUtils;
   9 my $U = "OpenILS::Application::AppUtils";
  10
  11
  12 __PACKAGE__->register_method(
  13         api_name => 'open-ils.reporter.folder.create',
  14         method => 'create_folder'
  15 );
  16
  17 sub create_folder {
  18         my( $self, $conn, $auth, $type, $folder ) = @_;
  19
  20         my $e = new_rstore_editor(xact=>1, authtoken=>$auth);
  21         return $e->die_event unless $e->checkauth;
  22         return $e->die_event unless $e->allowed('RUN_REPORTS');
  23         return $e->die_event unless ($type ne 'template' || $e->allowed('CREATE_REPORT_TEMPLATE'));
  24
  25         return 0 if $folder->owner ne $e->requestor->id;
  26
  27         $folder->owner($e->requestor->id);
  28         my $meth = "create_reporter_${type}_folder";
  29         $e->$meth($folder) or return $e->die_event;
  30         $e->commit;
  31
  32         return $folder->id;
  33 }
  34
  35
  36 __PACKAGE__->register_method(
  37     api_name => 'open-ils.reporter.report.exists',
  38     method => 'report_exists',
  39     notes => q/
  40         Returns 1 if a report with the given name and folder already exists.
  41     /
  42 );
  43
  44 sub report_exists {
  45     my( $self, $conn, $auth, $report ) = @_;
  46
  47     my $e = new_rstore_editor(authtoken=>$auth);
  48     return $e->event unless $e->checkauth;
  49     return $e->event unless $e->allowed('RUN_REPORTS');
  50
  51     my $existing = $e->search_reporter_report(
  52         {folder=>$report->folder, name=>$report->name});
  53     return 1 if @$existing;
  54     return 0;
  55 }
  56
  57
  58 __PACKAGE__->register_method(
  59         api_name => 'open-ils.reporter.folder.visible.retrieve',
  60         method => 'retrieve_visible_folders'
  61 );
  62
  63 sub retrieve_visible_folders {
  64         my( $self, $conn, $auth, $type ) = @_;
  65         my $e = new_rstore_editor(authtoken=>$auth);
  66         return $e->event unless $e->checkauth;
  67         if($type eq 'output') {
  68                 return $e->event unless $e->allowed(['RUN_REPORTS','VIEW_REPORT_OUTPUT']);
  69         } else {
  70                 return $e->event unless $e->allowed('RUN_REPORTS');
  71         }
  72
  73         my $class = 'rrf';
  74         $class = 'rtf' if $type eq 'template';
  75         $class = 'rof' if $type eq 'output';
  76         my $flesh = {
  77                 flesh => 1,
  78                 flesh_fields => { $class => ['owner', 'share_with']},
  79                 order_by => { $class => 'name ASC'}
  80         };
  81
  82         my $meth = "search_reporter_${type}_folder";
  83         my $fs = $e->$meth( [{ owner => $e->requestor->id }, $flesh] );
  84
  85         my @orgs;
  86         my $o = $U->storagereq(
  87                 'open-ils.storage.actor.org_unit.full_path.atomic', $e->requestor->ws_ou);
  88         push( @orgs, $_->id ) for @$o;
  89
  90         my $fs2 = $e->$meth(
  91                 [
  92                         {
  93                                 shared => 't',
  94                                 share_with => \@orgs,
  95                                 owner => { '!=' => $e->requestor->id }
  96                         },
  97                         $flesh
  98                 ]
  99         );
 100         push( @$fs, @$fs2);
 101         return $fs;
 102 }
 103
 104
 105
 106 __PACKAGE__->register_method(
 107         api_name => 'open-ils.reporter.folder_data.retrieve',
 108         method => 'retrieve_folder_data'
 109 );
 110
 111 sub retrieve_folder_data {
 112         my( $self, $conn, $auth, $type, $folderid, $limit ) = @_;
 113         my $e = new_rstore_editor(authtoken=>$auth);
 114         return $e->event unless $e->checkauth;
 115         if($type eq 'output') {
 116                 return $e->event unless $e->allowed(['RUN_REPORTS','VIEW_REPORT_OUTPUT']);
 117         } else {
 118                 return $e->event unless $e->allowed('RUN_REPORTS');
 119         }
 120         my $meth = "search_reporter_${type}";
 121         my $class = 'rr';
 122         $class = 'rt' if $type eq 'template';
 123         my $flesh = {
 124                 flesh => 1,
 125                 flesh_fields => { $class => ['owner']},
 126                 order_by => { $class => 'create_time DESC'}
 127         };
 128         $flesh->{limit} = $limit if $limit;
 129         return $e->$meth([{ folder => $folderid }, $flesh]);
 130 }
 131
 132 __PACKAGE__->register_method(
 133         api_name => 'open-ils.reporter.schedule.retrieve_by_folder',
 134         method => 'retrieve_schedules');
 135 sub retrieve_schedules {
 136         my( $self, $conn, $auth, $folderId, $limit, $complete ) = @_;
 137         my $e = new_rstore_editor(authtoken=>$auth);
 138         return $e->event unless $e->checkauth;
 139         return $e->event unless $e->allowed(['RUN_REPORTS','VIEW_REPORT_OUTPUT']);
 140
 141         my $search = { folder => $folderId };
 142         my $query = [
 143                 { folder => $folderId },
 144                 {
 145                         order_by => { rs => 'run_time DESC' } ,
 146                         flesh => 1,
 147                         flesh_fields => { rs => ['report'] }
 148                 }
 149         ];
 150
 151         $query->[1]->{limit} = $limit if $limit;
 152         $query->[0]->{complete_time} = undef unless $complete;
 153         $query->[0]->{complete_time} = { '!=' => undef } if $complete;
 154
 155         return $e->search_reporter_schedule($query);
 156 }
 157
 158 __PACKAGE__->register_method(
 159         api_name => 'open-ils.reporter.schedule.retrieve',
 160         method => 'retrieve_schedules');
 161 sub retrieve_schedule {
 162         my( $self, $conn, $auth, $sched_id ) = @_;
 163         my $e = new_rstore_editor(authtoken=>$auth);
 164         return $e->event unless $e->checkauth;
 165         return $e->event unless $e->allowed(['RUN_REPORTS','VIEW_REPORT_OUTPUT']);
 166         my $s = $e->retrieve_reporter_schedule($sched_id)
 167                 or return $e->event;
 168         return $s;
 169 }
 170
 171
 172 __PACKAGE__->register_method(
 173         api_name => 'open-ils.reporter.template.create',
 174         method => 'create_template');
 175 sub create_template {
 176         my( $self, $conn, $auth, $template ) = @_;
 177         my $e = new_rstore_editor(authtoken=>$auth, xact=>1);
 178         return $e->die_event unless $e->checkauth;
 179         return $e->die_event unless $e->allowed('RUN_REPORTS');
 180         return $e->die_event unless $e->allowed('CREATE_REPORT_TEMPLATE');
 181         $template->owner($e->requestor->id);
 182
 183         my $existing = $e->search_reporter_template( {owner=>$template->owner,
 184                         folder=>$template->folder, name=>$template->name},{idlist=>1});
 185         return OpenILS::Event->new('REPORT_TEMPLATE_EXISTS') if @$existing;
 186
 187         my $tmpl = $e->create_reporter_template($template)
 188                 or return $e->die_event;
 189         $e->commit;
 190         return $tmpl;
 191 }
 192
 193
 194
 195
 196
 197 __PACKAGE__->register_method(
 198         api_name => 'open-ils.reporter.report.create',
 199         method => 'create_report');
 200 sub create_report {
 201         my( $self, $conn, $auth, $report, $schedule ) = @_;
 202         my $e = new_rstore_editor(authtoken=>$auth, xact=>1);
 203         return $e->die_event unless $e->checkauth;
 204         return $e->die_event unless $e->allowed('RUN_REPORTS');
 205         $report->owner($e->requestor->id);
 206
 207         my $existing = $e->search_reporter_report( {owner=>$report->owner,
 208                         folder=>$report->folder, name=>$report->name},{idlist=>1});
 209         return OpenILS::Event->new('REPORT_REPORT_EXISTS') if @$existing;
 210
 211         my $rpt = $e->create_reporter_report($report)
 212                 or return $e->die_event;
 213         $schedule->report($rpt->id);
 214         $schedule->runner($e->requestor->id);
 215         $e->create_reporter_schedule($schedule) or return $e->die_event;
 216         $e->commit;
 217         return $rpt;
 218 }
 219
 220
 221 __PACKAGE__->register_method(
 222         api_name => 'open-ils.reporter.schedule.create',
 223         method => 'create_schedule');
 224 sub create_schedule {
 225         my( $self, $conn, $auth, $schedule ) = @_;
 226         my $e = new_rstore_editor(authtoken=>$auth, xact=>1);
 227         return $e->die_event unless $e->checkauth;
 228         return $e->die_event unless $e->allowed('RUN_REPORTS');
 229         my $sched = $e->create_reporter_schedule($schedule)
 230                 or return $e->die_event;
 231         $e->commit;
 232         return $sched;
 233 }
 234
 235 __PACKAGE__->register_method(
 236         api_name => 'open-ils.reporter.template.retrieve',
 237         method => 'retrieve_template');
 238 sub retrieve_template {
 239         my( $self, $conn, $auth, $id ) = @_;
 240         my $e = new_rstore_editor(authtoken=>$auth);
 241         return $e->event unless $e->checkauth;
 242         return $e->event unless $e->allowed(['RUN_REPORTS','VIEW_REPORT_OUTPUT']);
 243         my $t = $e->retrieve_reporter_template($id)
 244                 or return $e->event;
 245         return $t;
 246 }
 247
 248
 249 __PACKAGE__->register_method(
 250         api_name => 'open-ils.reporter.report.retrieve',
 251         method => 'retrieve_report');
 252 sub retrieve_report {
 253         my( $self, $conn, $auth, $id ) = @_;
 254         my $e = new_rstore_editor(authtoken=>$auth);
 255         return $e->event unless $e->checkauth;
 256         return $e->event unless $e->allowed(['RUN_REPORTS','VIEW_REPORT_OUTPUT']);
 257         my $r = $e->retrieve_reporter_report($id)
 258                 or return $e->event;
 259         return $r;
 260 }
 261
 262
 263 __PACKAGE__->register_method(
 264         api_name => 'open-ils.reporter.template.update',
 265         method => 'update_template');
 266 sub update_template {
 267         my( $self, $conn, $auth, $tmpl ) = @_;
 268         my $e = new_rstore_editor(authtoken=>$auth, xact=>1);
 269         return $e->die_event unless $e->checkauth;
 270         return $e->die_event unless $e->allowed('RUN_REPORTS');
 271         return $e->die_event unless $e->allowed('CREATE_REPORT_TEMPLATE');
 272         my $t = $e->retrieve_reporter_template($tmpl->id)
 273                 or return $e->die_event;
 274         return 0 if $t->owner ne $e->requestor->id;
 275         $e->update_reporter_template($tmpl)
 276                 or return $e->die_event;
 277         $e->commit;
 278         return 1;
 279 }
 280
 281
 282 __PACKAGE__->register_method(
 283         api_name => 'open-ils.reporter.report.update',
 284         method => 'update_report');
 285 sub update_report {
 286         my( $self, $conn, $auth, $report ) = @_;
 287         my $e = new_rstore_editor(authtoken=>$auth, xact=>1);
 288         return $e->die_event unless $e->checkauth;
 289         return $e->die_event unless $e->allowed('RUN_REPORTS');
 290         my $r = $e->retrieve_reporter_report($report->id)
 291                 or return $e->die_event;
 292         if( $r->owner ne $e->requestor->id ) {
 293                 $e->rollback;
 294                 return 0;
 295         }
 296         $e->update_reporter_report($report)
 297                 or return $e->die_event;
 298         $e->commit;
 299         return 1;
 300 }
 301
 302
 303 __PACKAGE__->register_method(
 304         api_name => 'open-ils.reporter.schedule.update',
 305         method => 'update_schedule');
 306 sub update_schedule {
 307         my( $self, $conn, $auth, $schedule ) = @_;
 308         my $e = new_rstore_editor(authtoken=>$auth, xact=>1);
 309         return $e->die_event unless $e->checkauth;
 310         return $e->die_event unless $e->allowed('RUN_REPORTS');
 311         my $s = $e->retrieve_reporter_schedule($schedule->id)
 312                 or return $e->die_event;
 313         my $r = $e->retrieve_reporter_report($s->report)
 314                 or return $e->die_event;
 315         if( $r->owner ne $e->requestor->id ) {
 316                 $e->rollback;
 317                 return 0;
 318         }
 319         $e->update_reporter_schedule($schedule)
 320                 or return $e->die_event;
 321         $e->commit;
 322         return 1;
 323 }
 324
 325
 326 __PACKAGE__->register_method(
 327         api_name => 'open-ils.reporter.folder.update',
 328         method => 'update_folder');
 329 sub update_folder {
 330         my( $self, $conn, $auth, $type, $folder ) = @_;
 331         my $e = new_rstore_editor(authtoken=>$auth, xact=>1);
 332         return $e->die_event unless $e->checkauth;
 333         return $e->die_event unless $e->allowed('RUN_REPORTS');
 334         my $meth = "retrieve_reporter_${type}_folder";
 335         my $f = $e->$meth($folder->id) or return $e->die_event;
 336         return 0 if $f->owner ne $e->requestor->id;
 337         $meth = "update_reporter_${type}_folder";
 338         $e->$meth($folder) or return $e->die_event;
 339         $e->commit;
 340         return 1;
 341 }
 342
 343
 344 __PACKAGE__->register_method(
 345         api_name => 'open-ils.reporter.folder.delete',
 346         method => 'delete_folder');
 347 sub delete_folder {
 348         my( $self, $conn, $auth, $type, $folderId ) = @_;
 349         my $e = new_rstore_editor(authtoken=>$auth, xact=>1);
 350         return $e->die_event unless $e->checkauth;
 351         return $e->die_event unless $e->allowed('RUN_REPORTS');
 352         my $meth = "retrieve_reporter_${type}_folder";
 353         my $f = $e->$meth($folderId) or return $e->die_event;
 354         return 0 if $f->owner ne $e->requestor->id;
 355         $meth = "delete_reporter_${type}_folder";
 356         $e->$meth($f) or return $e->die_event;
 357         $e->commit;
 358         return 1;
 359 }
 360
 361
 362 __PACKAGE__->register_method(
 363         api_name => 'open-ils.reporter.template.delete',
 364         method => 'delete_template');
 365 sub delete_template {
 366         my( $self, $conn, $auth, $templateId ) = @_;
 367         my $e = new_rstore_editor(authtoken=>$auth, xact=>1);
 368         return $e->die_event unless $e->checkauth;
 369         return $e->die_event unless $e->allowed('RUN_REPORTS');
 370
 371         my $t = $e->retrieve_reporter_template($templateId)
 372                 or return $e->die_event;
 373         return 0 if $t->owner ne $e->requestor->id;
 374         $e->delete_reporter_template($t) or return $e->die_event;
 375         $e->commit;
 376         return 1;
 377 }
 378
 379
 380
 381 __PACKAGE__->register_method(
 382         api_name => 'open-ils.reporter.template.delete.cascade',
 383         method => 'cascade_delete_template');
 384
 385 #__PACKAGE__->register_method(
 386 #       api_name => 'open-ils.reporter.template.delete.cascade.force',
 387 #       method => 'cascade_delete_template');
 388
 389 sub cascade_delete_template {
 390         my( $self, $conn, $auth, $templateId ) = @_;
 391
 392         my $e = new_rstore_editor(authtoken=>$auth, xact=>1);
 393         return $e->die_event unless $e->checkauth;
 394         return $e->die_event unless $e->allowed('RUN_REPORTS');
 395
 396     my $ret = cascade_delete_template_impl(
 397         $e, $e->requestor->id, $templateId, ($self->api_name =~ /force/o) );
 398     return $ret if ref $ret; # some fatal event occurred
 399
 400     $e->rollback if $ret == 0;
 401     $e->commit if $ret > 0;
 402     return $ret;
 403 }
 404
 405
 406 __PACKAGE__->register_method(
 407         api_name => 'open-ils.reporter.report.delete.cascade',
 408         method => 'cascade_delete_report');
 409
 410 #__PACKAGE__->register_method(
 411 #       api_name => 'open-ils.reporter.report.delete.cascade.force',
 412 #       method => 'cascade_delete_report');
 413
 414 sub cascade_delete_report {
 415         my( $self, $conn, $auth, $reportId ) = @_;
 416
 417         my $e = new_rstore_editor(authtoken=>$auth, xact=>1);
 418         return $e->die_event unless $e->checkauth;
 419         return $e->die_event unless $e->allowed('RUN_REPORTS');
 420
 421     my $ret = cascade_delete_report_impl($e, $e->requestor->id, $reportId);
 422     return $ret if ref $ret; # some fatal event occurred
 423
 424     $e->rollback if $ret == 0;
 425     $e->commit if $ret > 0;
 426     return $ret;
 427 }
 428
 429
 430 # performs a cascading template delete
 431 # returns 2 if all data was deleted
 432 # returns 1 if some data was deleted
 433 # returns 0 if no data was deleted
 434 # returns event on error
 435 sub cascade_delete_template_impl {
 436     my( $e, $owner, $templateId ) = @_;
 437
 438     # fetch the template to delete
 439     my $template = $e->search_reporter_template(
 440         {id=>$templateId, owner=>$owner})->[0] or return 0;
 441
 442     # fetch he attached report IDs for this  owner
 443     my $reports = $e->search_reporter_report(
 444         {template=>$templateId, owner=>$owner},{idlist=>1});
 445
 446     # delete the attached reports
 447     my $all_rpts_deleted = 1;
 448     for my $r (@$reports) {
 449         my $evt = cascade_delete_report_impl($e, $owner, $r);
 450         return $evt if ref $evt;
 451         $all_rpts_deleted = 0 unless $evt == 2;
 452     }
 453
 454     # fetch all reports attached to this template that
 455     # do not belong to $owner.  If there are any, we can't
 456     # delete the template
 457     my $alt_reports = $e->search_reporter_report(
 458         {template=>$templateId, owner=>{"!=" => $owner}},{idlist=>1});
 459
 460     # all_rpts_deleted will be false if a report has an
 461     # attached scheduled owned by a different user
 462     return 1 if @$alt_reports or not $all_rpts_deleted;
 463
 464     $e->delete_reporter_template($template)
 465         or return $e->die_event;
 466     return 2;
 467 }
 468
 469 # performs a cascading report delete
 470 # returns 2 if all data was deleted
 471 # returns 1 if some data was deleted
 472 # returns 0 if no data was deleted
 473 # returns event on error
 474 sub cascade_delete_report_impl {
 475     my( $e, $owner, $reportId ) = @_;
 476
 477     # fetch the report to delete
 478     my $report = $e->search_reporter_report(
 479         {id=>$reportId, owner=>$owner})->[0] or return 0;
 480
 481     # fetch the attached schedule IDs for this owner
 482     my $scheds = $e->search_reporter_schedule(
 483         {report=>$reportId, runner=>$owner},{idlist=>1});
 484
 485     # delete the attached schedules
 486     for my $sched (@$scheds) {
 487         my $evt = delete_schedule_impl($e, $sched);
 488         return $evt if $evt;
 489     }
 490
 491     # fetch all schedules attached to this report that
 492     # do not belong to $owner.  If there are any, we can't
 493     # delete the report
 494     my $alt_scheds = $e->search_reporter_schedule(
 495         {report=>$reportId, runner=>{"!=" => $owner}},{idlist=>1});
 496
 497     return 1 if @$alt_scheds;
 498
 499     $e->delete_reporter_report($report)
 500         or return $e->die_event;
 501
 502     return 2;
 503 }
 504
 505
 506 # deletes the requested schedule
 507 # returns undef on success, event on error
 508 sub delete_schedule_impl {
 509     my( $e, $schedId ) = @_;
 510     my $s = $e->retrieve_reporter_schedule($schedId)
 511         or return $e->die_event;
 512     $e->delete_reporter_schedule($s) or return $e->die_event;
 513     return undef;
 514 }
 515
 516
 517
 518
 519 __PACKAGE__->register_method(
 520         api_name => 'open-ils.reporter.report.delete',
 521         method => 'delete_report');
 522 sub delete_report {
 523         my( $self, $conn, $auth, $reportId ) = @_;
 524         my $e = new_rstore_editor(authtoken=>$auth, xact=>1);
 525         return $e->die_event unless $e->checkauth;
 526         return $e->die_event unless $e->allowed('RUN_REPORTS');
 527
 528         my $t = $e->retrieve_reporter_report($reportId)
 529                 or return $e->die_event;
 530         return 0 if $t->owner ne $e->requestor->id;
 531         $e->delete_reporter_report($t) or return $e->die_event;
 532         $e->commit;
 533         return 1;
 534 }
 535
 536
 537 __PACKAGE__->register_method(
 538         api_name => 'open-ils.reporter.schedule.delete',
 539         method => 'delete_schedule');
 540 sub delete_schedule {
 541         my( $self, $conn, $auth, $scheduleId ) = @_;
 542         my $e = new_rstore_editor(authtoken=>$auth, xact=>1);
 543         return $e->die_event unless $e->checkauth;
 544         return $e->die_event unless $e->allowed('RUN_REPORTS');
 545
 546         my $t = $e->retrieve_reporter_schedule($scheduleId)
 547                 or return $e->die_event;
 548         return 0 if $t->runner ne $e->requestor->id;
 549         $e->delete_reporter_schedule($t) or return $e->die_event;
 550         $e->commit;
 551         return 1;
 552 }
 553
 554
 555 __PACKAGE__->register_method(
 556         api_name => 'open-ils.reporter.template_has_reports',
 557         method => 'has_reports');
 558 sub has_reports {
 559         my( $self, $conn, $auth, $templateId ) = @_;
 560         my $e = new_rstore_editor(authtoken=>$auth);
 561         return $e->die_event unless $e->checkauth;
 562         return $e->die_event unless $e->allowed('RUN_REPORTS');
 563         my $rpts = $e->search_reporter_report({template=>$templateId},{idlist=>1});
 564         return 1 if @$rpts;
 565         return 0;
 566 }
 567
 568 __PACKAGE__->register_method(
 569         api_name => 'open-ils.reporter.report_has_output',
 570         method => 'has_output');
 571 sub has_output {
 572         my( $self, $conn, $auth, $reportId ) = @_;
 573         my $e = new_rstore_editor(authtoken=>$auth);
 574         return $e->die_event unless $e->checkauth;
 575         return $e->die_event unless $e->allowed('RUN_REPORTS');
 576         my $outs = $e->search_reporter_schedule({report=>$reportId},{idlist=>1});
 577         return 1 if @$outs;
 578         return 0;
 579 }
 580
 581
 582
 583 __PACKAGE__->register_method(
 584         method => 'org_full_path',
 585         api_name => 'open-ils.reporter.org_unit.full_path');
 586
 587 sub org_full_path {
 588         my( $self, $conn, $orgid ) = @_;
 589         return $U->storagereq(
 590                 'open-ils.storage.actor.org_unit.full_path.atomic', $orgid );
 591 }
 592
 593
 594
 595
 596 __PACKAGE__->register_method(
 597         method => 'magic_fetch_all',
 598         api_name => 'open-ils.reporter.magic_fetch');
 599 sub magic_fetch_all {
 600         my( $self, $conn, $auth, $args ) = @_;
 601         my $e = new_editor(authtoken => $auth);
 602         return $e->event unless $e->checkauth;
 603         return $e->event unless $e->allowed('RUN_REPORTS');
 604
 605         my $hint = $$args{hint};
 606         my $org_col = $$args{org_column};
 607         my $orgs = $$args{org};
 608
 609 #       if ($orgs && !$$args{no_fetch}) {
 610 #               ($orgs) = $self
 611 #                               ->method_lookup( 'open-ils.reporter.org_unit.full_path' )
 612 #                               ->run( @$orgs );
 613 #               $orgs = [ map {$_->id} @$orgs ];
 614 #       }
 615
 616         # Find the class the iplements the given hint
 617         my ($class) = grep {
 618                 $Fieldmapper::fieldmap->{$_}{hint} eq $hint } Fieldmapper->classes;
 619
 620         return undef unless $class->Selector;
 621
 622         $class =~ s/Fieldmapper:://og;
 623         $class =~ s/::/_/og;
 624
 625         my $method;
 626         my $margs;
 627
 628         if( $org_col ) {
 629                 $method = "search_$class";
 630                 $margs = { $org_col => $orgs };
 631         } else {
 632                 $method = "retrieve_all_$class";
 633         }
 634
 635         $logger->info("reporter.magic_fetch => $method");
 636
 637         return $e->$method($margs);
 638 }
 639
 640
 641 1;