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