LP#1879983: Create and protect a floor on appt granularity
[Evergreen.git] / Open-ILS / src / perlmods / lib / OpenILS / Application / Curbside.pm
1 package OpenILS::Application::Curbside;
2
3 use strict;
4 use warnings;
5
6 use POSIX qw/strftime/;
7 use OpenSRF::AppSession;
8 use OpenILS::Application;
9 use base qw/OpenILS::Application/;
10
11 use OpenILS::Utils::DateTime qw/:datetime/;
12 use OpenILS::Utils::CStoreEditor qw/:funcs/;
13 use OpenILS::Utils::Fieldmapper;
14 use OpenILS::Application::AppUtils;
15 my $U = "OpenILS::Application::AppUtils";
16
17 use Digest::MD5 qw(md5_hex);
18
19 use DateTime;
20 use DateTime::Format::ISO8601;
21
22 my $date_parser = DateTime::Format::ISO8601->new;
23
24 use OpenSRF::Utils::Logger qw/$logger/;
25
26 sub fetch_mine { # returns appointments owned by $authtoken user, optional $org filter
27     my ($self, $conn, $authtoken, $org, $limit, $offset) = @_;
28
29     my $e = new_editor(xact => 1, authtoken => $authtoken);
30     return $e->die_event unless $e->checkauth;
31
32     # NOTE: not checking if curbside is enabled here
33     # because the pickup lib might be anything
34
35     my $slots = $e->search_action_curbside([{
36         patron    => $e->requestor->id,
37         delivered => { '=' => undef },
38         ( $org ? (org => $org) : () )
39     },{
40         ($limit  ? (limit  => $limit) : ()),
41         ($offset ? (offset => $offset) : ()),
42         flesh => 2, flesh_fields => {acsp => ['patron'], au => ['card']},
43         order_by => { acsp => {slot => {direction => 'asc'}} }
44     }]);
45
46     $conn->respond($_) for @$slots;
47     return undef;
48 }
49 __PACKAGE__->register_method(
50     method   => "fetch_mine",
51     api_name => "open-ils.curbside.fetch_mine",
52     stream   => 1,
53     signature => {
54         params => [
55             {type => 'string', desc => 'Authentication token'},
56             {type => 'number', desc => 'Optional Library ID to filter further'},
57             {type => 'number', desc => 'Fetch limit'},
58             {type => 'number', desc => 'Fetch offset'},
59         ],
60         return => { desc => 'A stream of appointments that the authenticated user owns'}
61     }
62 );
63
64 sub fetch_appointments { # returns appointment for user at location
65     my ($self, $conn, $authtoken, $usr, $org) = @_;
66
67     my $e = new_editor(xact => 1, authtoken => $authtoken);
68     return $e->die_event unless $e->checkauth;
69
70     $org ||= $e->requestor->ws_ou;
71
72     return new OpenILS::Event("CURBSIDE_NOT_ALLOWED") unless ($U->is_true(
73         $U->ou_ancestor_setting_value($org, 'circ.curbside')
74     ));
75
76     return new OpenILS::Event("BAD_PARAMS", "desc" => "No user ID supplied") unless $usr;
77
78     unless ($usr == $e->requestor->id) {
79         return $e->die_event unless $e->allowed("STAFF_LOGIN");
80     }
81
82     my $slots = $e->search_action_curbside([{
83         patron    => $usr,
84         delivered => { '=' => undef },
85         org       => $org,
86     },{
87         order_by => { acsp => {slot => {direction => 'asc'}} }
88     }]);
89
90     $conn->respond($_) for @$slots;
91     return undef;
92 }
93 __PACKAGE__->register_method(
94     method   => "fetch_appointments",
95     api_name => "open-ils.curbside.open_user_appointments_at_lib",
96     stream   => 1,
97     signature => {
98         params => [
99             {type => 'string', desc => 'Authentication token'},
100             {type => 'number', desc => 'Patron ID'},
101             {type => 'number', desc => 'Optional pickup library. If not supplied, taken from WS of session.'},
102         ],
103         return => { desc => 'A stream of appointments that the authenticated user owns'}
104     }
105 );
106
107 sub fetch_holds_for_patron_at_pickup_lib {
108     my ($self, $conn, $authtoken, $usr, $org) = @_;
109
110     my $e = new_editor(xact => 1, authtoken => $authtoken);
111     return $e->die_event unless $e->checkauth;
112
113     $org ||= $e->requestor->ws_ou;
114
115     return new OpenILS::Event("CURBSIDE_NOT_ALLOWED") unless ($U->is_true(
116         $U->ou_ancestor_setting_value($org, 'circ.curbside')
117     ));
118
119     return new OpenILS::Event("BAD_PARAMS", "desc" => "No user ID supplied") unless $usr;
120
121     my $holds = $e->search_action_hold_request({
122         usr => $usr,
123         current_shelf_lib => $org,
124         pickup_lib => $org,
125         shelf_time => {'!=' => undef},
126         cancel_time => undef,
127         fulfillment_time => undef
128     }, { idlist => 1 });
129
130     return scalar(@$holds);
131
132 }
133 __PACKAGE__->register_method(
134     method   => "fetch_holds_for_patron_at_pickup_lib",
135     api_name => "open-ils.curbside.patron.ready_holds_at_lib.count",
136     signature => {
137         params => [
138             {type => 'string', desc => 'Authentication token'},
139             {type => 'number', desc => 'Patron ID'},
140             {type => 'number', desc => 'Optional pickup library. If not supplied, taken from WS of session.'},
141         ],
142         return => { desc => 'Number of holds on the shelf for the patron at the specified library'}
143     }
144 );
145
146 sub _flesh_and_emit_slots {
147     my ($conn, $e, $slots) = @_;
148
149     for my $s (@$slots) {
150         my $start_time;
151         my $end_time;
152         if ($s->delivered) {
153             $start_time = DateTime::Format::ISO8601->new->parse_datetime(clean_ISO8601($s->delivered));
154             $end_time = $start_time->clone->add(seconds => 90); # 90 seconds is arbitrary
155         }
156         my $holds = $e->search_action_hold_request([{
157             usr => $s->patron->id,
158             current_shelf_lib => $s->org,
159             pickup_lib => $s->org,
160             shelf_time => {'!=' => undef},
161             cancel_time => undef,
162             ($s->delivered) ?
163                 (
164                     '-and' => [ { fulfillment_time => {'>=' => $start_time->strftime('%FT%T%z') } },
165                                 { fulfillment_time => {'<=' => $end_time->strftime('%FT%T%z') } } ],
166                 ) :
167                 (fulfillment_time => undef),
168         },{
169             flesh => 1, flesh_fields => {ahr => ['current_copy']},
170         }]);
171
172         my $rhrr_list = $e->search_reporter_hold_request_record(
173             {id => [ map { $_->id } @$holds ]}
174         );
175
176         my %bib_data = map {
177             ($_->id => $e->retrieve_metabib_wide_display_entry( $_->bib_record))
178         } @$rhrr_list;
179
180         $conn->respond({slot_id => $s->id, slot => $s, holds => $holds, bib_data_by_hold => \%bib_data});
181     }
182 }
183
184 sub fetch_delivered { # returns appointments delivered TODAY
185     my ($self, $conn, $authtoken, $org, $limit, $offset) = @_;
186
187     my $e = new_editor(xact => 1, authtoken => $authtoken);
188     return $e->die_event unless $e->checkauth;
189
190     $org ||= $e->requestor->ws_ou;
191
192     return new OpenILS::Event("CURBSIDE_NOT_ALLOWED") unless ($U->is_true(
193         $U->ou_ancestor_setting_value($org, 'circ.curbside')
194     ));
195
196     my $slots = $e->search_action_curbside([{
197         org => $org,
198         arrival => { '!=' => undef},
199         delivered => { '>' => 'today'},
200     },{
201         ($limit  ? (limit  => $limit) : ()),
202         ($offset ? (offset => $offset) : ()),
203         flesh => 2, flesh_fields => {acsp => ['patron'], au => ['card']},
204         order_by => { acsp => {delivered => {direction => 'desc'}} }
205     }]);
206
207     _flesh_and_emit_slots($conn, $e, $slots);
208
209     return undef;
210 }
211 __PACKAGE__->register_method(
212     method   => "fetch_delivered",
213     api_name => "open-ils.curbside.fetch_delivered",
214     stream   => 1,
215     signature => {
216         params => [
217             {type => 'string', desc => 'Authentication token'},
218             {type => 'number', desc => 'Library ID'},
219             {type => 'number', desc => 'Fetch limit'},
220             {type => 'number', desc => 'Fetch offset'},
221         ],
222         return => { desc => 'A stream of appointments that were delivered today'}
223     }
224 );
225
226 sub fetch_latest_delivered { # returns appointments delivered TODAY
227     my ($self, $conn, $authtoken, $org) = @_;
228
229     my $e = new_editor(xact => 1, authtoken => $authtoken);
230     return $e->die_event unless $e->checkauth;
231
232     $org ||= $e->requestor->ws_ou;
233
234     return new OpenILS::Event("CURBSIDE_NOT_ALLOWED") unless ($U->is_true(
235         $U->ou_ancestor_setting_value($org, 'circ.curbside')
236     ));
237
238     my $slots = $e->search_action_curbside([{
239         org => $org,
240         arrival => { '!=' => undef},
241         delivered => { '>' => 'today'},
242     },{
243         order_by => { acsp => {delivered => {direction => 'desc'}} }
244     }],{ idlist => 1 });
245
246     return md5_hex( join(',', @$slots) );
247 }
248 __PACKAGE__->register_method(
249     method   => "fetch_latest_delivered",
250     api_name => "open-ils.curbside.fetch_delivered.latest",
251     signature => {
252         params => [
253             {type => 'string', desc => 'Authentication token'},
254             {type => 'number', desc => 'Library ID'},
255         ],
256         return => { desc => 'Hash of appointment IDs delivered today, or error event'}
257     }
258 );
259
260 sub fetch_arrived {
261     my ($self, $conn, $authtoken, $org, $limit, $offset) = @_;
262
263     my $e = new_editor(xact => 1, authtoken => $authtoken);
264     return $e->die_event unless $e->checkauth;
265
266     $org ||= $e->requestor->ws_ou;
267
268     return new OpenILS::Event("CURBSIDE_NOT_ALLOWED") unless ($U->is_true(
269         $U->ou_ancestor_setting_value($org, 'circ.curbside')
270     ));
271
272     my $slots = $e->search_action_curbside([{
273         org => $org,
274         arrival => { '!=' => undef},
275         delivered => undef,
276     },{
277         ($limit  ? (limit  => $limit) : ()),
278         ($offset ? (offset => $offset) : ()),
279         flesh => 3, flesh_fields => {acsp => ['patron'], au => ['card','standing_penalties'], ausp => ['standing_penalty']},
280         order_by => { acsp => 'arrival' }
281     }]);
282
283
284     _flesh_and_emit_slots($conn, $e, $slots);
285
286     return undef;
287 }
288 __PACKAGE__->register_method(
289     method   => "fetch_arrived",
290     api_name => "open-ils.curbside.fetch_arrived",
291     stream   => 1,
292     signature => {
293         params => [
294             {type => 'string', desc => 'Authentication token'},
295             {type => 'number', desc => 'Library ID'},
296             {type => 'number', desc => 'Fetch limit'},
297             {type => 'number', desc => 'Fetch offset'},
298         ],
299         return => { desc => 'A stream of appointments for patrons that have arrived but are not delivered'}
300     }
301 );
302
303 sub fetch_latest_arrived {
304     my ($self, $conn, $authtoken, $org) = @_;
305
306     my $e = new_editor(xact => 1, authtoken => $authtoken);
307     return $e->die_event unless $e->checkauth;
308
309     $org ||= $e->requestor->ws_ou;
310
311     return new OpenILS::Event("CURBSIDE_NOT_ALLOWED") unless ($U->is_true(
312         $U->ou_ancestor_setting_value($org, 'circ.curbside')
313     ));
314
315     my $slots = $e->search_action_curbside([{
316         org => $org,
317         arrival => { '!=' => undef},
318         delivered => undef,
319     },{
320         order_by => { acsp => { arrival => { direction => 'desc' } } }
321     }],{ idlist => 1 });
322
323     return md5_hex( join(',', @$slots) );
324 }
325 __PACKAGE__->register_method(
326     method   => "fetch_latest_arrived",
327     api_name => "open-ils.curbside.fetch_arrived.latest",
328     signature => {
329         params => [
330             {type => 'string', desc => 'Authentication token'},
331             {type => 'number', desc => 'Library ID'},
332         ],
333         return => { desc => 'Hash of appointment IDs for undelivered appointments'}
334     }
335 );
336
337 sub fetch_staged {
338     my ($self, $conn, $authtoken, $org, $limit, $offset) = @_;
339
340     my $e = new_editor(xact => 1, authtoken => $authtoken);
341     return $e->die_event unless $e->checkauth;
342
343     $org ||= $e->requestor->ws_ou;
344
345     return new OpenILS::Event("CURBSIDE_NOT_ALLOWED") unless ($U->is_true(
346         $U->ou_ancestor_setting_value($org, 'circ.curbside')
347     ));
348
349     my $slots = $e->search_action_curbside([{
350         org => $org,
351         staged => { '!=' => undef},
352         arrival => undef
353     },{
354         ($limit  ? (limit  => $limit) : ()),
355         ($offset ? (offset => $offset) : ()),
356         flesh => 3, flesh_fields => {acsp => ['patron'], au => ['card','standing_penalties'], ausp => ['standing_penalty']},
357         order_by => { acsp => 'slot' }
358     }]);
359
360     _flesh_and_emit_slots($conn, $e, $slots);
361
362     return undef;
363 }
364 __PACKAGE__->register_method(
365     method   => "fetch_staged",
366     api_name => "open-ils.curbside.fetch_staged",
367     stream   => 1,
368     signature => {
369         params => [
370             {type => 'string', desc => 'Authentication token'},
371             {type => 'number', desc => 'Library ID'},
372             {type => 'number', desc => 'Fetch limit'},
373             {type => 'number', desc => 'Fetch offset'},
374         ],
375         return => { desc => 'A stream of appointments that are staged but patrons have not yet arrived'}
376     }
377 );
378
379 sub fetch_latest_staged {
380     my ($self, $conn, $authtoken, $org) = @_;
381
382     my $e = new_editor(xact => 1, authtoken => $authtoken);
383     return $e->die_event unless $e->checkauth;
384
385     $org ||= $e->requestor->ws_ou;
386
387     return new OpenILS::Event("CURBSIDE_NOT_ALLOWED") unless ($U->is_true(
388         $U->ou_ancestor_setting_value($org, 'circ.curbside')
389     ));
390
391     my $slots = $e->search_action_curbside([{
392         org => $org,
393         staged => { '!=' => undef},
394         arrival => undef
395     },{
396         order_by => [
397             { class => acsp => field => slot => direction => 'desc' },
398             { class => acsp => field => id   => direction => 'desc' }
399         ]
400     }],{ idlist => 1 });
401
402     return md5_hex( join(',', @$slots) );
403 }
404 __PACKAGE__->register_method(
405     method   => "fetch_latest_staged",
406     api_name => "open-ils.curbside.fetch_staged.latest",
407     signature => {
408         params => [
409             {type => 'string', desc => 'Authentication token'},
410             {type => 'number', desc => 'Library ID'},
411         ],
412         return => { desc => 'Hash of appointment IDs for staged appointment'}
413     }
414 );
415
416 sub fetch_to_be_staged {
417     my ($self, $conn, $authtoken, $org, $limit, $offset) = @_;
418
419     my $e = new_editor(xact => 1, authtoken => $authtoken);
420     return $e->die_event unless $e->checkauth;
421
422     $org ||= $e->requestor->ws_ou;
423
424     return new OpenILS::Event("CURBSIDE_NOT_ALLOWED") unless ($U->is_true(
425         $U->ou_ancestor_setting_value($org, 'circ.curbside')
426     ));
427
428     my $gran = $U->ou_ancestor_setting_value($org, 'circ.curbside.granularity') || '15 minutes';
429     my $gran_seconds = interval_to_seconds($gran);
430     my $horizon = DateTime->now; # NOTE: does not need timezone set because it gets UTC, not floating, so we can math with it
431     $horizon->add(seconds => $gran_seconds * 2);
432
433     my $slots = $e->search_action_curbside([{
434         org => $org,
435         staged => undef,
436         slot => { '<=' => $horizon->strftime('%FT%T%z') },
437     },{
438         ($limit  ? (limit  => $limit) : ()),
439         ($offset ? (offset => $offset) : ()),
440         flesh => 3, flesh_fields => {acsp => ['patron','stage_staff'], au => ['card','standing_penalties'], ausp => ['standing_penalty']},
441         order_by => { acsp => 'slot' }
442     }]);
443
444     _flesh_and_emit_slots($conn, $e, $slots);
445
446     return undef;
447 }
448 __PACKAGE__->register_method(
449     method   => "fetch_to_be_staged",
450     api_name => "open-ils.curbside.fetch_to_be_staged",
451     stream   => 1,
452     signature => {
453         params => [
454             {type => 'string', desc => 'Authentication token'},
455             {type => 'number', desc => 'Library ID'},
456             {type => 'number', desc => 'Fetch limit'},
457             {type => 'number', desc => 'Fetch offset'},
458         ],
459         return => { desc => 'A stream of appointments that need to be staged'}
460     }
461 );
462
463 sub fetch_latest_to_be_staged {
464     my ($self, $conn, $authtoken, $org) = @_;
465
466     my $e = new_editor(xact => 1, authtoken => $authtoken);
467     return $e->die_event unless $e->checkauth;
468
469     $org ||= $e->requestor->ws_ou;
470
471     return new OpenILS::Event("CURBSIDE_NOT_ALLOWED") unless ($U->is_true(
472         $U->ou_ancestor_setting_value($org, 'circ.curbside')
473     ));
474
475     my $gran = $U->ou_ancestor_setting_value($org, 'circ.curbside.granularity') || '15 minutes';
476     my $gran_seconds = interval_to_seconds($gran);
477     my $horizon = DateTime->now; # NOTE: does not need timezone set because it gets UTC, not floating, so we can math with it
478     $horizon->add(seconds => $gran_seconds * 2);
479
480     my $slots = $e->search_action_curbside([{
481         org => $org,
482         staged => undef,
483         slot => { '<=' => $horizon->strftime('%FT%T%z') },
484     },{
485         order_by => [
486             { class => acsp => field => slot => direction => 'desc' },
487             { class => acsp => field => id   => direction => 'desc' }
488         ]
489     }]);
490
491     return md5_hex( join(',', map { join('-', $_->id(), $_->stage_staff() // '', $_->arrival() // '') } @$slots) );
492 }
493 __PACKAGE__->register_method(
494     method   => "fetch_latest_to_be_staged",
495     api_name => "open-ils.curbside.fetch_to_be_staged.latest",
496     signature => {
497         params => [
498             {type => 'string', desc => 'Authentication token'},
499             {type => 'number', desc => 'Library ID'},
500         ],
501         return => { desc => 'Hash of appointment IDs that needs to be staged'}
502     }
503 );
504
505 sub times_for_date {
506     my ($self, $conn, $authtoken, $date, $org) = @_;
507
508     my $e = new_editor(xact => 1, authtoken => $authtoken);
509     return $e->die_event unless $e->checkauth;
510
511     $org ||= $e->requestor->ws_ou;
512
513     return new OpenILS::Event("CURBSIDE_NOT_ALLOWED") unless ($U->is_true(
514         $U->ou_ancestor_setting_value($org, 'circ.curbside')
515     ));
516
517     my $start_obj = $date_parser->parse_datetime($date);
518     return $conn->respond_complete unless ($start_obj);
519
520     my $gran = $U->ou_ancestor_setting_value($org, 'circ.curbside.granularity') || '15 minutes';
521     $gran .= ' minutes' if ($gran =~ /^\s*\d+\s*$/); # Assume minutes for bare numbers (maybe surrounded by spaces)
522
523     my $gran_seconds = interval_to_seconds($gran);
524     $gran_seconds = 600 if ($gran_seconds < 600); # No smaller than 10 minute intervals
525
526     my $max = $U->ou_ancestor_setting_value($org, 'circ.curbside.max_concurrent') || 10;
527
528     my $hoo = $e->retrieve_actor_org_unit_hours_of_operation($org);
529     return undef unless ($hoo);
530
531     my $dow = $start_obj->day_of_week_0;
532
533     my $open_method = "dow_${dow}_open";
534     my $close_method = "dow_${dow}_close";
535
536     my $open_time = $hoo->$open_method;
537     my $close_time = $hoo->$close_method;
538     return $conn->respond_complete if ($open_time eq $close_time); # location closed that day
539
540     my $tz = $U->ou_ancestor_setting_value($org, 'lib.timezone') || 'local';
541     $start_obj = $date_parser->parse_datetime($date.'T'.$open_time)->set_time_zone($tz); # reset this to opening time
542     my $end_obj = $date_parser->parse_datetime($date.'T'.$close_time)->set_time_zone($tz);
543
544     my $now_obj = DateTime->now; # NOTE: does not need timezone set because it gets UTC, not floating, so we can math with it
545     # Add two step intervals to avoid having an appointment be scheduled
546     # sooner than the library could stage the items. Setting the earliest
547     # available time to be no earlier than two intervals from now
548     # is arbitrary and could be made configurable in the future, though
549     # it does follow the hard-coding of the horizon in fetch_to_be_staged().
550     $now_obj->add(seconds => 2 * $gran_seconds);
551
552     my $step_obj = $start_obj->clone;
553     while (DateTime->compare($step_obj,$end_obj) < 0) { # inside HOO
554         if (DateTime->compare($step_obj,$now_obj) >= 0) { # only offer times in the future
555             my $step_ts = $step_obj->strftime('%FT%T%z');
556             my $other_slots = $e->search_action_curbside({org => $org, slot => $step_ts}, {idlist => 1});
557             my $available = $max - scalar(@$other_slots);
558             $available = $available < 0 ? 0 : $available; # so truthiness testing is always easy in the client
559
560             $conn->respond([$step_obj->strftime('%T'), $available]);
561         }
562         $step_obj->add(seconds => $gran_seconds);
563     }
564
565     $e->disconnect;
566     return undef;
567 }
568 __PACKAGE__->register_method(
569     method   => "times_for_date",
570     api_name => "open-ils.curbside.times_for_date",
571     stream   => 1,
572     argc     => 2,
573     signature=> {
574         params => [
575             {type => "string", desc => "Authentication token"},
576             {type => "string", desc => "Date to find times for"},
577             {type => "number", desc => "Library ID (default ws_ou)"},
578         ],
579         return => {desc => 'A stream of array refs, structure: ["hh:mm:ss",$available_count]; event on error.'}
580     },
581     notes   => 'Restricted to logged in users to avoid spamming induced load'
582 );
583
584 sub create_update_appointment {
585     my ($self, $conn, $authtoken, $patron, $date, $time, $org, $notes) = @_;
586     my $mode = 'create';
587     $mode = 'update' if ($self->api_name =~ /update/);
588
589     my $e = new_editor(xact => 1, authtoken => $authtoken);
590     return $e->die_event unless $e->checkauth;
591
592     $org ||= $e->requestor->ws_ou;
593
594     return new OpenILS::Event("CURBSIDE_NOT_ALLOWED") unless ($U->is_true(
595         $U->ou_ancestor_setting_value($org, 'circ.curbside')
596     ));
597
598     unless ($patron == $e->requestor->id) {
599         return $e->die_event unless $e->allowed("STAFF_LOGIN");
600     }
601
602     my $date_obj = $date_parser->parse_datetime($date); # no TZ necessary, just using it to test the input and get DOW
603     return undef unless ($date_obj);
604
605     if ($time =~ /^\d\d:\d\d$/) {
606         $time .= ":00"; # tack on seconds if needed to keep
607                         # interval_to_seconds happy
608     }
609
610     my $slot;
611
612     # do they already have an open slot?
613     # NOTE: once arrival is set, it's past the point of editing.
614     my $old_slot = $e->search_action_curbside({
615         patron  => $patron,
616         org     => $org,
617         slot    => { '!=' => undef },
618         arrival => undef
619     })->[0];
620     if ($old_slot) {
621         if ($mode eq 'create') {
622             my $ev = new OpenILS::Event("CURBSIDE_EXISTS");
623             $e->disconnect;
624             return $ev;
625         } else {
626             $slot = $old_slot;
627         }
628     }
629
630     my $gran = $U->ou_ancestor_setting_value($org, 'circ.curbside.granularity') || '15 minutes';
631     my $max = $U->ou_ancestor_setting_value($org, 'circ.curbside.max_concurrent') || 10;
632
633     # some sanity checking
634     my $hoo = $e->retrieve_actor_org_unit_hours_of_operation($org);
635     return undef unless ($hoo);
636
637     my $dow = $date_obj->day_of_week_0;
638
639     my $open_method = "dow_${dow}_open";
640     my $close_method = "dow_${dow}_close";
641
642     my $open_time = $hoo->$open_method;
643     my $close_time = $hoo->$close_method;
644     return undef if ($open_time eq $close_time); # location closed that day
645
646     my $open_seconds = interval_to_seconds($open_time);
647     my $close_seconds = interval_to_seconds($close_time);
648
649     my $time_seconds = interval_to_seconds($time);
650     my $gran_seconds = interval_to_seconds($gran);
651
652     return undef if ($time_seconds < $open_seconds); # too early
653     return undef if ($time_seconds > $close_seconds + 1); # too late (/at/ closing allowed)
654
655     my $time_into_open_second = $time_seconds - $open_seconds;
656     if (my $extra_time = $time_into_open_second % $gran) { # a remainder means we got a time we shouldn't have
657         $time_into_open_second -= $extra_time; # just back it off to have staff gather earlier
658     }
659
660     my $tz = $U->ou_ancestor_setting_value($org, 'lib.timezone') || 'local';
661     $date_obj = $date_parser->parse_datetime($date.'T'.$open_time)->set_time_zone($tz);
662
663     my $slot_ts = $date_obj->add(seconds => $time_into_open_second)->strftime('%FT%T%z');
664
665     # finally, confirm that there aren't too many already
666     my $other_slots = $e->search_action_curbside(
667         { org => $org,
668           slot => $slot_ts,
669           ( $slot ? (id => { '<>' => $slot->id }) : () ) # exclude our own slot from the count
670         },
671         {idlist => 1}
672     );
673     if (scalar(@$other_slots) >= $max) { # oops... return error
674         my $ev = new OpenILS::Event("CURBSIDE_MAX_FOR_TIME");
675         $e->disconnect;
676         return $ev;
677     }
678
679     my $method = 'update_action_curbside';
680     if ($mode eq 'create' or !$slot) {
681         $slot = $e->search_action_curbside({
682             patron  => $patron,
683             org     => $org,
684             slot    => undef,
685             arrival => undef,
686         })->[0];
687     }
688
689     if (!$slot) { # just in case the hold-ready reactor isn't in place
690         $slot = Fieldmapper::action::curbside->new;
691         $slot->isnew(1);
692         $slot->patron($patron);
693         $slot->org($org);
694         $slot->notes($notes) if ($notes);
695         $method = 'create_action_curbside';
696     } else {
697         $slot->notes($notes) if ($notes);
698         $slot->ischanged(1);
699         $method = 'update_action_curbside';
700     }
701
702     $slot->slot($slot_ts);
703     $e->$method($slot) or return $e->die_event;
704
705     $e->commit;
706     $conn->respond_complete($e->retrieve_action_curbside($slot->id));
707
708     OpenSRF::AppSession
709         ->create('open-ils.trigger')
710         ->request(
711             'open-ils.trigger.event.autocreate',
712             'hold.confirm_curbside',
713             $slot, $slot->org);
714
715     return undef;
716 }
717 __PACKAGE__->register_method(
718     method   => "create_update_appointment",
719     api_name => "open-ils.curbside.update_appointment",
720     signature => {
721         params => [
722             {type => 'string', desc => 'Authentication token'},
723             {type => 'number', desc => 'Patron ID'},
724             {type => 'string', desc => 'New Date'},
725             {type => 'string', desc => 'New Time'},
726             {type => 'number', desc => 'Library ID (default ws_ou)'},
727         ],
728         return => { desc => 'An action::curbside record on success, '.
729                             'an ILS Event on config, permission, or '.
730                             'recoverable errors, or nothing on bad '.
731                             'or silly data'}
732     }
733 );
734
735 __PACKAGE__->register_method(
736     method   => "create_update_appointment",
737     api_name => "open-ils.curbside.create_appointment",
738     signature => {
739         params => [
740             {type => 'string', desc => 'Authentication token'},
741             {type => 'number', desc => 'Patron ID'},
742             {type => 'string', desc => 'Date'},
743             {type => 'string', desc => 'Time'},
744             {type => 'number', desc => 'Library ID (default ws_ou)'},
745         ],
746         return => { desc => 'An action::curbside record on success, '.
747                             'an ILS Event on config, permission, or '.
748                             'recoverable errors, or nothing on bad '.
749                             'or silly data'}
750     }
751 );
752
753 sub delete_appointment {
754     my ($self, $conn, $authtoken, $appointment) = @_;
755     my $e = new_editor(xact => 1, authtoken => $authtoken);
756     return $e->die_event unless $e->checkauth;
757
758     my $slot = $e->retrieve_action_curbside($appointment);
759     return undef unless ($slot);
760
761     unless ($slot->patron == $e->requestor->id) {
762         return $e->die_event unless $e->allowed("STAFF_LOGIN");
763     }
764
765     $e->delete_action_curbside($slot) or return $e->die_event;
766     $e->commit;
767
768     return -1;
769 }
770 __PACKAGE__->register_method(
771     method   => "delete_appointment",
772     api_name => "open-ils.curbside.delete_appointment",
773     signature => {
774         params => [
775             {type => 'string', desc => 'Authentication token'},
776             {type => 'number', desc => 'Appointment ID'},
777         ],
778         return => { desc => '-1 on success, nothing when no appointment found, '.
779                             'or an ILS Event on permission error'}
780     }
781 );
782
783 sub manage_staging_claim {
784     my ($self, $conn, $authtoken, $appointment) = @_;
785     my $e = new_editor(xact => 1, authtoken => $authtoken);
786     return $e->die_event unless $e->checkauth;
787     return $e->die_event unless $e->allowed("STAFF_LOGIN");
788
789     my $slot = $e->retrieve_action_curbside($appointment);
790     return undef unless ($slot);
791
792     if ($self->api_name =~ /unclaim/) {
793         $slot->clear_stage_staff();
794     } else {
795         $slot->stage_staff($e->requestor->id);
796     }
797
798     $e->update_action_curbside($slot) or return $e->die_event;
799     $e->commit;
800
801     return $e->retrieve_action_curbside([
802         $slot->id, {
803             flesh => 3,
804             flesh_fields => {acsp => ['patron','stage_staff'], au => ['card','standing_penalties'], ausp => ['standing_penalty']},
805         }
806     ]);
807 }
808 __PACKAGE__->register_method(
809     method   => "manage_staging_claim",
810     api_name => "open-ils.curbside.claim_staging",
811     signature => {
812         params => [
813             {type => 'string', desc => 'Authentication token'},
814             {type => 'number', desc => 'Appointment ID'},
815         ],
816         return => { desc => 'Appointment on success, nothing when no appointment found, '.
817                             'an ILS Event on permission error'}
818     }
819 );
820 __PACKAGE__->register_method(
821     method   => "manage_staging_claim",
822     api_name => "open-ils.curbside.unclaim_staging",
823     signature => {
824         params => [
825             {type => 'string', desc => 'Authentication token'},
826             {type => 'number', desc => 'Appointment ID'},
827         ],
828         return => { desc => 'Appointment on success, nothing when no appointment found, '.
829                             'an ILS Event on permission error'}
830     }
831 );
832
833 sub mark_staged {
834     my ($self, $conn, $authtoken, $appointment) = @_;
835     my $e = new_editor(xact => 1, authtoken => $authtoken);
836     return $e->die_event unless $e->checkauth;
837     return $e->die_event unless $e->allowed("STAFF_LOGIN");
838
839     my $slot = $e->retrieve_action_curbside($appointment);
840     return undef unless ($slot);
841
842     $slot->staged('now');
843     $slot->stage_staff($e->requestor->id);
844     $e->update_action_curbside($slot) or return $e->die_event;
845     $e->commit;
846
847     return $e->retrieve_action_curbside($slot->id);
848 }
849 __PACKAGE__->register_method(
850     method   => "mark_staged",
851     api_name => "open-ils.curbside.mark_staged",
852     signature => {
853         params => [
854             {type => 'string', desc => 'Authentication token'},
855             {type => 'number', desc => 'Appointment ID'},
856         ],
857         return => { desc => 'Appointment on success, nothing when no appointment found, '.
858                             'an ILS Event on permission error'}
859     }
860 );
861
862 sub mark_unstaged {
863     my ($self, $conn, $authtoken, $appointment) = @_;
864     my $e = new_editor(xact => 1, authtoken => $authtoken);
865     return $e->die_event unless $e->checkauth;
866     return $e->die_event unless $e->allowed("STAFF_LOGIN");
867
868     my $slot = $e->retrieve_action_curbside($appointment);
869     return undef unless ($slot);
870
871     $slot->clear_staged();
872     $slot->clear_stage_staff();
873     $e->update_action_curbside($slot) or return $e->die_event;
874     $e->commit;
875
876     return $e->retrieve_action_curbside($slot->id);
877 }
878 __PACKAGE__->register_method(
879     method   => "mark_unstaged",
880     api_name => "open-ils.curbside.mark_unstaged",
881     signature => {
882         params => [
883             {type => 'string', desc => 'Authentication token'},
884             {type => 'number', desc => 'Appointment ID'},
885         ],
886         return => { desc => 'Appointment on success, nothing when no appointment found, '.
887                             'an ILS Event on permission error'}
888     }
889 );
890
891 sub mark_arrived {
892     my ($self, $conn, $authtoken, $appointment) = @_;
893     my $e = new_editor(xact => 1, authtoken => $authtoken);
894     return $e->die_event unless $e->checkauth;
895
896     my $slot = $e->retrieve_action_curbside($appointment);
897     return undef unless ($slot);
898
899     unless ($slot->patron == $e->requestor->id) {
900         return $e->die_event unless $e->allowed("STAFF_LOGIN");
901     }
902
903     $slot->arrival('now');
904
905     $e->update_action_curbside($slot) or return $e->die_event;
906     $e->commit;
907
908     return $e->retrieve_action_curbside($slot->id);
909 }
910 __PACKAGE__->register_method(
911     method   => "mark_arrived",
912     api_name => "open-ils.curbside.mark_arrived",
913     signature => {
914         params => [
915             {type => 'string', desc => 'Authentication token'},
916             {type => 'number', desc => 'Appointment ID'},
917         ],
918         return => { desc => 'Appointment on success, nothing when no appointment found, '.
919                             'or an ILS Event on permission error'}
920     }
921 );
922
923 sub mark_delivered {
924     my ($self, $conn, $authtoken, $appointment) = @_;
925     my $e = new_editor(xact => 1, authtoken => $authtoken);
926     return $e->die_event unless $e->checkauth;
927     return $e->die_event unless $e->allowed("STAFF_LOGIN");
928
929     my $slot = $e->retrieve_action_curbside($appointment);
930     return undef unless ($slot);
931
932     if (!$slot->staged) {
933         $slot->staged('now');
934         $slot->stage_staff($e->requestor->id);
935     }
936
937     if (!$slot->arrival) {
938         $slot->arrival('now');
939     }
940
941     $slot->delivered('now');
942     $slot->delivery_staff($e->requestor->id);
943
944     $e->update_action_curbside($slot) or return $e->die_event;
945     $e->commit;
946
947     my $holds = $e->search_action_hold_request({
948         usr => $slot->patron,
949         current_shelf_lib => $slot->org,
950         pickup_lib => $slot->org,
951         shelf_time => {'!=' => undef},
952         cancel_time => undef,
953         fulfillment_time => undef
954     });
955
956     my $circ_sess = OpenSRF::AppSession->connect('open-ils.circ');
957     my @requests = map {
958         $circ_sess->request( # Just try as hard as possible to check out everything
959             'open-ils.circ.checkout.full.override',
960             $authtoken, { patron => $slot->patron, copyid => $_->current_copy }
961         )
962     } @$holds;
963
964     my @successful_checkouts;
965     my $successful_patron;
966     for my $r (@requests) {
967         my $co_res = $r->gather(1);
968         $conn->respond($co_res);
969         next if (ref($co_res) eq 'ARRAY'); # success is always singular
970
971         if ($co_res->{textcode} eq 'SUCCESS') { # that's great news...
972             push @successful_checkouts, $co_res->{payload}->{circ}->id;
973             $successful_patron = $co_res->{payload}->{circ}->usr;
974         }
975     }
976
977     $conn->respond_complete($e->retrieve_action_curbside($slot->id));
978
979     $circ_sess->request(
980         'open-ils.circ.checkout.batch_notify.session.atomic',
981         $authtoken,
982         $successful_patron,
983         \@successful_checkouts
984     ) if (@successful_checkouts);
985
986     $circ_sess->disconnect;
987     return undef;
988 }
989 __PACKAGE__->register_method(
990     method   => "mark_delivered",
991     api_name => "open-ils.curbside.mark_delivered",
992     stream   => 1,
993     signature => {
994         params => [
995             {type => 'string', desc => 'Authentication token'},
996             {type => 'number', desc => 'Appointment ID'},
997         ],
998         return => { desc => 'Nothing for no appointment found, '.
999                             'a stream of open-ils.circ.checkout.full.override '.
1000                             'responses followed by the finalized slot, '.
1001                             'or an ILS Event on permission error'}
1002     }
1003 );
1004
1005 1;