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 ) = @_;
  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 = {flesh => 1,flesh_fields => { $class => ['owner']}};
  88         return $e->$meth([{ folder => $folderid }, $flesh]);
  89 }
  90
  91
  92 __PACKAGE__->register_method(
  93         api_name => 'open-ils.reporter.template.create',
  94         method => 'create_template');
  95 sub create_template {
  96         my( $self, $conn, $auth, $template ) = @_;
  97         my $e = new_rstore_editor(authtoken=>$auth, xact=>1);
  98         return $e->die_event unless $e->checkauth;
  99         return $e->die_event unless $e->allowed('RUN_REPORTS');
 100         $template->owner($e->requestor->id);
 101         my $tmpl = $e->create_reporter_template($template)
 102                 or return $e->die_event;
 103         $e->commit;
 104         return $tmpl;
 105 }
 106
 107
 108 __PACKAGE__->register_method(
 109         api_name => 'open-ils.reporter.report.create',
 110         method => 'create_report');
 111 sub create_report {
 112         my( $self, $conn, $auth, $report, $schedule ) = @_;
 113         my $e = new_rstore_editor(authtoken=>$auth, xact=>1);
 114         return $e->die_event unless $e->checkauth;
 115         return $e->die_event unless $e->allowed('RUN_REPORTS');
 116         $report->owner($e->requestor->id);
 117         my $rpt = $e->create_reporter_report($report)
 118                 or return $e->die_event;
 119         $schedule->report($rpt->id);
 120         $schedule->runner($e->requestor->id);
 121         $e->create_reporter_schedule($schedule) or return $e->die_event;
 122         $e->commit;
 123         return $rpt;
 124 }
 125
 126
 127 __PACKAGE__->register_method(
 128         api_name => 'open-ils.scheduleer.schedule.create',
 129         method => 'create_schedule');
 130 sub create_schedule {
 131         my( $self, $conn, $auth, $schedule ) = @_;
 132         my $e = new_rstore_editor(authtoken=>$auth, xact=>1);
 133         return $e->die_event unless $e->checkauth;
 134         return $e->die_event unless $e->allowed('RUN_REPORTS');
 135         my $sched = $e->create_reporter_schedule($schedule)
 136                 or return $e->die_event;
 137         $e->commit;
 138         return $sched;
 139 }
 140
 141 __PACKAGE__->register_method(
 142         api_name => 'open-ils.reporter.template.retrieve',
 143         method => 'retrieve_template');
 144 sub retrieve_template {
 145         my( $self, $conn, $auth, $id ) = @_;
 146         my $e = new_rstore_editor(authtoken=>$auth);
 147         return $e->event unless $e->checkauth;
 148         return $e->event unless $e->allowed('RUN_REPORTS');
 149         my $t = $e->retrieve_reporter_template($id)
 150                 or return $e->event;
 151         return $t;
 152 }
 153
 154
 155 __PACKAGE__->register_method(
 156         api_name => 'open-ils.reporter.report.retrieve',
 157         method => 'retrieve_report');
 158 sub retrieve_report {
 159         my( $self, $conn, $auth, $id ) = @_;
 160         my $e = new_rstore_editor(authtoken=>$auth);
 161         return $e->event unless $e->checkauth;
 162         return $e->event unless $e->allowed('RUN_REPORTS');
 163         my $r = $e->retrieve_reporter_report($id)
 164                 or return $e->event;
 165         return $r;
 166 }
 167
 168
 169 __PACKAGE__->register_method(
 170         api_name => 'open-ils.reporter.template.update',
 171         method => 'update_template');
 172 sub update_template {
 173         my( $self, $conn, $auth, $tmpl ) = @_;
 174         my $e = new_rstore_editor(authtoken=>$auth, xact=>1);
 175         return $e->die_event unless $e->checkauth;
 176         return $e->die_event unless $e->allowed('RUN_REPORTS');
 177         my $t = $e->retrieve_reporter_template($tmpl->id)
 178                 or return $e->die_event;
 179         return 0 if $t->owner ne $e->requestor->id;
 180         $e->update_reporter_template($tmpl)
 181                 or return $e->die_event;
 182         $e->commit;
 183         return 1;
 184 }
 185
 186
 187 __PACKAGE__->register_method(
 188         api_name => 'open-ils.reporter.report.update',
 189         method => 'update_report');
 190 sub update_report {
 191         my( $self, $conn, $auth, $report ) = @_;
 192         my $e = new_rstore_editor(authtoken=>$auth, xact=>1);
 193         return $e->die_event unless $e->checkauth;
 194         return $e->die_event unless $e->allowed('RUN_REPORTS');
 195         my $r = $e->retrieve_reporter_report($report->id)
 196                 or return $e->die_event;
 197         if( $r->owner ne $e->requestor->id ) {
 198                 $e->rollback;
 199                 return 0;
 200         }
 201         $e->update_reporter_report($report)
 202                 or return $e->die_event;
 203         $e->commit;
 204         return 1;
 205 }
 206
 207
 208 __PACKAGE__->register_method(
 209         api_name => 'open-ils.reporter.folder.update',
 210         method => 'update_folder');
 211 sub update_folder {
 212         my( $self, $conn, $auth, $type, $folder ) = @_;
 213         my $e = new_rstore_editor(authtoken=>$auth, xact=>1);
 214         return $e->die_event unless $e->checkauth;
 215         return $e->die_event unless $e->allowed('RUN_REPORTS');
 216         my $meth = "retrieve_reporter_${type}_folder";
 217         my $f = $e->$meth($folder->id) or return $e->die_event;
 218         return 0 if $f->owner ne $e->requestor->id;
 219         $meth = "update_reporter_${type}_folder";
 220         $e->$meth($folder) or return $e->die_event;
 221         $e->commit;
 222         return 1;
 223 }
 224
 225
 226 __PACKAGE__->register_method(
 227         api_name => 'open-ils.reporter.folder.delete',
 228         method => 'delete_folder');
 229 sub delete_folder {
 230         my( $self, $conn, $auth, $type, $folderId ) = @_;
 231         my $e = new_rstore_editor(authtoken=>$auth, xact=>1);
 232         return $e->die_event unless $e->checkauth;
 233         return $e->die_event unless $e->allowed('RUN_REPORTS');
 234         my $meth = "retrieve_reporter_${type}_folder";
 235         my $f = $e->$meth($folderId) or return $e->die_event;
 236         return 0 if $f->owner ne $e->requestor->id;
 237         $meth = "delete_reporter_${type}_folder";
 238         $e->$meth($f) or return $e->die_event;
 239         $e->commit;
 240         return 1;
 241 }
 242
 243
 244 __PACKAGE__->register_method(
 245         api_name => 'open-ils.reporter.template.delete',
 246         method => 'delete_template');
 247 sub delete_template {
 248         my( $self, $conn, $auth, $templateId ) = @_;
 249         my $e = new_rstore_editor(authtoken=>$auth, xact=>1);
 250         return $e->die_event unless $e->checkauth;
 251         return $e->die_event unless $e->allowed('RUN_REPORTS');
 252
 253         my $t = $e->retrieve_reporter_template($templateId)
 254                 or return $e->die_event;
 255         return 0 if $t->owner ne $e->requestor->id;
 256         $e->delete_reporter_template($t) or return $e->die_event;
 257         $e->commit;
 258         return 1;
 259 }
 260
 261 __PACKAGE__->register_method(
 262         api_name => 'open-ils.reporter.report.delete',
 263         method => 'delete_report');
 264 sub delete_report {
 265         my( $self, $conn, $auth, $reportId ) = @_;
 266         my $e = new_rstore_editor(authtoken=>$auth, xact=>1);
 267         return $e->die_event unless $e->checkauth;
 268         return $e->die_event unless $e->allowed('RUN_REPORTS');
 269
 270         my $t = $e->retrieve_reporter_report($reportId)
 271                 or return $e->die_event;
 272         return 0 if $t->owner ne $e->requestor->id;
 273         $e->delete_reporter_report($t) or return $e->die_event;
 274         $e->commit;
 275         return 1;
 276 }
 277
 278
 279 __PACKAGE__->register_method(
 280         api_name => 'open-ils.reporter.template_has_reports',
 281         method => 'has_reports');
 282 sub has_reports {
 283         my( $self, $conn, $auth, $templateId ) = @_;
 284         my $e = new_rstore_editor(authtoken=>$auth);
 285         return $e->die_event unless $e->checkauth;
 286         return $e->die_event unless $e->allowed('RUN_REPORTS');
 287         my $rpts = $e->search_reporter_report({template=>$templateId},{idlist=>1});
 288         return 1 if @$rpts;
 289         return 0;
 290 }
 291
 292
 293 __PACKAGE__->register_method(
 294         method => 'org_full_path',
 295         api_name => 'open-ils.reporter.org_unit.full_path');
 296
 297 sub org_full_path {
 298         my( $self, $conn, $orgid ) = @_;
 299         return $U->storagereq(
 300                 'open-ils.storage.actor.org_unit.full_path.atomic', $orgid );
 301 }
 302
 303
 304
 305
 306 __PACKAGE__->register_method(
 307         method => 'magic_fetch_all',
 308         api_name => 'open-ils.reporter.magic_fetch');
 309 sub magic_fetch_all {
 310         my( $self, $conn, $auth, $args ) = @_;
 311         my $e = new_editor(authtoken => $auth);
 312         return $e->event unless $e->checkauth;
 313         return $e->event unless $e->allowed('RUN_REPORTS');
 314
 315         my $hint = $$args{hint};
 316
 317         # Find the class the iplements the given hint
 318         my ($class) = grep {
 319                 $Fieldmapper::fieldmap->{$_}{hint} eq $hint } Fieldmapper->classes;
 320
 321         return undef unless $class->Selector;
 322
 323         $class =~ s/Fieldmapper:://og;
 324         $class =~ s/::/_/og;
 325         my $method = "retrieve_all_$class";
 326
 327         $logger->info("reporter.magic_fetch => $method");
 328
 329         return $e->$method();
 330 }
 331
 332
 333 1;