Open-ILS/src/perlmods/lib/OpenILS/Application/Circ/HoldNotify.pm

   1 # ---------------------------------------------------------------
   2 # Copyright (C) 2005  Georgia Public Library Service
   3 # Bill Erickson <billserickson@gmail.com>
   4
   5 # This program is free software; you can redistribute it and/or
   6 # modify it under the terms of the GNU General Public License
   7 # as published by the Free Software Foundation; either version 2
   8 # of the License, or (at your option) any later version.
   9
  10 # This program is distributed in the hope that it will be useful,
  11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 # GNU General Public License for more details.
  14 # ---------------------------------------------------------------
  15
  16
  17 package OpenILS::Application::Circ::HoldNotify;
  18 use base qw/OpenILS::Application/;
  19 use strict; use warnings;
  20 use OpenSRF::EX qw(:try);
  21 use vars q/$AUTOLOAD/;
  22 use OpenILS::Event;
  23 use OpenSRF::Utils::JSON;
  24 use OpenSRF::Utils::Logger qw(:logger);
  25 use OpenILS::Utils::CStoreEditor q/:funcs/;
  26 use OpenSRF::Utils::SettingsClient;
  27 use OpenILS::Application::AppUtils;
  28 use OpenILS::Const qw/:const/;
  29 use OpenILS::Utils::Fieldmapper;
  30 use Email::Send;
  31 use Data::Dumper;
  32 use OpenSRF::EX qw/:try/;
  33 my $U = 'OpenILS::Application::AppUtils';
  34
  35 use open ':utf8';
  36
  37
  38 __PACKAGE__->register_method(
  39     method => 'send_email_notify_pub',
  40     api_name => 'open-ils.circ.send_hold_notify.email',
  41 );
  42
  43
  44 sub send_email_notify_pub {
  45     my( $self, $conn, $auth, $hold_id ) = @_;
  46     my $e = new_editor(authtoken => $auth);
  47     return $e->event unless $e->checkauth;
  48     return $e->event unless $e->allowed('CREATE_HOLD_NOTIFICATION');
  49     my $notifier = __PACKAGE__->new(requestor => $e->requestor, hold_id => $hold_id);
  50     return $notifier->event if $notifier->event;
  51     my $stat = $notifier->send_email_notify;
  52 #   $e->commit if $stat == '1';
  53     return $stat;
  54 }
  55
  56
  57
  58
  59
  60 # ---------------------------------------------------------------
  61 # Define the notifier object
  62 # ---------------------------------------------------------------
  63
  64 my @AUTOLOAD_FIELDS = qw/
  65     hold
  66     copy
  67     volume
  68     title
  69     editor
  70     patron
  71     event
  72     pickup_lib
  73     smtp_server
  74     settings_client
  75 /;
  76
  77 sub AUTOLOAD {
  78     my $self = shift;
  79     my $type = ref($self) or die "$self is not an object";
  80     my $data = shift;
  81     my $name = $AUTOLOAD;
  82     $name =~ s/.*://o;
  83
  84     unless (grep { $_ eq $name } @AUTOLOAD_FIELDS) {
  85         $logger->error("hold_notify: $type: invalid autoload field: $name");
  86         die "$type: invalid autoload field: $name\n"
  87     }
  88
  89     {
  90         no strict 'refs';
  91         *{"${type}::${name}"} = sub {
  92             my $s = shift;
  93             my $v = shift;
  94             $s->{$name} = $v if defined $v;
  95             return $s->{$name};
  96         }
  97     }
  98     return $self->$name($data);
  99 }
 100
 101
 102 sub new {
 103     my( $class, %args ) = @_;
 104     $class = ref($class) || $class;
 105     my $self = bless( {}, $class );
 106     $self->editor( new_editor( xact => 1, requestor => $args{requestor} ));
 107     $logger->debug("circulator: creating new hold-notifier with requestor ".
 108         $self->editor->requestor->id);
 109     $self->fetch_data($args{hold_id});
 110     return $self;
 111 }
 112
 113 sub send_email_notify {
 114     my $self = shift;
 115
 116     my $sc = OpenSRF::Utils::SettingsClient->new;
 117     my $setting = $sc->config_value(
 118         qw/ apps open-ils.circ app_settings notify_hold email / );
 119
 120     $logger->debug("hold_notify: email enabled setting = $setting");
 121
 122     if( !$setting or $setting ne 'true' ) {
 123       $self->editor->rollback;
 124         $logger->info("hold_notify: not sending hold notify - email notifications disabled");
 125         return 0;
 126     }
 127
 128     unless ($U->is_true($self->hold->email_notify)) {
 129       $self->editor->rollback;
 130         $logger->info("hold_notify: not sending hold notification because email_notify is false");
 131         return 0;
 132     }
 133
 134     unless( $self->patron->email and $self->patron->email =~ /.+\@.+/ ) { # see if it's remotely email-esque
 135       $self->editor->rollback;
 136        return OpenILS::Event->new('PATRON_NO_EMAIL_ADDRESS');
 137    }
 138
 139     $logger->info("hold_notify: attempting email notify on hold ".$self->hold->id);
 140
 141     my $sclient = OpenSRF::Utils::SettingsClient->new;
 142     $self->settings_client($sclient);
 143     my $template = $sclient->config_value('email_notify', 'template');
 144     my $str = $self->flesh_template($self->load_template($template));
 145
 146     unless( $str ) {
 147       $self->editor->rollback;
 148         $logger->error("hold_notify: No email notify template found - cannot notify");
 149         return 0;
 150     }
 151
 152    my $reqr = $self->editor->requestor;
 153    $self->editor->rollback; # we're done with this transaction
 154
 155     return 0 unless $self->send_email($str);
 156
 157     # ------------------------------------------------------------------
 158     # If the hold email takes too long to send, the existing editor
 159     # transaction may have timed out.  Create a one-off editor to write
 160     # the notification to the DB.
 161     # ------------------------------------------------------------------
 162     my $we = new_editor(xact=>1, requestor=>$reqr);
 163
 164     my $notify = Fieldmapper::action::hold_notification->new;
 165     $notify->hold($self->hold->id);
 166     $notify->notify_staff($we->requestor->id);
 167     $notify->notify_time('now');
 168     $notify->method('email');
 169
 170     $we->create_action_hold_notification($notify)
 171         or return $we->die_event;
 172     $we->commit;
 173
 174     return 1;
 175 }
 176
 177 sub send_email {
 178     my( $self, $text ) = @_;
 179
 180    # !!! $self->editor xact has been rolled back before we get here
 181
 182     my $smtp = $self->settings_client->config_value('email_notify', 'smtp_server');
 183
 184     $logger->info("hold_notify: sending email notice to ".
 185         $self->patron->email." with SMTP server $smtp");
 186
 187     my $sender = Email::Send->new({mailer => 'SMTP'});
 188     $sender->mailer_args([Host => $smtp]);
 189
 190     my $stat;
 191     my $err;
 192
 193     try {
 194         $stat = $sender->send($text);
 195     } catch Error with {
 196         $err = $stat = shift;
 197         $logger->error("hold_notify: Email notify failed with error: $err");
 198     };
 199
 200     if( !$err and $stat and $stat->type eq 'success' ) {
 201         $logger->info("hold_notify: successfully sent hold notification");
 202         return 1;
 203     } else {
 204         $logger->warn("hold_notify: unable to send hold notification: ".Dumper($stat));
 205         return 0;
 206     }
 207
 208     return undef;
 209 }
 210
 211
 212 # -------------------------------------------------------------------------
 213 # Fetches all of the hold-related data
 214 # -------------------------------------------------------------------------
 215 sub fetch_data {
 216     my $self        = shift;
 217     my $holdid  = shift;
 218     my $e           = $self->editor;
 219
 220     $logger->debug("circulator: fetching hold notify data");
 221
 222     $self->hold($e->retrieve_action_hold_request($holdid)) or return $self->event($e->event);
 223     $self->copy($e->retrieve_asset_copy($self->hold->current_copy)) or return $self->event($e->event);
 224     $self->volume($e->retrieve_asset_call_number($self->copy->call_number)) or return $self->event($e->event);
 225     $self->title($e->retrieve_biblio_record_entry($self->volume->record)) or return $self->event($e->event);
 226     $self->patron($e->retrieve_actor_user($self->hold->usr)) or return $self->event($e->event);
 227     $self->pickup_lib($e->retrieve_actor_org_unit($self->hold->pickup_lib)) or return $self->event($e->event);
 228 }
 229
 230
 231 sub extract_data {
 232     my $self = shift;
 233     my $e = $self->editor;
 234
 235     my $patron = $self->patron;
 236     my $o_name = $self->pickup_lib->name;
 237     my $p_name = $patron->first_given_name .' '.$patron->family_name;
 238
 239     # try to find a suitable address for the patron
 240     my $p_addr;
 241     my $p_addrs;
 242     unless( $p_addr =
 243             $e->retrieve_actor_user_address($patron->billing_address)) {
 244         unless( $p_addr =
 245                 $e->retrieve_actor_user_address($patron->mailing_address)) {
 246             $logger->warn("hold_notify: No address for user ".$patron->id);
 247             $p_addrs = "";
 248         }
 249     }
 250
 251     unless( defined $p_addrs ) {
 252         $p_addrs =
 253             $p_addr->street1." ".
 254             $p_addr->street2." ".
 255             $p_addr->city." ".
 256             $p_addr->state." ".
 257             $p_addr->post_code;
 258     }
 259
 260     my $l_addr = $e->retrieve_actor_org_address($self->pickup_lib->holds_address);
 261     my $l_addrs = (!$l_addr) ? "" :
 262             $l_addr->street1." ".
 263             $l_addr->street2." ".
 264             $l_addr->city." ".
 265             $l_addr->state." ".
 266             $l_addr->post_code;
 267
 268     my $title;
 269     my $author;
 270
 271     if( $self->title->id == OILS_PRECAT_RECORD ) {
 272         $title = ($self->copy->dummy_title) ?
 273             $self->copy->dummy_title : "";
 274         $author = ($self->copy->dummy_author) ?
 275             $self->copy->dummy_author : "";
 276     } else {
 277         my $mods    = $U->record_to_mvr($self->title);
 278         $title  = ($mods->title) ? $mods->title : "";
 279         $author = ($mods->author) ? $mods->author : "";
 280     }
 281
 282
 283     return {
 284         patron_email => $self->patron->email,
 285         pickup_lib_name => $o_name,
 286         pickup_lib_addr => $l_addrs,
 287         patron_name => $p_name,
 288         patron_addr => $p_addrs,
 289         title => $title,
 290         author => $author,
 291         call_number => $self->volume->label,
 292         copy_barcode => $self->copy->barcode,
 293         copy_number => $self->copy->copy_number,
 294     };
 295 }
 296
 297
 298
 299 sub load_template {
 300     my $self = shift;
 301     my $template = shift;
 302
 303     unless( open(F, $template) ) {
 304         $logger->error("hold_notify: Unable to open hold notification template file: $template");
 305         return undef;
 306     }
 307
 308     # load the template, strip comments
 309     my @lines = <F>;
 310     close(F);
 311
 312     my $str = '';
 313     for(@lines) {
 314     chomp $_;
 315     next if $_ =~ /^\s*\#/o;
 316     $_ =~ s/\#.*//og;
 317     $str .= "$_\n";
 318     }
 319
 320     return $str;
 321 }
 322
 323 sub flesh_template {
 324     my( $self, $str ) = @_;
 325     return undef unless $str;
 326
 327     my @time    = CORE::localtime();
 328     my $day         = $time[3];
 329     my $month   = $time[4] + 1;
 330     my $year    = $time[5] + 1900;
 331
 332     my $data = $self->extract_data;
 333
 334     my $email       = $$data{patron_email};
 335     my $p_name      = $$data{patron_name};
 336     my $p_addr      = $$data{patron_addr};
 337     my $o_name      = $$data{pickup_lib_name};
 338     my $o_addr      = $$data{pickup_lib_addr};
 339     my $title       = $$data{title};
 340     my $author      = $$data{author};
 341     my $cn          = $$data{call_number};
 342     my $barcode     = $$data{copy_barcode};
 343     my $copy_number = $$data{copy_number};
 344
 345     my $sender = $self->settings_client->config_value('email_notify', 'sender_address');
 346     my $reply_to = $self->pickup_lib->email;
 347     $reply_to ||= $sender;
 348
 349    # if they have an org setting for bounced emails, use that as the sender address
 350    if( my $set = $self->editor->search_actor_org_unit_setting(
 351          {  name => OILS_SETTING_ORG_BOUNCED_EMAIL,
 352             org_unit => $self->pickup_lib->id } )->[0] ) {
 353
 354       my $bemail = OpenSRF::Utils::JSON->JSON2perl($set->value);
 355       $sender = $bemail if $bemail;
 356    }
 357
 358    $str =~ s/\${EMAIL_SENDER}/$sender/;
 359    $str =~ s/\${EMAIL_RECIPIENT}/$email/;
 360    $str =~ s/\${EMAIL_REPLY_TO}/$reply_to/;
 361    $str =~ s/\${EMAIL_HEADERS}//;
 362
 363    $str =~ s/\${DATE}/$year-$month-$day/;
 364    $str =~ s/\${LIBRARY}/$o_name/;
 365    $str =~ s/\${LIBRARY_ADDRESS}/$o_addr/;
 366    $str =~ s/\${PATRON_NAME}/$p_name/;
 367    $str =~ s/\${PATRON_ADDRESS}/$p_addr/;
 368
 369    $str =~ s/\${TITLE}/$title/;
 370    $str =~ s/\${AUTHOR}/$author/;
 371    $str =~ s/\${CALL_NUMBER}/$cn/;
 372    $str =~ s/\${COPY_BARCODE}/$barcode/;
 373    $str =~ s/\${COPY_NUMBER}/$copy_number/;
 374
 375     return $str;
 376 }
 377
 378
 379
 380
 381
 382 1;