LP#850160 - Event Def Environment Fleshing Might Have Issue
[working/Evergreen.git] / Open-ILS / src / perlmods / lib / OpenILS / Application / Trigger / Event.pm
1 package OpenILS::Application::Trigger::Event;
2 use strict; use warnings;
3 use OpenSRF::EX qw/:try/;
4 use OpenSRF::Utils::JSON;
5 use OpenSRF::Utils::Logger qw/$logger/;
6 use OpenILS::Utils::Fieldmapper;
7 use OpenILS::Utils::CStoreEditor q/:funcs/;
8 use OpenILS::Application::Trigger::ModRunner;
9 use Safe;
10
11 my $log = 'OpenSRF::Utils::Logger';
12
13 sub invalidate {
14     my $class = shift;
15     my @events = @_;
16
17     # if called as an instance method
18     unshift(@events,$class) if ref($class);
19
20     my $e = new_editor();
21     $e->xact_begin;
22
23     map {
24         $_->editor($e);
25         $_->standalone(0);
26         $_->update_state('invalid');
27     } @events;
28
29     $e->commit;
30
31     return @events;
32 }
33
34 sub new {
35     my $class = shift;
36     my $id = shift;
37     my $editor = shift;
38     my $nochanges = shift; # no guarantees, yet...
39     $class = ref($class) || $class;
40
41     my $standalone = $editor ? 0 : 1;
42     $editor ||= new_editor();
43
44     if (ref($id) && ref($id) eq $class) {
45         $id->environment->{EventProcessor} = $id
46              if ($id->environment->{complete}); # in case it came over an opensrf tube
47         $id->editor( $editor );
48         $id->standalone( $standalone );
49         return $id;
50     }
51
52     my $self = bless { id => $id, editor => $editor, standalone => $standalone, nochanges => $nochanges } => $class;
53
54     return $self->init()
55 }
56
57 sub init {
58     my $self = shift;
59     my $id = shift;
60
61     return $self if ($self->event);
62
63     $self->id( $id ); 
64     $self->environment( {} ); 
65
66     if (!$self->id) {
67         $log->error("No Event ID provided");
68         die "No Event ID provided";
69     }
70
71     return $self if (!$self->id);
72
73     if ($self->standalone) {
74         $self->editor->xact_begin || return undef;
75     }
76
77     $self->event(
78         $self->editor->retrieve_action_trigger_event([
79             $self->id, {
80                 flesh => 2,
81                 flesh_fields => {
82                     atev    => [ qw/event_def/ ],
83                     atevdef => [ qw/hook env params/ ]
84                 }
85             }
86         ])
87     );
88
89     if ($self->standalone) {
90         $self->editor->xact_rollback || return undef;
91     }
92
93     $self->user_data(OpenSRF::Utils::JSON->JSON2perl( $self->event->user_data ))
94         if (defined( $self->event->user_data ));
95
96     if ($self->event->state eq 'valid') {
97         $self->valid(1);
98     } elsif ($self->event->state eq 'invalid') {
99         $self->valid(0);
100     } elsif ($self->event->state eq 'reacting') {
101         $self->valid(1);
102     } elsif ($self->event->state eq 'reacted') {
103         $self->valid(1);
104         $self->reacted(1);
105     } elsif ($self->event->state eq 'cleaning') {
106         $self->valid(1);
107         $self->reacted(1);
108     } elsif ($self->event->state eq 'complete') {
109         $self->valid(1);
110         $self->reacted(1);
111         $self->cleanedup(1);
112     } elsif ($self->event->state eq 'error') {
113         $self->valid(0);
114         $self->reacted(0);
115         $self->cleanedup(0);
116     }
117
118     unless ($self->nochanges) {
119         $self->update_state('found') || die 'Unable to update event state';
120     }
121
122     my $class = $self->_fm_class_by_hint( $self->event->event_def->hook->core_type );
123     
124     my $meth = "retrieve_" . $class;
125     $meth =~ s/Fieldmapper:://;
126     $meth =~ s/::/_/;
127     
128     if ($self->standalone) {
129         $self->editor->xact_begin || return undef;
130     }
131
132     $self->target( $self->editor->$meth( $self->event->target ) );
133
134     if ($self->standalone) {
135         $self->editor->xact_rollback || return undef;
136     }
137
138     unless ($self->target) {
139         $self->update_state('invalid') unless $self->nochanges;
140         $self->valid(0);
141     }
142
143     return $self;
144 }
145
146 sub cleanup {
147     my $self = shift;
148     my $env = shift || $self->environment;
149
150     return $self if (defined $self->cleanedup);
151
152     if (defined $self->reacted) {
153         $self->update_state( 'cleaning') || die 'Unable to update event state';
154         try {
155             my $cleanup = $self->reacted ? $self->event->event_def->cleanup_success : $self->event->event_def->cleanup_failure;
156             if($cleanup) {
157                 $self->cleanedup(
158                     OpenILS::Application::Trigger::ModRunner::Cleanup
159                         ->new( $cleanup, $env)
160                         ->run
161                         ->final_result
162                 );
163             } else {
164                 $self->cleanedup(1);
165             }
166         } otherwise {
167             $log->error("Event cleanup failed with ". shift() );
168             $self->update_state( 'error' ) || die 'Unable to update event state';
169         };
170
171         if ($self->cleanedup) {
172             $self->update_state( 'complete' ) || die 'Unable to update event state';
173         } else {
174             $self->update_state( 'error' ) || die 'Unable to update event state';
175         }
176
177     } else {
178         $self->{cleanedup} = undef;
179     }
180     return $self;
181 }
182
183 sub react {
184     my $self = shift;
185     my $env = shift || $self->environment;
186
187     return $self if (defined $self->reacted);
188
189     if ($self->valid) {
190         if ($self->event->event_def->group_field) { # can't react individually to a grouped definition
191             $self->{reacted} = undef;
192         } else {
193             $self->update_state( 'reacting') || die 'Unable to update event state';
194             try {
195                 my $reactor = OpenILS::Application::Trigger::ModRunner::Reactor->new(
196                     $self->event->event_def->reactor,
197                     $env
198                 );
199
200                 $self->reacted( $reactor->run->final_result);
201
202                 if ($env->{usr_message}{usr} && $env->{usr_message}{template}) {
203                     my $message_template_output =
204                         $reactor->pass('ProcessMessage')->run->final_result;
205
206                     if ($message_template_output) {
207                         my $usr_message = Fieldmapper::actor::usr_message->new;
208                         $usr_message->title( $env->{usr_message}{title} || $self->event->event_def->name );
209                         $usr_message->message( $message_template_output );
210                         $usr_message->usr( $env->{usr_message}{usr}->id );
211                         $usr_message->sending_lib( $env->{usr_message}{sending_lib}->id );
212
213                         if ($self->editor->xact_begin) {
214                             if ($self->editor->create_actor_usr_message( $usr_message )) {
215                                 $self->editor->xact_commit;
216                             } else {
217                                 $self->editor->xact_rollback;
218                             }
219                         }
220                     }
221                 }
222
223             } otherwise {
224                 $log->error("Event reacting failed with ". shift() );
225                 $self->update_state( 'error' ) || die 'Unable to update event state';
226             };
227
228             if (defined $self->reacted) {
229                 $self->update_state( 'reacted' ) || die 'Unable to update event state';
230             } else {
231                 $self->update_state( 'error' ) || die 'Unable to update event state';
232             }
233         }
234     } else {
235         $self->{reacted} = undef;
236     }
237     return $self;
238 }
239
240 sub validate {
241     my $self = shift;
242
243     return $self if (defined $self->valid);
244
245     if ($self->build_environment->environment->{complete}) {
246         $self->update_state( 'validating') || die 'Unable to update event state';
247         try {
248             $self->valid(
249                 OpenILS::Application::Trigger::ModRunner::Validator
250                     ->new( $self->event->event_def->validator, $self->environment )
251                     ->run
252                     ->final_result
253             );
254         } otherwise {
255             $log->error("Event validation failed with ". shift() );
256             $self->update_state( 'error' ) || die 'Unable to update event state';
257         };
258
259         if (defined $self->valid) {
260             if ($self->valid) {
261                 $self->update_state( 'valid' ) || die 'Unable to update event state';
262             } else {
263                 $self->update_state( 'invalid' ) || die 'Unable to update event state';
264             }
265         } else {
266             $self->update_state( 'error' ) || die 'Unable to update event state';
267         }
268     } else {
269         $self->{valid} = undef
270     }
271
272     return $self;
273 }
274  
275 sub revalidate_test {
276     my $self = shift;
277
278     if ($self->build_environment->environment->{complete}) {
279         try {
280             $self->valid(
281                 OpenILS::Application::Trigger::ModRunner::Validator->new(
282                     $self->event->event_def->validator,
283                     $self->environment
284                 )->run->final_result
285             );
286         } otherwise {
287             $log->error("Event revalidation failed with ". shift());
288         };
289
290         return 1 if defined $self->valid and $self->valid;
291         return 0;
292     }
293
294     $logger->error(
295         "revalidate: could not build environment for event " .
296         $self->event->id
297     );
298     return 0;
299 }
300  
301 sub cleanedup {
302     my $self = shift;
303     return undef unless (ref $self);
304
305     my $c = shift;
306     $self->{cleanedup} = $c if (defined $c);
307     return $self->{cleanedup};
308 }
309
310 sub user_data {
311     my $self = shift;
312     return undef unless (ref $self);
313
314     my $r = shift;
315     $self->{user_data} = $r if (defined $r);
316     return $self->{user_data};
317 }
318
319 sub reacted {
320     my $self = shift;
321     return undef unless (ref $self);
322
323     my $r = shift;
324     $self->{reacted} = $r if (defined $r);
325     return $self->{reacted};
326 }
327
328 sub valid {
329     my $self = shift;
330     return undef unless (ref $self);
331
332     my $v = shift;
333     $self->{valid} = $v if (defined $v);
334     return $self->{valid};
335 }
336
337 sub event {
338     my $self = shift;
339     return undef unless (ref $self);
340
341     my $e = shift;
342     $self->{event} = $e if (defined $e);
343     return $self->{event};
344 }
345
346 sub id {
347     my $self = shift;
348     return undef unless (ref $self);
349
350     my $i = shift;
351     $self->{id} = $i if (defined $i);
352     return $self->{id};
353 }
354
355 sub environment {
356     my $self = shift;
357     return undef unless (ref $self);
358
359     my $e = shift;
360     $self->{environment} = $e if (defined $e);
361     return $self->{environment};
362 }
363
364 sub editor {
365     my $self = shift;
366     return undef unless (ref $self);
367
368     my $e = shift;
369     $self->{editor} = $e if (defined $e);
370     return $self->{editor};
371 }
372
373 sub nochanges {
374     # no guarantees, yet.
375     my $self = shift;
376     return undef unless (ref $self);
377
378     my $e = shift;
379     $self->{nochanges} = $e if (defined $e);
380     return $self->{nochanges};
381 }
382
383 sub unfind {
384     my $self = shift;
385     return undef unless (ref $self);
386
387     die 'Cannot unfind a reacted event' if (defined $self->reacted);
388
389     $self->update_state( 'pending' ) || die 'Unable to update event state';
390     $self->{id} = undef;
391     $self->{event} = undef;
392     $self->{environment} = undef;
393     return $self;
394 }
395
396 sub target {
397     my $self = shift;
398     return undef unless (ref $self);
399
400     my $t = shift;
401     $self->{target} = $t if (defined $t);
402     return $self->{target};
403 }
404
405 sub standalone {
406     my $self = shift;
407     return undef unless (ref $self);
408
409     my $t = shift;
410     $self->{standalone} = $t if (defined $t);
411     return $self->{standalone};
412 }
413
414 sub update_state {
415     my $self = shift;
416     return undef unless ($self && ref $self);
417
418     my $state = shift;
419     return undef unless ($state);
420
421     my $fields = shift;
422
423     if ($self->standalone) {
424         $self->editor->xact_begin || return undef;
425     }
426
427     my $e = $self->editor->retrieve_action_trigger_event( $self->id );
428     if (!$e) {
429         $log->error( "Could not retrieve object ".$self->id." for update" ) if (!$e);
430         return undef;
431     }
432
433     if ($fields && ref($fields)) {
434         $e->$_($$fields{$_}) for (keys %$fields);
435     }
436
437     $log->info( "Retrieved object ".$self->id." for update" );
438     $e->start_time( 'now' ) unless $e->start_time;
439     $e->update_time( 'now' );
440     $e->update_process( $$ );
441     $e->state( $state );
442
443     $e->clear_start_time() if ($e->state eq 'pending');
444     $e->complete_time( 'now' ) if ($e->state eq 'complete');
445
446     my $ok = $self->editor->update_action_trigger_event( $e );
447     if (!$ok) {
448         $self->editor->xact_rollback if ($self->standalone);
449         $log->error( "Update of event ".$self->id." failed" );
450         return undef;
451     } else {
452         $e = $self->editor->data;
453         $e = $self->editor->retrieve_action_trigger_event( $e ) if (!ref($e));
454         if (!$e) {
455             $log->error( "Update of event ".$self->id." did not return an object" );
456             return undef;
457         }
458         $log->info( "Update of event ".$e->id." suceeded" );
459         $ok = $self->editor->xact_commit if ($self->standalone);
460     }
461
462     if ($ok) {
463         $self->event->start_time( $e->start_time );
464         $self->event->update_time( $e->update_time );
465         $self->event->update_process( $e->update_process );
466         $self->event->state( $e->state );
467     }
468
469     return $ok || undef;
470 }
471
472 my $current_environment;
473
474 sub build_environment {
475     my $self = shift;
476     return $self if ($self->environment->{complete});
477
478     $self->update_state( 'collecting') || die 'Unable to update event state';
479
480     try {
481    
482         my $compartment = new Safe;
483         $compartment->permit(':default','require','dofile','caller');
484         $compartment->share('$current_environment');
485
486         $self->environment->{EventProcessor} = $self;
487         $self->environment->{target} = $self->target;
488         $self->environment->{event} = $self->event;
489         $self->environment->{template} = $self->event->event_def->template;
490         $self->environment->{usr_message}{template} = $self->event->event_def->message_template;
491         $self->environment->{usr_message}{title} = $self->event->event_def->message_title;
492         $self->environment->{user_data} = $self->user_data;
493
494         $current_environment = $self->environment;
495
496         $self->environment->{params}{ $_->param } = $compartment->reval($_->value) for ( @{$self->event->event_def->params} );
497     
498         for my $e ( @{$self->event->event_def->env} ) {
499             my (@label, @path);
500             @path = split(/\./, $e->path) if ($e->path);
501             @label = split(/\./, $e->label) if ($e->label);
502     
503             $self->_object_by_path( $self->target, $e->collector, \@label, \@path );
504         }
505
506         if ($self->event->event_def->group_field) {
507             my @group_path = split(/\./, $self->event->event_def->group_field);
508             pop(@group_path); # the last part is a field, should not get fleshed
509             my $group_object = $self->_object_by_path( $self->target, undef, [], \@group_path ) if (@group_path);
510         }
511
512         if ($self->event->event_def->message_usr_path and $self->environment->{usr_message}{template}) {
513             my @usr_path = split(/\./, $self->event->event_def->message_usr_path);
514             $self->_object_by_path( $self->target, undef, [qw/usr_message usr/], \@usr_path );
515
516             if ($self->event->event_def->message_library_path) {
517                 my @library_path = split(/\./, $self->event->event_def->message_library_path);
518                 $self->_object_by_path( $self->target, undef, [qw/usr_message sending_lib/], \@library_path );
519             } else {
520                 $self->_object_by_path( $self->event->event_def, undef, [qw/usr_message sending_lib/], ['owner'] );
521             }
522         }
523     
524         $self->environment->{complete} = 1;
525     } otherwise {
526         $log->error( shift() );
527         $self->update_state( 'error' ) || die 'Unable to update event state';
528     };
529
530     if ($self->environment->{complete}) {
531         $self->update_state( 'collected' ) || die 'Unable to update event state';
532     } else {
533         $self->update_state( 'error' ) || die 'Unable to update event state';
534     }
535
536     return $self;
537 }
538
539 sub _fm_class_by_hint {
540     my $self = shift;
541     my $hint = shift;
542
543     my ($class) = grep {
544         OpenILS::Application->publish_fieldmapper->{$_}->{hint} eq $hint
545     } keys %{ OpenILS::Application->publish_fieldmapper };
546
547     return $class;
548 }
549
550 my %_object_by_path_cache = ();
551 sub ClearObjectCache {
552     for my $did ( keys %_object_by_path_cache ) {
553         my $phash = $_object_by_path_cache{$did};
554         for my $path ( keys %$phash ) {
555             my $shash = $$phash{$path};
556             for my $fhint ( keys %$shash ) {
557                 my $hhash = $$shash{$fhint};
558                 for my $step ( keys %$hhash ) {
559                     my $fhash = $$hhash{$step};
560                     for my $ffield ( keys %$fhash ) {
561                         my $lhash = $$fhash{$ffield};
562                         for my $lfield ( keys %$lhash ) {
563                             delete $$lhash{$lfield};
564                         }
565                         delete $$fhash{$ffield};
566                     }
567                     delete $$hhash{$step};
568                 }
569                 delete $$shash{$fhint};
570             }
571             delete $$phash{$path};
572         }
573         delete $_object_by_path_cache{$did};
574     }
575 }
576         
577 sub _object_by_path {
578     my $self = shift;
579     my $context = shift;
580     my $collector = shift;
581     my $label = shift;
582     my $path = shift;
583     my $ed = shift;
584     my $red = shift;
585
586     my $outer = 0;
587     if (!$ed) {
588         $ed = new_editor(xact=>1);
589         $outer = 1;
590     }
591
592     my $step = shift(@$path);
593
594     my $fhint = OpenILS::Application->publish_fieldmapper->{$context->class_name}{links}{$step}{class};
595     my $fclass = $self->_fm_class_by_hint( $fhint );
596
597     OpenSRF::EX::ERROR->throw(
598         "$step is not a field on ".$context->class_name."  Please repair the environment.")
599         unless $fhint;
600
601     my $ffield = OpenILS::Application->publish_fieldmapper->{$context->class_name}{links}{$step}{key};
602     my $rtype = OpenILS::Application->publish_fieldmapper->{$context->class_name}{links}{$step}{reltype};
603
604     my $meth = 'retrieve_';
605     my $multi = 0;
606     my $lfield = $step;
607     if ($rtype ne 'has_a') {
608         $meth = 'search_';
609         $multi = 1;
610         $lfield = $context->Identity;
611     }
612
613     $meth .= $fclass;
614     $meth =~ s/Fieldmapper:://;
615     $meth =~ s/::/_/g;
616
617     my $obj = $context->$step(); 
618
619     $logger->debug(
620         sprintf "_object_by_path(): meth=%s, obj=%s, multi=%s, step=%s, lfield=%s",
621         map {defined($_)? $_ : ''} ($meth,  $obj,   $multi,   $step,   $lfield)
622     );
623
624     if (!ref $obj) {
625
626         my $lval = $context->$lfield();
627
628         if(defined $lval) {
629
630             my $def_id = $self->event->event_def->id;
631             my $str_path = join('.', @$path);
632
633             my @params = (($multi) ? { $ffield => $lval } : $lval);
634             @params = ([@params], {substream => 1}) if $meth =~ /^search/;
635
636             $obj = $_object_by_path_cache{$def_id}{$str_path}{$fhint}{$step}{$ffield}{$lval} ||
637                 (
638                     (grep /cstore/, @{
639                         OpenILS::Application->publish_fieldmapper->{$fclass}{controller}
640                     }) ? $ed : ($red ||= new_rstore_editor(xact=>1))
641                 )->$meth(@params);
642
643             $_object_by_path_cache{$def_id}{$str_path}{$fhint}{$step}{$ffield}{$lval} ||= $obj;
644         }
645     }
646
647     if (@$path) {
648
649         my $obj_list = [];
650         if (!$multi) {
651             $obj_list = [$obj] if ($obj);
652         } else {
653             $obj_list = $obj;
654         }
655
656         for (@$obj_list) {
657             my @path_clone = @$path;
658             $self->_object_by_path( $_, $collector, $label, \@path_clone, $ed, $red );
659         }
660
661         $obj = $$obj_list[0] if (!$multi || $rtype eq 'might_have');
662         $context->$step( $obj ) if ($obj && (!$label || !@$label));
663
664     } else {
665
666         if ($collector) {
667             my $obj_list = [$obj] if ($obj && !$multi);
668             $obj_list = $obj if ($multi);
669
670             my @new_obj_list;
671             for my $o ( @$obj_list ) {
672                 push @new_obj_list,
673                     OpenILS::Application::Trigger::ModRunner::Collector
674                         ->new( $collector, $o )
675                         ->run
676                         ->final_result
677             }
678
679             if (!$multi) {
680                 $obj = $new_obj_list[0];
681             } else {
682                 $obj = \@new_obj_list;
683             }
684         }
685
686         if ($label && @$label) {
687             my $node = $self->environment;
688             my $i = 0; my $max = scalar(@$label) - 1;
689             for (; $i < $max; $i++) {
690                 my $part = $$label[$i];
691                 $$node{$part} ||= {};
692                 $node = $$node{$part};
693             }
694             $$node{$$label[-1]} = $obj;
695         } else {
696             $obj = $$obj[0] if $rtype eq 'might_have' and ref($obj) eq 'ARRAY';
697             $context->$step( $obj ) if ($obj);
698         }
699     }
700
701     if ($outer) {
702         $ed->rollback;
703         $red->rollback if $red;
704     }
705     return $obj;
706 }
707
708 1;