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 $branchcode = $self->{branchcode};
  95     if ( $single_holidays->{$branchcode} ) {
  96         $self->{single_holidays}{$branchcode} = $single_holidays->{$branchcode};
  97         return $single_holidays->{$branchcode};
  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( $branchcode );
 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}{$branchcode} = DateTime::Set->from_datetimes( dates => $dates );
 114     $single_holidays->{$branchcode} = $self->{single_holidays}{$branchcode};
 115     return $single_holidays->{$branchcode};
 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     my $branchcode = $self->{branchcode};
 348     $self->{single_holidays}{$branchcode} =
 349       DateTime::Set->from_datetimes( dates => \@dt );
 350     $single_holidays->{$branchcode} = $self->{single_holidays}{$branchcode};
 351
 352     return;
 353 }
 354
 355 1;
 356 __END__
 357
 358 =head1 NAME
 359
 360 Koha::Calendar - Object containing a branches calendar
 361
 362 =head1 VERSION
 363
 364 This documentation refers to Koha::Calendar version 0.0.1
 365
 366 =head1 SYNOPSIS
 367
 368   use Koha::Calendar
 369
 370   my $c = Koha::Calendar->new( branchcode => 'MAIN' );
 371   my $dt = DateTime->now();
 372
 373   # are we open
 374   $open = $c->is_holiday($dt);
 375   # when will item be due if loan period = $dur (a DateTime::Duration object)
 376   $duedate = $c->addDate($dt,$dur,'days');
 377
 378
 379 =head1 DESCRIPTION
 380
 381   Implements those features of C4::Calendar needed for Staffs Rolling Loans
 382
 383 =head1 METHODS
 384
 385 =head2 new : Create a calendar object
 386
 387 my $calendar = Koha::Calendar->new( branchcode => 'MAIN' );
 388
 389 The option branchcode is required
 390
 391
 392 =head2 addDate
 393
 394     my $dt = $calendar->addDate($date, $dur, $unit)
 395
 396 C<$date> is a DateTime object representing the starting date of the interval.
 397
 398 C<$offset> is a DateTime::Duration to add to it
 399
 400 C<$unit> is a string value 'days' or 'hours' toflag granularity of duration
 401
 402 Currently unit is only used to invoke Staffs return Monday at 10 am rule this
 403 parameter will be removed when issuingrules properly cope with that
 404
 405
 406 =head2 addHours
 407
 408     my $dt = $calendar->addHours($date, $dur, $return_by_hour )
 409
 410 C<$date> is a DateTime object representing the starting date of the interval.
 411
 412 C<$offset> is a DateTime::Duration to add to it
 413
 414 C<$return_by_hour> is an integer value representing the opening hour for the branch
 415
 416
 417 =head2 addDays
 418
 419     my $dt = $calendar->addDays($date, $dur)
 420
 421 C<$date> is a DateTime object representing the starting date of the interval.
 422
 423 C<$offset> is a DateTime::Duration to add to it
 424
 425 C<$unit> is a string value 'days' or 'hours' toflag granularity of duration
 426
 427 Currently unit is only used to invoke Staffs return Monday at 10 am rule this
 428 parameter will be removed when issuingrules properly cope with that
 429
 430
 431 =head2 is_holiday
 432
 433 $yesno = $calendar->is_holiday($dt);
 434
 435 passed a DateTime object returns 1 if it is a closed day
 436 0 if not according to the calendar
 437
 438 =head2 days_between
 439
 440 $duration = $calendar->days_between($start_dt, $end_dt);
 441
 442 Passed two dates returns a DateTime::Duration object measuring the length between them
 443 ignoring closed days. Always returns a positive number irrespective of the
 444 relative order of the parameters
 445
 446 =head2 next_open_day
 447
 448 $datetime = $calendar->next_open_day($duedate_dt)
 449
 450 Passed a Datetime returns another Datetime representing the next open day. It is
 451 intended for use to calculate the due date when useDaysMode syspref is set to either
 452 'Datedue' or 'Calendar'.
 453
 454 =head2 prev_open_day
 455
 456 $datetime = $calendar->prev_open_day($duedate_dt)
 457
 458 Passed a Datetime returns another Datetime representing the previous open day. It is
 459 intended for use to calculate the due date when useDaysMode syspref is set to either
 460 'Datedue' or 'Calendar'.
 461
 462 =head2 set_daysmode
 463
 464 For testing only allows the calling script to change days mode
 465
 466 =head2 clear_weekly_closed_days
 467
 468 In test mode changes the testing set of closed days to a new set with
 469 no closed days. TODO passing an array of closed days to this would
 470 allow testing of more configurations
 471
 472 =head2 add_holiday
 473
 474 Passed a datetime object this will add it to the calendar's list of
 475 closed days. This is for testing so that we can alter the Calenfar object's
 476 list of specified dates
 477
 478 =head1 DIAGNOSTICS
 479
 480 Will croak if not passed a branchcode in new
 481
 482 =head1 BUGS AND LIMITATIONS
 483
 484 This only contains a limited subset of the functionality in C4::Calendar
 485 Only enough to support Staffs Rolling loans
 486
 487 =head1 AUTHOR
 488
 489 Colin Campbell colin.campbell@ptfs-europe.com
 490
 491 =head1 LICENSE AND COPYRIGHT
 492
 493 Copyright (c) 2011 PTFS-Europe Ltd All rights reserved
 494
 495 This program is free software: you can redistribute it and/or modify
 496 it under the terms of the GNU General Public License as published by
 497 the Free Software Foundation, either version 2 of the License, or
 498 (at your option) any later version.
 499
 500 This program is distributed in the hope that it will be useful,
 501 but WITHOUT ANY WARRANTY; without even the implied warranty of
 502 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 503 GNU General Public License for more details.
 504
 505 You should have received a copy of the GNU General Public License
 506 along with this program.  If not, see <http://www.gnu.org/licenses/>.