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         my $flesh = {flesh => 1,flesh_fields => { $class => ['owner', 'share_with']}};
  48
  49         my $meth = "search_reporter_${type}_folder";
  50         my $fs = $e->$meth( [{ owner => $e->requestor->id }, $flesh] );
  51
  52         my @orgs;
  53         my $o = $U->storagereq(
  54                 'open-ils.storage.actor.org_unit.full_path.atomic', $e->requestor->ws_ou);
  55         push( @orgs, $_->id ) for @$o;
  56
  57         my $fs2 = $e->$meth(
  58                 [
  59                         {
  60                                 shared => 't',
  61                                 share_with => \@orgs,
  62                                 owner => { '!=' => $e->requestor->id }
  63                         },
  64                         $flesh
  65                 ]
  66         );
  67         push( @$fs, @$fs2);
  68         return $fs;
  69 }
  70
  71
  72
  73 __PACKAGE__->register_method(
  74         api_name => 'open-ils.reporter.folder_data.retrieve',
  75         method => 'retrieve_folder_data'
  76 );
  77
  78 sub retrieve_folder_data {
  79         my( $self, $conn, $auth, $type, $folderid ) = @_;
  80         my $e = new_rstore_editor(authtoken=>$auth);
  81         return $e->event unless $e->checkauth;
  82         return $e->event unless $e->allowed('RUN_REPORTS');
  83         my $meth = "search_reporter_${type}";
  84         my $class = 'rr';
  85         $class = 'rt' if $type eq 'template';
  86         my $flesh = {flesh => 1,flesh_fields => { $class => ['owner']}};
  87         return $e->$meth([{ folder => $folderid }, $flesh]);
  88 }
  89
  90
  91 __PACKAGE__->register_method(
  92         api_name => 'open-ils.reporter.template.create',
  93         method => 'create_template');
  94 sub create_template {
  95         my( $self, $conn, $auth, $template ) = @_;
  96         my $e = new_rstore_editor(authtoken=>$auth, xact=>1);
  97         return $e->die_event unless $e->checkauth;
  98         return $e->die_event unless $e->allowed('RUN_REPORTS');
  99         $template->owner($e->requestor->id);
 100         my $tmpl = $e->create_reporter_template($template)
 101                 or return $e->die_event;
 102         $e->commit;
 103         return $tmpl;
 104 }
 105
 106
 107 __PACKAGE__->register_method(
 108         api_name => 'open-ils.reporter.report.create',
 109         method => 'create_report');
 110 sub create_report {
 111         my( $self, $conn, $auth, $report ) = @_;
 112         my $e = new_rstore_editor(authtoken=>$auth, xact=>1);
 113         return $e->die_event unless $e->checkauth;
 114         return $e->die_event unless $e->allowed('RUN_REPORTS');
 115         $report->owner($e->requestor->id);
 116         my $tmpl = $e->create_reporter_report($report)
 117                 or return $e->die_event;
 118         $e->commit;
 119         return $tmpl;
 120 }
 121
 122
 123 __PACKAGE__->register_method(
 124         api_name => 'open-ils.reporter.template.retrieve',
 125         method => 'retrieve_template');
 126 sub retrieve_template {
 127         my( $self, $conn, $auth, $id ) = @_;
 128         my $e = new_rstore_editor(authtoken=>$auth);
 129         return $e->event unless $e->checkauth;
 130         return $e->event unless $e->allowed('RUN_REPORTS');
 131         my $t = $e->retrieve_reporter_template($id)
 132                 or return $e->event;
 133         return $t;
 134 }
 135
 136
 137 __PACKAGE__->register_method(
 138         api_name => 'open-ils.reporter.report.retrieve',
 139         method => 'retrieve_report');
 140 sub retrieve_report {
 141         my( $self, $conn, $auth, $id ) = @_;
 142         my $e = new_rstore_editor(authtoken=>$auth);
 143         return $e->event unless $e->checkauth;
 144         return $e->event unless $e->allowed('RUN_REPORTS');
 145         my $r = $e->retrieve_reporter_report($id)
 146                 or return $e->event;
 147         return $r;
 148 }
 149
 150
 151 __PACKAGE__->register_method(
 152         api_name => 'open-ils.reporter.template.update',
 153         method => 'update_template');
 154 sub update_template {
 155         my( $self, $conn, $auth, $tmpl ) = @_;
 156         my $e = new_rstore_editor(authtoken=>$auth, xact=>1);
 157         return $e->die_event unless $e->checkauth;
 158         return $e->die_event unless $e->allowed('RUN_REPORTS');
 159         my $t = $e->retrieve_reporter_template($tmpl->id)
 160                 or return $e->die_event;
 161         return 0 if $t->owner ne $e->requestor->id;
 162         $e->update_reporter_template($tmpl)
 163                 or return $e->die_event;
 164         $e->commit;
 165         return 1;
 166 }
 167
 168
 169 __PACKAGE__->register_method(
 170         api_name => 'open-ils.reporter.folder.update',
 171         method => 'update_folder');
 172 sub update_folder {
 173         my( $self, $conn, $auth, $type, $folder ) = @_;
 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 $meth = "retrieve_reporter_${type}_folder";
 178         my $f = $e->$meth($folder->id) or return $e->die_event;
 179         return 0 if $f->owner ne $e->requestor->id;
 180         $meth = "update_reporter_${type}_folder";
 181         $e->$meth($folder) or return $e->die_event;
 182         $e->commit;
 183         return 1;
 184 }
 185
 186
 187 __PACKAGE__->register_method(
 188         api_name => 'open-ils.reporter.folder.delete',
 189         method => 'delete_folder');
 190 sub delete_folder {
 191         my( $self, $conn, $auth, $type, $folderId ) = @_;
 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 $meth = "retrieve_reporter_${type}_folder";
 196         my $f = $e->$meth($folderId) or return $e->die_event;
 197         return 0 if $f->owner ne $e->requestor->id;
 198         $meth = "delete_reporter_${type}_folder";
 199         $e->$meth($f) or return $e->die_event;
 200         $e->commit;
 201         return 1;
 202 }
 203
 204
 205 __PACKAGE__->register_method(
 206         api_name => 'open-ils.reporter.template.delete',
 207         method => 'delete_template');
 208 sub delete_template {
 209         my( $self, $conn, $auth, $templateId ) = @_;
 210         my $e = new_rstore_editor(authtoken=>$auth, xact=>1);
 211         return $e->die_event unless $e->checkauth;
 212         return $e->die_event unless $e->allowed('RUN_REPORTS');
 213
 214         my $t = $e->retrieve_reporter_template($templateId)
 215                 or return $e->die_event;
 216         return 0 if $t->owner ne $e->requestor->id;
 217         $e->delete_reporter_template($t) or return $e->die_event;
 218         $e->commit;
 219         return 1;
 220 }
 221
 222 __PACKAGE__->register_method(
 223         api_name => 'open-ils.reporter.report.delete',
 224         method => 'delete_report');
 225 sub delete_report {
 226         my( $self, $conn, $auth, $reportId ) = @_;
 227         my $e = new_rstore_editor(authtoken=>$auth, xact=>1);
 228         return $e->die_event unless $e->checkauth;
 229         return $e->die_event unless $e->allowed('RUN_REPORTS');
 230
 231         my $t = $e->retrieve_reporter_report($reportId)
 232                 or return $e->die_event;
 233         return 0 if $t->owner ne $e->requestor->id;
 234         $e->delete_reporter_report($t) or return $e->die_event;
 235         $e->commit;
 236         return 1;
 237 }
 238
 239
 240 __PACKAGE__->register_method(
 241         api_name => 'open-ils.reporter.template_has_reports',
 242         method => 'has_reports');
 243 sub has_reports {
 244         my( $self, $conn, $auth, $templateId ) = @_;
 245         my $e = new_rstore_editor(authtoken=>$auth);
 246         return $e->die_event unless $e->checkauth;
 247         return $e->die_event unless $e->allowed('RUN_REPORTS');
 248         my $rpts = $e->search_reporter_report({template=>$templateId},{idlist=>1});
 249         return 1 if @$rpts;
 250         return 0;
 251 }
 252
 253
 254 __PACKAGE__->register_method(
 255         method => 'org_full_path',
 256         api_name => 'open-ils.reporter.org_unit.full_path');
 257
 258 sub org_full_path {
 259         my( $self, $conn, $orgid ) = @_;
 260         return $U->storagereq(
 261                 'open-ils.storage.actor.org_unit.full_path.atomic', $orgid );
 262 }
 263
 264
 265
 266
 267 __PACKAGE__->register_method(
 268         method => 'magic_fetch_all',
 269         api_name => 'open-ils.reporter.magic_fetch');
 270 sub magic_fetch_all {
 271         my( $self, $conn, $auth, $args ) = @_;
 272         my $e = new_editor(authtoken => $auth);
 273         return $e->event unless $e->checkauth;
 274         return $e->event unless $e->allowed('RUN_REPORTS');
 275
 276         my $hint = $$args{hint};
 277
 278         # Find the class the iplements the given hint
 279         my ($class) = grep {
 280                 $Fieldmapper::fieldmap->{$_}{hint} eq $hint } Fieldmapper->classes;
 281
 282         return undef unless $class->Selector;
 283
 284         $class =~ s/Fieldmapper:://og;
 285         $class =~ s/::/_/og;
 286         my $method = "retrieve_all_$class";
 287
 288         $logger->info("reporter.magic_fetch => $method");
 289
 290         return $e->$method();
 291 }
 292
 293
 294 1;