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 use OpenSRF::Utils::JSON;
   8
   9 use OpenSRF::AppSession;
  10 use OpenSRF::Utils::SettingsClient;
  11 use OpenSRF::Utils::Logger qw/$logger/;
  12 use OpenSRF::Utils qw/:datetime/;
  13
  14 use DateTime;
  15 use DateTime::Format::ISO8601;
  16
  17 use OpenILS::Utils::Fieldmapper;
  18 use OpenILS::Utils::CStoreEditor q/:funcs/;
  19 use OpenILS::Application::Trigger::Event;
  20 use OpenILS::Application::Trigger::EventGroup;
  21
  22
  23 my $log = 'OpenSRF::Utils::Logger';
  24
  25 sub initialize {}
  26 sub child_init {}
  27
  28 sub create_active_events_for_object {
  29     my $self = shift;
  30     my $client = shift;
  31     my $key = shift;
  32     my $target = shift;
  33     my $location = shift;
  34     my $granularity = shift;
  35     my $user_data = shift;
  36
  37     my $ident = $target->Identity;
  38     my $ident_value = $target->$ident();
  39
  40     my $editor = new_editor(xact=>1);
  41
  42     my $hooks = $editor->search_action_trigger_hook(
  43         { key       => $key,
  44           core_type => $target->json_hint
  45         }
  46     );
  47
  48     unless(@$hooks) {
  49         $editor->rollback;
  50         return undef;
  51     }
  52
  53     my %hook_hash = map { ($_->key, $_) } @$hooks;
  54
  55     my $orgs = $editor->json_query({ from => [ 'actor.org_unit_ancestors' => $location ] });
  56     my $defs = $editor->search_action_trigger_event_definition(
  57         { hook   => [ keys %hook_hash ],
  58           owner  => [ map { $_->{id} } @$orgs  ],
  59           active => 't'
  60         }
  61     );
  62
  63     for my $def ( @$defs ) {
  64         next if ($granularity && $def->granularity ne $granularity );
  65
  66         if ($def->usr_field && $def->opt_in_setting) {
  67             my $ufield = $def->usr_field;
  68             my $uid = $target->$ufield;
  69             $uid = $uid->id if (ref $uid); # fleshed user object, unflesh it
  70
  71             my $opt_in_setting = $editor->search_actor_usr_setting(
  72                 { usr   => $uid,
  73                   name  => $def->opt_in_setting,
  74                   value => 'true'
  75                 }
  76             );
  77
  78             next unless (@$opt_in_setting);
  79         }
  80
  81         my $date = DateTime->now;
  82
  83         if ($hook_hash{$def->hook}->passive eq 'f') {
  84
  85             if (my $dfield = $def->delay_field) {
  86                 if ($target->$dfield()) {
  87                     $date = DateTime::Format::ISO8601->new->parse_datetime( clense_ISO8601($target->$dfield) );
  88                 } else {
  89                     next;
  90                 }
  91             }
  92
  93             $date->add( seconds => interval_to_seconds($def->delay) );
  94         }
  95
  96         my $event = Fieldmapper::action_trigger::event->new();
  97         $event->target( $ident_value );
  98         $event->event_def( $def->id );
  99         $event->run_time( $date->strftime( '%F %T%z' ) );
 100         $event->user_data( OpenSRF::Utils::JSON->perl2JSON($user_data) ) if (defined($user_data));
 101
 102         $editor->create_action_trigger_event( $event );
 103
 104         $client->respond( $event->id );
 105     }
 106
 107     $editor->commit;
 108
 109     return undef;
 110 }
 111 __PACKAGE__->register_method(
 112     api_name => 'open-ils.trigger.event.autocreate',
 113     method   => 'create_active_events_for_object',
 114     api_level=> 1,
 115     stream   => 1,
 116     argc     => 3
 117 );
 118
 119 sub create_event_for_object_and_def {
 120     my $self = shift;
 121     my $client = shift;
 122     my $definitions = shift;
 123     my $target = shift;
 124     my $location = shift;
 125     my $user_data = shift;
 126
 127     my $ident = $target->Identity;
 128     my $ident_value = $target->$ident();
 129
 130     my @active = ($self->api_name =~ /inactive/o) ? () : ( active => 't' );
 131
 132     my $editor = new_editor(xact=>1);
 133
 134     my $orgs = $editor->json_query({ from => [ 'actor.org_unit_ancestors' => $location ] });
 135     my $defs = $editor->search_action_trigger_event_definition(
 136         { id => $definitions,
 137           owner  => [ map { $_->{id} } @$orgs  ],
 138           @active
 139         }
 140     );
 141
 142     my $hooks = $editor->search_action_trigger_hook(
 143         { key       => [ map { $_->hook } @$defs ],
 144           core_type => $target->json_hint
 145         }
 146     );
 147
 148     my %hook_hash = map { ($_->key, $_) } @$hooks;
 149
 150     for my $def ( @$defs ) {
 151
 152         if ($def->usr_field && $def->opt_in_setting) {
 153             my $ufield = $def->usr_field;
 154             my $uid = $target->$ufield;
 155             $uid = $uid->id if (ref $uid); # fleshed user object, unflesh it
 156
 157             my $opt_in_setting = $editor->search_actor_usr_setting(
 158                 { usr   => $uid,
 159                   name  => $def->opt_in_setting,
 160                   value => 'true'
 161                 }
 162             );
 163
 164             next unless (@$opt_in_setting);
 165         }
 166
 167         my $date = DateTime->now;
 168
 169         if ($hook_hash{$def->hook}->passive eq 'f') {
 170
 171             if (my $dfield = $def->delay_field) {
 172                 if ($target->$dfield()) {
 173                     $date = DateTime::Format::ISO8601->new->parse_datetime( clense_ISO8601($target->$dfield) );
 174                 } else {
 175                     next;
 176                 }
 177             }
 178
 179             $date->add( seconds => interval_to_seconds($def->delay) );
 180         }
 181
 182         my $event = Fieldmapper::action_trigger::event->new();
 183         $event->target( $ident_value );
 184         $event->event_def( $def->id );
 185         $event->run_time( $date->strftime( '%F %T%z' ) );
 186         $event->user_data( OpenSRF::Utils::JSON->perl2JSON($user_data) ) if (defined($user_data));
 187
 188         $editor->create_action_trigger_event( $event );
 189
 190         $client->respond( $event->id );
 191     }
 192
 193     $editor->commit;
 194
 195     return undef;
 196 }
 197 __PACKAGE__->register_method(
 198     api_name => 'open-ils.trigger.event.autocreate.by_definition',
 199     method   => 'create_event_for_object_and_def',
 200     api_level=> 1,
 201     stream   => 1,
 202     argc     => 3
 203 );
 204 __PACKAGE__->register_method(
 205     api_name => 'open-ils.trigger.event.autocreate.by_definition.include_inactive',
 206     method   => 'create_event_for_object_and_def',
 207     api_level=> 1,
 208     stream   => 1,
 209     argc     => 3
 210 );
 211
 212
 213 # Retrieves events by object, or object type + filter
 214 #  $object : a target object or object type (class hint)
 215 #
 216 #  $filter : an optional hash of filters ... top level keys:
 217 #     event
 218 #        filters on the atev objects, such as states or null-ness of timing
 219 #        fields. contains the effective default of:
 220 #          { state => 'pending' }
 221 #        an example, which overrides the default, and will find
 222 #        stale 'found' events:
 223 #          { state => 'found', update_time => { '<' => 'yesterday' } }
 224 #
 225 #      event_def
 226 #        filters on the atevdef object. contains the effective default of:
 227 #          { active => 't' }
 228 #
 229 #      hook
 230 #        filters on the hook object. no defaults, but there is a pinned,
 231 #        unchangeable filter based on the passed hint or object type (see
 232 #        $object above). an example for finding passive events:
 233 #          { passive => 't' }
 234 #
 235 #     target
 236 #        filters against the target field on the event. this can contain
 237 #        either an array of target ids (if you passed an object type, and
 238 #        not an object) or can contain a json_query that will return exactly
 239 #        a list of target-type ids.  If you pass an object, the pkey value of
 240 #        that object will be used as a filter in addition to the filter passed
 241 #        in here.  example filter for circs of user 1234 that are open:
 242 #          { select => { circ => ['id'] },
 243 #            from => 'circ',
 244 #            where => {
 245 #              usr => 1234,
 246 #              checkin_time => undef,
 247 #              '-or' => [
 248 #                { stop_fines => undef },
 249 #                { stop_fines => { 'not in' => ['LOST','LONGOVERDUE','CLAIMSRETURNED'] } }
 250 #              ]
 251 #            }
 252
 253 sub events_by_target {
 254     my $self = shift;
 255     my $client = shift;
 256     my $object = shift;
 257     my $filter = shift || {};
 258     my $flesh_fields = shift || {};
 259     my $flesh_depth = shift || 1;
 260
 261     my $obj_class = ref($object) || _fm_class_by_hint($object);
 262     my $obj_hint = ref($object) ? _fm_hint_by_class(ref($object)) : $object;
 263
 264     my $object_ident_field = $obj_class->Identity;
 265
 266     my $query = {
 267         select => { atev => ["id"] },
 268         from   => {
 269             atev => {
 270                 atevdef => {
 271                     field => "id",
 272                     fkey => "event_def",
 273                     join => {
 274                         ath => { field => "key", fkey => "hook" }
 275                     }
 276                 }
 277             }
 278         },
 279         where  => {
 280             "+ath"  => { core_type => $obj_hint },
 281             "+atevdef" => { active => 't' },
 282             "+atev" => { state => 'pending' }
 283         },
 284         order_by => { "atev" => [ 'run_time', 'add_time' ] }
 285     };
 286
 287     $query->{limit} = $filter->{limit} if defined $filter->{limit};
 288     $query->{offset} = $filter->{offset} if defined $filter->{offset};
 289     $query->{order_by} = $filter->{order_by} if defined $filter->{order_by};
 290
 291
 292     # allow multiple 'target' filters
 293     $query->{where}->{'+atev'}->{'-and'} = [];
 294
 295     # if we got a real object, filter on its pkey value
 296     if (ref($object)) { # pass an object, require that target
 297         push @{ $query->{where}->{'+atev'}->{'-and'} },
 298             { target => $object->$object_ident_field }
 299     }
 300
 301     # we have a fancy complex target filter or a list of target ids
 302     if ($$filter{target}) {
 303         push @{ $query->{where}->{'+atev'}->{'-and'} },
 304             { target => {in => $$filter{target} } };
 305     }
 306
 307     # pass no target filter or object, you get no events
 308     if (!@{ $query->{where}->{'+atev'}->{'-and'} }) {
 309         return undef;
 310     }
 311
 312     # any hook filters, other than the required core_type filter
 313     if ($$filter{hook}) {
 314         $query->{where}->{'+ath'}->{$_} = $$filter{hook}{$_}
 315             for (grep { $_ ne 'core_type' } keys %{$$filter{hook}});
 316     }
 317
 318     # any event_def filters.  defaults to { active => 't' }
 319     if ($$filter{event_def}) {
 320         $query->{where}->{'+atevdef'}->{$_} = $$filter{event_def}{$_}
 321             for (keys %{$$filter{event_def}});
 322     }
 323
 324     # any event filters.  defaults to { state => 'pending' }.
 325     # don't overwrite '-and' used for multiple target filters above
 326     if ($$filter{event}) {
 327         $query->{where}->{'+atev'}->{$_} = $$filter{event}{$_}
 328             for (grep { $_ ne '-and' } keys %{$$filter{event}});
 329     }
 330
 331     my $e = new_editor();
 332
 333     my $events = $e->json_query($query);
 334
 335     $flesh_fields->{atev} = ['event_def'] unless $flesh_fields->{atev};
 336
 337     for my $id (@$events) {
 338         my $event = $e->retrieve_action_trigger_event([
 339             $id->{id},
 340             {flesh => $flesh_depth, flesh_fields => $flesh_fields}
 341         ]);
 342
 343         (my $meth = $obj_class) =~ s/^Fieldmapper:://o;
 344         $meth =~ s/::/_/go;
 345         $meth = 'retrieve_'.$meth;
 346
 347         $event->target($e->$meth($event->target));
 348         $client->respond($event);
 349     }
 350
 351     return undef;
 352 }
 353 __PACKAGE__->register_method(
 354     api_name => 'open-ils.trigger.events_by_target',
 355     method   => 'events_by_target',
 356     api_level=> 1,
 357     stream   => 1,
 358     argc     => 2
 359 );
 360
 361 sub _fm_hint_by_class {
 362     my $class = shift;
 363     return Fieldmapper->publish_fieldmapper->{$class}->{hint};
 364 }
 365
 366 sub _fm_class_by_hint {
 367     my $hint = shift;
 368
 369     my ($class) = grep {
 370         Fieldmapper->publish_fieldmapper->{$_}->{hint} eq $hint
 371     } keys %{ Fieldmapper->publish_fieldmapper };
 372
 373     return $class;
 374 }
 375
 376 sub create_batch_events {
 377     my $self = shift;
 378     my $client = shift;
 379     my $key = shift;
 380     my $location_field = shift; # where to look for event_def.owner filtering ... circ_lib, for instance, where hook.core_type = circ
 381     my $filter = shift || {};
 382     my $granularity = shift;
 383     my $user_data = shift;
 384
 385     my $active = ($self->api_name =~ /active/o) ? 1 : 0;
 386     if ($active && !keys(%$filter)) {
 387         $log->info("Active batch event creation requires a target filter but none was supplied to create_batch_events");
 388         return undef;
 389     }
 390
 391     return undef unless ($key && $location_field);
 392
 393     my $editor = new_editor(xact=>1);
 394     my $hooks = $editor->search_action_trigger_hook(
 395         { passive => $active ? 'f' : 't', key => $key }
 396     );
 397
 398     my %hook_hash = map { ($_->key, $_) } @$hooks;
 399
 400     my $defs = $editor->search_action_trigger_event_definition(
 401         { hook   => [ keys %hook_hash ], active => 't' },
 402     );
 403
 404     my $orig_filter_and = [];
 405     if ($$filter{'-and'}) {
 406         for my $f ( @{ $$filter{'-and'} } ) {
 407             push @$orig_filter_and, $f;
 408         }
 409     }
 410
 411     for my $def ( @$defs ) {
 412         next if ($granularity && $def->granularity ne $granularity );
 413
 414         my $date = DateTime->now->subtract( seconds => interval_to_seconds($def->delay) );
 415
 416         # we may need to do some work to backport this to 1.2
 417         $filter->{ $location_field } = { 'in' =>
 418             {
 419                 select  => { aou => [{ column => 'id', transform => 'actor.org_unit_descendants', result_field => 'id' }] },
 420                 from    => 'aou',
 421                 where   => { id => $def->owner }
 422             }
 423         };
 424
 425         my $run_time = 'now';
 426         if ($active) {
 427             $run_time =
 428                 DateTime
 429                     ->now
 430                     ->add( seconds => interval_to_seconds($def->delay) )
 431                     ->strftime( '%F %T%z' );
 432         } else {
 433             if ($def->max_delay) {
 434                 my @times = sort {$a <=> $b} interval_to_seconds($def->delay), interval_to_seconds($def->max_delay);
 435                 $filter->{ $def->delay_field } = {
 436                     'between' => [
 437                         DateTime->now->subtract( seconds => $times[1] )->strftime( '%F %T%z' ),
 438                         DateTime->now->subtract( seconds => $times[0] )->strftime( '%F %T%z' )
 439                     ]
 440                 };
 441             } else {
 442                 $filter->{ $def->delay_field } = {
 443                     '<=' => DateTime->now->subtract( seconds => interval_to_seconds($def->delay) )->strftime( '%F %T%z' )
 444                 };
 445             }
 446         }
 447
 448         my $class = _fm_class_by_hint($hook_hash{$def->hook}->core_type);
 449
 450         # filter where this target has an event (and it's pending, for active hooks)
 451         $$filter{'-and'} = [];
 452         for my $f ( @$orig_filter_and ) {
 453             push @{ $$filter{'-and'} }, $f;
 454         }
 455
 456         push @{ $filter->{'-and'} }, {
 457             '-not-exists' => {
 458                 from  => 'atev',
 459                 where => {
 460                     event_def => $def->id,
 461                     target    => { '=' => { '+' . $hook_hash{$def->hook}->core_type => $class->Identity } },
 462                     ($active ? (state  => 'pending') : ())
 463                 }
 464             }
 465         };
 466
 467         if ($def->usr_field && $def->opt_in_setting) {
 468             push @{ $filter->{'-and'} }, {
 469                 '-exists' => {
 470                     from  => 'aus',
 471                     where => {
 472                         name => $def->id,
 473                         usr  => { '=' => { '+' . $hook_hash{$def->hook}->core_type => $def->usr_field } },
 474                         value=> 'true'
 475                     }
 476                 }
 477             };
 478         }
 479
 480         $class =~ s/^Fieldmapper:://o;
 481         $class =~ s/::/_/go;
 482
 483         my $method = 'search_'. $class;
 484         my $object_ids = $editor->$method( $filter, {idlist => 1, timeout => 1800} );
 485
 486         for my $o_id (@$object_ids) {
 487
 488             my $event = Fieldmapper::action_trigger::event->new();
 489             $event->target( $o_id );
 490             $event->event_def( $def->id );
 491             $event->run_time( $run_time );
 492             $event->user_data( OpenSRF::Utils::JSON->perl2JSON($user_data) ) if (defined($user_data));
 493
 494             $editor->create_action_trigger_event( $event );
 495
 496             $client->respond( $event->id );
 497         }
 498     }
 499
 500     $editor->commit;
 501
 502     return undef;
 503 }
 504 __PACKAGE__->register_method(
 505     api_name => 'open-ils.trigger.passive.event.autocreate.batch',
 506     method   => 'create_batch_events',
 507     api_level=> 1,
 508     stream   => 1,
 509     argc     => 2
 510 );
 511
 512 __PACKAGE__->register_method(
 513     api_name => 'open-ils.trigger.active.event.autocreate.batch',
 514     method   => 'create_batch_events',
 515     api_level=> 1,
 516     stream   => 1,
 517     argc     => 2
 518 );
 519
 520 sub fire_single_event {
 521     my $self = shift;
 522     my $client = shift;
 523     my $event_id = shift;
 524
 525     my $e = OpenILS::Application::Trigger::Event->new($event_id);
 526
 527     if ($e->validate->valid) {
 528         $logger->info("Event is valid, reacting...");
 529         $e->react->cleanup;
 530     }
 531
 532     $e->editor->disconnect;
 533
 534     return {
 535         valid     => $e->valid,
 536         reacted   => $e->reacted,
 537         cleanedup => $e->cleanedup,
 538         event     => $e->event
 539     };
 540 }
 541 __PACKAGE__->register_method(
 542     api_name => 'open-ils.trigger.event.fire',
 543     method   => 'fire_single_event',
 544     api_level=> 1,
 545     argc     => 1
 546 );
 547
 548 sub fire_event_group {
 549     my $self = shift;
 550     my $client = shift;
 551     my $events = shift;
 552
 553     my $e = OpenILS::Application::Trigger::EventGroup->new(@$events);
 554
 555     if ($e->validate->valid) {
 556         $logger->info("Event group is valid, reacting...");
 557         $e->react->cleanup;
 558     }
 559
 560     $e->editor->disconnect;
 561
 562     return {
 563         valid     => $e->valid,
 564         reacted   => $e->reacted,
 565         cleanedup => $e->cleanedup,
 566         events    => [map { $_->event } @{$e->events}]
 567     };
 568 }
 569 __PACKAGE__->register_method(
 570     api_name => 'open-ils.trigger.event_group.fire',
 571     method   => 'fire_event_group',
 572     api_level=> 1,
 573     argc     => 1
 574 );
 575
 576 sub pending_events {
 577     my $self = shift;
 578     my $client = shift;
 579     my $granularity = shift;
 580
 581     my $editor = new_editor();
 582
 583     my $query = [{ state => 'pending', run_time => {'<' => 'now'} }, { order_by => { atev => [ qw/run_time add_time/] }, 'join' => 'atevdef' }];
 584
 585     if (defined $granularity) {
 586         $query->[0]->{'+atevdef'} = {'-or' => [ {granularity => $granularity}, {granularity => undef} ] };
 587     } else {
 588         $query->[0]->{'+atevdef'} = {granularity => undef};
 589     }
 590
 591     return $editor->search_action_trigger_event(
 592         $query, { idlist=> 1, timeout => 1800 }
 593     );
 594 }
 595 __PACKAGE__->register_method(
 596     api_name => 'open-ils.trigger.event.find_pending',
 597     method   => 'pending_events',
 598     api_level=> 1
 599 );
 600
 601 sub grouped_events {
 602     my $self = shift;
 603     my $client = shift;
 604     my $granularity = shift;
 605
 606     my ($events) = $self->method_lookup('open-ils.trigger.event.find_pending')->run($granularity);
 607
 608     my %groups = ( '*' => [] );
 609
 610     for my $e_id ( @$events ) {
 611         $logger->info("trigger: processing event $e_id");
 612
 613         # let the client know we're still chugging along TODO add osrf support for method_lookup $client's
 614         $client->status( new OpenSRF::DomainObject::oilsContinueStatus );
 615
 616         my $e;
 617         try {
 618            $e = OpenILS::Application::Trigger::Event->new($e_id);
 619         } catch Error with {
 620             $logger->error("Event creation failed with ".shift());
 621         };
 622
 623         next unless $e;
 624
 625         try {
 626             $e->build_environment;
 627         } catch Error with {
 628             $logger->error("Event environment building failed with ".shift());
 629         };
 630
 631         if (my $group = $e->event->event_def->group_field) {
 632
 633             # split the grouping link steps
 634             my @steps = split /\./, $group;
 635
 636             # find the grouping object
 637             my $node = $e->target;
 638             $node = $node->$_() for ( @steps );
 639
 640             # get the pkey value for the grouping object on this event
 641             my $node_ident = $node->Identity;
 642             my $ident_value = $node->$node_ident();
 643
 644             # push this event onto the event+grouping_pkey_value stack
 645             $groups{$e->event->event_def->id}{$ident_value} ||= [];
 646             push @{ $groups{$e->event->event_def->id}{$ident_value} }, $e;
 647         } else {
 648             # it's a non-grouped event
 649             push @{ $groups{'*'} }, $e;
 650         }
 651
 652         $e->editor->disconnect;
 653     }
 654
 655     return \%groups;
 656 }
 657 __PACKAGE__->register_method(
 658     api_name => 'open-ils.trigger.event.find_pending_by_group',
 659     method   => 'grouped_events',
 660     api_level=> 1
 661 );
 662
 663 sub run_all_events {
 664     my $self = shift;
 665     my $client = shift;
 666     my $granularity = shift;
 667
 668     my ($groups) = $self->method_lookup('open-ils.trigger.event.find_pending_by_group')->run($granularity);
 669
 670     for my $def ( keys %$groups ) {
 671         if ($def eq '*') {
 672             for my $event ( @{ $$groups{'*'} } ) {
 673                 try {
 674                     $client->respond(
 675                         $self
 676                             ->method_lookup('open-ils.trigger.event.fire')
 677                             ->run($event)
 678                     );
 679                 } catch Error with {
 680                     $logger->error("event firing failed with ".shift());
 681                 };
 682             }
 683         } else {
 684             my $defgroup = $$groups{$def};
 685             for my $ident ( keys %$defgroup ) {
 686                 try {
 687                     $client->respond(
 688                         $self
 689                             ->method_lookup('open-ils.trigger.event_group.fire')
 690                             ->run($$defgroup{$ident})
 691                     );
 692                 } catch Error with {
 693                     $logger->error("event firing failed with ".shift());
 694                 };
 695             }
 696         }
 697     }
 698
 699
 700 }
 701 __PACKAGE__->register_method(
 702     api_name => 'open-ils.trigger.event.run_all_pending',
 703     method   => 'run_all_events',
 704     api_level=> 1
 705 );
 706
 707
 708 1;