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 ) = @_;
 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                 { order_by => { rs => 'run_time DESC' } }
 109         ];
 110
 111         $query->[1]->{limit} = $limit if $limit;
 112         return $e->search_reporter_schedule($query);
 113 }
 114
 115 __PACKAGE__->register_method(
 116         api_name => 'open-ils.reporter.schedule.retrieve',
 117         method => 'retrieve_schedules');
 118 sub retrieve_schedule {
 119         my( $self, $conn, $auth, $sched_id ) = @_;
 120         my $e = new_rstore_editor(authtoken=>$auth);
 121         return $e->event unless $e->checkauth;
 122         return $e->event unless $e->allowed('RUN_REPORTS');
 123         my $s = $e->retrieve_reporter_schedule($sched_id)
 124                 or return $e->event;
 125         return $s;
 126 }
 127
 128
 129 __PACKAGE__->register_method(
 130         api_name => 'open-ils.reporter.template.create',
 131         method => 'create_template');
 132 sub create_template {
 133         my( $self, $conn, $auth, $template ) = @_;
 134         my $e = new_rstore_editor(authtoken=>$auth, xact=>1);
 135         return $e->die_event unless $e->checkauth;
 136         return $e->die_event unless $e->allowed('RUN_REPORTS');
 137         $template->owner($e->requestor->id);
 138
 139         my $existing = $e->search_reporter_template( {owner=>$template->owner,
 140                         folder=>$template->folder, name=>$template->name},{idlist=>1});
 141         return OpenILS::Event->new('REPORT_TEMPLATE_EXISTS') if @$existing;
 142
 143         my $tmpl = $e->create_reporter_template($template)
 144                 or return $e->die_event;
 145         $e->commit;
 146         return $tmpl;
 147 }
 148
 149
 150 __PACKAGE__->register_method(
 151         api_name => 'open-ils.reporter.report.create',
 152         method => 'create_report');
 153 sub create_report {
 154         my( $self, $conn, $auth, $report, $schedule ) = @_;
 155         my $e = new_rstore_editor(authtoken=>$auth, xact=>1);
 156         return $e->die_event unless $e->checkauth;
 157         return $e->die_event unless $e->allowed('RUN_REPORTS');
 158         $report->owner($e->requestor->id);
 159
 160         my $existing = $e->search_reporter_report( {owner=>$report->owner,
 161                         folder=>$report->folder, name=>$report->name},{idlist=>1});
 162         return OpenILS::Event->new('REPORT_REPORT_EXISTS') if @$existing;
 163
 164         my $rpt = $e->create_reporter_report($report)
 165                 or return $e->die_event;
 166         $schedule->report($rpt->id);
 167         $schedule->runner($e->requestor->id);
 168         $e->create_reporter_schedule($schedule) or return $e->die_event;
 169         $e->commit;
 170         return $rpt;
 171 }
 172
 173
 174 __PACKAGE__->register_method(
 175         api_name => 'open-ils.scheduleer.schedule.create',
 176         method => 'create_schedule');
 177 sub create_schedule {
 178         my( $self, $conn, $auth, $schedule ) = @_;
 179         my $e = new_rstore_editor(authtoken=>$auth, xact=>1);
 180         return $e->die_event unless $e->checkauth;
 181         return $e->die_event unless $e->allowed('RUN_REPORTS');
 182         my $sched = $e->create_reporter_schedule($schedule)
 183                 or return $e->die_event;
 184         $e->commit;
 185         return $sched;
 186 }
 187
 188 __PACKAGE__->register_method(
 189         api_name => 'open-ils.reporter.template.retrieve',
 190         method => 'retrieve_template');
 191 sub retrieve_template {
 192         my( $self, $conn, $auth, $id ) = @_;
 193         my $e = new_rstore_editor(authtoken=>$auth);
 194         return $e->event unless $e->checkauth;
 195         return $e->event unless $e->allowed('RUN_REPORTS');
 196         my $t = $e->retrieve_reporter_template($id)
 197                 or return $e->event;
 198         return $t;
 199 }
 200
 201
 202 __PACKAGE__->register_method(
 203         api_name => 'open-ils.reporter.report.retrieve',
 204         method => 'retrieve_report');
 205 sub retrieve_report {
 206         my( $self, $conn, $auth, $id ) = @_;
 207         my $e = new_rstore_editor(authtoken=>$auth);
 208         return $e->event unless $e->checkauth;
 209         return $e->event unless $e->allowed('RUN_REPORTS');
 210         my $r = $e->retrieve_reporter_report($id)
 211                 or return $e->event;
 212         return $r;
 213 }
 214
 215
 216 __PACKAGE__->register_method(
 217         api_name => 'open-ils.reporter.template.update',
 218         method => 'update_template');
 219 sub update_template {
 220         my( $self, $conn, $auth, $tmpl ) = @_;
 221         my $e = new_rstore_editor(authtoken=>$auth, xact=>1);
 222         return $e->die_event unless $e->checkauth;
 223         return $e->die_event unless $e->allowed('RUN_REPORTS');
 224         my $t = $e->retrieve_reporter_template($tmpl->id)
 225                 or return $e->die_event;
 226         return 0 if $t->owner ne $e->requestor->id;
 227         $e->update_reporter_template($tmpl)
 228                 or return $e->die_event;
 229         $e->commit;
 230         return 1;
 231 }
 232
 233
 234 __PACKAGE__->register_method(
 235         api_name => 'open-ils.reporter.report.update',
 236         method => 'update_report');
 237 sub update_report {
 238         my( $self, $conn, $auth, $report ) = @_;
 239         my $e = new_rstore_editor(authtoken=>$auth, xact=>1);
 240         return $e->die_event unless $e->checkauth;
 241         return $e->die_event unless $e->allowed('RUN_REPORTS');
 242         my $r = $e->retrieve_reporter_report($report->id)
 243                 or return $e->die_event;
 244         if( $r->owner ne $e->requestor->id ) {
 245                 $e->rollback;
 246                 return 0;
 247         }
 248         $e->update_reporter_report($report)
 249                 or return $e->die_event;
 250         $e->commit;
 251         return 1;
 252 }
 253
 254
 255 __PACKAGE__->register_method(
 256         api_name => 'open-ils.reporter.folder.update',
 257         method => 'update_folder');
 258 sub update_folder {
 259         my( $self, $conn, $auth, $type, $folder ) = @_;
 260         my $e = new_rstore_editor(authtoken=>$auth, xact=>1);
 261         return $e->die_event unless $e->checkauth;
 262         return $e->die_event unless $e->allowed('RUN_REPORTS');
 263         my $meth = "retrieve_reporter_${type}_folder";
 264         my $f = $e->$meth($folder->id) or return $e->die_event;
 265         return 0 if $f->owner ne $e->requestor->id;
 266         $meth = "update_reporter_${type}_folder";
 267         $e->$meth($folder) or return $e->die_event;
 268         $e->commit;
 269         return 1;
 270 }
 271
 272
 273 __PACKAGE__->register_method(
 274         api_name => 'open-ils.reporter.folder.delete',
 275         method => 'delete_folder');
 276 sub delete_folder {
 277         my( $self, $conn, $auth, $type, $folderId ) = @_;
 278         my $e = new_rstore_editor(authtoken=>$auth, xact=>1);
 279         return $e->die_event unless $e->checkauth;
 280         return $e->die_event unless $e->allowed('RUN_REPORTS');
 281         my $meth = "retrieve_reporter_${type}_folder";
 282         my $f = $e->$meth($folderId) or return $e->die_event;
 283         return 0 if $f->owner ne $e->requestor->id;
 284         $meth = "delete_reporter_${type}_folder";
 285         $e->$meth($f) or return $e->die_event;
 286         $e->commit;
 287         return 1;
 288 }
 289
 290
 291 __PACKAGE__->register_method(
 292         api_name => 'open-ils.reporter.template.delete',
 293         method => 'delete_template');
 294 sub delete_template {
 295         my( $self, $conn, $auth, $templateId ) = @_;
 296         my $e = new_rstore_editor(authtoken=>$auth, xact=>1);
 297         return $e->die_event unless $e->checkauth;
 298         return $e->die_event unless $e->allowed('RUN_REPORTS');
 299
 300         my $t = $e->retrieve_reporter_template($templateId)
 301                 or return $e->die_event;
 302         return 0 if $t->owner ne $e->requestor->id;
 303         $e->delete_reporter_template($t) or return $e->die_event;
 304         $e->commit;
 305         return 1;
 306 }
 307
 308 __PACKAGE__->register_method(
 309         api_name => 'open-ils.reporter.report.delete',
 310         method => 'delete_report');
 311 sub delete_report {
 312         my( $self, $conn, $auth, $reportId ) = @_;
 313         my $e = new_rstore_editor(authtoken=>$auth, xact=>1);
 314         return $e->die_event unless $e->checkauth;
 315         return $e->die_event unless $e->allowed('RUN_REPORTS');
 316
 317         my $t = $e->retrieve_reporter_report($reportId)
 318                 or return $e->die_event;
 319         return 0 if $t->owner ne $e->requestor->id;
 320         $e->delete_reporter_report($t) or return $e->die_event;
 321         $e->commit;
 322         return 1;
 323 }
 324
 325
 326 __PACKAGE__->register_method(
 327         api_name => 'open-ils.reporter.schedule.delete',
 328         method => 'delete_schedule');
 329 sub delete_schedule {
 330         my( $self, $conn, $auth, $scheduleId ) = @_;
 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
 335         my $t = $e->retrieve_reporter_schedule($scheduleId)
 336                 or return $e->die_event;
 337         return 0 if $t->runner ne $e->requestor->id;
 338         $e->delete_reporter_schedule($t) or return $e->die_event;
 339         $e->commit;
 340         return 1;
 341 }
 342
 343
 344 __PACKAGE__->register_method(
 345         api_name => 'open-ils.reporter.template_has_reports',
 346         method => 'has_reports');
 347 sub has_reports {
 348         my( $self, $conn, $auth, $templateId ) = @_;
 349         my $e = new_rstore_editor(authtoken=>$auth);
 350         return $e->die_event unless $e->checkauth;
 351         return $e->die_event unless $e->allowed('RUN_REPORTS');
 352         my $rpts = $e->search_reporter_report({template=>$templateId},{idlist=>1});
 353         return 1 if @$rpts;
 354         return 0;
 355 }
 356
 357 __PACKAGE__->register_method(
 358         api_name => 'open-ils.reporter.report_has_output',
 359         method => 'has_output');
 360 sub has_output {
 361         my( $self, $conn, $auth, $reportId ) = @_;
 362         my $e = new_rstore_editor(authtoken=>$auth);
 363         return $e->die_event unless $e->checkauth;
 364         return $e->die_event unless $e->allowed('RUN_REPORTS');
 365         my $outs = $e->search_reporter_schedule({report=>$reportId},{idlist=>1});
 366         return 1 if @$outs;
 367         return 0;
 368 }
 369
 370
 371
 372 __PACKAGE__->register_method(
 373         method => 'org_full_path',
 374         api_name => 'open-ils.reporter.org_unit.full_path');
 375
 376 sub org_full_path {
 377         my( $self, $conn, $orgid ) = @_;
 378         return $U->storagereq(
 379                 'open-ils.storage.actor.org_unit.full_path.atomic', $orgid );
 380 }
 381
 382
 383
 384
 385 __PACKAGE__->register_method(
 386         method => 'magic_fetch_all',
 387         api_name => 'open-ils.reporter.magic_fetch');
 388 sub magic_fetch_all {
 389         my( $self, $conn, $auth, $args ) = @_;
 390         my $e = new_editor(authtoken => $auth);
 391         return $e->event unless $e->checkauth;
 392         return $e->event unless $e->allowed('RUN_REPORTS');
 393
 394         my $hint = $$args{hint};
 395
 396         # Find the class the iplements the given hint
 397         my ($class) = grep {
 398                 $Fieldmapper::fieldmap->{$_}{hint} eq $hint } Fieldmapper->classes;
 399
 400         return undef unless $class->Selector;
 401
 402         $class =~ s/Fieldmapper:://og;
 403         $class =~ s/::/_/og;
 404         my $method = "retrieve_all_$class";
 405
 406         $logger->info("reporter.magic_fetch => $method");
 407
 408         return $e->$method();
 409 }
 410
 411
 412 1;