Open-ILS/src/support-scripts/generate_circ_notices.pl

   1 #!/usr/bin/perl
   2 # ---------------------------------------------------------------
   3 # Copyright (C) 2008  Georgia Public Library Service
   4 # Bill Erickson <erickson@esilibrary.com>
   5 #
   6 # This program is free software; you can redistribute it and/or
   7 # modify it under the terms of the GNU General Public License
   8 # as published by the Free Software Foundation; either version 2
   9 # of the License, or (at your option) any later version.
  10 #
  11 # This program is distributed in the hope that it will be useful,
  12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 # GNU General Public License for more details.
  15 #  ---------------------------------------------------------------
  16 use strict; use warnings;
  17 require 'oils_header.pl';
  18 use vars qw/$logger/;
  19 use DateTime;
  20 use Template;
  21 use Data::Dumper;
  22 use Email::Send;
  23 use Getopt::Long;
  24 use Unicode::Normalize;
  25 use DateTime::Format::ISO8601;
  26 use OpenSRF::Utils qw/:datetime/;
  27 use OpenSRF::Utils::JSON;
  28 use OpenSRF::Utils::SettingsClient;
  29 use OpenSRF::AppSession;
  30 use OpenILS::Const qw/:const/;
  31 use OpenILS::Application::AppUtils;
  32 use OpenILS::Const qw/:const/;
  33 my $U = 'OpenILS::Application::AppUtils';
  34
  35 my $settings = undef;
  36 my $e = OpenILS::Utils::CStoreEditor->new;
  37
  38 my @global_overdue_circs; # all circ collections stored here go into the final global XML file
  39
  40 # - set up default values
  41 my $opt_osrf_config = '/openils/conf/opensrf_core.xml';
  42 my $opt_send_email = 0;
  43 my $opt_gen_day_intervals = 0;
  44 my $opt_days_back = '';
  45 my $opt_gen_global_templates = 0;
  46 my $opt_show_help = 0;
  47 my $opt_append_global_email_fail;
  48 my $opt_notice_types = '';
  49 my $opt_use_email_outfile;
  50 my $opt_use_email_recipient;
  51
  52 GetOptions(
  53     'osrf_config=s' => \$opt_osrf_config,
  54     'send-email' => \$opt_send_email,
  55     'generate-day-intervals' => \$opt_gen_day_intervals,
  56     'generate-global-templates' => \$opt_gen_global_templates,
  57     'days-back=s' => \$opt_days_back,
  58     'append-global-email-fail' => \$opt_append_global_email_fail,
  59     'notice-types=s' => \$opt_notice_types,
  60     'use-email-outfile=s' => \$opt_use_email_outfile,
  61     'use-email-recipient=s' => \$opt_use_email_recipient,
  62     'help' => \$opt_show_help,
  63 );
  64
  65 help() and exit if $opt_show_help;
  66
  67 sub help {
  68     print <<HELP;
  69
  70 Evergreen Circulation Notice Generator
  71
  72     ---osrf_config <config_file>
  73
  74     --send-email
  75         If set, generate email notices
  76
  77     --use-email-outfile <file>
  78         Instead of sending emails, append each email (complete with headers) to this file
  79
  80     --use-email-recipient <user\@example.com>
  81         Send all email notices to this user instead of the patron.  This updates the
  82         email address on the user object attached to the circulations, so no
  83         change to the email templates is required.
  84
  85     --generate-day-intervals
  86         If set, notices which have a notify_interval of >= 1 day will be processed.
  87
  88     --generate-global-templates
  89         Collect all non-emailed notices into a global set and generate templates based on that set.
  90
  91     --append-global-email-fail
  92         If an attempt was made to send an email notice but it failed, the notice is appended
  93         to the global notice file set.  This will only have any bearing if --generate-global-templates
  94         is enabled.
  95
  96     --days-back <days_back_comma_separted>
  97         This is used to set the effective run date of the script.
  98         This is useful if you don't want to generate notices on certain days.  For example, if you don't
  99         generate notices on the weekend, you would run this script on weekdays and set --days-back to
 100         0,1,2 when it's run on Monday to capture any notices from Saturday and Sunday.
 101
 102     --notice-types <overdue,predue,...>
 103         Comma-separated list of notice types to generate for this run of the script
 104
 105     --help
 106         Print this help message
 107 HELP
 108 }
 109
 110
 111 sub main {
 112     osrf_connect($opt_osrf_config);
 113     $settings = OpenSRF::Utils::SettingsClient->new;
 114
 115     die "Please specify at least 1 type of notice to generate with --notice-types\n"
 116         unless $opt_notice_types;
 117
 118     unlink $opt_use_email_outfile if $opt_use_email_outfile;
 119
 120     my $sender_address = $settings->config_value(notifications => 'sender_address');
 121     my $od_sender_addr = $settings->config_value(notifications => overdue => 'sender_address') || $sender_address;
 122     my $pd_sender_addr = $settings->config_value(notifications => predue => 'sender_address') || $sender_address;
 123     my $overdue_notices = $settings->config_value(notifications => overdue => 'notice');
 124     my $predue_notices = $settings->config_value(notifications => predue => 'notice');
 125
 126     $overdue_notices = [$overdue_notices] unless ref $overdue_notices eq 'ARRAY';
 127     $predue_notices = [$predue_notices] unless ref $predue_notices eq 'ARRAY';
 128
 129     my @overdues = sort {
 130         OpenSRF::Utils->interval_to_seconds($a->{notify_interval}) <=>
 131         OpenSRF::Utils->interval_to_seconds($b->{notify_interval}) } @$overdue_notices;
 132
 133     my @predues = sort {
 134         OpenSRF::Utils->interval_to_seconds($a->{notify_interval}) <=>
 135         OpenSRF::Utils->interval_to_seconds($b->{notify_interval}) } @$predue_notices;
 136
 137     for my $db (($opt_days_back) ? split(',', $opt_days_back) : 0) {
 138         if($opt_notice_types =~ /overdue/) {
 139             generate_notice_set($_, 'overdue', $db) for @overdues;
 140         }
 141         if($opt_notice_types =~ /predue/) {
 142             generate_notice_set($_, 'predue', $db) for @predues;
 143         }
 144     }
 145
 146     generate_global_overdue_file() if $opt_gen_global_templates;
 147 }
 148
 149 sub generate_global_overdue_file {
 150     $logger->info("notice: processing ".scalar(@global_overdue_circs)." for global template");
 151     return unless @global_overdue_circs;
 152
 153     my $tt = Template->new({ABSOLUTE => 1});
 154
 155     $tt->process(
 156         $settings->config_value(notifications => overdue => 'combined_template'),
 157         {
 158             overdues => \@global_overdue_circs,
 159             get_bib_attr => \&get_bib_attr,
 160             parse_due_date => \&parse_due_date, # let the templates decide date format
 161             escape_xml => \&escape_xml,
 162         },
 163         \&global_overdue_output
 164     ) or $logger->error('notice: Template error '.$tt->error);
 165 }
 166
 167 sub global_overdue_output {
 168     print shift();
 169 }
 170
 171
 172 sub generate_notice_set {
 173     my($notice, $type, $days_back) = @_;
 174
 175     my $notify_interval = OpenSRF::Utils->interval_to_seconds($notice->{notify_interval});
 176     $notify_interval = -$notify_interval if $type eq 'overdue';
 177
 178     my ($start_date, $end_date) = make_date_range($notify_interval - $days_back * 86400);
 179
 180     $logger->info("notice: retrieving circs with due date in range $start_date -> $end_date");
 181
 182     my $QUERY = {
 183         select => {
 184             circ => ['id']
 185         },
 186         from => 'circ',
 187         where => {
 188             '+circ' => {
 189                 checkin_time => undef,
 190                 '-or' => [
 191                     {stop_fines => {'not in' => ["LOST","LONGOVERDUE","CLAIMSRETURNED"]}},
 192                     {stop_fines => undef}
 193                 ],
 194                                 due_date => {between => [$start_date, $end_date]},
 195             }
 196         }
 197     };
 198
 199     # if a circ duration is defined for this type of notice
 200     if(my $durs = $notice->{circ_duration_range}) {
 201         $QUERY->{where}->{'+circ'}->{duration} = {between => [$durs->{from}, $durs->{to}]};
 202     }
 203
 204     my $circs = $e->json_query($QUERY, {timeout => 18000, substream => 1});
 205     process_circs($notice, $type, map {$_->{id}} @$circs);
 206 }
 207
 208
 209 sub process_circs {
 210     my $notice = shift;
 211     my $type = shift;
 212     my @circs = @_;
 213
 214         return unless @circs;
 215
 216         $logger->info("notice: processing $type notices with notify interval ".
 217         $notice->{notify_interval}."  and ".scalar(@circs)." circs");
 218
 219         my $org;
 220         my $patron;
 221         my @current;
 222
 223         my $x = 0;
 224         for my $circ (@circs) {
 225                 $circ = $e->retrieve_action_circulation($circ);
 226
 227                 if( !defined $org or
 228                                 $circ->circ_lib != $org  or $circ->usr ne $patron ) {
 229                         $org = $circ->circ_lib;
 230                         $patron = $circ->usr;
 231                         generate_notice($notice, $type, @current) if @current;
 232                         @current = ();
 233                 }
 234
 235                 push(@current, $circ);
 236                 $x++;
 237         }
 238
 239         $logger->info("notice: processed $x circs");
 240         generate_notice($notice, $type, @current);
 241 }
 242
 243 my %ORG_CACHE;
 244
 245 sub generate_notice {
 246     my $notice = shift;
 247     my $type = shift;
 248     my @circs = @_;
 249     return unless @circs;
 250     my $circ_list = fetch_circ_data(@circs);
 251     my $tt = Template->new({ABSOLUTE => 1});
 252
 253     my $sender = $settings->config_value(
 254         notifications => $type => 'sender_address') ||
 255         $settings->config_value(notifications => 'sender_address');
 256
 257     # see if there is a configured bounce address for this org unit.
 258     # if so, use that as the sender
 259         if(my $set = $e->search_actor_org_unit_setting(
 260                         {name => 'org.bounced_emails', org_unit => $circ_list->[0]->circ_lib->id} )->[0]) {
 261                 my $bemail = OpenSRF::Utils::JSON->JSON2perl($set->value);
 262                 $sender = $bemail if $bemail;
 263         }
 264
 265
 266     my $context = {
 267         circ_list => $circ_list,
 268         get_bib_attr => \&get_bib_attr,
 269         parse_due_date => \&parse_due_date, # let the templates decide date format
 270         smtp_sender => $sender,
 271         notice => $notice,
 272     };
 273
 274     push(@global_overdue_circs, $context) if
 275         $type eq 'overdue' and $notice->{file_append} =~ /always/i;
 276
 277     if( ($opt_send_email or $opt_use_email_outfile) and $notice->{email_notify} and
 278             my $email = $circ_list->[0]->usr->email) {
 279
 280         if(my $tmpl = $notice->{email_template}) {
 281
 282             if($opt_use_email_outfile) { # append emails to output file
 283                 $tt->process($tmpl, $context, \&append_use_email_file)
 284                     or $logger->error('notice: Template error '.$tt->error);
 285
 286             } else {
 287                 $tt->process($tmpl, $context,
 288                     sub {
 289                         email_template_output($notice, $type, $context, $email, @_);
 290                     }
 291                 ) or $logger->error('notice: Template error '.$tt->error);
 292             }
 293         }
 294     } else {
 295         push(@global_overdue_circs, $context)
 296             if $type eq 'overdue' and $notice->{file_append} =~ /noemail/i;
 297     }
 298 }
 299
 300 sub append_use_email_file {
 301     my $output = shift;
 302     unless(open(F, ">>$opt_use_email_outfile")) {
 303         $logger->error("notice: unable to open --use-email-outfile $opt_use_email_outfile for writing: $@");
 304         return;
 305     }
 306     $logger->debug("notice: appending emails to outfile $opt_use_email_outfile");
 307     print F $output;
 308     close $opt_use_email_outfile;
 309 }
 310
 311 my $last_mvr;
 312 sub get_bib_attr {
 313     my $circ = shift;
 314     my $attr = shift;
 315     my $copy = $circ->target_copy;
 316     if($copy->call_number->id == OILS_PRECAT_CALL_NUMBER) {
 317         return $copy->dummy_title || '' if $attr eq 'title';
 318         return $copy->dummy_author || '' if $attr eq 'author';
 319     } else {
 320         $last_mvr = $U->record_to_mvr($copy->call_number->record)
 321             unless $last_mvr and $last_mvr->doc_id == $copy->call_number->record->id;
 322         return $last_mvr->title || '' if $attr eq 'title';
 323         return $last_mvr->author || '' if $attr eq 'author';
 324     }
 325 }
 326
 327 # provides a date that Template::Plugin::Date can parse
 328 sub parse_due_date {
 329     my $circ = shift;
 330     my $due = DateTime::Format::ISO8601->new->parse_datetime(clense_ISO8601($circ->due_date));
 331     return sprintf(
 332         "%0.2d:%0.2d:%0.2d %0.2d-%0.2d-%0.4d",
 333         $due->hour,
 334         $due->minute,
 335         $due->second,
 336         $due->day,
 337         $due->month,
 338         $due->year
 339     );
 340 }
 341
 342 sub escape_xml {
 343     my $str = shift;
 344     $str =~ s/&/&amp;/sog;
 345     $str =~ s/</&lt;/sog;
 346     $str =~ s/>/&gt;/sog;
 347     return $str;
 348 }
 349
 350
 351 sub email_template_output {
 352     my $notice = shift;
 353     my $type = shift;
 354     my $context = shift;
 355     my $email = shift;
 356     my $msg = shift;
 357
 358         my $sender = Email::Send->new({mailer => 'SMTP'});
 359     my $smtp_server = $settings->config_value(notifications => 'smtp_server');
 360     $logger->debug("notice: smtp server is $smtp_server");
 361         $sender->mailer_args([Host => $smtp_server]);
 362         my $stat = $sender->send($msg);
 363
 364         if( $stat and $stat->type eq 'success' ) {
 365                 $logger->info("notice: successfully sent $type email to $email");
 366         } else {
 367                 $logger->warn("notice: unable to send $type email to $email: ".Dumper($stat));
 368         # if we were unable to send the email, add this notice set to the global notify set
 369         push(@global_overdue_circs, $context)
 370             if $opt_append_global_email_fail and
 371                 $type eq 'overdue' and $notice->{file_append} =~ /noemail/i;
 372         }
 373 }
 374
 375 sub fetch_circ_data {
 376     my @circs = @_;
 377
 378         my $circ_lib_id = $circs[0]->circ_lib;
 379         my $usr_id = $circs[0]->usr;
 380         $logger->debug("notice: printing user:$usr_id circ_lib:$circ_lib_id");
 381
 382     my $usr = $e->retrieve_actor_user([
 383         $usr_id,
 384         {   flesh => 1,
 385             flesh_fields => {
 386                 au => [qw/card billing_address mailing_address/]
 387             }
 388         }
 389     ]);
 390
 391     # if the caller has defined a test email recipient, override
 392     # the user's email if they have one.
 393     $usr->email($opt_use_email_recipient) if $usr->email and $opt_use_email_recipient;
 394
 395     my $circ_lib = $ORG_CACHE{$circ_lib_id} ||
 396         $e->retrieve_actor_org_unit([
 397             $circ_lib_id,
 398             {   flesh => 1,
 399                 flesh_fields => {
 400                     aou => [qw/billing_address mailing_address/],
 401                 }
 402             }
 403         ]);
 404     $ORG_CACHE{$circ_lib_id} = $circ_lib;
 405
 406     my $circ_objs = $e->search_action_circulation([
 407         {id => [map {$_->id} @circs]},
 408         {   flesh => 3,
 409             flesh_fields => {
 410                 circ => [q/target_copy/],
 411                 acp => ['call_number'],
 412                 acn => ['record'],
 413             }
 414         }
 415     ]);
 416
 417     $_->circ_lib($circ_lib) for @$circ_objs;
 418     $_->usr($usr) for @$circ_objs;
 419
 420     return $circ_objs
 421 }
 422
 423
 424 sub make_date_range {
 425         my $offset = shift;
 426     #my $is_day_precision = shift; # window?
 427
 428         my $epoch = CORE::time + $offset;
 429         my $date = DateTime->from_epoch(epoch => $epoch, time_zone => 'local');
 430
 431         $date->set_hour(0);
 432         $date->set_minute(0);
 433         $date->set_second(0);
 434         my $start = "$date";
 435
 436         $date->set_hour(23);
 437         $date->set_minute(59);
 438         $date->set_second(59);
 439
 440         return ($start, "$date");
 441 }
 442
 443 main();