Open-ILS/src/perlmods/OpenILS/Application/Trigger/EventGroup.pm

   1 package OpenILS::Application::Trigger::EventGroup;
   2 use OpenILS::Application::Trigger::Event;
   3 use base 'OpenILS::Application::Trigger::Event';
   4 use strict; use warnings;
   5 use OpenSRF::EX qw/:try/;
   6
   7 use OpenSRF::Utils::Logger qw/:logger/;
   8
   9 use OpenILS::Utils::Fieldmapper;
  10 use OpenILS::Utils::CStoreEditor q/:funcs/;
  11 use OpenILS::Application::Trigger::ModRunner;
  12
  13 my $log = 'OpenSRF::Utils::Logger';
  14
  15 sub new {
  16     my $class = shift;
  17     my @ids = @_;
  18     $class = ref($class) || $class;
  19
  20     my $editor = new_editor(xact=>1);
  21
  22     my $self = bless {
  23         environment => {},
  24         events      => [
  25             map {
  26                 ref($_) ?
  27                     do { $_->standalone(0); $_->editor($editor); $_ } :
  28                     OpenILS::Application::Trigger::Event->new($_, $editor)
  29             } @ids
  30         ],
  31         ids         => \@ids,
  32         editor      => $editor
  33     } => $class;
  34
  35
  36     $self->editor->xact_commit; # flush out those updates
  37     $self->editor->xact_begin;
  38
  39     return $self;
  40 }
  41
  42 sub react {
  43     my $self = shift;
  44
  45     return $self if (defined $self->reacted);
  46
  47     if ($self->valid) {
  48         $self->update_state( 'reacting') || die 'Unable to update event group state';
  49         $self->build_environment;
  50
  51         try {
  52             $self->reacted(
  53                 OpenILS::Application::Trigger::ModRunner::Reactor
  54                     ->new( $self->event->event_def->reactor, $self->environment )
  55                     ->run
  56                     ->final_result
  57             );
  58         } otherwise {
  59             $log->error( shift() );
  60             $self->update_state( 'error' ) || die 'Unable to update event group state';
  61         };
  62
  63         if (defined $self->reacted) {
  64             $self->update_state( 'reacted' ) || die 'Unable to update event group state';
  65         } else {
  66             $self->update_state( 'error' ) || die 'Unable to update event group state';
  67         }
  68     } else {
  69         $self->{reacted} = undef;
  70     }
  71     return $self;
  72 }
  73
  74 sub validate {
  75     my $self = shift;
  76
  77     return $self if (defined $self->valid);
  78
  79     $self->update_state( 'validating') || die 'Unable to update event group state';
  80     $self->editor->xact_begin;
  81
  82     my @valid_events;
  83     try {
  84         for my $event ( @{ $self->events } ) {
  85             $event->validate;
  86             push @valid_events, $event if ($event->valid);
  87         }
  88         $self->valid(1) if (@valid_events);
  89         $self->{events} = \@valid_events;
  90         $self->editor->xact_commit;
  91     } otherwise {
  92         $log->error( shift() );
  93         $self->editor->xact_rollback;
  94         $self->update_state( 'error' ) || die 'Unable to update event group state';
  95     };
  96
  97     return $self;
  98 }
  99
 100 sub cleanedup {
 101     my $self = shift;
 102     return undef unless (ref $self);
 103
 104     my $c = shift;
 105     $self->{cleanedup} = $c if (defined $c);
 106     return $self->{cleanedup};
 107 }
 108
 109 sub reacted {
 110     my $self = shift;
 111     return undef unless (ref $self);
 112
 113     my $r = shift;
 114     $self->{reacted} = $r if (defined $r);
 115     return $self->{reacted};
 116 }
 117
 118 sub valid {
 119     my $self = shift;
 120     return undef unless (ref $self);
 121
 122     my $v = shift;
 123     $self->{valid} = $v if (defined $v);
 124     return $self->{valid};
 125 }
 126
 127 sub event {
 128     my $self = shift;
 129     return undef unless (ref $self);
 130
 131     return $self->{events}[0];
 132 }
 133
 134 sub events {
 135     my $self = shift;
 136     return undef unless (ref $self);
 137
 138     return $self->{events};
 139 }
 140
 141 sub ids {
 142     my $self = shift;
 143     return undef unless (ref $self);
 144
 145     return $self->{ids};
 146 }
 147
 148 sub environment {
 149     my $self = shift;
 150     return undef unless (ref $self);
 151
 152     my $e = shift;
 153     $self->{environment} = $e if (defined $e);
 154     return $self->{environment};
 155 }
 156
 157 sub editor {
 158     my $self = shift;
 159     return undef unless (ref $self);
 160
 161     my $e = shift;
 162     $self->{editor} = $e if (defined $e);
 163     return $self->{editor};
 164 }
 165
 166 sub unfind {
 167     my $self = shift;
 168     return undef unless (ref $self);
 169
 170     die 'Cannot unfind a reacted event group' if (defined $self->reacted);
 171
 172     $self->update_state( 'pending' ) || die 'Unable to update event group state';
 173     $self->{events} = undef;
 174     return $self;
 175 }
 176
 177 sub update_state {
 178     my $self = shift;
 179     return undef unless ($self && ref $self);
 180
 181     my $state = shift;
 182     return undef unless ($state);
 183
 184     $self->editor->xact_begin || return undef;
 185
 186     my @oks;
 187     for my $event ( @{ $self->events } ) {
 188         my $e = $self->editor->retrieve_action_trigger_event( $event->id );
 189         $e->start_time( 'now' ) unless $e->start_time;
 190         $e->update_time( 'now' );
 191         $e->update_process( $$ );
 192         $e->state( $state );
 193
 194         $e->clear_start_time() if ($e->state eq 'pending');
 195
 196         my $ok = $self->editor->update_action_trigger_event( $e );
 197         if ($ok) {
 198             push @oks, $ok;
 199         }
 200     }
 201
 202     if (scalar(@oks) < scalar(@{ $self->ids })) {
 203         $self->editor->xact_rollback;
 204         return undef;
 205     } else {
 206         $ok = $self->editor->xact_commit;
 207     }
 208
 209     if ($ok) {
 210         for my $event ( @{ $self->events } ) {
 211             my $updated = $self->editor->data;
 212             $event->start_time( $updated->start_time );
 213             $event->update_time( $updated->update_time );
 214             $event->update_process( $updated->update_process );
 215             $event->state( $updated->state );
 216         }
 217     }
 218
 219     return $ok || undef;
 220 }
 221
 222 sub build_environment {
 223     my $self = shift;
 224     my $env = $self->environment;
 225
 226     $$evn{target} = [];
 227     $$evn{event} = [];
 228     for my $e ( @{ $self->events } ) {
 229         for my $evn_part ( keys %{ $e->environment } ) {
 230             if ($env_part eq 'target') {
 231                 push @{ $$evn{target} }, $e->environment->{target};
 232             } elsif ($env_part eq 'event') {
 233                 push @{ $$evn{event} }, $e->environment->{event};
 234             } else {
 235                 $$evn{$evn_part} = $e->environment->{$evn_part};
 236             }
 237         }
 238     }
 239
 240     return $self;
 241 }
 242
 243 1;