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     $self->{days_mode} ||= q{};
 171
 172     if ( $self->{days_mode} eq 'Calendar' ) {
 173         # use the calendar to skip all days the library is closed
 174         # when adding
 175         my $days = abs $days_duration->in_units('days');
 176
 177         if ( $days_duration->is_negative() ) {
 178             while ($days) {
 179                 $base_date = $self->prev_open_day($base_date);
 180                 --$days;
 181             }
 182         } else {
 183             while ($days) {
 184                 $base_date = $self->next_open_day($base_date);
 185                 --$days;
 186             }
 187         }
 188
 189     } else { # Days or Datedue
 190         # use straight days, then use calendar to push
 191         # the date to the next open day if Datedue
 192         $base_date->add_duration($days_duration);
 193
 194         if ( $self->{days_mode} eq 'Datedue' ) {
 195             # Datedue, then use the calendar to push
 196             # the date to the next open day if holiday
 197             if ( $self->is_holiday($base_date) ) {
 198                 if ( $days_duration->is_negative() ) {
 199                     $base_date = $self->prev_open_day($base_date);
 200                 } else {
 201                     $base_date = $self->next_open_day($base_date);
 202                 }
 203             }
 204         }
 205     }
 206
 207     return $base_date;
 208 }
 209
 210 sub is_holiday {
 211     my ( $self, $dt ) = @_;
 212     my $localdt = $dt->clone();
 213     my $day   = $localdt->day;
 214     my $month = $localdt->month;
 215
 216     $localdt->truncate( to => 'day' );
 217
 218     if ( $self->exception_holidays->contains($localdt) ) {
 219         # exceptions are not holidays
 220         return 0;
 221     }
 222
 223     my $dow = $localdt->day_of_week;
 224     # Representation fix
 225     # TODO: Shouldn't we shift the rest of the $dow also?
 226     if ( $dow == 7 ) {
 227         $dow = 0;
 228     }
 229
 230     if ( $self->{weekly_closed_days}->[$dow] == 1 ) {
 231         return 1;
 232     }
 233
 234     if ( exists $self->{day_month_closed_days}->{$month}->{$day} ) {
 235         return 1;
 236     }
 237
 238     if ( $self->single_holidays->contains($localdt) ) {
 239         return 1;
 240     }
 241
 242     # damn have to go to work after all
 243     return 0;
 244 }
 245
 246 sub next_open_day {
 247     my ( $self, $dt ) = @_;
 248     my $base_date = $dt->clone();
 249
 250     $base_date->add(days => 1);
 251
 252     while ($self->is_holiday($base_date)) {
 253         $base_date->add(days => 1);
 254     }
 255
 256     return $base_date;
 257 }
 258
 259 sub prev_open_day {
 260     my ( $self, $dt ) = @_;
 261     my $base_date = $dt->clone();
 262
 263     $base_date->add(days => -1);
 264
 265     while ($self->is_holiday($base_date)) {
 266         $base_date->add(days => -1);
 267     }
 268
 269     return $base_date;
 270 }
 271
 272 sub days_between {
 273     my $self     = shift;
 274     my $start_dt = shift;
 275     my $end_dt   = shift;
 276
 277     if ( $start_dt->compare($end_dt) > 0 ) {
 278         # swap dates
 279         my $int_dt = $end_dt;
 280         $end_dt = $start_dt;
 281         $start_dt = $int_dt;
 282     }
 283
 284
 285     # start and end should not be closed days
 286     my $days = $start_dt->delta_days($end_dt)->delta_days;
 287     for (my $dt = $start_dt->clone();
 288         $dt <= $end_dt;
 289         $dt->add(days => 1)
 290     ) {
 291         if ($self->is_holiday($dt)) {
 292             $days--;
 293         }
 294     }
 295     return DateTime::Duration->new( days => $days );
 296
 297 }
 298
 299 sub hours_between {
 300     my ($self, $start_date, $end_date) = @_;
 301     my $start_dt = $start_date->clone();
 302     my $end_dt = $end_date->clone();
 303     my $duration = $end_dt->delta_ms($start_dt);
 304     $start_dt->truncate( to => 'day' );
 305     $end_dt->truncate( to => 'day' );
 306     # NB this is a kludge in that it assumes all days are 24 hours
 307     # However for hourly loans the logic should be expanded to
 308     # take into account open/close times then it would be a duration
 309     # of library open hours
 310     my $skipped_days = 0;
 311     for (my $dt = $start_dt->clone();
 312         $dt <= $end_dt;
 313         $dt->add(days => 1)
 314     ) {
 315         if ($self->is_holiday($dt)) {
 316             ++$skipped_days;
 317         }
 318     }
 319     if ($skipped_days) {
 320         $duration->subtract_duration(DateTime::Duration->new( hours => 24 * $skipped_days));
 321     }
 322
 323     return $duration;
 324
 325 }
 326
 327 sub set_daysmode {
 328     my ( $self, $mode ) = @_;
 329
 330     # if not testing this is a no op
 331     if ( $self->{test} ) {
 332         $self->{days_mode} = $mode;
 333     }
 334
 335     return;
 336 }
 337
 338 sub clear_weekly_closed_days {
 339     my $self = shift;
 340     $self->{weekly_closed_days} = [ 0, 0, 0, 0, 0, 0, 0 ];    # Sunday only
 341     return;
 342 }
 343
 344 sub add_holiday {
 345     my $self = shift;
 346     my $new_dt = shift;
 347     my @dt = $self->single_holidays->as_list;
 348     push @dt, $new_dt;
 349     my $branchcode = $self->{branchcode};
 350     $self->{single_holidays}{$branchcode} =
 351       DateTime::Set->from_datetimes( dates => \@dt );
 352     $single_holidays->{$branchcode} = $self->{single_holidays}{$branchcode};
 353
 354     return;
 355 }
 356
 357 1;
 358 __END__
 359
 360 =head1 NAME
 361
 362 Koha::Calendar - Object containing a branches calendar
 363
 364 =head1 VERSION
 365
 366 This documentation refers to Koha::Calendar version 0.0.1
 367
 368 =head1 SYNOPSIS
 369
 370   use Koha::Calendar
 371
 372   my $c = Koha::Calendar->new( branchcode => 'MAIN' );
 373   my $dt = DateTime->now();
 374
 375   # are we open
 376   $open = $c->is_holiday($dt);
 377   # when will item be due if loan period = $dur (a DateTime::Duration object)
 378   $duedate = $c->addDate($dt,$dur,'days');
 379
 380
 381 =head1 DESCRIPTION
 382
 383   Implements those features of C4::Calendar needed for Staffs Rolling Loans
 384
 385 =head1 METHODS
 386
 387 =head2 new : Create a calendar object
 388
 389 my $calendar = Koha::Calendar->new( branchcode => 'MAIN' );
 390
 391 The option branchcode is required
 392
 393
 394 =head2 addDate
 395
 396     my $dt = $calendar->addDate($date, $dur, $unit)
 397
 398 C<$date> is a DateTime object representing the starting date of the interval.
 399
 400 C<$offset> is a DateTime::Duration to add to it
 401
 402 C<$unit> is a string value 'days' or 'hours' toflag granularity of duration
 403
 404 Currently unit is only used to invoke Staffs return Monday at 10 am rule this
 405 parameter will be removed when issuingrules properly cope with that
 406
 407
 408 =head2 addHours
 409
 410     my $dt = $calendar->addHours($date, $dur, $return_by_hour )
 411
 412 C<$date> is a DateTime object representing the starting date of the interval.
 413
 414 C<$offset> is a DateTime::Duration to add to it
 415
 416 C<$return_by_hour> is an integer value representing the opening hour for the branch
 417
 418
 419 =head2 addDays
 420
 421     my $dt = $calendar->addDays($date, $dur)
 422
 423 C<$date> is a DateTime object representing the starting date of the interval.
 424
 425 C<$offset> is a DateTime::Duration to add to it
 426
 427 C<$unit> is a string value 'days' or 'hours' toflag granularity of duration
 428
 429 Currently unit is only used to invoke Staffs return Monday at 10 am rule this
 430 parameter will be removed when issuingrules properly cope with that
 431
 432
 433 =head2 is_holiday
 434
 435 $yesno = $calendar->is_holiday($dt);
 436
 437 passed a DateTime object returns 1 if it is a closed day
 438 0 if not according to the calendar
 439
 440 =head2 days_between
 441
 442 $duration = $calendar->days_between($start_dt, $end_dt);
 443
 444 Passed two dates returns a DateTime::Duration object measuring the length between them
 445 ignoring closed days. Always returns a positive number irrespective of the
 446 relative order of the parameters
 447
 448 =head2 next_open_day
 449
 450 $datetime = $calendar->next_open_day($duedate_dt)
 451
 452 Passed a Datetime returns another Datetime representing the next open day. It is
 453 intended for use to calculate the due date when useDaysMode syspref is set to either
 454 'Datedue' or 'Calendar'.
 455
 456 =head2 prev_open_day
 457
 458 $datetime = $calendar->prev_open_day($duedate_dt)
 459
 460 Passed a Datetime returns another Datetime representing the previous open day. It is
 461 intended for use to calculate the due date when useDaysMode syspref is set to either
 462 'Datedue' or 'Calendar'.
 463
 464 =head2 set_daysmode
 465
 466 For testing only allows the calling script to change days mode
 467
 468 =head2 clear_weekly_closed_days
 469
 470 In test mode changes the testing set of closed days to a new set with
 471 no closed days. TODO passing an array of closed days to this would
 472 allow testing of more configurations
 473
 474 =head2 add_holiday
 475
 476 Passed a datetime object this will add it to the calendar's list of
 477 closed days. This is for testing so that we can alter the Calenfar object's
 478 list of specified dates
 479
 480 =head1 DIAGNOSTICS
 481
 482 Will croak if not passed a branchcode in new
 483
 484 =head1 BUGS AND LIMITATIONS
 485
 486 This only contains a limited subset of the functionality in C4::Calendar
 487 Only enough to support Staffs Rolling loans
 488
 489 =head1 AUTHOR
 490
 491 Colin Campbell colin.campbell@ptfs-europe.com
 492
 493 =head1 LICENSE AND COPYRIGHT
 494
 495 Copyright (c) 2011 PTFS-Europe Ltd All rights reserved
 496
 497 This program is free software: you can redistribute it and/or modify
 498 it under the terms of the GNU General Public License as published by
 499 the Free Software Foundation, either version 2 of the License, or
 500 (at your option) any later version.
 501
 502 This program is distributed in the hope that it will be useful,
 503 but WITHOUT ANY WARRANTY; without even the implied warranty of
 504 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 505 GNU General Public License for more details.
 506
 507 You should have received a copy of the GNU General Public License
 508 along with this program.  If not, see <http://www.gnu.org/licenses/>.