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_batch_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     my $active = ($self->api_name =~ /active/o) ? 1 : 0;
 259     if ($active && !keys(%$filter)) {
 260         $log->info("Active batch event creation requires a target filter but none was supplied to create_batch_events");
 261         return undef;
 262     }
 263
 264     return undef unless ($key && $location_field);
 265
 266     my $editor = new_editor(xact=>1);
 267     my $hooks = $editor->search_action_trigger_hook(
 268         { passive => $active ? 'f' : 't', key => $key }
 269     );
 270
 271     my %hook_hash = map { ($_->key, $_) } @$hooks;
 272
 273     my $defs = $editor->search_action_trigger_event_definition(
 274         { hook   => [ keys %hook_hash ], active => 't' },
 275     );
 276
 277     for my $def ( @$defs ) {
 278
 279         my $date = DateTime->now->subtract( seconds => interval_to_seconds($def->delay) );
 280
 281         # we may need to do some work to backport this to 1.2
 282         $filter->{ $location_field } = { 'in' =>
 283             {
 284                 select  => { aou => [{ column => 'id', transform => 'actor.org_unit_descendents', result_field => 'id' }] },
 285                 from    => 'aou',
 286                 where   => { id => $def->owner }
 287             }
 288         };
 289
 290         my $run_time = 'now';
 291         if ($active) {
 292             $run_time = {
 293                 '<=' => DateTime
 294                     ->now
 295                     ->add( seconds => interval_to_seconds($def->delay) )
 296                     ->strftime( '%F %T%z' )
 297             };
 298         } else {
 299             $filter->{ $def->delay_field } = {
 300                 '<=' => DateTime
 301                     ->now
 302                     ->subtract( seconds => interval_to_seconds($def->delay) )
 303                     ->strftime( '%F %T%z' )
 304             };
 305         }
 306
 307         my $class = _fm_class_by_hint($hook_hash{$def->hook}->core_type);
 308         $class =~ s/^Fieldmapper:://o;
 309         $class =~ s/::/_/go;
 310
 311         my $method = 'search_'. $class;
 312         my $objects = $editor->$method( $filter );
 313
 314         for my $o (@$objects) {
 315
 316             my $ident = $o->Identity;
 317             my $ident_value = $o->$ident();
 318
 319             my $previous;
 320             if ($active) {
 321                 # only allow one pending event of type $def for each target
 322                 $previous = $editor->search_action_trigger_event({
 323                     event_def => $def->id,
 324                     target    => $ident_value,
 325                     state     => 'pending'
 326                 });
 327
 328             } else {
 329                 # only allow one event of type $def for each target
 330                 $previous = $editor->search_action_trigger_event({
 331                     event_def => $def->id,
 332                     target    => $ident_value
 333                 });
 334
 335             }
 336
 337             next if (ref($previous) && @$previous);
 338
 339             my $event = Fieldmapper::action_trigger::event->new();
 340             $event->target( $ident_value );
 341             $event->event_def( $def->id );
 342             $event->run_time( $run_time );
 343
 344             $editor->create_action_trigger_event( $event );
 345
 346             $client->respond( $event->id );
 347         }
 348     }
 349
 350     $editor->commit;
 351
 352     return undef;
 353 }
 354 __PACKAGE__->register_method(
 355     api_name => 'open-ils.trigger.passive.event.autocreate.batch',
 356     method   => 'create_batch_events',
 357     api_level=> 1,
 358     stream   => 1,
 359     argc     => 2
 360 );
 361
 362 __PACKAGE__->register_method(
 363     api_name => 'open-ils.trigger.active.event.autocreate.batch',
 364     method   => 'create_batch_events',
 365     api_level=> 1,
 366     stream   => 1,
 367     argc     => 2
 368 );
 369
 370
 371 sub fire_single_event {
 372     my $self = shift;
 373     my $client = shift;
 374     my $event_id = shift;
 375
 376     my $e = OpenILS::Application::Trigger::Event->new($event_id);
 377
 378     if ($e->validate->valid) {
 379         $e->react->cleanup;
 380     }
 381
 382     return {
 383         valid     => $e->valid,
 384         reacted   => $e->reacted,
 385         cleanedup => $e->cleanedup,
 386         event     => $e->event
 387     };
 388 }
 389 __PACKAGE__->register_method(
 390     api_name => 'open-ils.trigger.event.fire',
 391     method   => 'fire_single_event',
 392     api_level=> 1,
 393     argc     => 1
 394 );
 395
 396 sub fire_event_group {
 397     my $self = shift;
 398     my $client = shift;
 399     my $events = shift;
 400
 401     my $e = OpenILS::Application::Trigger::EventGroup->new(@$events);
 402
 403     if ($e->validate->valid) {
 404         $e->react->cleanup;
 405     }
 406
 407     return {
 408         valid     => $e->valid,
 409         reacted   => $e->reacted,
 410         cleanedup => $e->cleanedup,
 411         events    => [map { $_->event } @{$e->events}]
 412     };
 413 }
 414 __PACKAGE__->register_method(
 415     api_name => 'open-ils.trigger.event_group.fire',
 416     method   => 'fire_event_group',
 417     api_level=> 1,
 418     argc     => 1
 419 );
 420
 421 sub pending_events {
 422     my $self = shift;
 423     my $client = shift;
 424
 425     my $editor = new_editor();
 426
 427     return $editor->search_action_trigger_event([
 428         { state => 'pending', run_time => {'<' => 'now'} },
 429         { idlist=> 1 }
 430     ]);
 431 }
 432 __PACKAGE__->register_method(
 433     api_name => 'open-ils.trigger.event.find_pending',
 434     method   => 'pending_events',
 435     api_level=> 1
 436 );
 437
 438
 439 sub grouped_events {
 440     my $self = shift;
 441     my $client = shift;
 442
 443     my ($events) = $self->method_lookup('open-ils.trigger.event.find_pending')->run();
 444
 445     my %groups = ( '*' => [] );
 446
 447     for my $e_id ( @$events ) {
 448         my $e = OpenILS::Application::Trigger::Event->new($e_id);
 449         if ($e->validate->valid) {
 450             if (my $group = $e->event->event_def->group_field) {
 451
 452                 # split the grouping link steps
 453                 my @steps = split '.', $group;
 454
 455                 # find the grouping object
 456                 my $node = $e->target;
 457                 $node = $node->$_() for ( @steps );
 458
 459                 # get the pkey value for the grouping object on this event
 460                 my $node_ident = $node->Identity;
 461                 my $ident_value = $node->$node_ident();
 462
 463                 # push this event onto the event+grouping_pkey_value stack
 464                 $groups{$e->event->event_def->id}{$ident_value} ||= [];
 465                 push @{ $groups{$e->event->event_def->id}{$ident_value} }, $e;
 466             } else {
 467                 # it's a non-grouped event
 468                 push @{ $groups{'*'} }, $e;
 469             }
 470         }
 471     }
 472
 473     return \%groups;
 474 }
 475 __PACKAGE__->register_method(
 476     api_name => 'open-ils.trigger.event.find_pending_by_group',
 477     method   => 'grouped_events',
 478     api_level=> 1
 479 );
 480
 481 sub run_all_events {
 482     my $self = shift;
 483     my $client = shift;
 484
 485     my ($groups) = $self->method_lookup('open-ils.trigger.event.find_pending_by_group')->run();
 486
 487     for my $def ( %$groups ) {
 488         if ($def eq '*') {
 489             for my $event ( @{ $$groups{'*'} } ) {
 490                 $client->respond(
 491                     $self
 492                         ->method_lookup('open-ils.trigger.event.fire')
 493                         ->run($event)
 494                 );
 495             }
 496         } else {
 497             my $defgroup = $$groups{$def};
 498             for my $ident ( keys %$defgroup ) {
 499                 $client->respond(
 500                     $self
 501                         ->method_lookup('open-ils.trigger.event_group.fire')
 502                         ->run($$defgroup{$ident})
 503                 );
 504             }
 505         }
 506     }
 507
 508
 509 }
 510 __PACKAGE__->register_method(
 511     api_name => 'open-ils.trigger.event.run_all_pending',
 512     method   => 'run_all_events',
 513     api_level=> 1
 514 );
 515
 516
 517 1;