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

   1 package OpenILS::Application::Reporter;
   2 use base qw/OpenSRF::Application/;
   3 use strict; use warnings;
   4 use OpenSRF::Utils::Logger qw/$logger/;
   5 use OpenILS::Utils::CStoreEditor qw/:funcs/;
   6 use OpenILS::Utils::Fieldmapper;
   7 use OpenILS::Application::AppUtils;
   8 my $U = "OpenILS::Application::AppUtils";
   9
  10
  11 __PACKAGE__->register_method(
  12         api_name => 'open-ils.reporter.folder.create',
  13         method => 'create_folder'
  14 );
  15
  16 sub create_folder {
  17         my( $self, $conn, $auth, $type, $folder ) = @_;
  18
  19         my $e = new_rstore_editor(xact=>1, authtoken=>$auth);
  20         return $e->die_event unless $e->checkauth;
  21         return $e->die_event unless $e->allowed('RUN_REPORTS');
  22
  23         return 0 if $folder->owner ne $e->requestor->id;
  24
  25         $folder->owner($e->requestor->id);
  26         my $meth = "create_reporter_${type}_folder";
  27         $e->$meth($folder) or return $e->die_event;
  28         $e->commit;
  29
  30         return $folder->id;
  31 }
  32
  33
  34 __PACKAGE__->register_method(
  35         api_name => 'open-ils.reporter.folder.visible.retrieve',
  36         method => 'retrieve_visible_folders'
  37 );
  38
  39 sub retrieve_visible_folders {
  40         my( $self, $conn, $auth, $type ) = @_;
  41         my $e = new_rstore_editor(authtoken=>$auth);
  42         return $e->event unless $e->checkauth;
  43         return $e->event unless $e->allowed('RUN_REPORTS');
  44
  45         my $class = 'rrf';
  46         $class = 'rtf' if $type eq 'template';
  47         $class = 'rof' if $type eq 'output';
  48         my $flesh = {flesh => 1,flesh_fields => { $class => ['owner', 'share_with']}};
  49
  50         my $meth = "search_reporter_${type}_folder";
  51         my $fs = $e->$meth( [{ owner => $e->requestor->id }, $flesh] );
  52
  53         my @orgs;
  54         my $o = $U->storagereq(
  55                 'open-ils.storage.actor.org_unit.full_path.atomic', $e->requestor->ws_ou);
  56         push( @orgs, $_->id ) for @$o;
  57
  58         my $fs2 = $e->$meth(
  59                 [
  60                         {
  61                                 shared => 't',
  62                                 share_with => \@orgs,
  63                                 owner => { '!=' => $e->requestor->id }
  64                         },
  65                         $flesh
  66                 ]
  67         );
  68         push( @$fs, @$fs2);
  69         return $fs;
  70 }
  71
  72
  73
  74 __PACKAGE__->register_method(
  75         api_name => 'open-ils.reporter.folder_data.retrieve',
  76         method => 'retrieve_folder_data'
  77 );
  78
  79 sub retrieve_folder_data {
  80         my( $self, $conn, $auth, $type, $folderid, $limit ) = @_;
  81         my $e = new_rstore_editor(authtoken=>$auth);
  82         return $e->event unless $e->checkauth;
  83         return $e->event unless $e->allowed('RUN_REPORTS');
  84         my $meth = "search_reporter_${type}";
  85         my $class = 'rr';
  86         $class = 'rt' if $type eq 'template';
  87         my $flesh = {
  88                 flesh => 1,
  89                 flesh_fields => { $class => ['owner']},
  90                 order_by => { $class => 'create_time DESC'}
  91         };
  92         $flesh->{limit} = $limit if $limit;
  93         return $e->$meth([{ folder => $folderid }, $flesh]);
  94 }
  95
  96 __PACKAGE__->register_method(
  97         api_name => 'open-ils.reporter.schedule.retrieve_by_folder',
  98         method => 'retrieve_schedules');
  99 sub retrieve_schedules {
 100         my( $self, $conn, $auth, $folderId, $limit, $complete ) = @_;
 101         my $e = new_rstore_editor(authtoken=>$auth);
 102         return $e->event unless $e->checkauth;
 103         return $e->event unless $e->allowed('RUN_REPORTS');
 104
 105         my $search = { folder => $folderId };
 106         my $query = [
 107                 { folder => $folderId },
 108                 {
 109                         order_by => { rs => 'run_time DESC' } ,
 110                         flesh => 1,
 111                         flesh_fields => { rs => ['report'] }
 112                 }
 113         ];
 114
 115         $query->[1]->{limit} = $limit if $limit;
 116         $query->[0]->{complete_time} = undef unless $complete;
 117         $query->[0]->{complete_time} = { '!=' => undef } if $complete;
 118
 119         return $e->search_reporter_schedule($query);
 120 }
 121
 122 __PACKAGE__->register_method(
 123         api_name => 'open-ils.reporter.schedule.retrieve',
 124         method => 'retrieve_schedules');
 125 sub retrieve_schedule {
 126         my( $self, $conn, $auth, $sched_id ) = @_;
 127         my $e = new_rstore_editor(authtoken=>$auth);
 128         return $e->event unless $e->checkauth;
 129         return $e->event unless $e->allowed('RUN_REPORTS');
 130         my $s = $e->retrieve_reporter_schedule($sched_id)
 131                 or return $e->event;
 132         return $s;
 133 }
 134
 135
 136 __PACKAGE__->register_method(
 137         api_name => 'open-ils.reporter.template.create',
 138         method => 'create_template');
 139 sub create_template {
 140         my( $self, $conn, $auth, $template ) = @_;
 141         my $e = new_rstore_editor(authtoken=>$auth, xact=>1);
 142         return $e->die_event unless $e->checkauth;
 143         return $e->die_event unless $e->allowed('RUN_REPORTS');
 144         $template->owner($e->requestor->id);
 145
 146         my $existing = $e->search_reporter_template( {owner=>$template->owner,
 147                         folder=>$template->folder, name=>$template->name},{idlist=>1});
 148         return OpenILS::Event->new('REPORT_TEMPLATE_EXISTS') if @$existing;
 149
 150         my $tmpl = $e->create_reporter_template($template)
 151                 or return $e->die_event;
 152         $e->commit;
 153         return $tmpl;
 154 }
 155
 156
 157 __PACKAGE__->register_method(
 158         api_name => 'open-ils.reporter.report.create',
 159         method => 'create_report');
 160 sub create_report {
 161         my( $self, $conn, $auth, $report, $schedule ) = @_;
 162         my $e = new_rstore_editor(authtoken=>$auth, xact=>1);
 163         return $e->die_event unless $e->checkauth;
 164         return $e->die_event unless $e->allowed('RUN_REPORTS');
 165         $report->owner($e->requestor->id);
 166
 167         my $existing = $e->search_reporter_report( {owner=>$report->owner,
 168                         folder=>$report->folder, name=>$report->name},{idlist=>1});
 169         return OpenILS::Event->new('REPORT_REPORT_EXISTS') if @$existing;
 170
 171         my $rpt = $e->create_reporter_report($report)
 172                 or return $e->die_event;
 173         $schedule->report($rpt->id);
 174         $schedule->runner($e->requestor->id);
 175         $e->create_reporter_schedule($schedule) or return $e->die_event;
 176         $e->commit;
 177         return $rpt;
 178 }
 179
 180
 181 __PACKAGE__->register_method(
 182         api_name => 'open-ils.scheduleer.schedule.create',
 183         method => 'create_schedule');
 184 sub create_schedule {
 185         my( $self, $conn, $auth, $schedule ) = @_;
 186         my $e = new_rstore_editor(authtoken=>$auth, xact=>1);
 187         return $e->die_event unless $e->checkauth;
 188         return $e->die_event unless $e->allowed('RUN_REPORTS');
 189         my $sched = $e->create_reporter_schedule($schedule)
 190                 or return $e->die_event;
 191         $e->commit;
 192         return $sched;
 193 }
 194
 195 __PACKAGE__->register_method(
 196         api_name => 'open-ils.reporter.template.retrieve',
 197         method => 'retrieve_template');
 198 sub retrieve_template {
 199         my( $self, $conn, $auth, $id ) = @_;
 200         my $e = new_rstore_editor(authtoken=>$auth);
 201         return $e->event unless $e->checkauth;
 202         return $e->event unless $e->allowed('RUN_REPORTS');
 203         my $t = $e->retrieve_reporter_template($id)
 204                 or return $e->event;
 205         return $t;
 206 }
 207
 208
 209 __PACKAGE__->register_method(
 210         api_name => 'open-ils.reporter.report.retrieve',
 211         method => 'retrieve_report');
 212 sub retrieve_report {
 213         my( $self, $conn, $auth, $id ) = @_;
 214         my $e = new_rstore_editor(authtoken=>$auth);
 215         return $e->event unless $e->checkauth;
 216         return $e->event unless $e->allowed('RUN_REPORTS');
 217         my $r = $e->retrieve_reporter_report($id)
 218                 or return $e->event;
 219         return $r;
 220 }
 221
 222
 223 __PACKAGE__->register_method(
 224         api_name => 'open-ils.reporter.template.update',
 225         method => 'update_template');
 226 sub update_template {
 227         my( $self, $conn, $auth, $tmpl ) = @_;
 228         my $e = new_rstore_editor(authtoken=>$auth, xact=>1);
 229         return $e->die_event unless $e->checkauth;
 230         return $e->die_event unless $e->allowed('RUN_REPORTS');
 231         my $t = $e->retrieve_reporter_template($tmpl->id)
 232                 or return $e->die_event;
 233         return 0 if $t->owner ne $e->requestor->id;
 234         $e->update_reporter_template($tmpl)
 235                 or return $e->die_event;
 236         $e->commit;
 237         return 1;
 238 }
 239
 240
 241 __PACKAGE__->register_method(
 242         api_name => 'open-ils.reporter.report.update',
 243         method => 'update_report');
 244 sub update_report {
 245         my( $self, $conn, $auth, $report ) = @_;
 246         my $e = new_rstore_editor(authtoken=>$auth, xact=>1);
 247         return $e->die_event unless $e->checkauth;
 248         return $e->die_event unless $e->allowed('RUN_REPORTS');
 249         my $r = $e->retrieve_reporter_report($report->id)
 250                 or return $e->die_event;
 251         if( $r->owner ne $e->requestor->id ) {
 252                 $e->rollback;
 253                 return 0;
 254         }
 255         $e->update_reporter_report($report)
 256                 or return $e->die_event;
 257         $e->commit;
 258         return 1;
 259 }
 260
 261
 262 __PACKAGE__->register_method(
 263         api_name => 'open-ils.reporter.schedule.update',
 264         method => 'update_schedule');
 265 sub update_schedule {
 266         my( $self, $conn, $auth, $schedule ) = @_;
 267         my $e = new_rstore_editor(authtoken=>$auth, xact=>1);
 268         return $e->die_event unless $e->checkauth;
 269         return $e->die_event unless $e->allowed('RUN_REPORTS');
 270         my $s = $e->retrieve_reporter_schedule($schedule->id)
 271                 or return $e->die_event;
 272         my $r = $e->retrieve_reporter_report($s->report)
 273                 or return $e->die_event;
 274         if( $r->owner ne $e->requestor->id ) {
 275                 $e->rollback;
 276                 return 0;
 277         }
 278         $e->update_reporter_schedule($schedule)
 279                 or return $e->die_event;
 280         $e->commit;
 281         return 1;
 282 }
 283
 284
 285 __PACKAGE__->register_method(
 286         api_name => 'open-ils.reporter.folder.update',
 287         method => 'update_folder');
 288 sub update_folder {
 289         my( $self, $conn, $auth, $type, $folder ) = @_;
 290         my $e = new_rstore_editor(authtoken=>$auth, xact=>1);
 291         return $e->die_event unless $e->checkauth;
 292         return $e->die_event unless $e->allowed('RUN_REPORTS');
 293         my $meth = "retrieve_reporter_${type}_folder";
 294         my $f = $e->$meth($folder->id) or return $e->die_event;
 295         return 0 if $f->owner ne $e->requestor->id;
 296         $meth = "update_reporter_${type}_folder";
 297         $e->$meth($folder) or return $e->die_event;
 298         $e->commit;
 299         return 1;
 300 }
 301
 302
 303 __PACKAGE__->register_method(
 304         api_name => 'open-ils.reporter.folder.delete',
 305         method => 'delete_folder');
 306 sub delete_folder {
 307         my( $self, $conn, $auth, $type, $folderId ) = @_;
 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 $meth = "retrieve_reporter_${type}_folder";
 312         my $f = $e->$meth($folderId) or return $e->die_event;
 313         return 0 if $f->owner ne $e->requestor->id;
 314         $meth = "delete_reporter_${type}_folder";
 315         $e->$meth($f) or return $e->die_event;
 316         $e->commit;
 317         return 1;
 318 }
 319
 320
 321 __PACKAGE__->register_method(
 322         api_name => 'open-ils.reporter.template.delete',
 323         method => 'delete_template');
 324 sub delete_template {
 325         my( $self, $conn, $auth, $templateId ) = @_;
 326         my $e = new_rstore_editor(authtoken=>$auth, xact=>1);
 327         return $e->die_event unless $e->checkauth;
 328         return $e->die_event unless $e->allowed('RUN_REPORTS');
 329
 330         my $t = $e->retrieve_reporter_template($templateId)
 331                 or return $e->die_event;
 332         return 0 if $t->owner ne $e->requestor->id;
 333         $e->delete_reporter_template($t) or return $e->die_event;
 334         $e->commit;
 335         return 1;
 336 }
 337
 338 __PACKAGE__->register_method(
 339         api_name => 'open-ils.reporter.report.delete',
 340         method => 'delete_report');
 341 sub delete_report {
 342         my( $self, $conn, $auth, $reportId ) = @_;
 343         my $e = new_rstore_editor(authtoken=>$auth, xact=>1);
 344         return $e->die_event unless $e->checkauth;
 345         return $e->die_event unless $e->allowed('RUN_REPORTS');
 346
 347         my $t = $e->retrieve_reporter_report($reportId)
 348                 or return $e->die_event;
 349         return 0 if $t->owner ne $e->requestor->id;
 350         $e->delete_reporter_report($t) or return $e->die_event;
 351         $e->commit;
 352         return 1;
 353 }
 354
 355
 356 __PACKAGE__->register_method(
 357         api_name => 'open-ils.reporter.schedule.delete',
 358         method => 'delete_schedule');
 359 sub delete_schedule {
 360         my( $self, $conn, $auth, $scheduleId ) = @_;
 361         my $e = new_rstore_editor(authtoken=>$auth, xact=>1);
 362         return $e->die_event unless $e->checkauth;
 363         return $e->die_event unless $e->allowed('RUN_REPORTS');
 364
 365         my $t = $e->retrieve_reporter_schedule($scheduleId)
 366                 or return $e->die_event;
 367         return 0 if $t->runner ne $e->requestor->id;
 368         $e->delete_reporter_schedule($t) or return $e->die_event;
 369         $e->commit;
 370         return 1;
 371 }
 372
 373
 374 __PACKAGE__->register_method(
 375         api_name => 'open-ils.reporter.template_has_reports',
 376         method => 'has_reports');
 377 sub has_reports {
 378         my( $self, $conn, $auth, $templateId ) = @_;
 379         my $e = new_rstore_editor(authtoken=>$auth);
 380         return $e->die_event unless $e->checkauth;
 381         return $e->die_event unless $e->allowed('RUN_REPORTS');
 382         my $rpts = $e->search_reporter_report({template=>$templateId},{idlist=>1});
 383         return 1 if @$rpts;
 384         return 0;
 385 }
 386
 387 __PACKAGE__->register_method(
 388         api_name => 'open-ils.reporter.report_has_output',
 389         method => 'has_output');
 390 sub has_output {
 391         my( $self, $conn, $auth, $reportId ) = @_;
 392         my $e = new_rstore_editor(authtoken=>$auth);
 393         return $e->die_event unless $e->checkauth;
 394         return $e->die_event unless $e->allowed('RUN_REPORTS');
 395         my $outs = $e->search_reporter_schedule({report=>$reportId},{idlist=>1});
 396         return 1 if @$outs;
 397         return 0;
 398 }
 399
 400
 401
 402 __PACKAGE__->register_method(
 403         method => 'org_full_path',
 404         api_name => 'open-ils.reporter.org_unit.full_path');
 405
 406 sub org_full_path {
 407         my( $self, $conn, $orgid ) = @_;
 408         return $U->storagereq(
 409                 'open-ils.storage.actor.org_unit.full_path.atomic', $orgid );
 410 }
 411
 412
 413
 414
 415 __PACKAGE__->register_method(
 416         method => 'magic_fetch_all',
 417         api_name => 'open-ils.reporter.magic_fetch');
 418 sub magic_fetch_all {
 419         my( $self, $conn, $auth, $args ) = @_;
 420         my $e = new_editor(authtoken => $auth);
 421         return $e->event unless $e->checkauth;
 422         return $e->event unless $e->allowed('RUN_REPORTS');
 423
 424         my $hint = $$args{hint};
 425         my $org_col = $$args{org_column};
 426         my $orgs = $$args{org};
 427
 428 #       if ($orgs && !$$args{no_fetch}) {
 429 #               ($orgs) = $self
 430 #                               ->method_lookup( 'open-ils.reporter.org_unit.full_path' )
 431 #                               ->run( @$orgs );
 432 #               $orgs = [ map {$_->id} @$orgs ];
 433 #       }
 434
 435         # Find the class the iplements the given hint
 436         my ($class) = grep {
 437                 $Fieldmapper::fieldmap->{$_}{hint} eq $hint } Fieldmapper->classes;
 438
 439         return undef unless $class->Selector;
 440
 441         $class =~ s/Fieldmapper:://og;
 442         $class =~ s/::/_/og;
 443
 444         my $method;
 445         my $margs;
 446
 447         if( $org_col ) {
 448                 $method = "search_$class";
 449                 $margs = { $org_col => $orgs };
 450         } else {
 451                 $method = "retrieve_all_$class";
 452         }
 453
 454         $logger->info("reporter.magic_fetch => $method");
 455
 456         return $e->$method($margs);
 457 }
 458
 459
 460 1;