1 package OpenILS::Application::Trigger::EventGroup;
2 use strict; use warnings;
3 use OpenILS::Application::Trigger::Event;
4 use base 'OpenILS::Application::Trigger::Event';
5 use OpenSRF::EX qw/:try/;
7 use OpenSRF::Utils::Logger qw/$logger/;
9 use OpenILS::Utils::Fieldmapper;
10 use OpenILS::Utils::CStoreEditor q/:funcs/;
11 use OpenILS::Application::Trigger::ModRunner;
13 my $log = 'OpenSRF::Utils::Logger';
18 my $nochanges = shift;
20 $class = ref($class) || $class;
22 my $editor = new_editor(xact=>1);
29 do { $_->standalone(0); $_->editor($editor); $_ } :
30 OpenILS::Application::Trigger::Event->new($_, $editor, $nochanges)
33 ids => [ map { ref($_) ? $_->id : $_ } @ids ],
38 $self->editor->xact_commit; # flush out those updates
39 $self->editor->xact_begin;
48 return new_impl($class, \@ids, 1);
55 return new_impl($class, \@ids);
61 return $self if (defined $self->reacted);
64 $self->update_state( 'reacting') || die 'Unable to update event group state';
65 $self->build_environment;
68 my $env = $self->environment;
69 my $reactor = OpenILS::Application::Trigger::ModRunner::Reactor->new(
70 $self->event->event_def->reactor,
74 $self->reacted( $reactor->run->final_result);
76 if ($env->{usr_message}{usr} && $env->{usr_message}{template}) {
77 my $message_template_output =
78 $reactor->pass('ProcessMessage')->run->final_result;
80 if ($message_template_output) {
81 my $usr_message = Fieldmapper::actor::usr_message->new;
82 $usr_message->title( $env->{usr_message}{title} || $self->event->event_def->name );
83 $usr_message->message( $message_template_output );
84 $usr_message->usr( $env->{usr_message}{usr}->id );
85 $usr_message->sending_lib( $env->{usr_message}{sending_lib}->id );
86 $usr_message->pub('t');
88 if ($self->editor->xact_begin) {
89 if ($self->editor->create_actor_usr_message( $usr_message )) {
90 $self->editor->xact_commit;
92 $self->editor->xact_rollback;
99 $log->error("Event reacting failed with ". shift() );
100 $self->update_state( 'error' ) || die 'Unable to update event group state';
103 if (defined $self->reacted) {
104 $self->update_state( 'reacted' ) || die 'Unable to update event group state';
106 $self->update_state( 'error' ) || die 'Unable to update event group state';
109 $self->{reacted} = undef;
117 return $self if (defined $self->valid);
119 $self->update_state( 'validating') || die 'Unable to update event group state';
120 $self->editor->xact_begin;
124 for my $event ( @{ $self->events } ) {
126 push @valid_events, $event if ($event->valid);
128 $self->valid(1) if (@valid_events);
129 $self->{events} = \@valid_events;
130 $self->{ids} = [ map { $_->id } @valid_events ];
131 $self->editor->xact_commit;
133 $log->error("Event group validation failed with ". shift() );
134 $self->editor->xact_rollback;
135 $self->update_state( 'error' ) || die 'Unable to update event group state';
141 sub revalidate_test {
144 $self->editor->xact_begin;
148 for my $event ( @{ $self->events } ) {
149 push @valid_events, $event->id if $event->revalidate_test;
151 $self->editor->xact_rollback;
153 $log->error("Event group validation failed with ". shift());
154 $self->editor->xact_rollback;
157 return \@valid_events;
162 return undef unless (ref $self);
165 $self->{cleanedup} = $c if (defined $c);
166 return $self->{cleanedup};
171 return undef unless (ref $self);
174 $self->{reacted} = $r if (defined $r);
175 return $self->{reacted};
180 return undef unless (ref $self);
183 $self->{valid} = $v if (defined $v);
184 return $self->{valid};
189 return undef unless (ref $self);
191 return $self->{events}[0]->event;
196 return undef unless (ref $self);
198 return $self->{events};
203 return undef unless (ref $self);
210 return undef unless (ref $self);
213 $self->{environment} = $e if (defined $e);
214 return $self->{environment};
219 return undef unless (ref $self);
222 $self->{editor} = $e if (defined $e);
223 return $self->{editor};
228 return undef unless (ref $self);
230 die 'Cannot unfind a reacted event group' if (defined $self->reacted);
232 $self->update_state( 'pending' ) || die 'Unable to update event group state';
233 $self->{events} = undef;
239 return undef unless ($self && ref $self);
242 return undef unless ($state);
246 $self->editor->xact_begin || return undef;
251 for my $event ( @{ $self->events } ) {
252 my $e = $self->editor->retrieve_action_trigger_event( $event->id );
253 $e->start_time( 'now' ) unless $e->start_time;
254 $e->update_time( 'now' );
255 $e->update_process( $$ );
258 $e->clear_start_time() if ($e->state eq 'pending');
260 $e->complete_time('now')
261 if ($e->state eq 'complete' && !$e->complete_time);
263 if ($fields && ref($fields)) {
264 $e->$_($$fields{$_}) for (keys %$fields);
267 my $ok = $self->editor->update_action_trigger_event( $e );
270 $last_updated = $e->id;
274 if (scalar(@oks) < scalar(@{ $self->ids })) {
275 $self->editor->xact_rollback;
279 my $updated = $self->editor->retrieve_action_trigger_event($last_updated);
280 $ok = $self->editor->xact_commit;
283 for my $event ( @{ $self->events } ) {
284 my $e = $event->event;
285 $e->start_time( $updated->start_time );
286 $e->update_time( $updated->update_time );
287 $e->update_process( $updated->update_process );
288 $e->state( $updated->state );
299 $member = $member->id if (ref($member));
301 my @list = grep { $member == $_->id } @{ $self->events };
306 sub build_environment {
308 my $env = $self->environment;
310 $$env{EventProcessor} = $self;
313 $$env{user_data} = [];
314 for my $e ( @{ $self->events } ) {
315 for my $env_part ( keys %{ $e->environment } ) {
316 next if ($env_part eq 'EventProcessor');
317 if ($env_part eq 'target') {
318 push @{ $$env{target} }, $e->environment->{target};
319 } elsif ($env_part eq 'event') {
320 push @{ $$env{event} }, $e->environment->{event};
321 } elsif ($env_part eq 'user_data') {
322 push @{ $$env{user_data} }, $e->environment->{user_data};
324 $$env{$env_part} = $e->environment->{$env_part};