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

   1 package OpenILS::Application::Trigger;
   2 use strict; use warnings;
   3 use OpenILS::Application;
   4 use base qw/OpenILS::Application/;
   5
   6 use OpenSRF::EX qw/:try/;
   7
   8 use OpenSRF::AppSession;
   9 use OpenSRF::Utils::SettingsClient;
  10 use OpenSRF::Utils::Logger qw/:level/;
  11 use OpenSRF::Utils qw/:datetime/;
  12
  13 use DateTime;
  14 use DateTime::Format::ISO8601;
  15
  16 use OpenILS::Utils::Fieldmapper;
  17 use OpenILS::Utils::CStoreEditor q/:funcs/;
  18 use OpenILS::Application::Trigger::Event;
  19 use OpenILS::Application::Trigger::EventGroup;
  20
  21
  22 my $log = 'OpenSRF::Utils::Logger';
  23
  24 sub initialize {}
  25 sub child_init {}
  26
  27 sub create_active_events_for_object {
  28     my $self = shift;
  29     my $client = shift;
  30     my $key = shift;
  31     my $target = shift;
  32     my $location = shift;
  33
  34     my $ident = $target->Identity;
  35     my $ident_value = $target->$ident();
  36
  37     my $editor = new_editor(xact=>1);
  38
  39     my $hooks = $editor->search_action_trigger_hook(
  40         { key       => $key,
  41           core_type => $target->json_hint
  42         }
  43     );
  44
  45     my %hook_hash = map { ($_->key, $_) } @$hooks;
  46
  47     my $orgs = $editor->json_query({ from => [ 'actor.org_unit_ancestors' => $location ] });
  48     my $defs = $editor->search_action_trigger_event_definition(
  49         { hook   => [ keys %hook_hash ],
  50           owner  => [ map { $_->{id} } @$orgs  ],
  51           active => 't'
  52         }
  53     );
  54
  55     for my $def ( @$defs ) {
  56
  57         my $date = DateTime->now;
  58
  59         if ($hook_hash{$def->hook}->passive eq 'f') {
  60
  61             if (my $dfield = $def->delay_field) {
  62                 if ($target->$dfield()) {
  63                     $date = DateTime::Format::ISO8601->new->parse_datetime( clense_ISO8601($target->$dfield) );
  64                 } else {
  65                     next;
  66                 }
  67             }
  68
  69             $date->add( seconds => interval_to_seconds($def->delay) );
  70         }
  71
  72         my $event = Fieldmapper::action_trigger::event->new();
  73         $event->target( $ident_value );
  74         $event->event_def( $def->id );
  75         $event->run_time( $date->strftime( '%F %T%z' ) );
  76
  77         $editor->create_action_trigger_event( $event );
  78
  79         $client->respond( $event->id );
  80     }
  81
  82     $editor->commit;
  83
  84     return undef;
  85 }
  86 __PACKAGE__->register_method(
  87     api_name => 'open-ils.trigger.event.autocreate',
  88     method   => 'create_active_events_for_object',
  89     api_level=> 1,
  90     stream   => 1,
  91     argc     => 3
  92 );
  93
  94
  95 # Retrieves events by object, or object type + filter
  96 #  $object : a target object or object type (class hint)
  97 #
  98 #  $filter : an optional hash of filters ... top level keys:
  99 #     event
 100 #        filters on the atev objects, such as states or null-ness of timing
 101 #        fields. contains the effective default of:
 102 #          { state => 'pending' }
 103 #        an example, which overrides the default, and will find
 104 #        stale 'found' events:
 105 #          { state => 'found', update_time => { '<' => 'yesterday' } }
 106 #
 107 #      event_def
 108 #        filters on the atevdef object. contains the effective default of:
 109 #          { active => 't' }
 110 #
 111 #      hook
 112 #        filters on the hook object. no defaults, but there is a pinned,
 113 #        unchangeable filter based on the passed hint or object type (see
 114 #        $object above). an example for finding passive events:
 115 #          { passive => 't' }
 116 #
 117 #     target
 118 #        filters against the target field on the event. this can contain
 119 #        either an array of target ids (if you passed an object type, and
 120 #        not an object) or can contain a json_query that will return exactly
 121 #        a list of target-type ids.  If you pass an object, the pkey value of
 122 #        that object will be used as a filter in addition to the filter passed
 123 #        in here.  example filter for circs of user 1234 that are open:
 124 #          { select => { circ => ['id'] },
 125 #            from => 'circ',
 126 #            where => {
 127 #              usr => 1234,
 128 #              checkin_time => undef,
 129 #              '-or' => [
 130 #                { stop_fines => undef },
 131 #                { stop_fines => { 'not in' => ['LOST','LONGOVERDUE','CLAIMSRETURNED'] } }
 132 #              ]
 133 #            }
 134
 135 sub events_by_target {
 136     my $self = shift;
 137     my $client = shift;
 138     my $object = shift;
 139     my $filter = shift || {};
 140
 141     my $obj_class = ref($object) || _fm_class_by_hint($object);
 142     my $obj_hint = ref($object) ? _fm_hint_by_class(ref($object)) : $object;
 143
 144     my $object_ident_field = $obj_class->Identity;
 145
 146     my $query = {
 147         select => { atev => ["id"] },
 148         from   => {
 149             atev => {
 150                 atevdef => {
 151                     field => "id",
 152                     fkey => "event_def",
 153                     join => {
 154                         ath => { field => "key", fkey => "hook" }
 155                     }
 156                 }
 157             }
 158         },
 159         where  => {
 160             "+ath"  => { core_type => $obj_hint },
 161             "+atevdef" => { active => 't' },
 162             "+atev" => { state => 'pending' }
 163         },
 164         order_by => { "+atev" => [ 'run_time' ] },
 165         distinct => 1
 166     };
 167
 168
 169     # allow multiple 'target' filters
 170     $query->{where}->{'+atev'}->{'-and'} = [];
 171
 172     # if we got a real object, filter on its pkey value
 173     if (ref($object)) { # pass an object, require that target
 174         push @{ $query->{where}->{'+atev'}->{'-and'} },
 175             { target => $object->$object_ident_field }
 176     }
 177
 178     # we have a fancy complex target filter or a list of target ids
 179     if ($$filter{target}) {
 180         push @{ $query->{where}->{'+atev'}->{'-and'} },
 181             { target => {in => $$filter{target} } };
 182     }
 183
 184     # pass no target filter or object, you get no events
 185     if (!@{ $query->{where}->{'+atev'}->{'-and'} }) {
 186         return undef;
 187     }
 188
 189     # any hook filters, other than the required core_type filter
 190     if ($$filter{hook}) {
 191         $query->{where}->{'+ath'}->{$_} = $$filter{hook}{$_}
 192             for (grep { $_ ne 'core_type' } keys %{$$filter{hook}});
 193     }
 194
 195     # any event_def filters.  defaults to { active => 't' }
 196     if ($$filter{event_def}) {
 197         $query->{where}->{'+atevdef'}->{$_} = $$filter{event_def}{$_}
 198             for (keys %{$$filter{event_def}});
 199     }
 200
 201     # any event filters.  defaults to { state => 'pending' }.
 202     # don't overwrite '-and' used for multiple target filters above
 203     if ($$filter{event}) {
 204         $query->{where}->{'+atev'}->{$_} = $$filter{event}{$_}
 205             for (grep { $_ ne '-and' } keys %{$$filter{event}});
 206     }
 207
 208     my $e = new_editor();
 209
 210     my $events = $e->json_query($query);
 211
 212     for my $id (@$events) {
 213         my $event = $e->retrieve_action_trigger_event([
 214             $id->{id},
 215             {flesh => 1, flesh_fields => {atev => ['event_def']}}
 216         ]);
 217
 218         (my $meth = $obj_class) =~ s/^Fieldmapper:://o;
 219         $meth =~ s/::/_/go;
 220         $meth = 'retrieve_'.$meth;
 221
 222         $event->target($e->$meth($event->target));
 223         $client->respond($event);
 224     }
 225
 226     return undef;
 227 }
 228 __PACKAGE__->register_method(
 229     api_name => 'open-ils.trigger.events_by_target',
 230     method   => 'events_by_target',
 231     api_level=> 1,
 232     stream   => 1,
 233     argc     => 2
 234 );
 235
 236 sub _fm_hint_by_class {
 237     my $class = shift;
 238     return Fieldmapper->publish_fieldmapper->{$class}->{hint};
 239 }
 240
 241 sub _fm_class_by_hint {
 242     my $hint = shift;
 243
 244     my ($class) = grep {
 245         Fieldmapper->publish_fieldmapper->{$_}->{hint} eq $hint
 246     } keys %{ Fieldmapper->publish_fieldmapper };
 247
 248     return $class;
 249 }
 250
 251 sub create_passive_events {
 252     my $self = shift;
 253     my $client = shift;
 254     my $key = shift;
 255     my $location_field = shift; # where to look for event_def.owner filtering ... circ_lib, for instance, where hook.core_type = circ
 256     my $filter = shift || {};
 257
 258     return undef unless ($key && $location_field);
 259
 260     my $editor = new_editor(xact=>1);
 261     my $hooks = $editor->search_action_trigger_hook(
 262         { passive => 't', key => $key }
 263     );
 264
 265     my %hook_hash = map { ($_->key, $_) } @$hooks;
 266
 267     my $defs = $editor->search_action_trigger_event_definition(
 268         { hook   => [ keys %hook_hash ], active => 't' },
 269     );
 270
 271     for my $def ( @$defs ) {
 272
 273         my $date = DateTime->now->subtract( seconds => interval_to_seconds($def->delay) );
 274
 275         # we may need to do some work to backport this to 1.2
 276         $filter->{ $location_field } = { 'in' =>
 277             {
 278                 select  => { aou => [{ column => 'id', transform => 'actor.org_unit_descendents', result_field => 'id' }] },
 279                 from    => 'aou',
 280                 where   => { id => $def->owner }
 281             }
 282         };
 283
 284         $filter->{ $def->delay_field } = {
 285             '<=' => DateTime
 286                 ->now
 287                 ->subtract( seconds => interval_to_seconds($def->delay) )
 288                 ->strftime( '%F %T%z' )
 289         };
 290
 291         my $class = _fm_class_by_hint($hook_hash{$def->hook}->core_type);
 292         $class =~ s/^Fieldmapper:://o;
 293         $class =~ s/::/_/go;
 294
 295         my $method = 'search_'. $class;
 296         my $objects = $editor->$method( $filter );
 297
 298         for my $o (@$objects) {
 299
 300             my $ident = $o->Identity;
 301             my $ident_value = $o->$ident();
 302
 303             my $previous = $editor->search_action_trigger_event({
 304                 event_def => $def->id,
 305                 target    => $ident_value
 306             });
 307
 308
 309             # only allow one event of type $def for each target
 310             next if (@$previous);
 311
 312             my $event = Fieldmapper::action_trigger::event->new();
 313             $event->target( $ident_value );
 314             $event->event_def( $def->id );
 315             $event->run_time( 'now' );
 316
 317             $editor->create_action_trigger_event( $event );
 318
 319             $client->respond( $event->id );
 320         }
 321     }
 322
 323     $editor->commit;
 324
 325     return undef;
 326 }
 327 __PACKAGE__->register_method(
 328     api_name => 'open-ils.trigger.passive.event.autocreate',
 329     method   => 'create_passive_events',
 330     api_level=> 1,
 331     stream   => 1,
 332     argc     => 2
 333 );
 334
 335
 336 sub fire_single_event {
 337     my $self = shift;
 338     my $client = shift;
 339     my $event_id = shift;
 340
 341     my $e = OpenILS::Application::Trigger::Event->new($event_id);
 342
 343     if ($e->validate->valid) {
 344         $e->react->cleanup;
 345     }
 346
 347     return {
 348         valid     => $e->valid,
 349         reacted   => $e->reacted,
 350         cleanedup => $e->cleanedup,
 351         event     => $e->event
 352     };
 353 }
 354 __PACKAGE__->register_method(
 355     api_name => 'open-ils.trigger.event.fire',
 356     method   => 'fire_single_event',
 357     api_level=> 1,
 358     argc     => 1
 359 );
 360
 361 sub fire_event_group {
 362     my $self = shift;
 363     my $client = shift;
 364     my $events = shift;
 365
 366     my $e = OpenILS::Application::Trigger::EventGroup->new(@$events);
 367
 368     if ($e->validate->valid) {
 369         $e->react->cleanup;
 370     }
 371
 372     return {
 373         valid     => $e->valid,
 374         reacted   => $e->reacted,
 375         cleanedup => $e->cleanedup,
 376         events    => [map { $_->event } @{$e->events}]
 377     };
 378 }
 379 __PACKAGE__->register_method(
 380     api_name => 'open-ils.trigger.event_group.fire',
 381     method   => 'fire_event_group',
 382     api_level=> 1,
 383     argc     => 1
 384 );
 385
 386 sub pending_events {
 387     my $self = shift;
 388     my $client = shift;
 389
 390     my $editor = new_editor();
 391
 392     return $editor->search_action_trigger_event([
 393         { state => 'pending', run_time => {'<' => 'now'} },
 394         { idlist=> 1 }
 395     ]);
 396 }
 397 __PACKAGE__->register_method(
 398     api_name => 'open-ils.trigger.event.find_pending',
 399     method   => 'pending_events',
 400     api_level=> 1
 401 );
 402
 403
 404 sub grouped_events {
 405     my $self = shift;
 406     my $client = shift;
 407
 408     my ($events) = $self->method_lookup('open-ils.trigger.event.find_pending')->run();
 409
 410     my %groups = ( '*' => [] );
 411
 412     for my $e_id ( @$events ) {
 413         my $e = OpenILS::Application::Trigger::Event->new($e_id);
 414         if ($e->validate->valid) {
 415             if (my $group = $e->event->event_def->group_field) {
 416
 417                 # split the grouping link steps
 418                 my @steps = split '.', $group;
 419
 420                 # find the grouping object
 421                 my $node = $e->target;
 422                 $node = $node->$_() for ( @steps );
 423
 424                 # get the pkey value for the grouping object on this event
 425                 my $node_ident = $node->Identity;
 426                 my $ident_value = $node->$node_ident();
 427
 428                 # push this event onto the event+grouping_pkey_value stack
 429                 $groups{$e->event->event_def->id}{$ident_value} ||= [];
 430                 push @{ $groups{$e->event->event_def->id}{$ident_value} }, $e;
 431             } else {
 432                 # it's a non-grouped event
 433                 push @{ $groups{'*'} }, $e;
 434             }
 435         }
 436     }
 437
 438     return \%groups;
 439 }
 440 __PACKAGE__->register_method(
 441     api_name => 'open-ils.trigger.event.find_pending_by_group',
 442     method   => 'grouped_events',
 443     api_level=> 1
 444 );
 445
 446 sub run_all_events {
 447     my $self = shift;
 448     my $client = shift;
 449
 450     my ($groups) = $self->method_lookup('open-ils.trigger.event.find_pending_by_group')->run();
 451
 452     for my $def ( %$groups ) {
 453         if ($def eq '*') {
 454             for my $event ( @{ $$groups{'*'} } ) {
 455                 $client->respond(
 456                     $self
 457                         ->method_lookup('open-ils.trigger.event.fire')
 458                         ->run($event)
 459                 );
 460             }
 461         } else {
 462             my $defgroup = $$groups{$def};
 463             for my $ident ( keys %$defgroup ) {
 464                 $client->respond(
 465                     $self
 466                         ->method_lookup('open-ils.trigger.event_group.fire')
 467                         ->run($$defgroup{$ident})
 468                 );
 469             }
 470         }
 471     }
 472
 473
 474 }
 475 __PACKAGE__->register_method(
 476     api_name => 'open-ils.trigger.event.run_all_pending',
 477     method   => 'run_all_events',
 478     api_level=> 1
 479 );
 480
 481
 482 1;