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     my $flesh_fields = shift || {};
 141     my $flesh_depth = shift || 1;
 142
 143     my $obj_class = ref($object) || _fm_class_by_hint($object);
 144     my $obj_hint = ref($object) ? _fm_hint_by_class(ref($object)) : $object;
 145
 146     my $object_ident_field = $obj_class->Identity;
 147
 148     my $query = {
 149         select => { atev => ["id"] },
 150         from   => {
 151             atev => {
 152                 atevdef => {
 153                     field => "id",
 154                     fkey => "event_def",
 155                     join => {
 156                         ath => { field => "key", fkey => "hook" }
 157                     }
 158                 }
 159             }
 160         },
 161         where  => {
 162             "+ath"  => { core_type => $obj_hint },
 163             "+atevdef" => { active => 't' },
 164             "+atev" => { state => 'pending' }
 165         },
 166         order_by => { "+atev" => [ 'run_time' ] },
 167         distinct => 1
 168     };
 169
 170
 171     # allow multiple 'target' filters
 172     $query->{where}->{'+atev'}->{'-and'} = [];
 173
 174     # if we got a real object, filter on its pkey value
 175     if (ref($object)) { # pass an object, require that target
 176         push @{ $query->{where}->{'+atev'}->{'-and'} },
 177             { target => $object->$object_ident_field }
 178     }
 179
 180     # we have a fancy complex target filter or a list of target ids
 181     if ($$filter{target}) {
 182         push @{ $query->{where}->{'+atev'}->{'-and'} },
 183             { target => {in => $$filter{target} } };
 184     }
 185
 186     # pass no target filter or object, you get no events
 187     if (!@{ $query->{where}->{'+atev'}->{'-and'} }) {
 188         return undef;
 189     }
 190
 191     # any hook filters, other than the required core_type filter
 192     if ($$filter{hook}) {
 193         $query->{where}->{'+ath'}->{$_} = $$filter{hook}{$_}
 194             for (grep { $_ ne 'core_type' } keys %{$$filter{hook}});
 195     }
 196
 197     # any event_def filters.  defaults to { active => 't' }
 198     if ($$filter{event_def}) {
 199         $query->{where}->{'+atevdef'}->{$_} = $$filter{event_def}{$_}
 200             for (keys %{$$filter{event_def}});
 201     }
 202
 203     # any event filters.  defaults to { state => 'pending' }.
 204     # don't overwrite '-and' used for multiple target filters above
 205     if ($$filter{event}) {
 206         $query->{where}->{'+atev'}->{$_} = $$filter{event}{$_}
 207             for (grep { $_ ne '-and' } keys %{$$filter{event}});
 208     }
 209
 210     my $e = new_editor();
 211
 212     my $events = $e->json_query($query);
 213
 214     $flesh_fields->{atev} = ['event_def'] unless $flesh_fields->{atev};
 215
 216     for my $id (@$events) {
 217         my $event = $e->retrieve_action_trigger_event([
 218             $id->{id},
 219             {flesh => $flesh_depth, flesh_fields => $flesh_fields}
 220         ]);
 221
 222         (my $meth = $obj_class) =~ s/^Fieldmapper:://o;
 223         $meth =~ s/::/_/go;
 224         $meth = 'retrieve_'.$meth;
 225
 226         $event->target($e->$meth($event->target));
 227         $client->respond($event);
 228     }
 229
 230     return undef;
 231 }
 232 __PACKAGE__->register_method(
 233     api_name => 'open-ils.trigger.events_by_target',
 234     method   => 'events_by_target',
 235     api_level=> 1,
 236     stream   => 1,
 237     argc     => 2
 238 );
 239
 240 sub _fm_hint_by_class {
 241     my $class = shift;
 242     return Fieldmapper->publish_fieldmapper->{$class}->{hint};
 243 }
 244
 245 sub _fm_class_by_hint {
 246     my $hint = shift;
 247
 248     my ($class) = grep {
 249         Fieldmapper->publish_fieldmapper->{$_}->{hint} eq $hint
 250     } keys %{ Fieldmapper->publish_fieldmapper };
 251
 252     return $class;
 253 }
 254
 255 sub create_batch_events {
 256     my $self = shift;
 257     my $client = shift;
 258     my $key = shift;
 259     my $location_field = shift; # where to look for event_def.owner filtering ... circ_lib, for instance, where hook.core_type = circ
 260     my $filter = shift || {};
 261
 262     my $active = ($self->api_name =~ /active/o) ? 1 : 0;
 263     if ($active && !keys(%$filter)) {
 264         $log->info("Active batch event creation requires a target filter but none was supplied to create_batch_events");
 265         return undef;
 266     }
 267
 268     return undef unless ($key && $location_field);
 269
 270     my $editor = new_editor(xact=>1);
 271     my $hooks = $editor->search_action_trigger_hook(
 272         { passive => $active ? 'f' : 't', key => $key }
 273     );
 274
 275     my %hook_hash = map { ($_->key, $_) } @$hooks;
 276
 277     my $defs = $editor->search_action_trigger_event_definition(
 278         { hook   => [ keys %hook_hash ], active => 't' },
 279     );
 280
 281     for my $def ( @$defs ) {
 282
 283         my $date = DateTime->now->subtract( seconds => interval_to_seconds($def->delay) );
 284
 285         # we may need to do some work to backport this to 1.2
 286         $filter->{ $location_field } = { 'in' =>
 287             {
 288                 select  => { aou => [{ column => 'id', transform => 'actor.org_unit_descendants', result_field => 'id' }] },
 289                 from    => 'aou',
 290                 where   => { id => $def->owner }
 291             }
 292         };
 293
 294         my $run_time = 'now';
 295         if ($active) {
 296             $run_time =
 297                 DateTime
 298                     ->now
 299                     ->add( seconds => interval_to_seconds($def->delay) )
 300                     ->strftime( '%F %T%z' );
 301         } else {
 302             $filter->{ $def->delay_field } = {
 303                 '<=' => DateTime
 304                     ->now
 305                     ->subtract( seconds => interval_to_seconds($def->delay) )
 306                     ->strftime( '%F %T%z' )
 307             };
 308         }
 309
 310         my $class = _fm_class_by_hint($hook_hash{$def->hook}->core_type);
 311         $class =~ s/^Fieldmapper:://o;
 312         $class =~ s/::/_/go;
 313
 314         my $method = 'search_'. $class;
 315         my $objects = $editor->$method( $filter );
 316
 317         for my $o (@$objects) {
 318
 319             my $ident = $o->Identity;
 320             my $ident_value = $o->$ident();
 321
 322             my $previous;
 323             if ($active) {
 324                 # only allow one pending event of type $def for each target
 325                 $previous = $editor->search_action_trigger_event({
 326                     event_def => $def->id,
 327                     target    => $ident_value,
 328                     state     => 'pending'
 329                 });
 330
 331             } else {
 332                 # only allow one event of type $def for each target
 333                 $previous = $editor->search_action_trigger_event({
 334                     event_def => $def->id,
 335                     target    => $ident_value
 336                 });
 337
 338             }
 339
 340             next if (ref($previous) && @$previous);
 341
 342             my $event = Fieldmapper::action_trigger::event->new();
 343             $event->target( $ident_value );
 344             $event->event_def( $def->id );
 345             $event->run_time( $run_time );
 346
 347             $editor->create_action_trigger_event( $event );
 348
 349             $client->respond( $event->id );
 350         }
 351     }
 352
 353     $editor->commit;
 354
 355     return undef;
 356 }
 357 __PACKAGE__->register_method(
 358     api_name => 'open-ils.trigger.passive.event.autocreate.batch',
 359     method   => 'create_batch_events',
 360     api_level=> 1,
 361     stream   => 1,
 362     argc     => 2
 363 );
 364
 365 __PACKAGE__->register_method(
 366     api_name => 'open-ils.trigger.active.event.autocreate.batch',
 367     method   => 'create_batch_events',
 368     api_level=> 1,
 369     stream   => 1,
 370     argc     => 2
 371 );
 372
 373
 374 sub fire_single_event {
 375     my $self = shift;
 376     my $client = shift;
 377     my $event_id = shift;
 378
 379     my $e = OpenILS::Application::Trigger::Event->new($event_id);
 380
 381     if ($e->validate->valid) {
 382         $e->react->cleanup;
 383     }
 384
 385     return {
 386         valid     => $e->valid,
 387         reacted   => $e->reacted,
 388         cleanedup => $e->cleanedup,
 389         event     => $e->event
 390     };
 391 }
 392 __PACKAGE__->register_method(
 393     api_name => 'open-ils.trigger.event.fire',
 394     method   => 'fire_single_event',
 395     api_level=> 1,
 396     argc     => 1
 397 );
 398
 399 sub fire_event_group {
 400     my $self = shift;
 401     my $client = shift;
 402     my $events = shift;
 403
 404     my $e = OpenILS::Application::Trigger::EventGroup->new(@$events);
 405
 406     if ($e->validate->valid) {
 407         $e->react->cleanup;
 408     }
 409
 410     return {
 411         valid     => $e->valid,
 412         reacted   => $e->reacted,
 413         cleanedup => $e->cleanedup,
 414         events    => [map { $_->event } @{$e->events}]
 415     };
 416 }
 417 __PACKAGE__->register_method(
 418     api_name => 'open-ils.trigger.event_group.fire',
 419     method   => 'fire_event_group',
 420     api_level=> 1,
 421     argc     => 1
 422 );
 423
 424 sub pending_events {
 425     my $self = shift;
 426     my $client = shift;
 427
 428     my $editor = new_editor();
 429
 430     return $editor->search_action_trigger_event([
 431         { state => 'pending', run_time => {'<' => 'now'} },
 432         { idlist=> 1 }
 433     ]);
 434 }
 435 __PACKAGE__->register_method(
 436     api_name => 'open-ils.trigger.event.find_pending',
 437     method   => 'pending_events',
 438     api_level=> 1
 439 );
 440
 441
 442 sub grouped_events {
 443     my $self = shift;
 444     my $client = shift;
 445
 446     my ($events) = $self->method_lookup('open-ils.trigger.event.find_pending')->run();
 447
 448     my %groups = ( '*' => [] );
 449
 450     for my $e_id ( @$events ) {
 451         my $e = OpenILS::Application::Trigger::Event->new($e_id);
 452         if ($e->validate->valid) {
 453             if (my $group = $e->event->event_def->group_field) {
 454
 455                 # split the grouping link steps
 456                 my @steps = split '.', $group;
 457
 458                 # find the grouping object
 459                 my $node = $e->target;
 460                 $node = $node->$_() for ( @steps );
 461
 462                 # get the pkey value for the grouping object on this event
 463                 my $node_ident = $node->Identity;
 464                 my $ident_value = $node->$node_ident();
 465
 466                 # push this event onto the event+grouping_pkey_value stack
 467                 $groups{$e->event->event_def->id}{$ident_value} ||= [];
 468                 push @{ $groups{$e->event->event_def->id}{$ident_value} }, $e;
 469             } else {
 470                 # it's a non-grouped event
 471                 push @{ $groups{'*'} }, $e;
 472             }
 473         }
 474     }
 475
 476     return \%groups;
 477 }
 478 __PACKAGE__->register_method(
 479     api_name => 'open-ils.trigger.event.find_pending_by_group',
 480     method   => 'grouped_events',
 481     api_level=> 1
 482 );
 483
 484 sub run_all_events {
 485     my $self = shift;
 486     my $client = shift;
 487
 488     my ($groups) = $self->method_lookup('open-ils.trigger.event.find_pending_by_group')->run();
 489
 490     for my $def ( %$groups ) {
 491         if ($def eq '*') {
 492             for my $event ( @{ $$groups{'*'} } ) {
 493                 $client->respond(
 494                     $self
 495                         ->method_lookup('open-ils.trigger.event.fire')
 496                         ->run($event)
 497                 );
 498             }
 499         } else {
 500             my $defgroup = $$groups{$def};
 501             for my $ident ( keys %$defgroup ) {
 502                 $client->respond(
 503                     $self
 504                         ->method_lookup('open-ils.trigger.event_group.fire')
 505                         ->run($$defgroup{$ident})
 506                 );
 507             }
 508         }
 509     }
 510
 511
 512 }
 513 __PACKAGE__->register_method(
 514     api_name => 'open-ils.trigger.event.run_all_pending',
 515     method   => 'run_all_events',
 516     api_level=> 1
 517 );
 518
 519
 520 1;