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     binmode STDOUT, ":utf8";
 169     print shift();
 170 }
 171
 172
 173 sub generate_notice_set {
 174     my($notice, $type, $days_back) = @_;
 175
 176     my $notify_interval = OpenSRF::Utils->interval_to_seconds($notice->{notify_interval});
 177     $notify_interval = -$notify_interval if $type eq 'overdue';
 178
 179     my ($start_date, $end_date) = make_date_range($notify_interval - $days_back * 86400);
 180
 181     $logger->info("notice: retrieving circs with due date in range $start_date -> $end_date");
 182
 183     my $QUERY = {
 184         select => {
 185             circ => ['id']
 186         },
 187         from => 'circ',
 188         where => {
 189             '+circ' => {
 190                 checkin_time => undef,
 191                 '-or' => [
 192                     {stop_fines => {'not in' => ["LOST","LONGOVERDUE","CLAIMSRETURNED"]}},
 193                     {stop_fines => undef}
 194                 ],
 195                                 due_date => {between => [$start_date, $end_date]}
 196             }
 197         },
 198         order_by => {circ => ['usr', 'circ_lib']}
 199     };
 200
 201     # if a circ duration is defined for this type of notice
 202     if(my $durs = $notice->{circ_duration_range}) {
 203         $QUERY->{where}->{'+circ'}->{duration} = {between => [$durs->{from}, $durs->{to}]};
 204     }
 205
 206     my $circs = $e->json_query($QUERY, {timeout => 18000, substream => 1});
 207     process_circs($notice, $type, map {$_->{id}} @$circs);
 208 }
 209
 210
 211 sub process_circs {
 212     my $notice = shift;
 213     my $type = shift;
 214     my @circs = @_;
 215
 216         return unless @circs;
 217
 218         $logger->info("notice: processing $type notices with notify interval ".
 219         $notice->{notify_interval}."  and ".scalar(@circs)." circs");
 220
 221         my $org;
 222         my $patron;
 223         my @current;
 224
 225         my $x = 0;
 226         for my $circ (@circs) {
 227                 $circ = $e->retrieve_action_circulation($circ);
 228
 229                 if( !defined $org or
 230                                 $circ->circ_lib != $org  or $circ->usr ne $patron ) {
 231                         $org = $circ->circ_lib;
 232                         $patron = $circ->usr;
 233                         generate_notice($notice, $type, @current) if @current;
 234                         @current = ();
 235                 }
 236
 237                 push(@current, $circ);
 238                 $x++;
 239         }
 240
 241         $logger->info("notice: processed $x circs");
 242         generate_notice($notice, $type, @current);
 243 }
 244
 245 my %ORG_CACHE;
 246 my %ORG_FROM_CACHE;
 247
 248 sub get_from_addr {
 249     my $type = shift;
 250     my $org_id = shift;
 251
 252     return $ORG_FROM_CACHE{$org_id} if $ORG_FROM_CACHE{$org_id};
 253
 254     if(my $bemail = $U->ou_ancestor_setting_value($org_id, 'org.bounced_emails', $e)) {
 255                 return $ORG_FROM_CACHE{$org_id} = $bemail;
 256         }
 257
 258     return $ORG_FROM_CACHE{$org_id} =
 259         $settings->config_value(notifications => $type => 'sender_address') ||
 260         $settings->config_value(notifications => 'sender_address');
 261 }
 262
 263 sub generate_notice {
 264     my $notice = shift;
 265     my $type = shift;
 266     my @circs = @_;
 267     return unless @circs;
 268     my $circ_list = fetch_circ_data(@circs);
 269     return unless @$circ_list;
 270     my $tt = Template->new({ABSOLUTE => 1});
 271
 272     # see if there is a configured bounce address for this org unit.
 273     # if so, use that as the sender
 274     my $org_id = $circ_list->[0]->circ_lib->id;
 275     my $sender = get_from_addr($type, $org_id);
 276
 277     my $context = {
 278         circ_list => $circ_list,
 279         get_bib_attr => \&get_bib_attr,
 280         parse_due_date => \&parse_due_date, # let the templates decide date format
 281         smtp_sender => $sender,
 282         notice => $notice,
 283     };
 284
 285     push(@global_overdue_circs, $context) if
 286         $type eq 'overdue' and $notice->{file_append} =~ /always/i;
 287
 288     if( ($opt_send_email or $opt_use_email_outfile) and
 289             $notice->{email_notify} and
 290             my $email = $circ_list->[0]->usr->email) {
 291
 292         if(my $tmpl = $notice->{email_template}) {
 293             $tt->process($tmpl, $context,
 294                 sub {
 295                     handle_email_template_output($notice, $type, $context, $email, @_);
 296                 }
 297             ) or $logger->error('notice: Template error '.$tt->error);
 298         }
 299     } else {
 300         push(@global_overdue_circs, $context)
 301             if $type eq 'overdue' and $notice->{file_append} =~ /noemail/i;
 302     }
 303 }
 304
 305 my $last_mvr;
 306 sub get_bib_attr {
 307     my $circ = shift;
 308     my $attr = shift;
 309     my $copy = $circ->target_copy;
 310     if($copy->call_number->id == OILS_PRECAT_CALL_NUMBER) {
 311         return $copy->dummy_title || '' if $attr eq 'title';
 312         return $copy->dummy_author || '' if $attr eq 'author';
 313     } else {
 314         $last_mvr = $U->record_to_mvr($copy->call_number->record)
 315             unless $last_mvr and $last_mvr->doc_id == $copy->call_number->record->id;
 316         return $last_mvr->title || '' if $attr eq 'title';
 317         return $last_mvr->author || '' if $attr eq 'author';
 318     }
 319 }
 320
 321 # provides a date that Template::Plugin::Date can parse
 322 sub parse_due_date {
 323     my $circ = shift;
 324     my $due = DateTime::Format::ISO8601->new->parse_datetime(clense_ISO8601($circ->due_date));
 325     return sprintf(
 326         "%0.2d:%0.2d:%0.2d %0.2d-%0.2d-%0.4d",
 327         $due->hour,
 328         $due->minute,
 329         $due->second,
 330         $due->day,
 331         $due->month,
 332         $due->year
 333     );
 334 }
 335
 336 sub escape_xml {
 337     my $str = shift;
 338     $str =~ s/&/&amp;/sog;
 339     $str =~ s/</&lt;/sog;
 340     $str =~ s/>/&gt;/sog;
 341     return $str;
 342 }
 343
 344
 345 sub handle_email_template_output {
 346     my $notice = shift;
 347     my $type = shift;
 348     my $context = shift;
 349     my $email = shift;
 350     my $msg = shift;
 351
 352     if($opt_use_email_outfile) {
 353         if(open(F, ">>$opt_use_email_outfile")) {
 354             binmode F, ":utf8";
 355             $logger->debug("notice: appending emails to outfile $opt_use_email_outfile");
 356             print F $msg;
 357             close F;
 358         } else {
 359             $logger->error("notice: unable to open --use-email-outfile $opt_use_email_outfile for writing: $@");
 360         }
 361     }
 362
 363
 364     if($opt_send_email) {
 365             my $sender = Email::Send->new({mailer => 'SMTP'});
 366         my $smtp_server = $settings->config_value(notifications => 'smtp_server');
 367         $logger->debug("notice: smtp server is $smtp_server");
 368             $sender->mailer_args([Host => $smtp_server]);
 369             my $stat = $sender->send($msg);
 370
 371             if( $stat and $stat->type eq 'success' ) {
 372                     $logger->info("notice: successfully sent $type email to $email");
 373             } else {
 374                     $logger->warn("notice: unable to send $type email to $email: ".Dumper($stat));
 375             # if we were unable to send the email, add this notice set to the global notify set
 376             push(@global_overdue_circs, $context)
 377                 if $opt_append_global_email_fail and
 378                     $type eq 'overdue' and $notice->{file_append} =~ /noemail/i;
 379             }
 380     }
 381 }
 382
 383 sub fetch_circ_data {
 384     my @circs = @_;
 385
 386         my $circ_lib_id = $circs[0]->circ_lib;
 387         my $usr_id = $circs[0]->usr;
 388         $logger->debug("notice: printing user:$usr_id circ_lib:$circ_lib_id");
 389
 390     my $usr = $e->retrieve_actor_user([
 391         $usr_id,
 392         {   flesh => 1,
 393             flesh_fields => {
 394                 au => [qw/card billing_address mailing_address/]
 395             }
 396         }
 397     ]);
 398
 399     # if the caller has defined a test email recipient, override
 400     # the user's email if they have one.
 401     $usr->email($opt_use_email_recipient) if $usr->email and $opt_use_email_recipient;
 402
 403     my $circ_lib = $ORG_CACHE{$circ_lib_id} ||
 404         $e->retrieve_actor_org_unit([
 405             $circ_lib_id,
 406             {   flesh => 1,
 407                 flesh_fields => {
 408                     aou => [qw/billing_address mailing_address/],
 409                 }
 410             }
 411         ]);
 412     $ORG_CACHE{$circ_lib_id} = $circ_lib;
 413
 414     my $circ_ids = [map {$_->id} @circs];
 415
 416     my $circ_objs = $e->search_action_circulation([
 417         {id => $circ_ids},
 418         {   flesh => 3,
 419             flesh_fields => {
 420                 circ => [q/target_copy/],
 421                 acp => ['call_number'],
 422                 acn => ['record'],
 423             }
 424         }
 425     ], {substream => 1});
 426
 427     $logger->error("notice: error retrieving circ objects @$circ_ids") unless @$circ_ids;
 428
 429     $_->circ_lib($circ_lib) for @$circ_objs;
 430     $_->usr($usr) for @$circ_objs;
 431
 432     return $circ_objs
 433 }
 434
 435
 436 sub make_date_range {
 437         my $offset = shift;
 438     #my $is_day_precision = shift; # window?
 439
 440         my $epoch = CORE::time + $offset;
 441         my $date = DateTime->from_epoch(epoch => $epoch, time_zone => 'local');
 442
 443         $date->set_hour(0);
 444         $date->set_minute(0);
 445         $date->set_second(0);
 446         my $start = "$date";
 447
 448         $date->set_hour(23);
 449         $date->set_minute(59);
 450         $date->set_second(59);
 451
 452         return ($start, "$date");
 453 }
 454
 455 main();