3 # Copyright ByWater Solutions 2014
4 # Copyright PTFS Europe 2016
6 # This file is part of Koha.
8 # Koha is free software; you can redistribute it and/or modify it
9 # under the terms of the GNU General Public License as published by
10 # the Free Software Foundation; either version 3 of the License, or
11 # (at your option) any later version.
13 # Koha is distributed in the hope that it will be useful, but
14 # WITHOUT ANY WARRANTY; without even the implied warranty of
15 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 # GNU General Public License for more details.
18 # You should have received a copy of the GNU General Public License
19 # along with Koha; if not, see <http://www.gnu.org/licenses>.
23 use List::MoreUtils qw( any uniq );
24 use JSON qw( to_json );
25 use Unicode::Normalize qw( NFKD );
29 use C4::Log qw( logaction );
31 use Koha::ArticleRequests;
35 use Koha::CirculationRules;
36 use Koha::Club::Enrollments;
38 use Koha::DateUtils qw( dt_from_string );
40 use Koha::Exceptions::Password;
42 use Koha::Old::Checkouts;
43 use Koha::Patron::Attributes;
44 use Koha::Patron::Categories;
45 use Koha::Patron::Debarments;
46 use Koha::Patron::HouseboundProfile;
47 use Koha::Patron::HouseboundRole;
48 use Koha::Patron::Images;
49 use Koha::Patron::Messages;
50 use Koha::Patron::Modifications;
51 use Koha::Patron::Relationships;
55 use Koha::Result::Boolean;
56 use Koha::Subscription::Routinglists;
58 use Koha::Virtualshelves;
60 use base qw(Koha::Object);
62 use constant ADMINISTRATIVE_LOCKOUT => -1;
64 our $RESULTSET_PATRON_ID_MAPPING = {
65 Accountline => 'borrowernumber',
66 Aqbasketuser => 'borrowernumber',
67 Aqbudget => 'budget_owner_id',
68 Aqbudgetborrower => 'borrowernumber',
69 ArticleRequest => 'borrowernumber',
70 BorrowerDebarment => 'borrowernumber',
71 BorrowerFile => 'borrowernumber',
72 BorrowerModification => 'borrowernumber',
73 ClubEnrollment => 'borrowernumber',
74 Issue => 'borrowernumber',
75 ItemsLastBorrower => 'borrowernumber',
76 Linktracker => 'borrowernumber',
77 Message => 'borrowernumber',
78 MessageQueue => 'borrowernumber',
79 OldIssue => 'borrowernumber',
80 OldReserve => 'borrowernumber',
81 Rating => 'borrowernumber',
82 Reserve => 'borrowernumber',
83 Review => 'borrowernumber',
84 SearchHistory => 'userid',
85 Statistic => 'borrowernumber',
86 Suggestion => 'suggestedby',
87 TagAll => 'borrowernumber',
88 Virtualshelfcontent => 'borrowernumber',
89 Virtualshelfshare => 'borrowernumber',
90 Virtualshelve => 'owner',
95 Koha::Patron - Koha Patron Object class
106 my ( $class, $params ) = @_;
108 return $class->SUPER::new($params);
111 =head3 fixup_cardnumber
113 Autogenerate next cardnumber from highest value found in database
117 sub fixup_cardnumber {
120 my $max = $self->cardnumber;
121 Koha::Plugins->call( 'patron_barcode_transform', \$max );
123 $max ||= Koha::Patrons->search({
124 cardnumber => {-regexp => '^-?[0-9]+$'}
126 select => \'CAST(cardnumber AS SIGNED)',
127 as => ['cast_cardnumber']
128 })->_resultset->get_column('cast_cardnumber')->max;
129 $self->cardnumber(($max || 0) +1);
132 =head3 trim_whitespace
134 trim whitespace from data which has some non-whitespace in it.
135 Could be moved to Koha::Object if need to be reused
139 sub trim_whitespaces {
142 my $schema = Koha::Database->new->schema;
143 my @columns = $schema->source($self->_type)->columns;
145 for my $column( @columns ) {
146 my $value = $self->$column;
147 if ( defined $value ) {
148 $value =~ s/^\s*|\s*$//g;
149 $self->$column($value);
155 =head3 plain_text_password
157 $patron->plain_text_password( $password );
159 stores a copy of the unencrypted password in the object
160 for use in code before encrypting for db
164 sub plain_text_password {
165 my ( $self, $password ) = @_;
167 $self->{_plain_text_password} = $password;
170 return $self->{_plain_text_password}
171 if $self->{_plain_text_password};
178 Patron specific store method to cleanup record
179 and do other necessary things before saving
187 $self->_result->result_source->schema->txn_do(
190 C4::Context->preference("autoMemberNum")
191 and ( not defined $self->cardnumber
192 or $self->cardnumber eq '' )
195 # Warning: The caller is responsible for locking the members table in write
196 # mode, to avoid database corruption.
197 # We are in a transaction but the table is not locked
198 $self->fixup_cardnumber;
201 unless( $self->category->in_storage ) {
202 Koha::Exceptions::Object::FKConstraint->throw(
203 broken_fk => 'categorycode',
204 value => $self->categorycode,
208 $self->trim_whitespaces;
210 my $new_cardnumber = $self->cardnumber;
211 Koha::Plugins->call( 'patron_barcode_transform', \$new_cardnumber );
212 $self->cardnumber( $new_cardnumber );
214 # Set surname to uppercase if uppercasesurname is true
215 $self->surname( uc($self->surname) )
216 if C4::Context->preference("uppercasesurnames");
218 $self->relationship(undef) # We do not want to store an empty string in this field
219 if defined $self->relationship
220 and $self->relationship eq "";
222 unless ( $self->in_storage ) { #AddMember
224 # Generate a valid userid/login if needed
225 $self->generate_userid
226 if not $self->userid or not $self->has_valid_userid;
228 # Add expiration date if it isn't already there
229 unless ( $self->dateexpiry ) {
230 $self->dateexpiry( $self->category->get_expiry_date );
233 # Add enrollment date if it isn't already there
234 unless ( $self->dateenrolled ) {
235 $self->dateenrolled(dt_from_string);
238 # Set the privacy depending on the patron's category
239 my $default_privacy = $self->category->default_privacy || q{};
241 $default_privacy eq 'default' ? 1
242 : $default_privacy eq 'never' ? 2
243 : $default_privacy eq 'forever' ? 0
245 $self->privacy($default_privacy);
247 # Call any check_password plugins if password is passed
248 if ( C4::Context->config("enable_plugins") && $self->password ) {
249 my @plugins = Koha::Plugins->new()->GetPlugins({
250 method => 'check_password',
252 foreach my $plugin ( @plugins ) {
253 # This plugin hook will also be used by a plugin for the Norwegian national
254 # patron database. This is why we need to pass both the password and the
255 # borrowernumber to the plugin.
256 my $ret = $plugin->check_password(
258 password => $self->password,
259 borrowernumber => $self->borrowernumber
262 if ( $ret->{'error'} == 1 ) {
263 Koha::Exceptions::Password::Plugin->throw();
268 # Make a copy of the plain text password for later use
269 $self->plain_text_password( $self->password );
271 $self->password_expiration_date( $self->password
272 ? $self->category->get_password_expiry_date || undef
274 # Create a disabled account if no password provided
275 $self->password( $self->password
276 ? Koha::AuthUtils::hash_password( $self->password )
279 $self->borrowernumber(undef);
281 $self = $self->SUPER::store;
283 $self->add_enrolment_fee_if_needed(0);
285 logaction( "MEMBERS", "CREATE", $self->borrowernumber, "" )
286 if C4::Context->preference("BorrowersLog");
290 my $self_from_storage = $self->get_from_storage;
291 # FIXME We should not deal with that here, callers have to do this job
292 # Moved from ModMember to prevent regressions
293 unless ( $self->userid ) {
294 my $stored_userid = $self_from_storage->userid;
295 $self->userid($stored_userid);
298 # Password must be updated using $self->set_password
299 $self->password($self_from_storage->password);
301 if ( $self->category->categorycode ne
302 $self_from_storage->category->categorycode )
304 # Add enrolement fee on category change if required
305 $self->add_enrolment_fee_if_needed(1)
306 if C4::Context->preference('FeeOnChangePatronCategory');
308 # Clean up guarantors on category change if required
309 $self->guarantor_relationships->delete
310 unless ( $self->category->can_be_guarantee );
315 if ( C4::Context->preference("BorrowersLog") ) {
317 my $from_storage = $self_from_storage->unblessed;
318 my $from_object = $self->unblessed;
319 my @skip_fields = (qw/lastseen updated_on/);
320 for my $key ( keys %{$from_storage} ) {
321 next if any { /$key/ } @skip_fields;
324 !defined( $from_storage->{$key} )
325 && defined( $from_object->{$key} )
327 || ( defined( $from_storage->{$key} )
328 && !defined( $from_object->{$key} ) )
330 defined( $from_storage->{$key} )
331 && defined( $from_object->{$key} )
332 && ( $from_storage->{$key} ne
333 $from_object->{$key} )
338 before => $from_storage->{$key},
339 after => $from_object->{$key}
344 if ( defined($info) ) {
348 $self->borrowernumber,
351 { utf8 => 1, pretty => 1, canonical => 1 }
358 $self = $self->SUPER::store;
369 Delete patron's holds, lists and finally the patron.
371 Lists owned by the borrower are deleted or ownership is transfered depending on the
372 ListOwnershipUponPatronDeletion pref, but entries from the borrower to other lists are kept.
379 my $anonymous_patron = C4::Context->preference("AnonymousPatron");
380 Koha::Exceptions::Patron::FailedDeleteAnonymousPatron->throw() if $anonymous_patron && $self->id eq $anonymous_patron;
382 $self->_result->result_source->schema->txn_do(
384 # Cancel Patron's holds
385 my $holds = $self->holds;
386 while( my $hold = $holds->next ){
390 # If ListOwnershipUponPatronDeletion = transfer, change ownership of all
391 # public and shared lists to the user who deleted them.
392 if ( C4::Context->preference('ListOwnershipUponPatronDeletion') eq 'transfer' ) {
393 my $userenv = C4::Context->userenv();
394 my $usernumber = (ref($userenv) eq 'HASH') ? $userenv->{'number'} : 0;
395 my @publiclists = Koha::Virtualshelves->get_public_shelves;
396 my @sharedlists = Koha::Virtualshelves->search({ 'me.owner' => $self->borrowernumber, 'me.shelfnumber' => { -ident => 'virtualshelfshares.shelfnumber' } }, { prefetch => 'virtualshelfshares' });
397 foreach my $plist ( @publiclists ) {
398 $plist->set({ owner => $usernumber })->store;
400 foreach my $slist ( @sharedlists ) {
401 $slist->set({ owner => $usernumber })->store;
405 # Delete any remaining lists that this user is an owner of (always private lists,
406 # only public and shared lists if ListOwnershipUponPatronDeletion = delete)
407 $_->delete for Koha::Virtualshelves->search({ owner => $self->borrowernumber });
409 # We cannot have a FK on borrower_modifications.borrowernumber, the table is also used
411 $_->delete for Koha::Patron::Modifications->search( { borrowernumber => $self->borrowernumber } )->as_list;
413 $self->SUPER::delete;
415 logaction( "MEMBERS", "DELETE", $self->borrowernumber, "" ) if C4::Context->preference("BorrowersLog");
424 my $patron_category = $patron->category
426 Return the patron category for this patron
432 return Koha::Patron::Category->_new_from_dbic( $self->_result->categorycode );
442 return Koha::Patron::Images->find( $self->borrowernumber );
447 Returns a Koha::Library object representing the patron's home library.
453 return Koha::Library->_new_from_dbic($self->_result->branchcode);
458 Returns a Koha::SMS::Provider object representing the patron's SMS provider.
464 my $sms_provider_rs = $self->_result->sms_provider;
465 return unless $sms_provider_rs;
466 return Koha::SMS::Provider->_new_from_dbic($sms_provider_rs);
469 =head3 guarantor_relationships
471 Returns Koha::Patron::Relationships object for this patron's guarantors
473 Returns the set of relationships for the patrons that are guarantors for this patron.
475 This is returned instead of a Koha::Patron object because the guarantor
476 may not exist as a patron in Koha. If this is true, the guarantors name
477 exists in the Koha::Patron::Relationship object and will have no guarantor_id.
481 sub guarantor_relationships {
484 return Koha::Patron::Relationships->search( { guarantee_id => $self->id } );
487 =head3 guarantee_relationships
489 Returns Koha::Patron::Relationships object for this patron's guarantors
491 Returns the set of relationships for the patrons that are guarantees for this patron.
493 The method returns Koha::Patron::Relationship objects for the sake
494 of consistency with the guantors method.
495 A guarantee by definition must exist as a patron in Koha.
499 sub guarantee_relationships {
502 return Koha::Patron::Relationships->search(
503 { guarantor_id => $self->id },
505 prefetch => 'guarantee',
506 order_by => { -asc => [ 'guarantee.surname', 'guarantee.firstname' ] },
511 =head3 relationships_debt
513 Returns the amount owed by the patron's guarantors *and* the other guarantees of those guarantors
517 sub relationships_debt {
518 my ($self, $params) = @_;
520 my $include_guarantors = $params->{include_guarantors};
521 my $only_this_guarantor = $params->{only_this_guarantor};
522 my $include_this_patron = $params->{include_this_patron};
525 if ( $only_this_guarantor ) {
526 @guarantors = $self->guarantee_relationships->count ? ( $self ) : ();
527 Koha::Exceptions::BadParameter->throw( { parameter => 'only_this_guarantor' } ) unless @guarantors;
528 } elsif ( $self->guarantor_relationships->count ) {
529 # I am a guarantee, just get all my guarantors
530 @guarantors = $self->guarantor_relationships->guarantors->as_list;
532 # I am a guarantor, I need to get all the guarantors of all my guarantees
533 @guarantors = map { $_->guarantor_relationships->guarantors->as_list } $self->guarantee_relationships->guarantees->as_list;
536 my $non_issues_charges = 0;
537 my $seen = $include_this_patron ? {} : { $self->id => 1 }; # For tracking members already added to the total
538 foreach my $guarantor (@guarantors) {
539 $non_issues_charges += $guarantor->account->non_issues_charges if $include_guarantors && !$seen->{ $guarantor->id };
541 # We've added what the guarantor owes, not added in that guarantor's guarantees as well
542 my @guarantees = map { $_->guarantee } $guarantor->guarantee_relationships->as_list;
543 my $guarantees_non_issues_charges = 0;
544 foreach my $guarantee (@guarantees) {
545 next if $seen->{ $guarantee->id };
546 $guarantees_non_issues_charges += $guarantee->account->non_issues_charges;
547 # Mark this guarantee as seen so we don't double count a guarantee linked to multiple guarantors
548 $seen->{ $guarantee->id } = 1;
551 $non_issues_charges += $guarantees_non_issues_charges;
552 $seen->{ $guarantor->id } = 1;
555 return $non_issues_charges;
558 =head3 housebound_profile
560 Returns the HouseboundProfile associated with this patron.
564 sub housebound_profile {
566 my $profile = $self->_result->housebound_profile;
567 return Koha::Patron::HouseboundProfile->_new_from_dbic($profile)
572 =head3 housebound_role
574 Returns the HouseboundRole associated with this patron.
578 sub housebound_role {
581 my $role = $self->_result->housebound_role;
582 return Koha::Patron::HouseboundRole->_new_from_dbic($role) if ( $role );
588 Returns the siblings of this patron.
595 my @guarantors = $self->guarantor_relationships()->guarantors()->as_list;
597 return unless @guarantors;
600 map { $_->guarantee_relationships()->guarantees()->as_list } @guarantors;
602 return unless @siblings;
606 grep { !$seen{ $_->id }++ && ( $_->id != $self->id ) } @siblings;
608 return Koha::Patrons->search( { borrowernumber => { -in => [ map { $_->id } @siblings ] } } );
613 my $patron = Koha::Patrons->find($id);
614 $patron->merge_with( \@patron_ids );
616 This subroutine merges a list of patrons into the patron record. This is accomplished by finding
617 all related patron ids for the patrons to be merged in other tables and changing the ids to be that
618 of the keeper patron.
623 my ( $self, $patron_ids ) = @_;
625 my $anonymous_patron = C4::Context->preference("AnonymousPatron");
626 return if $anonymous_patron && $self->id eq $anonymous_patron;
628 my @patron_ids = @{ $patron_ids };
630 # Ensure the keeper isn't in the list of patrons to merge
631 @patron_ids = grep { $_ ne $self->id } @patron_ids;
633 my $schema = Koha::Database->new()->schema();
637 $self->_result->result_source->schema->txn_do( sub {
638 foreach my $patron_id (@patron_ids) {
640 next if $patron_id eq $anonymous_patron;
642 my $patron = Koha::Patrons->find( $patron_id );
646 # Unbless for safety, the patron will end up being deleted
647 $results->{merged}->{$patron_id}->{patron} = $patron->unblessed;
649 my $attributes = $patron->extended_attributes;
650 my $new_attributes = [
651 map { { code => $_->code, attribute => $_->attribute } }
654 $attributes->delete; # We need to delete before trying to merge them to prevent exception on unique and repeatable
655 for my $attribute ( @$new_attributes ) {
657 $self->add_extended_attribute($attribute);
659 # Don't block the merge if there is a non-repeatable attribute that cannot be added to the current patron.
660 unless ( $_->isa('Koha::Exceptions::Patron::Attribute::NonRepeatable') ) {
666 while (my ($r, $field) = each(%$RESULTSET_PATRON_ID_MAPPING)) {
667 my $rs = $schema->resultset($r)->search({ $field => $patron_id });
668 $results->{merged}->{ $patron_id }->{updated}->{$r} = $rs->count();
669 $rs->update({ $field => $self->id });
670 if ( $r eq 'BorrowerDebarment' ) {
671 Koha::Patron::Debarments::UpdateBorrowerDebarmentFlags($self->id);
675 $patron->move_to_deleted();
685 =head3 wants_check_for_previous_checkout
687 $wants_check = $patron->wants_check_for_previous_checkout;
689 Return 1 if Koha needs to perform PrevIssue checking, else 0.
693 sub wants_check_for_previous_checkout {
695 my $syspref = C4::Context->preference("checkPrevCheckout");
698 ## Hard syspref trumps all
699 return 1 if ($syspref eq 'hardyes');
700 return 0 if ($syspref eq 'hardno');
701 ## Now, patron pref trumps all
702 return 1 if ($self->checkprevcheckout eq 'yes');
703 return 0 if ($self->checkprevcheckout eq 'no');
705 # More complex: patron inherits -> determine category preference
706 my $checkPrevCheckoutByCat = $self->category->checkprevcheckout;
707 return 1 if ($checkPrevCheckoutByCat eq 'yes');
708 return 0 if ($checkPrevCheckoutByCat eq 'no');
710 # Finally: category preference is inherit, default to 0
711 if ($syspref eq 'softyes') {
718 =head3 do_check_for_previous_checkout
720 $do_check = $patron->do_check_for_previous_checkout($item);
722 Return 1 if the bib associated with $ITEM has previously been checked out to
723 $PATRON, 0 otherwise.
727 sub do_check_for_previous_checkout {
728 my ( $self, $item ) = @_;
731 my $biblio = Koha::Biblios->find( $item->{biblionumber} );
732 if ( $biblio->is_serial ) {
733 push @item_nos, $item->{itemnumber};
735 # Get all itemnumbers for given bibliographic record.
736 @item_nos = $biblio->items->get_column( 'itemnumber' );
739 # Create (old)issues search criteria
741 borrowernumber => $self->borrowernumber,
742 itemnumber => \@item_nos,
745 my $delay = C4::Context->preference('CheckPrevCheckoutDelay') || 0;
747 my $dtf = Koha::Database->new->schema->storage->datetime_parser;
748 my $newer_than = dt_from_string()->subtract( days => $delay );
749 $criteria->{'returndate'} = { '>' => $dtf->format_datetime($newer_than), };
752 # Check current issues table
753 my $issues = Koha::Checkouts->search($criteria);
754 return 1 if $issues->count; # 0 || N
756 # Check old issues table
757 my $old_issues = Koha::Old::Checkouts->search($criteria);
758 return $old_issues->count; # 0 || N
763 my $debarment_expiration = $patron->is_debarred;
765 Returns the date a patron debarment will expire, or undef if the patron is not
773 return unless $self->debarred;
774 return $self->debarred
775 if $self->debarred =~ '^9999'
776 or dt_from_string( $self->debarred ) > dt_from_string;
782 my $is_expired = $patron->is_expired;
784 Returns 1 if the patron is expired or 0;
790 return 0 unless $self->dateexpiry;
791 return 0 if $self->dateexpiry =~ '^9999';
792 return 1 if dt_from_string( $self->dateexpiry ) < dt_from_string->truncate( to => 'day' );
796 =head3 password_expired
798 my $password_expired = $patron->password_expired;
800 Returns 1 if the patron's password is expired or 0;
804 sub password_expired {
806 return 0 unless $self->password_expiration_date;
807 return 1 if dt_from_string( $self->password_expiration_date ) <= dt_from_string->truncate( to => 'day' );
811 =head3 is_going_to_expire
813 my $is_going_to_expire = $patron->is_going_to_expire;
815 Returns 1 if the patron is going to expired, depending on the NotifyBorrowerDeparture pref or 0
819 sub is_going_to_expire {
822 my $delay = C4::Context->preference('NotifyBorrowerDeparture') || 0;
824 return 0 unless $delay;
825 return 0 unless $self->dateexpiry;
826 return 0 if $self->dateexpiry =~ '^9999';
827 return 1 if dt_from_string( $self->dateexpiry, undef, 'floating' )->subtract( days => $delay ) < dt_from_string(undef, undef, 'floating')->truncate( to => 'day' );
833 $patron->set_password({ password => $plain_text_password [, skip_validation => 1 ] });
835 Set the patron's password.
839 The passed string is validated against the current password enforcement policy.
840 Validation can be skipped by passing the I<skip_validation> parameter.
842 Exceptions are thrown if the password is not good enough.
846 =item Koha::Exceptions::Password::TooShort
848 =item Koha::Exceptions::Password::WhitespaceCharacters
850 =item Koha::Exceptions::Password::TooWeak
852 =item Koha::Exceptions::Password::Plugin (if a "check password" plugin is enabled)
859 my ( $self, $args ) = @_;
861 my $password = $args->{password};
863 unless ( $args->{skip_validation} ) {
864 my ( $is_valid, $error ) = Koha::AuthUtils::is_password_valid( $password, $self->category );
867 if ( $error eq 'too_short' ) {
868 my $min_length = $self->category->effective_min_password_length;
869 $min_length = 3 if not $min_length or $min_length < 3;
871 my $password_length = length($password);
872 Koha::Exceptions::Password::TooShort->throw(
873 length => $password_length, min_length => $min_length );
875 elsif ( $error eq 'has_whitespaces' ) {
876 Koha::Exceptions::Password::WhitespaceCharacters->throw();
878 elsif ( $error eq 'too_weak' ) {
879 Koha::Exceptions::Password::TooWeak->throw();
884 if ( C4::Context->config("enable_plugins") ) {
885 # Call any check_password plugins
886 my @plugins = Koha::Plugins->new()->GetPlugins({
887 method => 'check_password',
889 foreach my $plugin ( @plugins ) {
890 # This plugin hook will also be used by a plugin for the Norwegian national
891 # patron database. This is why we need to pass both the password and the
892 # borrowernumber to the plugin.
893 my $ret = $plugin->check_password(
895 password => $password,
896 borrowernumber => $self->borrowernumber
899 # This plugin hook will also be used by a plugin for the Norwegian national
900 # patron database. This is why we need to call the actual plugins and then
901 # check skip_validation afterwards.
902 if ( $ret->{'error'} == 1 && !$args->{skip_validation} ) {
903 Koha::Exceptions::Password::Plugin->throw();
908 my $digest = Koha::AuthUtils::hash_password($password);
910 $self->password_expiration_date( $self->category->get_password_expiry_date || undef );
912 # We do not want to call $self->store and retrieve password from DB
913 $self->password($digest);
914 $self->login_attempts(0);
917 logaction( "MEMBERS", "CHANGE PASS", $self->borrowernumber, "" )
918 if C4::Context->preference("BorrowersLog");
926 my $new_expiry_date = $patron->renew_account
928 Extending the subscription to the expiry date.
935 if ( C4::Context->preference('BorrowerRenewalPeriodBase') eq 'combination' ) {
936 $date = ( dt_from_string gt dt_from_string( $self->dateexpiry ) ) ? dt_from_string : dt_from_string( $self->dateexpiry );
939 C4::Context->preference('BorrowerRenewalPeriodBase') eq 'dateexpiry'
940 ? dt_from_string( $self->dateexpiry )
943 my $expiry_date = $self->category->get_expiry_date($date);
945 $self->dateexpiry($expiry_date);
946 $self->date_renewed( dt_from_string() );
949 $self->add_enrolment_fee_if_needed(1);
951 logaction( "MEMBERS", "RENEW", $self->borrowernumber, "Membership renewed" ) if C4::Context->preference("BorrowersLog");
952 return dt_from_string( $expiry_date )->truncate( to => 'day' );
957 my $has_overdues = $patron->has_overdues;
959 Returns the number of patron's overdues
965 my $dtf = Koha::Database->new->schema->storage->datetime_parser;
966 return $self->_result->issues->search({ date_due => { '<' => $dtf->format_datetime( dt_from_string() ) } })->count;
971 $patron->track_login;
972 $patron->track_login({ force => 1 });
974 Tracks a (successful) login attempt.
975 The preference TrackLastPatronActivity must be enabled. Or you
976 should pass the force parameter.
981 my ( $self, $params ) = @_;
984 !C4::Context->preference('TrackLastPatronActivity');
985 $self->lastseen( dt_from_string() )->store;
988 =head3 move_to_deleted
990 my $is_moved = $patron->move_to_deleted;
992 Move a patron to the deletedborrowers table.
993 This can be done before deleting a patron, to make sure the data are not completely deleted.
997 sub move_to_deleted {
999 my $patron_infos = $self->unblessed;
1000 delete $patron_infos->{updated_on}; #This ensures the updated_on date in deletedborrowers will be set to the current timestamp
1001 return Koha::Database->new->schema->resultset('Deletedborrower')->create($patron_infos);
1004 =head3 can_request_article
1006 if ( $patron->can_request_article( $library->id ) ) { ... }
1008 Returns true if the patron can request articles. As limits apply for the patron
1009 on the same day, those completed the same day are considered as current.
1011 A I<library_id> can be passed as parameter, falling back to userenv if absent.
1015 sub can_request_article {
1016 my ($self, $library_id) = @_;
1018 $library_id //= C4::Context->userenv ? C4::Context->userenv->{'branch'} : undef;
1020 my $rule = Koha::CirculationRules->get_effective_rule(
1022 branchcode => $library_id,
1023 categorycode => $self->categorycode,
1024 rule_name => 'open_article_requests_limit'
1028 my $limit = ($rule) ? $rule->rule_value : undef;
1030 return 1 unless defined $limit;
1032 my $count = Koha::ArticleRequests->search(
1033 [ { borrowernumber => $self->borrowernumber, status => [ 'REQUESTED', 'PENDING', 'PROCESSING' ] },
1034 { borrowernumber => $self->borrowernumber, status => 'COMPLETED', updated_on => { '>=' => \'CAST(NOW() AS DATE)' } },
1037 return $count < $limit ? 1 : 0;
1040 =head3 article_request_fee
1042 my $fee = $patron->article_request_fee(
1044 [ library_id => $library->id, ]
1048 Returns the fee to be charged to the patron when it places an article request.
1050 A I<library_id> can be passed as parameter, falling back to userenv if absent.
1054 sub article_request_fee {
1055 my ($self, $params) = @_;
1057 my $library_id = $params->{library_id};
1059 $library_id //= C4::Context->userenv ? C4::Context->userenv->{'branch'} : undef;
1061 my $rule = Koha::CirculationRules->get_effective_rule(
1063 branchcode => $library_id,
1064 categorycode => $self->categorycode,
1065 rule_name => 'article_request_fee'
1069 my $fee = ($rule) ? $rule->rule_value + 0 : 0;
1074 =head3 add_article_request_fee_if_needed
1076 my $fee = $patron->add_article_request_fee_if_needed(
1078 [ item_id => $item->id,
1079 library_id => $library->id, ]
1083 If an article request fee needs to be charged, it adds a debit to the patron's
1086 Returns the fee line.
1088 A I<library_id> can be passed as parameter, falling back to userenv if absent.
1092 sub add_article_request_fee_if_needed {
1093 my ($self, $params) = @_;
1095 my $library_id = $params->{library_id};
1096 my $item_id = $params->{item_id};
1098 $library_id //= C4::Context->userenv ? C4::Context->userenv->{'branch'} : undef;
1100 my $amount = $self->article_request_fee(
1102 library_id => $library_id,
1108 if ( $amount > 0 ) {
1109 $debit_line = $self->account->add_debit(
1112 user_id => C4::Context->userenv ? C4::Context->userenv->{'number'} : undef,
1113 interface => C4::Context->interface,
1114 library_id => $library_id,
1115 type => 'ARTICLE_REQUEST',
1116 item_id => $item_id,
1124 =head3 article_requests
1126 my $article_requests = $patron->article_requests;
1128 Returns the patron article requests.
1132 sub article_requests {
1135 return Koha::ArticleRequests->_new_from_dbic( scalar $self->_result->article_requests );
1138 =head3 add_enrolment_fee_if_needed
1140 my $enrolment_fee = $patron->add_enrolment_fee_if_needed($renewal);
1142 Add enrolment fee for a patron if needed.
1144 $renewal - boolean denoting whether this is an account renewal or not
1148 sub add_enrolment_fee_if_needed {
1149 my ($self, $renewal) = @_;
1150 my $enrolment_fee = $self->category->enrolmentfee;
1151 if ( $enrolment_fee && $enrolment_fee > 0 ) {
1152 my $type = $renewal ? 'ACCOUNT_RENEW' : 'ACCOUNT';
1153 $self->account->add_debit(
1155 amount => $enrolment_fee,
1156 user_id => C4::Context->userenv ? C4::Context->userenv->{'number'} : undef,
1157 interface => C4::Context->interface,
1158 library_id => C4::Context->userenv ? C4::Context->userenv->{'branch'} : undef,
1163 return $enrolment_fee || 0;
1168 my $checkouts = $patron->checkouts
1174 my $checkouts = $self->_result->issues;
1175 return Koha::Checkouts->_new_from_dbic( $checkouts );
1178 =head3 pending_checkouts
1180 my $pending_checkouts = $patron->pending_checkouts
1182 This method will return the same as $self->checkouts, but with a prefetch on
1183 items, biblio and biblioitems.
1185 It has been introduced to replaced the C4::Members::GetPendingIssues subroutine
1187 It should not be used directly, prefer to access fields you need instead of
1188 retrieving all these fields in one go.
1192 sub pending_checkouts {
1194 my $checkouts = $self->_result->issues->search(
1198 { -desc => 'me.timestamp' },
1199 { -desc => 'issuedate' },
1200 { -desc => 'issue_id' }, # Sort by issue_id should be enough
1202 prefetch => { item => { biblio => 'biblioitems' } },
1205 return Koha::Checkouts->_new_from_dbic( $checkouts );
1208 =head3 old_checkouts
1210 my $old_checkouts = $patron->old_checkouts
1216 my $old_checkouts = $self->_result->old_issues;
1217 return Koha::Old::Checkouts->_new_from_dbic( $old_checkouts );
1222 my $overdue_items = $patron->overdues
1224 Return the overdue items
1230 my $dtf = Koha::Database->new->schema->storage->datetime_parser;
1231 return $self->checkouts->search(
1233 'me.date_due' => { '<' => $dtf->format_datetime(dt_from_string) },
1236 prefetch => { item => { biblio => 'biblioitems' } },
1241 =head3 get_routing_lists
1243 my $routinglists = $patron->get_routing_lists
1245 Returns the routing lists a patron is subscribed to.
1249 sub get_routing_lists {
1251 my $routing_list_rs = $self->_result->subscriptionroutinglists;
1252 return Koha::Subscription::Routinglists->_new_from_dbic($routing_list_rs);
1257 my $age = $patron->get_age
1259 Return the age of the patron
1266 return unless $self->dateofbirth;
1268 my $date_of_birth = dt_from_string( $self->dateofbirth );
1269 my $today = dt_from_string->truncate( to => 'day' );
1271 return $today->subtract_datetime( $date_of_birth )->years;
1276 my $is_valid = $patron->is_valid_age
1278 Return 1 if patron's age is between allowed limits, returns 0 if it's not.
1284 my $age = $self->get_age;
1286 my $patroncategory = $self->category;
1287 my ($low,$high) = ($patroncategory->dateofbirthrequired, $patroncategory->upperagelimit);
1289 return (defined($age) && (($high && ($age > $high)) or ($low && ($age < $low)))) ? 0 : 1;
1294 my $account = $patron->account
1300 return Koha::Account->new( { patron_id => $self->borrowernumber } );
1305 my $holds = $patron->holds
1307 Return all the holds placed by this patron
1313 my $holds_rs = $self->_result->reserves->search( {}, { order_by => 'reservedate' } );
1314 return Koha::Holds->_new_from_dbic($holds_rs);
1319 my $old_holds = $patron->old_holds
1321 Return all the historical holds for this patron
1327 my $old_holds_rs = $self->_result->old_reserves->search( {}, { order_by => 'reservedate' } );
1328 return Koha::Old::Holds->_new_from_dbic($old_holds_rs);
1331 =head3 return_claims
1333 my $return_claims = $patron->return_claims
1339 my $return_claims = $self->_result->return_claims_borrowernumbers;
1340 return Koha::Checkouts::ReturnClaims->_new_from_dbic( $return_claims );
1343 =head3 notice_email_address
1345 my $email = $patron->notice_email_address;
1347 Return the email address of patron used for notices.
1348 Returns the empty string if no email address.
1352 sub notice_email_address{
1355 my $which_address = C4::Context->preference("AutoEmailPrimaryAddress");
1356 # if syspref is set to 'first valid' (value == OFF), look up email address
1357 if ( $which_address eq 'OFF' ) {
1358 return $self->first_valid_email_address;
1361 return $self->$which_address || '';
1364 =head3 first_valid_email_address
1366 my $first_valid_email_address = $patron->first_valid_email_address
1368 Return the first valid email address for a patron.
1369 For now, the order is defined as email, emailpro, B_email.
1370 Returns the empty string if the borrower has no email addresses.
1374 sub first_valid_email_address {
1377 return $self->email() || $self->emailpro() || $self->B_email() || q{};
1380 =head3 get_club_enrollments
1384 sub get_club_enrollments {
1387 return Koha::Club::Enrollments->search( { borrowernumber => $self->borrowernumber(), date_canceled => undef } );
1390 =head3 get_enrollable_clubs
1394 sub get_enrollable_clubs {
1395 my ( $self, $is_enrollable_from_opac ) = @_;
1398 $params->{is_enrollable_from_opac} = $is_enrollable_from_opac
1399 if $is_enrollable_from_opac;
1400 $params->{is_email_required} = 0 unless $self->first_valid_email_address();
1402 $params->{borrower} = $self;
1404 return Koha::Clubs->get_enrollable($params);
1407 =head3 account_locked
1409 my $is_locked = $patron->account_locked
1411 Return true if the patron has reached the maximum number of login attempts
1412 (see pref FailedLoginAttempts). If login_attempts is < 0, this is interpreted
1413 as an administrative lockout (independent of FailedLoginAttempts; see also
1414 Koha::Patron->lock).
1415 Otherwise return false.
1416 If the pref is not set (empty string, null or 0), the feature is considered as
1421 sub account_locked {
1423 my $FailedLoginAttempts = C4::Context->preference('FailedLoginAttempts');
1424 return 1 if $FailedLoginAttempts
1425 and $self->login_attempts
1426 and $self->login_attempts >= $FailedLoginAttempts;
1427 return 1 if ($self->login_attempts || 0) < 0; # administrative lockout
1431 =head3 can_see_patron_infos
1433 my $can_see = $patron->can_see_patron_infos( $patron );
1435 Return true if the patron (usually the logged in user) can see the patron's infos for a given patron
1439 sub can_see_patron_infos {
1440 my ( $self, $patron ) = @_;
1441 return unless $patron;
1442 return $self->can_see_patrons_from( $patron->branchcode );
1445 =head3 can_see_patrons_from
1447 my $can_see = $patron->can_see_patrons_from( $branchcode );
1449 Return true if the patron (usually the logged in user) can see the patron's infos from a given library
1453 sub can_see_patrons_from {
1454 my ( $self, $branchcode ) = @_;
1456 if ( $self->branchcode eq $branchcode ) {
1458 } elsif ( $self->has_permission( { borrowers => 'view_borrower_infos_from_any_libraries' } ) ) {
1460 } elsif ( my $library_groups = $self->library->library_groups ) {
1461 while ( my $library_group = $library_groups->next ) {
1462 if ( $library_group->parent->has_child( $branchcode ) ) {
1473 my $can_log_into = $patron->can_log_into( $library );
1475 Given a I<Koha::Library> object, it returns a boolean representing
1476 the fact the patron can log into a the library.
1481 my ( $self, $library ) = @_;
1485 if ( C4::Context->preference('IndependentBranches') ) {
1487 if $self->is_superlibrarian
1488 or $self->branchcode eq $library->id;
1498 =head3 libraries_where_can_see_patrons
1500 my $libraries = $patron-libraries_where_can_see_patrons;
1502 Return the list of branchcodes(!) of libraries the patron is allowed to see other patron's infos.
1503 The branchcodes are arbitrarily returned sorted.
1504 We are supposing here that the object is related to the logged in patron (use of C4::Context::only_my_library)
1506 An empty array means no restriction, the patron can see patron's infos from any libraries.
1510 sub libraries_where_can_see_patrons {
1512 my $userenv = C4::Context->userenv;
1514 return () unless $userenv; # For tests, but userenv should be defined in tests...
1516 my @restricted_branchcodes;
1517 if (C4::Context::only_my_library) {
1518 push @restricted_branchcodes, $self->branchcode;
1522 $self->has_permission(
1523 { borrowers => 'view_borrower_infos_from_any_libraries' }
1527 my $library_groups = $self->library->library_groups({ ft_hide_patron_info => 1 });
1528 if ( $library_groups->count )
1530 while ( my $library_group = $library_groups->next ) {
1531 my $parent = $library_group->parent;
1532 if ( $parent->has_child( $self->branchcode ) ) {
1533 push @restricted_branchcodes, $parent->children->get_column('branchcode');
1538 @restricted_branchcodes = ( $self->branchcode ) unless @restricted_branchcodes;
1542 @restricted_branchcodes = grep { defined $_ } @restricted_branchcodes;
1543 @restricted_branchcodes = uniq(@restricted_branchcodes);
1544 @restricted_branchcodes = sort(@restricted_branchcodes);
1545 return @restricted_branchcodes;
1548 =head3 has_permission
1550 my $permission = $patron->has_permission($required);
1552 See C4::Auth::haspermission for details of syntax for $required
1556 sub has_permission {
1557 my ( $self, $flagsrequired ) = @_;
1558 return unless $self->userid;
1559 # TODO code from haspermission needs to be moved here!
1560 return C4::Auth::haspermission( $self->userid, $flagsrequired );
1563 =head3 is_superlibrarian
1565 my $is_superlibrarian = $patron->is_superlibrarian;
1567 Return true if the patron is a superlibrarian.
1571 sub is_superlibrarian {
1573 return $self->has_permission( { superlibrarian => 1 } ) ? 1 : 0;
1578 my $is_adult = $patron->is_adult
1580 Return true if the patron has a category with a type Adult (A) or Organization (I)
1586 return $self->category->category_type =~ /^(A|I)$/ ? 1 : 0;
1591 my $is_child = $patron->is_child
1593 Return true if the patron has a category with a type Child (C)
1599 return $self->category->category_type eq 'C' ? 1 : 0;
1602 =head3 has_valid_userid
1604 my $patron = Koha::Patrons->find(42);
1605 $patron->userid( $new_userid );
1606 my $has_a_valid_userid = $patron->has_valid_userid
1608 my $patron = Koha::Patron->new( $params );
1609 my $has_a_valid_userid = $patron->has_valid_userid
1611 Return true if the current userid of this patron is valid/unique, otherwise false.
1613 Note that this should be done in $self->store instead and raise an exception if needed.
1617 sub has_valid_userid {
1620 return 0 unless $self->userid;
1622 return 0 if ( $self->userid eq C4::Context->config('user') ); # DB user
1624 my $already_exists = Koha::Patrons->search(
1626 userid => $self->userid,
1629 ? ( borrowernumber => { '!=' => $self->borrowernumber } )
1634 return $already_exists ? 0 : 1;
1637 =head3 generate_userid
1639 my $patron = Koha::Patron->new( $params );
1640 $patron->generate_userid
1642 Generate a userid using the $surname and the $firstname (if there is a value in $firstname).
1644 Set a generated userid ($firstname.$surname if there is a $firstname, or $surname if there is no value in $firstname) plus offset (0 if the $userid is unique, or a higher numeric value if not unique).
1648 sub generate_userid {
1651 my $firstname = $self->firstname // q{};
1652 my $surname = $self->surname // q{};
1653 #The script will "do" the following code and increment the $offset until the generated userid is unique
1655 $firstname =~ s/[[:digit:][:space:][:blank:][:punct:][:cntrl:]]//g;
1656 $surname =~ s/[[:digit:][:space:][:blank:][:punct:][:cntrl:]]//g;
1657 my $userid = lc(($firstname)? "$firstname.$surname" : $surname);
1658 $userid = NFKD( $userid );
1659 $userid =~ s/\p{NonspacingMark}//g;
1660 $userid .= $offset unless $offset == 0;
1661 $self->userid( $userid );
1663 } while (! $self->has_valid_userid );
1668 =head3 add_extended_attribute
1672 sub add_extended_attribute {
1673 my ($self, $attribute) = @_;
1675 return Koha::Patron::Attribute->new(
1678 ( borrowernumber => $self->borrowernumber ),
1684 =head3 extended_attributes
1686 Return object of Koha::Patron::Attributes type with all attributes set for this patron
1692 sub extended_attributes {
1693 my ( $self, $attributes ) = @_;
1694 if ($attributes) { # setter
1695 my $schema = $self->_result->result_source->schema;
1698 # Remove the existing one
1699 $self->extended_attributes->filter_by_branch_limitations->delete;
1701 # Insert the new ones
1703 for my $attribute (@$attributes) {
1704 $self->add_extended_attribute($attribute);
1705 $new_types->{$attribute->{code}} = 1;
1708 # Check globally mandatory types
1709 my @required_attribute_types =
1710 Koha::Patron::Attribute::Types->search(
1713 category_code => [ undef, $self->categorycode ],
1714 'borrower_attribute_types_branches.b_branchcode' =>
1717 { join => 'borrower_attribute_types_branches' }
1718 )->get_column('code');
1719 for my $type ( @required_attribute_types ) {
1720 Koha::Exceptions::Patron::MissingMandatoryExtendedAttribute->throw(
1722 ) if !$new_types->{$type};
1728 my $rs = $self->_result->borrower_attributes;
1729 # We call search to use the filters in Koha::Patron::Attributes->search
1730 return Koha::Patron::Attributes->_new_from_dbic($rs)->search;
1735 my $messages = $patron->messages;
1737 Return the message attached to the patron.
1743 my $messages_rs = $self->_result->messages_borrowernumbers->search;
1744 return Koha::Patron::Messages->_new_from_dbic($messages_rs);
1749 Koha::Patrons->find($id)->lock({ expire => 1, remove => 1 });
1751 Lock and optionally expire a patron account.
1752 Remove holds and article requests if remove flag set.
1753 In order to distinguish from locking by entering a wrong password, let's
1754 call this an administrative lockout.
1759 my ( $self, $params ) = @_;
1760 $self->login_attempts( ADMINISTRATIVE_LOCKOUT );
1761 if( $params->{expire} ) {
1762 $self->dateexpiry( dt_from_string->subtract(days => 1) );
1765 if( $params->{remove} ) {
1766 $self->holds->delete;
1767 $self->article_requests->delete;
1774 Koha::Patrons->find($id)->anonymize;
1776 Anonymize or clear borrower fields. Fields in BorrowerMandatoryField
1777 are randomized, other personal data is cleared too.
1778 Patrons with issues are skipped.
1784 if( $self->_result->issues->count ) {
1785 warn "Exiting anonymize: patron ".$self->borrowernumber." still has issues";
1788 # Mandatory fields come from the corresponding pref, but email fields
1789 # are removed since scrambled email addresses only generate errors
1790 my $mandatory = { map { (lc $_, 1); } grep { !/email/ }
1791 split /\s*\|\s*/, C4::Context->preference('BorrowerMandatoryField') };
1792 $mandatory->{userid} = 1; # needed since sub store does not clear field
1793 my @columns = $self->_result->result_source->columns;
1794 @columns = grep { !/borrowernumber|branchcode|categorycode|^date|password|flags|updated_on|lastseen|lang|login_attempts|anonymized|auth_method/ } @columns;
1795 push @columns, 'dateofbirth'; # add this date back in
1796 foreach my $col (@columns) {
1797 $self->_anonymize_column($col, $mandatory->{lc $col} );
1799 $self->anonymized(1)->store;
1802 sub _anonymize_column {
1803 my ( $self, $col, $mandatory ) = @_;
1804 my $col_info = $self->_result->result_source->column_info($col);
1805 my $type = $col_info->{data_type};
1806 my $nullable = $col_info->{is_nullable};
1808 if( $type =~ /char|text/ ) {
1810 ? Koha::Token->new->generate({ pattern => '\w{10}' })
1814 } elsif( $type =~ /integer|int$|float|dec|double/ ) {
1815 $val = $nullable ? undef : 0;
1816 } elsif( $type =~ /date|time/ ) {
1817 $val = $nullable ? undef : dt_from_string;
1822 =head3 add_guarantor
1824 my $relationship = $patron->add_guarantor(
1826 borrowernumber => $borrowernumber,
1827 relationships => $relationship,
1831 Adds a new guarantor to a patron.
1836 my ( $self, $params ) = @_;
1838 my $guarantor_id = $params->{guarantor_id};
1839 my $relationship = $params->{relationship};
1841 return Koha::Patron::Relationship->new(
1843 guarantee_id => $self->id,
1844 guarantor_id => $guarantor_id,
1845 relationship => $relationship
1850 =head3 get_extended_attribute
1852 my $attribute_value = $patron->get_extended_attribute( $code );
1854 Return the attribute for the code passed in parameter.
1856 It not exist it returns undef
1858 Note that this will not work for repeatable attribute types.
1860 Maybe you certainly not want to use this method, it is actually only used for SHOW_BARCODE
1861 (which should be a real patron's attribute (not extended)
1865 sub get_extended_attribute {
1866 my ( $self, $code, $value ) = @_;
1867 my $rs = $self->_result->borrower_attributes;
1869 my $attribute = $rs->search({ code => $code, ( $value ? ( attribute => $value ) : () ) });
1870 return unless $attribute->count;
1871 return $attribute->next;
1876 my $json = $patron->to_api;
1878 Overloaded method that returns a JSON representation of the Koha::Patron object,
1879 suitable for API output.
1884 my ( $self, $params ) = @_;
1886 my $json_patron = $self->SUPER::to_api( $params );
1888 $json_patron->{restricted} = ( $self->is_debarred )
1890 : Mojo::JSON->false;
1892 return $json_patron;
1895 =head3 to_api_mapping
1897 This method returns the mapping for representing a Koha::Patron object
1902 sub to_api_mapping {
1904 borrowernotes => 'staff_notes',
1905 borrowernumber => 'patron_id',
1906 branchcode => 'library_id',
1907 categorycode => 'category_id',
1908 checkprevcheckout => 'check_previous_checkout',
1909 contactfirstname => undef, # Unused
1910 contactname => undef, # Unused
1911 contactnote => 'altaddress_notes',
1912 contacttitle => undef, # Unused
1913 dateenrolled => 'date_enrolled',
1914 dateexpiry => 'expiry_date',
1915 dateofbirth => 'date_of_birth',
1916 debarred => undef, # replaced by 'restricted'
1917 debarredcomment => undef, # calculated, API consumers will use /restrictions instead
1918 emailpro => 'secondary_email',
1919 flags => undef, # permissions manipulation handled in /permissions
1920 gonenoaddress => 'incorrect_address',
1921 lastseen => 'last_seen',
1922 lost => 'patron_card_lost',
1923 opacnote => 'opac_notes',
1924 othernames => 'other_name',
1925 password => undef, # password manipulation handled in /password
1926 phonepro => 'secondary_phone',
1927 relationship => 'relationship_type',
1929 smsalertnumber => 'sms_number',
1930 sort1 => 'statistics_1',
1931 sort2 => 'statistics_2',
1932 autorenew_checkouts => 'autorenew_checkouts',
1933 streetnumber => 'street_number',
1934 streettype => 'street_type',
1935 zipcode => 'postal_code',
1936 B_address => 'altaddress_address',
1937 B_address2 => 'altaddress_address2',
1938 B_city => 'altaddress_city',
1939 B_country => 'altaddress_country',
1940 B_email => 'altaddress_email',
1941 B_phone => 'altaddress_phone',
1942 B_state => 'altaddress_state',
1943 B_streetnumber => 'altaddress_street_number',
1944 B_streettype => 'altaddress_street_type',
1945 B_zipcode => 'altaddress_postal_code',
1946 altcontactaddress1 => 'altcontact_address',
1947 altcontactaddress2 => 'altcontact_address2',
1948 altcontactaddress3 => 'altcontact_city',
1949 altcontactcountry => 'altcontact_country',
1950 altcontactfirstname => 'altcontact_firstname',
1951 altcontactphone => 'altcontact_phone',
1952 altcontactsurname => 'altcontact_surname',
1953 altcontactstate => 'altcontact_state',
1954 altcontactzipcode => 'altcontact_postal_code',
1955 password_expiration_date => undef,
1956 primary_contact_method => undef,
1958 auth_method => undef,
1964 Koha::Patrons->queue_notice({ letter_params => $letter_params, message_name => 'DUE'});
1965 Koha::Patrons->queue_notice({ letter_params => $letter_params, message_transports => \@message_transports });
1966 Koha::Patrons->queue_notice({ letter_params => $letter_params, message_transports => \@message_transports, test_mode => 1 });
1968 Queue messages to a patron. Can pass a message that is part of the message_attributes
1969 table or supply the transport to use.
1971 If passed a message name we retrieve the patrons preferences for transports
1972 Otherwise we use the supplied transport. In the case of email or sms we fall back to print if
1973 we have no address/number for sending
1975 $letter_params is a hashref of the values to be passed to GetPreparedLetter
1977 test_mode will only report which notices would be sent, but nothing will be queued
1982 my ( $self, $params ) = @_;
1983 my $letter_params = $params->{letter_params};
1984 my $test_mode = $params->{test_mode};
1986 return unless $letter_params;
1987 return unless exists $params->{message_name} xor $params->{message_transports}; # We only want one of these
1989 my $library = Koha::Libraries->find( $letter_params->{branchcode} );
1990 my $from_email_address = $library->from_email_address;
1992 my @message_transports;
1994 $letter_code = $letter_params->{letter_code};
1995 if( $params->{message_name} ){
1996 my $messaging_prefs = C4::Members::Messaging::GetMessagingPreferences( {
1997 borrowernumber => $letter_params->{borrowernumber},
1998 message_name => $params->{message_name}
2000 @message_transports = ( keys %{ $messaging_prefs->{transports} } );
2001 $letter_code = $messaging_prefs->{transports}->{$message_transports[0]} unless $letter_code;
2003 @message_transports = @{$params->{message_transports}};
2005 return unless defined $letter_code;
2006 $letter_params->{letter_code} = $letter_code;
2009 foreach my $mtt (@message_transports){
2010 next if ($mtt eq 'itiva' and C4::Context->preference('TalkingTechItivaPhoneNotification') );
2011 # Notice is handled by TalkingTech_itiva_outbound.pl
2012 if ( ( $mtt eq 'email' and not $self->notice_email_address )
2013 or ( $mtt eq 'sms' and not $self->smsalertnumber )
2014 or ( $mtt eq 'phone' and not $self->phone ) )
2016 push @{ $return{fallback} }, $mtt;
2019 next if $mtt eq 'print' && $print_sent;
2020 $letter_params->{message_transport_type} = $mtt;
2021 my $letter = C4::Letters::GetPreparedLetter( %$letter_params );
2022 C4::Letters::EnqueueLetter({
2024 borrowernumber => $self->borrowernumber,
2025 from_address => $from_email_address,
2026 message_transport_type => $mtt
2027 }) unless $test_mode;
2028 push @{$return{sent}}, $mtt;
2029 $print_sent = 1 if $mtt eq 'print';
2034 =head3 safe_to_delete
2036 my $result = $patron->safe_to_delete;
2037 if ( $result eq 'has_guarantees' ) { ... }
2038 elsif ( $result ) { ... }
2039 else { # cannot delete }
2041 This method tells if the Koha:Patron object can be deleted. Possible return values
2047 =item 'has_checkouts'
2051 =item 'has_guarantees'
2053 =item 'is_anonymous_patron'
2059 sub safe_to_delete {
2062 my $anonymous_patron = C4::Context->preference('AnonymousPatron');
2066 if ( $anonymous_patron && $self->id eq $anonymous_patron ) {
2067 $error = 'is_anonymous_patron';
2069 elsif ( $self->checkouts->count ) {
2070 $error = 'has_checkouts';
2072 elsif ( $self->account->outstanding_debits->total_outstanding > 0 ) {
2073 $error = 'has_debt';
2075 elsif ( $self->guarantee_relationships->count ) {
2076 $error = 'has_guarantees';
2080 return Koha::Result::Boolean->new(0)->add_message({ message => $error });
2083 return Koha::Result::Boolean->new(1);
2088 my $recalls = $patron->recalls;
2090 Return the patron's recalls.
2097 return Koha::Recalls->search({ patron_id => $self->borrowernumber });
2100 =head3 account_balance
2102 my $balance = $patron->account_balance
2104 Return the patron's account balance
2108 sub account_balance {
2110 return $self->account->balance;
2114 =head3 has_messaging_preference
2116 my $bool = $patron->has_messaging_preference({
2117 message_name => $message_name, # A value from message_attributes.message_name
2118 message_transport_type => $message_transport_type, # email, sms, phone, itiva, etc...
2119 wants_digest => $wants_digest, # 1 if you are looking for the digest version, don't pass if you just want either
2124 sub has_messaging_preference {
2125 my ( $self, $params ) = @_;
2127 my $message_name = $params->{message_name};
2128 my $message_transport_type = $params->{message_transport_type};
2129 my $wants_digest = $params->{wants_digest};
2131 return $self->_result->search_related_rs(
2132 'borrower_message_preferences',
2136 [ 'borrower_message_transport_preferences', 'message_attribute' ]
2141 =head3 can_patron_change_staff_only_lists
2143 $patron->can_patron_change_staff_only_lists;
2145 Return 1 if a patron has 'Superlibrarian' or 'Catalogue' permission.
2146 Otherwise, return 0.
2150 sub can_patron_change_staff_only_lists {
2151 my ( $self, $params ) = @_;
2152 return 1 if C4::Auth::haspermission( $self->userid, { 'catalogue' => 1 });
2156 =head3 encode_secret
2158 $patron->encode_secret($secret32);
2160 Secret (TwoFactorAuth expects it in base32 format) is encrypted.
2161 You still need to call ->store.
2166 my ( $self, $secret ) = @_;
2168 return $self->secret( Koha::Encryption->new->encrypt_hex($secret) );
2170 return $self->secret($secret);
2173 =head3 decoded_secret
2175 my $secret32 = $patron->decoded_secret;
2177 Decode the patron secret. We expect to get back a base32 string, but this
2178 is not checked here. Caller of encode_secret is responsible for that.
2182 sub decoded_secret {
2184 if( $self->secret ) {
2185 return Koha::Encryption->new->decrypt_hex( $self->secret );
2187 return $self->secret;
2190 =head2 Internal methods
2202 Kyle M Hall <kyle@bywatersolutions.com>
2203 Alex Sassmannshausen <alex.sassmannshausen@ptfs-europe.com>
2204 Martin Renvoize <martin.renvoize@ptfs-europe.com>