Koha/Calendar.pm

   1 package Koha::Calendar;
   2 use strict;
   3 use warnings;
   4 use 5.010;
   5
   6 use DateTime;
   7 use DateTime::Set;
   8 use DateTime::Duration;
   9 use C4::Context;
  10 use Carp;
  11 use Readonly;
  12
  13 sub new {
  14     my ( $classname, %options ) = @_;
  15     my $self = {};
  16     bless $self, $classname;
  17     for my $o_name ( keys %options ) {
  18         my $o = lc $o_name;
  19         $self->{$o} = $options{$o_name};
  20     }
  21     if ( !defined $self->{branchcode} ) {
  22         croak 'No branchcode argument passed to Koha::Calendar->new';
  23     }
  24     $self->_init();
  25     return $self;
  26 }
  27
  28 sub _init {
  29     my $self       = shift;
  30     my $branch     = $self->{branchcode};
  31     my $dbh        = C4::Context->dbh();
  32     my $weekly_closed_days_sth = $dbh->prepare(
  33 'SELECT weekday FROM repeatable_holidays WHERE branchcode = ? AND weekday IS NOT NULL'
  34     );
  35     $weekly_closed_days_sth->execute( $branch );
  36     $self->{weekly_closed_days} = [ 0, 0, 0, 0, 0, 0, 0 ];
  37     Readonly::Scalar my $sunday => 7;
  38     while ( my $tuple = $weekly_closed_days_sth->fetchrow_hashref ) {
  39         $self->{weekly_closed_days}->[ $tuple->{weekday} ] = 1;
  40     }
  41     my $day_month_closed_days_sth = $dbh->prepare(
  42 'SELECT day, month FROM repeatable_holidays WHERE branchcode = ? AND weekday IS NULL'
  43     );
  44     $day_month_closed_days_sth->execute( $branch );
  45     $self->{day_month_closed_days} = {};
  46     while ( my $tuple = $day_month_closed_days_sth->fetchrow_hashref ) {
  47         $self->{day_month_closed_days}->{ $tuple->{month} }->{ $tuple->{day} } =
  48           1;
  49     }
  50
  51     $self->{days_mode}       = C4::Context->preference('useDaysMode');
  52     $self->{test}            = 0;
  53     return;
  54 }
  55
  56
  57 # FIXME: use of package-level variables for caching the holiday
  58 # lists breaks persistance engines.  As of 2013-12-10, the RM
  59 # is allowing this with the expectation that prior to release of
  60 # 3.16, bug 8089 will be fixed and we can switch the caching over
  61 # to Koha::Cache.
  62 our ( $exception_holidays, $single_holidays );
  63 sub exception_holidays {
  64     my ( $self ) = @_;
  65     my $dbh = C4::Context->dbh;
  66     my $branch = $self->{branchcode};
  67     if ( $exception_holidays ) {
  68         $self->{exception_holidays} = $exception_holidays;
  69         return $exception_holidays;
  70     }
  71     my $exception_holidays_sth = $dbh->prepare(
  72 'SELECT day, month, year FROM special_holidays WHERE branchcode = ? AND isexception = 1'
  73     );
  74     $exception_holidays_sth->execute( $branch );
  75     my $dates = [];
  76     while ( my ( $day, $month, $year ) = $exception_holidays_sth->fetchrow ) {
  77         push @{$dates},
  78           DateTime->new(
  79             day       => $day,
  80             month     => $month,
  81             year      => $year,
  82             time_zone => C4::Context->tz()
  83           )->truncate( to => 'day' );
  84     }
  85     $self->{exception_holidays} =
  86       DateTime::Set->from_datetimes( dates => $dates );
  87     $exception_holidays = $self->{exception_holidays};
  88     return $exception_holidays;
  89 }
  90
  91 sub single_holidays {
  92     my ( $self ) = @_;
  93     my $dbh = C4::Context->dbh;
  94     my $branch = $self->{branchcode};
  95     if ( $single_holidays ) {
  96         $self->{single_holidays} = $single_holidays;
  97         return $single_holidays;
  98     }
  99     my $single_holidays_sth = $dbh->prepare(
 100 'SELECT day, month, year FROM special_holidays WHERE branchcode = ? AND isexception = 0'
 101     );
 102     $single_holidays_sth->execute( $branch );
 103     my $dates = [];
 104     while ( my ( $day, $month, $year ) = $single_holidays_sth->fetchrow ) {
 105         push @{$dates},
 106           DateTime->new(
 107             day       => $day,
 108             month     => $month,
 109             year      => $year,
 110             time_zone => C4::Context->tz()
 111           )->truncate( to => 'day' );
 112     }
 113     $self->{single_holidays} = DateTime::Set->from_datetimes( dates => $dates );
 114     $single_holidays = $self->{single_holidays};
 115     return $single_holidays;
 116 }
 117 sub addDate {
 118     my ( $self, $startdate, $add_duration, $unit ) = @_;
 119
 120     # Default to days duration (legacy support I guess)
 121     if ( ref $add_duration ne 'DateTime::Duration' ) {
 122         $add_duration = DateTime::Duration->new( days => $add_duration );
 123     }
 124
 125     $unit ||= 'days'; # default days ?
 126     my $dt;
 127
 128     if ( $unit eq 'hours' ) {
 129         # Fixed for legacy support. Should be set as a branch parameter
 130         Readonly::Scalar my $return_by_hour => 10;
 131
 132         $dt = $self->addHours($startdate, $add_duration, $return_by_hour);
 133     } else {
 134         # days
 135         $dt = $self->addDays($startdate, $add_duration);
 136     }
 137
 138     return $dt;
 139 }
 140
 141 sub addHours {
 142     my ( $self, $startdate, $hours_duration, $return_by_hour ) = @_;
 143     my $base_date = $startdate->clone();
 144
 145     $base_date->add_duration($hours_duration);
 146
 147     # If we are using the calendar behave for now as if Datedue
 148     # was the chosen option (current intended behaviour)
 149
 150     if ( $self->{days_mode} ne 'Days' &&
 151           $self->is_holiday($base_date) ) {
 152
 153         if ( $hours_duration->is_negative() ) {
 154             $base_date = $self->prev_open_day($base_date);
 155         } else {
 156             $base_date = $self->next_open_day($base_date);
 157         }
 158
 159         $base_date->set_hour($return_by_hour);
 160
 161     }
 162
 163     return $base_date;
 164 }
 165
 166 sub addDays {
 167     my ( $self, $startdate, $days_duration ) = @_;
 168     my $base_date = $startdate->clone();
 169
 170     if ( $self->{days_mode} eq 'Calendar' ) {
 171         # use the calendar to skip all days the library is closed
 172         # when adding
 173         my $days = abs $days_duration->in_units('days');
 174
 175         if ( $days_duration->is_negative() ) {
 176             while ($days) {
 177                 $base_date = $self->prev_open_day($base_date);
 178                 --$days;
 179             }
 180         } else {
 181             while ($days) {
 182                 $base_date = $self->next_open_day($base_date);
 183                 --$days;
 184             }
 185         }
 186
 187     } else { # Days or Datedue
 188         # use straight days, then use calendar to push
 189         # the date to the next open day if Datedue
 190         $base_date->add_duration($days_duration);
 191
 192         if ( $self->{days_mode} eq 'Datedue' ) {
 193             # Datedue, then use the calendar to push
 194             # the date to the next open day if holiday
 195             if ( $self->is_holiday($base_date) ) {
 196                 if ( $days_duration->is_negative() ) {
 197                     $base_date = $self->prev_open_day($base_date);
 198                 } else {
 199                     $base_date = $self->next_open_day($base_date);
 200                 }
 201             }
 202         }
 203     }
 204
 205     return $base_date;
 206 }
 207
 208 sub is_holiday {
 209     my ( $self, $dt ) = @_;
 210     my $localdt = $dt->clone();
 211     my $day   = $localdt->day;
 212     my $month = $localdt->month;
 213
 214     $localdt->truncate( to => 'day' );
 215
 216     if ( $self->exception_holidays->contains($localdt) ) {
 217         # exceptions are not holidays
 218         return 0;
 219     }
 220
 221     my $dow = $localdt->day_of_week;
 222     # Representation fix
 223     # TODO: Shouldn't we shift the rest of the $dow also?
 224     if ( $dow == 7 ) {
 225         $dow = 0;
 226     }
 227
 228     if ( $self->{weekly_closed_days}->[$dow] == 1 ) {
 229         return 1;
 230     }
 231
 232     if ( exists $self->{day_month_closed_days}->{$month}->{$day} ) {
 233         return 1;
 234     }
 235
 236     if ( $self->single_holidays->contains($localdt) ) {
 237         return 1;
 238     }
 239
 240     # damn have to go to work after all
 241     return 0;
 242 }
 243
 244 sub next_open_day {
 245     my ( $self, $dt ) = @_;
 246     my $base_date = $dt->clone();
 247
 248     $base_date->add(days => 1);
 249
 250     while ($self->is_holiday($base_date)) {
 251         $base_date->add(days => 1);
 252     }
 253
 254     return $base_date;
 255 }
 256
 257 sub prev_open_day {
 258     my ( $self, $dt ) = @_;
 259     my $base_date = $dt->clone();
 260
 261     $base_date->add(days => -1);
 262
 263     while ($self->is_holiday($base_date)) {
 264         $base_date->add(days => -1);
 265     }
 266
 267     return $base_date;
 268 }
 269
 270 sub days_between {
 271     my $self     = shift;
 272     my $start_dt = shift;
 273     my $end_dt   = shift;
 274
 275     if ( $start_dt->compare($end_dt) > 0 ) {
 276         # swap dates
 277         my $int_dt = $end_dt;
 278         $end_dt = $start_dt;
 279         $start_dt = $int_dt;
 280     }
 281
 282
 283     # start and end should not be closed days
 284     my $days = $start_dt->delta_days($end_dt)->delta_days;
 285     for (my $dt = $start_dt->clone();
 286         $dt <= $end_dt;
 287         $dt->add(days => 1)
 288     ) {
 289         if ($self->is_holiday($dt)) {
 290             $days--;
 291         }
 292     }
 293     return DateTime::Duration->new( days => $days );
 294
 295 }
 296
 297 sub hours_between {
 298     my ($self, $start_date, $end_date) = @_;
 299     my $start_dt = $start_date->clone();
 300     my $end_dt = $end_date->clone();
 301     my $duration = $end_dt->delta_ms($start_dt);
 302     $start_dt->truncate( to => 'day' );
 303     $end_dt->truncate( to => 'day' );
 304     # NB this is a kludge in that it assumes all days are 24 hours
 305     # However for hourly loans the logic should be expanded to
 306     # take into account open/close times then it would be a duration
 307     # of library open hours
 308     my $skipped_days = 0;
 309     for (my $dt = $start_dt->clone();
 310         $dt <= $end_dt;
 311         $dt->add(days => 1)
 312     ) {
 313         if ($self->is_holiday($dt)) {
 314             ++$skipped_days;
 315         }
 316     }
 317     if ($skipped_days) {
 318         $duration->subtract_duration(DateTime::Duration->new( hours => 24 * $skipped_days));
 319     }
 320
 321     return $duration;
 322
 323 }
 324
 325 sub set_daysmode {
 326     my ( $self, $mode ) = @_;
 327
 328     # if not testing this is a no op
 329     if ( $self->{test} ) {
 330         $self->{days_mode} = $mode;
 331     }
 332
 333     return;
 334 }
 335
 336 sub clear_weekly_closed_days {
 337     my $self = shift;
 338     $self->{weekly_closed_days} = [ 0, 0, 0, 0, 0, 0, 0 ];    # Sunday only
 339     return;
 340 }
 341
 342 sub add_holiday {
 343     my $self = shift;
 344     my $new_dt = shift;
 345     my @dt = $self->single_holidays->as_list;
 346     push @dt, $new_dt;
 347     $self->{single_holidays} =
 348       DateTime::Set->from_datetimes( dates => \@dt );
 349     $single_holidays = $self->{single_holidays};
 350
 351     return;
 352 }
 353
 354 1;
 355 __END__
 356
 357 =head1 NAME
 358
 359 Koha::Calendar - Object containing a branches calendar
 360
 361 =head1 VERSION
 362
 363 This documentation refers to Koha::Calendar version 0.0.1
 364
 365 =head1 SYNOPSIS
 366
 367   use Koha::Calendar
 368
 369   my $c = Koha::Calendar->new( branchcode => 'MAIN' );
 370   my $dt = DateTime->now();
 371
 372   # are we open
 373   $open = $c->is_holiday($dt);
 374   # when will item be due if loan period = $dur (a DateTime::Duration object)
 375   $duedate = $c->addDate($dt,$dur,'days');
 376
 377
 378 =head1 DESCRIPTION
 379
 380   Implements those features of C4::Calendar needed for Staffs Rolling Loans
 381
 382 =head1 METHODS
 383
 384 =head2 new : Create a calendar object
 385
 386 my $calendar = Koha::Calendar->new( branchcode => 'MAIN' );
 387
 388 The option branchcode is required
 389
 390
 391 =head2 addDate
 392
 393     my $dt = $calendar->addDate($date, $dur, $unit)
 394
 395 C<$date> is a DateTime object representing the starting date of the interval.
 396
 397 C<$offset> is a DateTime::Duration to add to it
 398
 399 C<$unit> is a string value 'days' or 'hours' toflag granularity of duration
 400
 401 Currently unit is only used to invoke Staffs return Monday at 10 am rule this
 402 parameter will be removed when issuingrules properly cope with that
 403
 404
 405 =head2 addHours
 406
 407     my $dt = $calendar->addHours($date, $dur, $return_by_hour )
 408
 409 C<$date> is a DateTime object representing the starting date of the interval.
 410
 411 C<$offset> is a DateTime::Duration to add to it
 412
 413 C<$return_by_hour> is an integer value representing the opening hour for the branch
 414
 415
 416 =head2 addDays
 417
 418     my $dt = $calendar->addDays($date, $dur)
 419
 420 C<$date> is a DateTime object representing the starting date of the interval.
 421
 422 C<$offset> is a DateTime::Duration to add to it
 423
 424 C<$unit> is a string value 'days' or 'hours' toflag granularity of duration
 425
 426 Currently unit is only used to invoke Staffs return Monday at 10 am rule this
 427 parameter will be removed when issuingrules properly cope with that
 428
 429
 430 =head2 is_holiday
 431
 432 $yesno = $calendar->is_holiday($dt);
 433
 434 passed a DateTime object returns 1 if it is a closed day
 435 0 if not according to the calendar
 436
 437 =head2 days_between
 438
 439 $duration = $calendar->days_between($start_dt, $end_dt);
 440
 441 Passed two dates returns a DateTime::Duration object measuring the length between them
 442 ignoring closed days. Always returns a positive number irrespective of the
 443 relative order of the parameters
 444
 445 =head2 next_open_day
 446
 447 $datetime = $calendar->next_open_day($duedate_dt)
 448
 449 Passed a Datetime returns another Datetime representing the next open day. It is
 450 intended for use to calculate the due date when useDaysMode syspref is set to either
 451 'Datedue' or 'Calendar'.
 452
 453 =head2 prev_open_day
 454
 455 $datetime = $calendar->prev_open_day($duedate_dt)
 456
 457 Passed a Datetime returns another Datetime representing the previous open day. It is
 458 intended for use to calculate the due date when useDaysMode syspref is set to either
 459 'Datedue' or 'Calendar'.
 460
 461 =head2 set_daysmode
 462
 463 For testing only allows the calling script to change days mode
 464
 465 =head2 clear_weekly_closed_days
 466
 467 In test mode changes the testing set of closed days to a new set with
 468 no closed days. TODO passing an array of closed days to this would
 469 allow testing of more configurations
 470
 471 =head2 add_holiday
 472
 473 Passed a datetime object this will add it to the calendar's list of
 474 closed days. This is for testing so that we can alter the Calenfar object's
 475 list of specified dates
 476
 477 =head1 DIAGNOSTICS
 478
 479 Will croak if not passed a branchcode in new
 480
 481 =head1 BUGS AND LIMITATIONS
 482
 483 This only contains a limited subset of the functionality in C4::Calendar
 484 Only enough to support Staffs Rolling loans
 485
 486 =head1 AUTHOR
 487
 488 Colin Campbell colin.campbell@ptfs-europe.com
 489
 490 =head1 LICENSE AND COPYRIGHT
 491
 492 Copyright (c) 2011 PTFS-Europe Ltd All rights reserved
 493
 494 This program is free software: you can redistribute it and/or modify
 495 it under the terms of the GNU General Public License as published by
 496 the Free Software Foundation, either version 2 of the License, or
 497 (at your option) any later version.
 498
 499 This program is distributed in the hope that it will be useful,
 500 but WITHOUT ANY WARRANTY; without even the implied warranty of
 501 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 502 GNU General Public License for more details.
 503
 504 You should have received a copy of the GNU General Public License
 505 along with this program.  If not, see <http://www.gnu.org/licenses/>.