C4/SIP/ILS/Item.pm

   1 #
   2 # ILS::Item.pm
   3 #
   4 # A Class for hiding the ILS's concept of the item from OpenSIP
   5 #
   6
   7 package C4::SIP::ILS::Item;
   8
   9 use strict;
  10 use warnings;
  11
  12 use Sys::Syslog qw(syslog);
  13 use Carp;
  14
  15 use C4::SIP::ILS::Transaction;
  16
  17 use C4::Debug;
  18 use C4::Context;
  19 use C4::Biblio;
  20 use C4::Items;
  21 use C4::Circulation;
  22 use C4::Members;
  23 use C4::Reserves;
  24 use Koha::Database;
  25
  26 our $VERSION = 3.07.00.049;
  27
  28 =encoding UTF-8
  29
  30 =head1 EXAMPLE
  31
  32  our %item_db = (
  33     '1565921879' => {
  34         title => "Perl 5 desktop reference",
  35         id => '1565921879',
  36         sip_media_type => '001',
  37         magnetic_media => 0,
  38         hold_queue => [],
  39     },
  40     '0440242746' => {
  41         title => "The deep blue alibi",
  42         id => '0440242746',
  43         sip_media_type => '001',
  44         magnetic_media => 0,
  45         hold_queue => [
  46             {
  47             itemnumber => '823',
  48             priority => '1',
  49             reservenotes => undef,
  50             reservedate => '2008-10-09',
  51             found => undef,
  52             rtimestamp => '2008-10-09 11:15:06',
  53             biblionumber => '406',
  54             borrowernumber => '756',
  55             branchcode => 'CPL'
  56             }
  57         ],
  58     },
  59     '660' => {
  60         title => "Harry Potter y el cáliz de fuego",
  61         id => '660',
  62         sip_media_type => '001',
  63         magnetic_media => 0,
  64         hold_queue => [],
  65     },
  66 );
  67 =cut
  68
  69 sub priority_sort {
  70     defined $a->{priority} or return -1;
  71     defined $b->{priority} or return 1;
  72     return $a->{priority} <=> $b->{priority};
  73 }
  74
  75 sub new {
  76         my ($class, $item_id) = @_;
  77         my $type = ref($class) || $class;
  78         my $self;
  79     my $itemnumber = GetItemnumberFromBarcode($item_id);
  80         my $item = GetBiblioFromItemNumber($itemnumber);    # actually biblio.*, biblioitems.* AND items.*  (overkill)
  81         if (! $item) {
  82                 syslog("LOG_DEBUG", "new ILS::Item('%s'): not found", $item_id);
  83                 warn "new ILS::Item($item_id) : No item '$item_id'.";
  84         return;
  85         }
  86     $item->{  'itemnumber'   } = $itemnumber;
  87     $item->{      'id'       } = $item->{barcode};     # to SIP, the barcode IS the id.
  88     $item->{permanent_location}= $item->{homebranch};
  89     $item->{'collection_code'} = $item->{ccode};
  90     $item->{  'call_number'  } = $item->{itemcallnumber};
  91
  92     my $it = C4::Context->preference('item-level_itypes') ? $item->{itype} : $item->{itemtype};
  93     my $itemtype = Koha::Database->new()->schema()->resultset('Itemtype')->find( $it );
  94     $item->{sip_media_type} = $itemtype->sip_media_type() if $itemtype;
  95
  96         # check if its on issue and if so get the borrower
  97         my $issue = GetItemIssue($item->{'itemnumber'});
  98     if ($issue) {
  99         $item->{due_date} = $issue->{date_due};
 100     }
 101         my $borrower = GetMember(borrowernumber=>$issue->{'borrowernumber'});
 102         $item->{patron} = $borrower->{'cardnumber'};
 103     my $reserves = GetReservesFromBiblionumber({ biblionumber => $item->{biblionumber} });
 104     $item->{hold_queue} = [ sort priority_sort @$reserves ];
 105         $item->{hold_shelf}    = [( grep {   defined $_->{found}  and $_->{found} eq 'W' } @{$item->{hold_queue}} )];
 106         $item->{pending_queue} = [( grep {(! defined $_->{found}) or  $_->{found} ne 'W' } @{$item->{hold_queue}} )];
 107         $self = $item;
 108         bless $self, $type;
 109
 110     syslog("LOG_DEBUG", "new ILS::Item('%s'): found with title '%s'",
 111            $item_id, $self->{title});
 112
 113     return $self;
 114 }
 115
 116 # 0 means read-only
 117 # 1 means read/write
 118
 119 my %fields = (
 120     id                  => 0,
 121     sip_media_type      => 0,
 122     sip_item_properties => 0,
 123     magnetic_media      => 0,
 124     permanent_location  => 0,
 125     current_location    => 0,
 126     print_line          => 1,
 127     screen_msg          => 1,
 128     itemnumber          => 0,
 129     biblionumber        => 0,
 130     barcode             => 0,
 131     onloan              => 0,
 132     collection_code     => 0,
 133     call_number         => 0,
 134     enumchron           => 0,
 135     location            => 0,
 136     author              => 0,
 137     title               => 0,
 138 );
 139
 140 sub next_hold {
 141     my $self = shift;
 142     # use Data::Dumper; warn "next_hold() hold_shelf: " . Dumper($self->{hold_shelf}); warn "next_hold() pending_queue: " . $self->{pending_queue};
 143     foreach (@{$self->hold_shelf}) {    # If this item was taken from the hold shelf, then that reserve still governs
 144         next unless ($_->{itemnumber} and $_->{itemnumber} == $self->{itemnumber});
 145         return $_;
 146     }
 147     if (scalar @{$self->{pending_queue}}) {    # Otherwise, if there is at least one hold, the first (best priority) gets it
 148         return  $self->{pending_queue}->[0];
 149     }
 150     return;
 151 }
 152
 153 # hold_patron_id is NOT the barcode.  It's the borrowernumber.
 154 # If a return triggers capture for a hold the borrowernumber is passed
 155 # and saved so that other hold info can be retrieved
 156 sub hold_patron_id {
 157     my $self = shift;
 158     my $id   = shift;
 159     if ($id) {
 160         $self->{hold}->{borrowernumber} = $id;
 161     }
 162     if ($self->{hold} ) {
 163         return $self->{hold}->{borrowernumber};
 164     }
 165     return;
 166
 167 }
 168 sub hold_patron_name {
 169     my $self = shift;
 170     my $borrowernumber = (@_ ? shift: $self->hold_patron_id()) or return;
 171     my $holder = GetMember(borrowernumber=>$borrowernumber);
 172     unless ($holder) {
 173         syslog("LOG_ERR", "While checking hold, GetMember failed for borrowernumber '$borrowernumber'");
 174         return;
 175     }
 176     my $email = $holder->{email} || '';
 177     my $phone = $holder->{phone} || '';
 178     my $extra = ($email and $phone) ? " ($email, $phone)" :  # both populated, employ comma
 179                 ($email or  $phone) ? " ($email$phone)"   :  # only 1 populated, we don't care which: no comma
 180                 "" ;                                         # neither populated, empty string
 181     my $name = $holder->{firstname} ? $holder->{firstname} . ' ' : '';
 182     $name .= $holder->{surname} . $extra;
 183     return $name;
 184 }
 185
 186 sub hold_patron_bcode {
 187     my $self = shift;
 188     my $borrowernumber = (@_ ? shift: $self->hold_patron_id()) or return;
 189     my $holder = GetMember(borrowernumber => $borrowernumber);
 190     if ($holder) {
 191         if ($holder->{cardnumber}) {
 192             return $holder->{cardnumber};
 193         }
 194     }
 195     return;
 196 }
 197
 198 sub destination_loc {
 199     my $self = shift;
 200     my $set_loc = shift;
 201     if ($set_loc) {
 202         $self->{dest_loc} = $set_loc;
 203     }
 204     if ($self->{dest_loc} ) {
 205         return $self->{dest_loc};
 206     }
 207     return q{};
 208 }
 209
 210 our $AUTOLOAD;
 211
 212 sub DESTROY { } # keeps AUTOLOAD from catching inherent DESTROY calls
 213
 214 sub AUTOLOAD {
 215     my $self = shift;
 216     my $class = ref($self) or croak "$self is not an object";
 217     my $name = $AUTOLOAD;
 218
 219     $name =~ s/.*://;
 220
 221     unless (exists $fields{$name}) {
 222                 croak "Cannot access '$name' field of class '$class'";
 223     }
 224
 225         if (@_) {
 226         $fields{$name} or croak "Field '$name' of class '$class' is READ ONLY.";
 227                 return $self->{$name} = shift;
 228         } else {
 229                 return $self->{$name};
 230         }
 231 }
 232
 233 sub status_update {     # FIXME: this looks unimplemented
 234     my ($self, $props) = @_;
 235     my $status = C4::SIP::ILS::Transaction->new();
 236     $self->{sip_item_properties} = $props;
 237     $status->{ok} = 1;
 238     return $status;
 239 }
 240
 241 sub title_id {
 242     my $self = shift;
 243     return $self->{title};
 244 }
 245
 246 sub sip_circulation_status {
 247     my $self = shift;
 248     if ($self->{patron}) {
 249                 return '04';    # charged
 250     } elsif (scalar @{$self->{hold_queue}}) {
 251                 return '08';    # waiting on hold shelf
 252     } else {
 253                 return '03';    # available
 254     }                   # FIXME: 01-13 enumerated in spec.
 255 }
 256
 257 sub sip_security_marker {
 258     my $self = shift;
 259     return '02';        # FIXME? 00-other; 01-None; 02-Tattle-Tape Security Strip (3M); 03-Whisper Tape (3M)
 260 }
 261 sub sip_fee_type {
 262     my $self = shift;
 263     return '01';    # FIXME? 01-09 enumerated in spec.  We just use O1-other/unknown.
 264 }
 265
 266 sub fee {
 267     my $self = shift;
 268     return $self->{fee} || 0;
 269 }
 270 sub fee_currency {
 271     my $self = shift;
 272     return $self->{currency} || 'USD';
 273 }
 274 sub owner {
 275     my $self = shift;
 276     return $self->{homebranch};
 277 }
 278 sub hold_queue {
 279     my $self = shift;
 280         (defined $self->{hold_queue}) or return [];
 281     return $self->{hold_queue};
 282 }
 283 sub pending_queue {
 284     my $self = shift;
 285         (defined $self->{pending_queue}) or return [];
 286     return $self->{pending_queue};
 287 }
 288 sub hold_shelf {
 289     my $self = shift;
 290         (defined $self->{hold_shelf}) or return [];
 291     return $self->{hold_shelf};
 292 }
 293
 294 sub hold_queue_position {
 295         my ($self, $patron_id) = @_;
 296         ($self->{hold_queue}) or return 0;
 297         my $i = 0;
 298         foreach (@{$self->{hold_queue}}) {
 299                 $i++;
 300                 $_->{patron_id} or next;
 301                 if ($self->barcode_is_borrowernumber($patron_id, $_->{borrowernumber})) {
 302                         return $i;  # maybe should return $_->{priority}
 303                 }
 304         }
 305     return 0;
 306 }
 307
 308 sub due_date {
 309     my $self = shift;
 310     return $self->{due_date} || 0;
 311 }
 312 sub recall_date {
 313     my $self = shift;
 314     return $self->{recall_date} || 0;
 315 }
 316 sub hold_pickup_date {
 317     my $self = shift;
 318     return $self->{hold_pickup_date} || 0;
 319 }
 320
 321 # This is a partial check of "availability".  It is not supposed to check everything here.
 322 # An item is available for a patron if it is:
 323 # 1) checked out to the same patron
 324 #    AND no pending (i.e. non-W) hold queue
 325 # OR
 326 # 2) not checked out
 327 #    AND (not on hold_shelf OR is on hold_shelf for patron)
 328 #
 329 # What this means is we are consciously allowing the patron to checkout (but not renew) an item that DOES
 330 # have non-W holds on it, but has not been "picked" from the stacks.  That is to say, the
 331 # patron has retrieved the item before the librarian.
 332 #
 333 # We don't check if the patron is at the front of the pending queue in the first case, because
 334 # they should not be able to place a hold on an item they already have.
 335
 336 sub available {
 337         my ($self, $for_patron) = @_;
 338         my $count  = (defined $self->{pending_queue}) ? scalar @{$self->{pending_queue}} : 0;
 339         my $count2 = (defined $self->{hold_shelf}   ) ? scalar @{$self->{hold_shelf}   } : 0;
 340         $debug and print STDERR "availability check: pending_queue size $count, hold_shelf size $count2\n";
 341     if (defined($self->{patron_id})) {
 342                 ($self->{patron_id} eq $for_patron) or return 0;
 343                 return ($count ? 0 : 1);
 344         } else {        # not checked out
 345         ($count2) and return $self->barcode_is_borrowernumber($for_patron, $self->{hold_shelf}[0]->{borrowernumber});
 346         }
 347         return 0;
 348 }
 349
 350 sub _barcode_to_borrowernumber {
 351     my $known = shift;
 352     return unless defined $known;
 353     my $member = GetMember(cardnumber=>$known) or return;
 354     return $member->{borrowernumber};
 355 }
 356 sub barcode_is_borrowernumber {    # because hold_queue only has borrowernumber...
 357     my $self = shift;
 358     my $barcode = shift;
 359     my $number  = shift or return;    # can't be zero
 360     return unless defined $barcode; # might be 0 or 000 or 000000
 361     my $converted = _barcode_to_borrowernumber($barcode);
 362     return unless $converted;
 363     return ($number == $converted);
 364 }
 365 sub fill_reserve {
 366     my $self = shift;
 367     my $hold = shift or return;
 368     foreach (qw(biblionumber borrowernumber reservedate)) {
 369         $hold->{$_} or return;
 370     }
 371     return ModReserveFill($hold);
 372 }
 373 1;
 374 __END__
 375