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 );
28 use C4::Log qw( logaction );
30 use Koha::ArticleRequests;
34 use Koha::CirculationRules;
35 use Koha::Club::Enrollments;
37 use Koha::DateUtils qw( dt_from_string );
38 use Koha::Exceptions::Password;
40 use Koha::Old::Checkouts;
41 use Koha::Patron::Attributes;
42 use Koha::Patron::Categories;
43 use Koha::Patron::Debarments;
44 use Koha::Patron::HouseboundProfile;
45 use Koha::Patron::HouseboundRole;
46 use Koha::Patron::Images;
47 use Koha::Patron::Modifications;
48 use Koha::Patron::Relationships;
51 use Koha::Result::Boolean;
52 use Koha::Subscription::Routinglists;
54 use Koha::Virtualshelves;
56 use base qw(Koha::Object);
58 use constant ADMINISTRATIVE_LOCKOUT => -1;
60 our $RESULTSET_PATRON_ID_MAPPING = {
61 Accountline => 'borrowernumber',
62 Aqbasketuser => 'borrowernumber',
63 Aqbudget => 'budget_owner_id',
64 Aqbudgetborrower => 'borrowernumber',
65 ArticleRequest => 'borrowernumber',
66 BorrowerDebarment => 'borrowernumber',
67 BorrowerFile => 'borrowernumber',
68 BorrowerModification => 'borrowernumber',
69 ClubEnrollment => 'borrowernumber',
70 Issue => 'borrowernumber',
71 ItemsLastBorrower => 'borrowernumber',
72 Linktracker => 'borrowernumber',
73 Message => 'borrowernumber',
74 MessageQueue => 'borrowernumber',
75 OldIssue => 'borrowernumber',
76 OldReserve => 'borrowernumber',
77 Rating => 'borrowernumber',
78 Reserve => 'borrowernumber',
79 Review => 'borrowernumber',
80 SearchHistory => 'userid',
81 Statistic => 'borrowernumber',
82 Suggestion => 'suggestedby',
83 TagAll => 'borrowernumber',
84 Virtualshelfcontent => 'borrowernumber',
85 Virtualshelfshare => 'borrowernumber',
86 Virtualshelve => 'owner',
91 Koha::Patron - Koha Patron Object class
102 my ( $class, $params ) = @_;
104 return $class->SUPER::new($params);
107 =head3 fixup_cardnumber
109 Autogenerate next cardnumber from highest value found in database
113 sub fixup_cardnumber {
116 my $max = $self->cardnumber;
117 Koha::Plugins->call( 'patron_barcode_transform', \$max );
119 $max ||= Koha::Patrons->search({
120 cardnumber => {-regexp => '^-?[0-9]+$'}
122 select => \'CAST(cardnumber AS SIGNED)',
123 as => ['cast_cardnumber']
124 })->_resultset->get_column('cast_cardnumber')->max;
125 $self->cardnumber(($max || 0) +1);
128 =head3 trim_whitespace
130 trim whitespace from data which has some non-whitespace in it.
131 Could be moved to Koha::Object if need to be reused
135 sub trim_whitespaces {
138 my $schema = Koha::Database->new->schema;
139 my @columns = $schema->source($self->_type)->columns;
141 for my $column( @columns ) {
142 my $value = $self->$column;
143 if ( defined $value ) {
144 $value =~ s/^\s*|\s*$//g;
145 $self->$column($value);
151 =head3 plain_text_password
153 $patron->plain_text_password( $password );
155 stores a copy of the unencrypted password in the object
156 for use in code before encrypting for db
160 sub plain_text_password {
161 my ( $self, $password ) = @_;
163 $self->{_plain_text_password} = $password;
166 return $self->{_plain_text_password}
167 if $self->{_plain_text_password};
174 Patron specific store method to cleanup record
175 and do other necessary things before saving
183 $self->_result->result_source->schema->txn_do(
186 C4::Context->preference("autoMemberNum")
187 and ( not defined $self->cardnumber
188 or $self->cardnumber eq '' )
191 # Warning: The caller is responsible for locking the members table in write
192 # mode, to avoid database corruption.
193 # We are in a transaction but the table is not locked
194 $self->fixup_cardnumber;
197 unless( $self->category->in_storage ) {
198 Koha::Exceptions::Object::FKConstraint->throw(
199 broken_fk => 'categorycode',
200 value => $self->categorycode,
204 $self->trim_whitespaces;
206 my $new_cardnumber = $self->cardnumber;
207 Koha::Plugins->call( 'patron_barcode_transform', \$new_cardnumber );
208 $self->cardnumber( $new_cardnumber );
210 # Set surname to uppercase if uppercasesurname is true
211 $self->surname( uc($self->surname) )
212 if C4::Context->preference("uppercasesurnames");
214 $self->relationship(undef) # We do not want to store an empty string in this field
215 if defined $self->relationship
216 and $self->relationship eq "";
218 unless ( $self->in_storage ) { #AddMember
220 # Generate a valid userid/login if needed
221 $self->generate_userid
222 if not $self->userid or not $self->has_valid_userid;
224 # Add expiration date if it isn't already there
225 unless ( $self->dateexpiry ) {
226 $self->dateexpiry( $self->category->get_expiry_date );
229 # Add enrollment date if it isn't already there
230 unless ( $self->dateenrolled ) {
231 $self->dateenrolled(dt_from_string);
234 # Set the privacy depending on the patron's category
235 my $default_privacy = $self->category->default_privacy || q{};
237 $default_privacy eq 'default' ? 1
238 : $default_privacy eq 'never' ? 2
239 : $default_privacy eq 'forever' ? 0
241 $self->privacy($default_privacy);
243 # Call any check_password plugins if password is passed
244 if ( C4::Context->config("enable_plugins") && $self->password ) {
245 my @plugins = Koha::Plugins->new()->GetPlugins({
246 method => 'check_password',
248 foreach my $plugin ( @plugins ) {
249 # This plugin hook will also be used by a plugin for the Norwegian national
250 # patron database. This is why we need to pass both the password and the
251 # borrowernumber to the plugin.
252 my $ret = $plugin->check_password(
254 password => $self->password,
255 borrowernumber => $self->borrowernumber
258 if ( $ret->{'error'} == 1 ) {
259 Koha::Exceptions::Password::Plugin->throw();
264 # Make a copy of the plain text password for later use
265 $self->plain_text_password( $self->password );
267 # Create a disabled account if no password provided
268 $self->password( $self->password
269 ? Koha::AuthUtils::hash_password( $self->password )
272 $self->borrowernumber(undef);
274 $self = $self->SUPER::store;
276 $self->add_enrolment_fee_if_needed(0);
278 logaction( "MEMBERS", "CREATE", $self->borrowernumber, "" )
279 if C4::Context->preference("BorrowersLog");
283 my $self_from_storage = $self->get_from_storage;
284 # FIXME We should not deal with that here, callers have to do this job
285 # Moved from ModMember to prevent regressions
286 unless ( $self->userid ) {
287 my $stored_userid = $self_from_storage->userid;
288 $self->userid($stored_userid);
291 # Password must be updated using $self->set_password
292 $self->password($self_from_storage->password);
294 if ( $self->category->categorycode ne
295 $self_from_storage->category->categorycode )
297 # Add enrolement fee on category change if required
298 $self->add_enrolment_fee_if_needed(1)
299 if C4::Context->preference('FeeOnChangePatronCategory');
301 # Clean up guarantors on category change if required
302 $self->guarantor_relationships->delete
303 if ( $self->category->category_type ne 'C'
304 && $self->category->category_type ne 'P' );
309 if ( C4::Context->preference("BorrowersLog") ) {
311 my $from_storage = $self_from_storage->unblessed;
312 my $from_object = $self->unblessed;
313 my @skip_fields = (qw/lastseen updated_on/);
314 for my $key ( keys %{$from_storage} ) {
315 next if any { /$key/ } @skip_fields;
318 !defined( $from_storage->{$key} )
319 && defined( $from_object->{$key} )
321 || ( defined( $from_storage->{$key} )
322 && !defined( $from_object->{$key} ) )
324 defined( $from_storage->{$key} )
325 && defined( $from_object->{$key} )
326 && ( $from_storage->{$key} ne
327 $from_object->{$key} )
332 before => $from_storage->{$key},
333 after => $from_object->{$key}
338 if ( defined($info) ) {
342 $self->borrowernumber,
345 { utf8 => 1, pretty => 1, canonical => 1 }
352 $self = $self->SUPER::store;
363 Delete patron's holds, lists and finally the patron.
365 Lists owned by the borrower are deleted, but entries from the borrower to
366 other lists are kept.
373 my $anonymous_patron = C4::Context->preference("AnonymousPatron");
374 Koha::Exceptions::Patron::FailedDeleteAnonymousPatron->throw() if $anonymous_patron && $self->id eq $anonymous_patron;
376 $self->_result->result_source->schema->txn_do(
378 # Cancel Patron's holds
379 my $holds = $self->holds;
380 while( my $hold = $holds->next ){
384 # Delete all lists and all shares of this borrower
385 # Consistent with the approach Koha uses on deleting individual lists
386 # Note that entries in virtualshelfcontents added by this borrower to
387 # lists of others will be handled by a table constraint: the borrower
388 # is set to NULL in those entries.
390 # We could handle the above deletes via a constraint too.
391 # But a new BZ report 11889 has been opened to discuss another approach.
392 # Instead of deleting we could also disown lists (based on a pref).
393 # In that way we could save shared and public lists.
394 # The current table constraints support that idea now.
395 # This pref should then govern the results of other routines/methods such as
396 # Koha::Virtualshelf->new->delete too.
397 # FIXME Could be $patron->get_lists
398 $_->delete for Koha::Virtualshelves->search( { owner => $self->borrowernumber } );
400 # We cannot have a FK on borrower_modifications.borrowernumber, the table is also used
402 $_->delete for Koha::Patron::Modifications->search( { borrowernumber => $self->borrowernumber } );
404 $self->SUPER::delete;
406 logaction( "MEMBERS", "DELETE", $self->borrowernumber, "" ) if C4::Context->preference("BorrowersLog");
415 my $patron_category = $patron->category
417 Return the patron category for this patron
423 return Koha::Patron::Category->_new_from_dbic( $self->_result->categorycode );
433 return Koha::Patron::Images->find( $self->borrowernumber );
438 Returns a Koha::Library object representing the patron's home library.
444 return Koha::Library->_new_from_dbic($self->_result->branchcode);
449 Returns a Koha::SMS::Provider object representing the patron's SMS provider.
455 my $sms_provider_rs = $self->_result->sms_provider;
456 return unless $sms_provider_rs;
457 return Koha::SMS::Provider->_new_from_dbic($sms_provider_rs);
460 =head3 guarantor_relationships
462 Returns Koha::Patron::Relationships object for this patron's guarantors
464 Returns the set of relationships for the patrons that are guarantors for this patron.
466 This is returned instead of a Koha::Patron object because the guarantor
467 may not exist as a patron in Koha. If this is true, the guarantors name
468 exists in the Koha::Patron::Relationship object and will have no guarantor_id.
472 sub guarantor_relationships {
475 return Koha::Patron::Relationships->search( { guarantee_id => $self->id } );
478 =head3 guarantee_relationships
480 Returns Koha::Patron::Relationships object for this patron's guarantors
482 Returns the set of relationships for the patrons that are guarantees for this patron.
484 The method returns Koha::Patron::Relationship objects for the sake
485 of consistency with the guantors method.
486 A guarantee by definition must exist as a patron in Koha.
490 sub guarantee_relationships {
493 return Koha::Patron::Relationships->search(
494 { guarantor_id => $self->id },
496 prefetch => 'guarantee',
497 order_by => { -asc => [ 'guarantee.surname', 'guarantee.firstname' ] },
502 =head3 relationships_debt
504 Returns the amount owed by the patron's guarantors *and* the other guarantees of those guarantors
508 sub relationships_debt {
509 my ($self, $params) = @_;
511 my $include_guarantors = $params->{include_guarantors};
512 my $only_this_guarantor = $params->{only_this_guarantor};
513 my $include_this_patron = $params->{include_this_patron};
516 if ( $only_this_guarantor ) {
517 @guarantors = $self->guarantee_relationships->count ? ( $self ) : ();
518 Koha::Exceptions::BadParameter->throw( { parameter => 'only_this_guarantor' } ) unless @guarantors;
519 } elsif ( $self->guarantor_relationships->count ) {
520 # I am a guarantee, just get all my guarantors
521 @guarantors = $self->guarantor_relationships->guarantors;
523 # I am a guarantor, I need to get all the guarantors of all my guarantees
524 @guarantors = map { $_->guarantor_relationships->guarantors } $self->guarantee_relationships->guarantees;
527 my $non_issues_charges = 0;
528 my $seen = $include_this_patron ? {} : { $self->id => 1 }; # For tracking members already added to the total
529 foreach my $guarantor (@guarantors) {
530 $non_issues_charges += $guarantor->account->non_issues_charges if $include_guarantors && !$seen->{ $guarantor->id };
532 # We've added what the guarantor owes, not added in that guarantor's guarantees as well
533 my @guarantees = map { $_->guarantee } $guarantor->guarantee_relationships();
534 my $guarantees_non_issues_charges = 0;
535 foreach my $guarantee (@guarantees) {
536 next if $seen->{ $guarantee->id };
537 $guarantees_non_issues_charges += $guarantee->account->non_issues_charges;
538 # Mark this guarantee as seen so we don't double count a guarantee linked to multiple guarantors
539 $seen->{ $guarantee->id } = 1;
542 $non_issues_charges += $guarantees_non_issues_charges;
543 $seen->{ $guarantor->id } = 1;
546 return $non_issues_charges;
549 =head3 housebound_profile
551 Returns the HouseboundProfile associated with this patron.
555 sub housebound_profile {
557 my $profile = $self->_result->housebound_profile;
558 return Koha::Patron::HouseboundProfile->_new_from_dbic($profile)
563 =head3 housebound_role
565 Returns the HouseboundRole associated with this patron.
569 sub housebound_role {
572 my $role = $self->_result->housebound_role;
573 return Koha::Patron::HouseboundRole->_new_from_dbic($role) if ( $role );
579 Returns the siblings of this patron.
586 my @guarantors = $self->guarantor_relationships()->guarantors();
588 return unless @guarantors;
591 map { $_->guarantee_relationships()->guarantees() } @guarantors;
593 return unless @siblings;
597 grep { !$seen{ $_->id }++ && ( $_->id != $self->id ) } @siblings;
599 return wantarray ? @siblings : Koha::Patrons->search( { borrowernumber => { -in => [ map { $_->id } @siblings ] } } );
604 my $patron = Koha::Patrons->find($id);
605 $patron->merge_with( \@patron_ids );
607 This subroutine merges a list of patrons into the patron record. This is accomplished by finding
608 all related patron ids for the patrons to be merged in other tables and changing the ids to be that
609 of the keeper patron.
614 my ( $self, $patron_ids ) = @_;
616 my $anonymous_patron = C4::Context->preference("AnonymousPatron");
617 return if $anonymous_patron && $self->id eq $anonymous_patron;
619 my @patron_ids = @{ $patron_ids };
621 # Ensure the keeper isn't in the list of patrons to merge
622 @patron_ids = grep { $_ ne $self->id } @patron_ids;
624 my $schema = Koha::Database->new()->schema();
628 $self->_result->result_source->schema->txn_do( sub {
629 foreach my $patron_id (@patron_ids) {
631 next if $patron_id eq $anonymous_patron;
633 my $patron = Koha::Patrons->find( $patron_id );
637 # Unbless for safety, the patron will end up being deleted
638 $results->{merged}->{$patron_id}->{patron} = $patron->unblessed;
640 my $attributes = $patron->extended_attributes;
641 my $new_attributes = [
642 map { { code => $_->code, attribute => $_->attribute } }
645 $attributes->delete; # We need to delete before trying to merge them to prevent exception on unique and repeatable
646 for my $attribute ( @$new_attributes ) {
647 $self->add_extended_attribute($attribute);
650 while (my ($r, $field) = each(%$RESULTSET_PATRON_ID_MAPPING)) {
651 my $rs = $schema->resultset($r)->search({ $field => $patron_id });
652 $results->{merged}->{ $patron_id }->{updated}->{$r} = $rs->count();
653 $rs->update({ $field => $self->id });
654 if ( $r eq 'BorrowerDebarment' ) {
655 Koha::Patron::Debarments::UpdateBorrowerDebarmentFlags($self->id);
659 $patron->move_to_deleted();
669 =head3 wants_check_for_previous_checkout
671 $wants_check = $patron->wants_check_for_previous_checkout;
673 Return 1 if Koha needs to perform PrevIssue checking, else 0.
677 sub wants_check_for_previous_checkout {
679 my $syspref = C4::Context->preference("checkPrevCheckout");
682 ## Hard syspref trumps all
683 return 1 if ($syspref eq 'hardyes');
684 return 0 if ($syspref eq 'hardno');
685 ## Now, patron pref trumps all
686 return 1 if ($self->checkprevcheckout eq 'yes');
687 return 0 if ($self->checkprevcheckout eq 'no');
689 # More complex: patron inherits -> determine category preference
690 my $checkPrevCheckoutByCat = $self->category->checkprevcheckout;
691 return 1 if ($checkPrevCheckoutByCat eq 'yes');
692 return 0 if ($checkPrevCheckoutByCat eq 'no');
694 # Finally: category preference is inherit, default to 0
695 if ($syspref eq 'softyes') {
702 =head3 do_check_for_previous_checkout
704 $do_check = $patron->do_check_for_previous_checkout($item);
706 Return 1 if the bib associated with $ITEM has previously been checked out to
707 $PATRON, 0 otherwise.
711 sub do_check_for_previous_checkout {
712 my ( $self, $item ) = @_;
715 my $biblio = Koha::Biblios->find( $item->{biblionumber} );
716 if ( $biblio->is_serial ) {
717 push @item_nos, $item->{itemnumber};
719 # Get all itemnumbers for given bibliographic record.
720 @item_nos = $biblio->items->get_column( 'itemnumber' );
723 # Create (old)issues search criteria
725 borrowernumber => $self->borrowernumber,
726 itemnumber => \@item_nos,
729 my $delay = C4::Context->preference('CheckPrevCheckoutDelay') || 0;
731 my $dtf = Koha::Database->new->schema->storage->datetime_parser;
732 my $newer_than = dt_from_string()->subtract( days => $delay );
733 $criteria->{'returndate'} = { '>' => $dtf->format_datetime($newer_than), };
736 # Check current issues table
737 my $issues = Koha::Checkouts->search($criteria);
738 return 1 if $issues->count; # 0 || N
740 # Check old issues table
741 my $old_issues = Koha::Old::Checkouts->search($criteria);
742 return $old_issues->count; # 0 || N
747 my $debarment_expiration = $patron->is_debarred;
749 Returns the date a patron debarment will expire, or undef if the patron is not
757 return unless $self->debarred;
758 return $self->debarred
759 if $self->debarred =~ '^9999'
760 or dt_from_string( $self->debarred ) > dt_from_string;
766 my $is_expired = $patron->is_expired;
768 Returns 1 if the patron is expired or 0;
774 return 0 unless $self->dateexpiry;
775 return 0 if $self->dateexpiry =~ '^9999';
776 return 1 if dt_from_string( $self->dateexpiry ) < dt_from_string->truncate( to => 'day' );
780 =head3 is_going_to_expire
782 my $is_going_to_expire = $patron->is_going_to_expire;
784 Returns 1 if the patron is going to expired, depending on the NotifyBorrowerDeparture pref or 0
788 sub is_going_to_expire {
791 my $delay = C4::Context->preference('NotifyBorrowerDeparture') || 0;
793 return 0 unless $delay;
794 return 0 unless $self->dateexpiry;
795 return 0 if $self->dateexpiry =~ '^9999';
796 return 1 if dt_from_string( $self->dateexpiry, undef, 'floating' )->subtract( days => $delay ) < dt_from_string(undef, undef, 'floating')->truncate( to => 'day' );
802 $patron->set_password({ password => $plain_text_password [, skip_validation => 1 ] });
804 Set the patron's password.
808 The passed string is validated against the current password enforcement policy.
809 Validation can be skipped by passing the I<skip_validation> parameter.
811 Exceptions are thrown if the password is not good enough.
815 =item Koha::Exceptions::Password::TooShort
817 =item Koha::Exceptions::Password::WhitespaceCharacters
819 =item Koha::Exceptions::Password::TooWeak
821 =item Koha::Exceptions::Password::Plugin (if a "check password" plugin is enabled)
828 my ( $self, $args ) = @_;
830 my $password = $args->{password};
832 unless ( $args->{skip_validation} ) {
833 my ( $is_valid, $error ) = Koha::AuthUtils::is_password_valid( $password, $self->category );
836 if ( $error eq 'too_short' ) {
837 my $min_length = $self->category->effective_min_password_length;
838 $min_length = 3 if not $min_length or $min_length < 3;
840 my $password_length = length($password);
841 Koha::Exceptions::Password::TooShort->throw(
842 length => $password_length, min_length => $min_length );
844 elsif ( $error eq 'has_whitespaces' ) {
845 Koha::Exceptions::Password::WhitespaceCharacters->throw();
847 elsif ( $error eq 'too_weak' ) {
848 Koha::Exceptions::Password::TooWeak->throw();
853 if ( C4::Context->config("enable_plugins") ) {
854 # Call any check_password plugins
855 my @plugins = Koha::Plugins->new()->GetPlugins({
856 method => 'check_password',
858 foreach my $plugin ( @plugins ) {
859 # This plugin hook will also be used by a plugin for the Norwegian national
860 # patron database. This is why we need to pass both the password and the
861 # borrowernumber to the plugin.
862 my $ret = $plugin->check_password(
864 password => $password,
865 borrowernumber => $self->borrowernumber
868 # This plugin hook will also be used by a plugin for the Norwegian national
869 # patron database. This is why we need to call the actual plugins and then
870 # check skip_validation afterwards.
871 if ( $ret->{'error'} == 1 && !$args->{skip_validation} ) {
872 Koha::Exceptions::Password::Plugin->throw();
877 my $digest = Koha::AuthUtils::hash_password($password);
879 # We do not want to call $self->store and retrieve password from DB
880 $self->password($digest);
881 $self->login_attempts(0);
884 logaction( "MEMBERS", "CHANGE PASS", $self->borrowernumber, "" )
885 if C4::Context->preference("BorrowersLog");
893 my $new_expiry_date = $patron->renew_account
895 Extending the subscription to the expiry date.
902 if ( C4::Context->preference('BorrowerRenewalPeriodBase') eq 'combination' ) {
903 $date = ( dt_from_string gt dt_from_string( $self->dateexpiry ) ) ? dt_from_string : dt_from_string( $self->dateexpiry );
906 C4::Context->preference('BorrowerRenewalPeriodBase') eq 'dateexpiry'
907 ? dt_from_string( $self->dateexpiry )
910 my $expiry_date = $self->category->get_expiry_date($date);
912 $self->dateexpiry($expiry_date);
913 $self->date_renewed( dt_from_string() );
916 $self->add_enrolment_fee_if_needed(1);
918 logaction( "MEMBERS", "RENEW", $self->borrowernumber, "Membership renewed" ) if C4::Context->preference("BorrowersLog");
919 return dt_from_string( $expiry_date )->truncate( to => 'day' );
924 my $has_overdues = $patron->has_overdues;
926 Returns the number of patron's overdues
932 my $dtf = Koha::Database->new->schema->storage->datetime_parser;
933 return $self->_result->issues->search({ date_due => { '<' => $dtf->format_datetime( dt_from_string() ) } })->count;
938 $patron->track_login;
939 $patron->track_login({ force => 1 });
941 Tracks a (successful) login attempt.
942 The preference TrackLastPatronActivity must be enabled. Or you
943 should pass the force parameter.
948 my ( $self, $params ) = @_;
951 !C4::Context->preference('TrackLastPatronActivity');
952 $self->lastseen( dt_from_string() )->store;
955 =head3 move_to_deleted
957 my $is_moved = $patron->move_to_deleted;
959 Move a patron to the deletedborrowers table.
960 This can be done before deleting a patron, to make sure the data are not completely deleted.
964 sub move_to_deleted {
966 my $patron_infos = $self->unblessed;
967 delete $patron_infos->{updated_on}; #This ensures the updated_on date in deletedborrowers will be set to the current timestamp
968 return Koha::Database->new->schema->resultset('Deletedborrower')->create($patron_infos);
971 =head3 can_request_article
973 if ( $patron->can_request_article( $library->id ) ) { ... }
975 Returns true if the patron can request articles. As limits apply for the patron
976 on the same day, those completed the same day are considered as current.
978 A I<library_id> can be passed as parameter, falling back to userenv if absent.
982 sub can_request_article {
983 my ($self, $library_id) = @_;
985 $library_id //= C4::Context->userenv ? C4::Context->userenv->{'branch'} : undef;
987 my $rule = Koha::CirculationRules->get_effective_rule(
989 branchcode => $library_id,
990 categorycode => $self->categorycode,
991 rule_name => 'open_article_requests_limit'
995 my $limit = ($rule) ? $rule->rule_value : undef;
997 return 1 unless defined $limit;
999 my $count = Koha::ArticleRequests->search(
1000 [ { borrowernumber => $self->borrowernumber, status => [ 'REQUESTED', 'PENDING', 'PROCESSING' ] },
1001 { borrowernumber => $self->borrowernumber, status => 'COMPLETED', updated_on => { '>=' => \'CAST(NOW() AS DATE)' } },
1004 return $count < $limit ? 1 : 0;
1007 =head3 article_request_fee
1009 my $fee = $patron->article_request_fee(
1011 [ library_id => $library->id, ]
1015 Returns the fee to be charged to the patron when it places an article request.
1017 A I<library_id> can be passed as parameter, falling back to userenv if absent.
1021 sub article_request_fee {
1022 my ($self, $params) = @_;
1024 my $library_id = $params->{library_id};
1026 $library_id //= C4::Context->userenv ? C4::Context->userenv->{'branch'} : undef;
1028 my $rule = Koha::CirculationRules->get_effective_rule(
1030 branchcode => $library_id,
1031 categorycode => $self->categorycode,
1032 rule_name => 'article_request_fee'
1036 my $fee = ($rule) ? $rule->rule_value + 0 : 0;
1041 =head3 add_article_request_fee_if_needed
1043 my $fee = $patron->add_article_request_fee_if_needed(
1045 [ item_id => $item->id,
1046 library_id => $library->id, ]
1050 If an article request fee needs to be charged, it adds a debit to the patron's
1053 Returns the fee line.
1055 A I<library_id> can be passed as parameter, falling back to userenv if absent.
1059 sub add_article_request_fee_if_needed {
1060 my ($self, $params) = @_;
1062 my $library_id = $params->{library_id};
1063 my $item_id = $params->{item_id};
1065 $library_id //= C4::Context->userenv ? C4::Context->userenv->{'branch'} : undef;
1067 my $amount = $self->article_request_fee(
1069 library_id => $library_id,
1075 if ( $amount > 0 ) {
1076 $debit_line = $self->account->add_debit(
1079 user_id => C4::Context->userenv ? C4::Context->userenv->{'number'} : undef,
1080 interface => C4::Context->interface,
1081 library_id => $library_id,
1082 type => 'ARTICLE_REQUEST',
1083 item_id => $item_id,
1091 =head3 article_requests
1093 my $article_requests = $patron->article_requests;
1095 Returns the patron article requests.
1099 sub article_requests {
1102 return Koha::ArticleRequests->_new_from_dbic( scalar $self->_result->article_requests );
1105 =head3 add_enrolment_fee_if_needed
1107 my $enrolment_fee = $patron->add_enrolment_fee_if_needed($renewal);
1109 Add enrolment fee for a patron if needed.
1111 $renewal - boolean denoting whether this is an account renewal or not
1115 sub add_enrolment_fee_if_needed {
1116 my ($self, $renewal) = @_;
1117 my $enrolment_fee = $self->category->enrolmentfee;
1118 if ( $enrolment_fee && $enrolment_fee > 0 ) {
1119 my $type = $renewal ? 'ACCOUNT_RENEW' : 'ACCOUNT';
1120 $self->account->add_debit(
1122 amount => $enrolment_fee,
1123 user_id => C4::Context->userenv ? C4::Context->userenv->{'number'} : undef,
1124 interface => C4::Context->interface,
1125 library_id => C4::Context->userenv ? C4::Context->userenv->{'branch'} : undef,
1130 return $enrolment_fee || 0;
1135 my $checkouts = $patron->checkouts
1141 my $checkouts = $self->_result->issues;
1142 return Koha::Checkouts->_new_from_dbic( $checkouts );
1145 =head3 pending_checkouts
1147 my $pending_checkouts = $patron->pending_checkouts
1149 This method will return the same as $self->checkouts, but with a prefetch on
1150 items, biblio and biblioitems.
1152 It has been introduced to replaced the C4::Members::GetPendingIssues subroutine
1154 It should not be used directly, prefer to access fields you need instead of
1155 retrieving all these fields in one go.
1159 sub pending_checkouts {
1161 my $checkouts = $self->_result->issues->search(
1165 { -desc => 'me.timestamp' },
1166 { -desc => 'issuedate' },
1167 { -desc => 'issue_id' }, # Sort by issue_id should be enough
1169 prefetch => { item => { biblio => 'biblioitems' } },
1172 return Koha::Checkouts->_new_from_dbic( $checkouts );
1175 =head3 old_checkouts
1177 my $old_checkouts = $patron->old_checkouts
1183 my $old_checkouts = $self->_result->old_issues;
1184 return Koha::Old::Checkouts->_new_from_dbic( $old_checkouts );
1189 my $overdue_items = $patron->get_overdues
1191 Return the overdue items
1197 my $dtf = Koha::Database->new->schema->storage->datetime_parser;
1198 return $self->checkouts->search(
1200 'me.date_due' => { '<' => $dtf->format_datetime(dt_from_string) },
1203 prefetch => { item => { biblio => 'biblioitems' } },
1208 =head3 get_routing_lists
1210 my @routinglists = $patron->get_routing_lists
1212 Returns the routing lists a patron is subscribed to.
1216 sub get_routing_lists {
1218 my $routing_list_rs = $self->_result->subscriptionroutinglists;
1219 return Koha::Subscription::Routinglists->_new_from_dbic($routing_list_rs);
1224 my $age = $patron->get_age
1226 Return the age of the patron
1232 my $today_str = dt_from_string->strftime("%Y-%m-%d");
1233 return unless $self->dateofbirth;
1234 my $dob_str = dt_from_string( $self->dateofbirth )->strftime("%Y-%m-%d");
1236 my ( $dob_y, $dob_m, $dob_d ) = split /-/, $dob_str;
1237 my ( $today_y, $today_m, $today_d ) = split /-/, $today_str;
1239 my $age = $today_y - $dob_y;
1240 if ( $dob_m . $dob_d > $today_m . $today_d ) {
1249 my $is_valid = $patron->is_valid_age
1251 Return 1 if patron's age is between allowed limits, returns 0 if it's not.
1257 my $age = $self->get_age;
1259 my $patroncategory = $self->category;
1260 my ($low,$high) = ($patroncategory->dateofbirthrequired, $patroncategory->upperagelimit);
1262 return (defined($age) && (($high && ($age > $high)) or ($low && ($age < $low)))) ? 0 : 1;
1267 my $account = $patron->account
1273 return Koha::Account->new( { patron_id => $self->borrowernumber } );
1278 my $holds = $patron->holds
1280 Return all the holds placed by this patron
1286 my $holds_rs = $self->_result->reserves->search( {}, { order_by => 'reservedate' } );
1287 return Koha::Holds->_new_from_dbic($holds_rs);
1292 my $old_holds = $patron->old_holds
1294 Return all the historical holds for this patron
1300 my $old_holds_rs = $self->_result->old_reserves->search( {}, { order_by => 'reservedate' } );
1301 return Koha::Old::Holds->_new_from_dbic($old_holds_rs);
1304 =head3 return_claims
1306 my $return_claims = $patron->return_claims
1312 my $return_claims = $self->_result->return_claims_borrowernumbers;
1313 return Koha::Checkouts::ReturnClaims->_new_from_dbic( $return_claims );
1316 =head3 notice_email_address
1318 my $email = $patron->notice_email_address;
1320 Return the email address of patron used for notices.
1321 Returns the empty string if no email address.
1325 sub notice_email_address{
1328 my $which_address = C4::Context->preference("AutoEmailPrimaryAddress");
1329 # if syspref is set to 'first valid' (value == OFF), look up email address
1330 if ( $which_address eq 'OFF' ) {
1331 return $self->first_valid_email_address;
1334 return $self->$which_address || '';
1337 =head3 first_valid_email_address
1339 my $first_valid_email_address = $patron->first_valid_email_address
1341 Return the first valid email address for a patron.
1342 For now, the order is defined as email, emailpro, B_email.
1343 Returns the empty string if the borrower has no email addresses.
1347 sub first_valid_email_address {
1350 return $self->email() || $self->emailpro() || $self->B_email() || q{};
1353 =head3 get_club_enrollments
1357 sub get_club_enrollments {
1358 my ( $self, $return_scalar ) = @_;
1360 my $e = Koha::Club::Enrollments->search( { borrowernumber => $self->borrowernumber(), date_canceled => undef } );
1362 return $e if $return_scalar;
1364 return wantarray ? $e->as_list : $e;
1367 =head3 get_enrollable_clubs
1371 sub get_enrollable_clubs {
1372 my ( $self, $is_enrollable_from_opac, $return_scalar ) = @_;
1375 $params->{is_enrollable_from_opac} = $is_enrollable_from_opac
1376 if $is_enrollable_from_opac;
1377 $params->{is_email_required} = 0 unless $self->first_valid_email_address();
1379 $params->{borrower} = $self;
1381 my $e = Koha::Clubs->get_enrollable($params);
1383 return $e if $return_scalar;
1385 return wantarray ? $e->as_list : $e;
1388 =head3 account_locked
1390 my $is_locked = $patron->account_locked
1392 Return true if the patron has reached the maximum number of login attempts
1393 (see pref FailedLoginAttempts). If login_attempts is < 0, this is interpreted
1394 as an administrative lockout (independent of FailedLoginAttempts; see also
1395 Koha::Patron->lock).
1396 Otherwise return false.
1397 If the pref is not set (empty string, null or 0), the feature is considered as
1402 sub account_locked {
1404 my $FailedLoginAttempts = C4::Context->preference('FailedLoginAttempts');
1405 return 1 if $FailedLoginAttempts
1406 and $self->login_attempts
1407 and $self->login_attempts >= $FailedLoginAttempts;
1408 return 1 if ($self->login_attempts || 0) < 0; # administrative lockout
1412 =head3 can_see_patron_infos
1414 my $can_see = $patron->can_see_patron_infos( $patron );
1416 Return true if the patron (usually the logged in user) can see the patron's infos for a given patron
1420 sub can_see_patron_infos {
1421 my ( $self, $patron ) = @_;
1422 return unless $patron;
1423 return $self->can_see_patrons_from( $patron->branchcode );
1426 =head3 can_see_patrons_from
1428 my $can_see = $patron->can_see_patrons_from( $branchcode );
1430 Return true if the patron (usually the logged in user) can see the patron's infos from a given library
1434 sub can_see_patrons_from {
1435 my ( $self, $branchcode ) = @_;
1437 if ( $self->branchcode eq $branchcode ) {
1439 } elsif ( $self->has_permission( { borrowers => 'view_borrower_infos_from_any_libraries' } ) ) {
1441 } elsif ( my $library_groups = $self->library->library_groups ) {
1442 while ( my $library_group = $library_groups->next ) {
1443 if ( $library_group->parent->has_child( $branchcode ) ) {
1454 my $can_log_into = $patron->can_log_into( $library );
1456 Given a I<Koha::Library> object, it returns a boolean representing
1457 the fact the patron can log into a the library.
1462 my ( $self, $library ) = @_;
1466 if ( C4::Context->preference('IndependentBranches') ) {
1468 if $self->is_superlibrarian
1469 or $self->branchcode eq $library->id;
1479 =head3 libraries_where_can_see_patrons
1481 my $libraries = $patron-libraries_where_can_see_patrons;
1483 Return the list of branchcodes(!) of libraries the patron is allowed to see other patron's infos.
1484 The branchcodes are arbitrarily returned sorted.
1485 We are supposing here that the object is related to the logged in patron (use of C4::Context::only_my_library)
1487 An empty array means no restriction, the patron can see patron's infos from any libraries.
1491 sub libraries_where_can_see_patrons {
1493 my $userenv = C4::Context->userenv;
1495 return () unless $userenv; # For tests, but userenv should be defined in tests...
1497 my @restricted_branchcodes;
1498 if (C4::Context::only_my_library) {
1499 push @restricted_branchcodes, $self->branchcode;
1503 $self->has_permission(
1504 { borrowers => 'view_borrower_infos_from_any_libraries' }
1508 my $library_groups = $self->library->library_groups({ ft_hide_patron_info => 1 });
1509 if ( $library_groups->count )
1511 while ( my $library_group = $library_groups->next ) {
1512 my $parent = $library_group->parent;
1513 if ( $parent->has_child( $self->branchcode ) ) {
1514 push @restricted_branchcodes, $parent->children->get_column('branchcode');
1519 @restricted_branchcodes = ( $self->branchcode ) unless @restricted_branchcodes;
1523 @restricted_branchcodes = grep { defined $_ } @restricted_branchcodes;
1524 @restricted_branchcodes = uniq(@restricted_branchcodes);
1525 @restricted_branchcodes = sort(@restricted_branchcodes);
1526 return @restricted_branchcodes;
1529 =head3 has_permission
1531 my $permission = $patron->has_permission($required);
1533 See C4::Auth::haspermission for details of syntax for $required
1537 sub has_permission {
1538 my ( $self, $flagsrequired ) = @_;
1539 return unless $self->userid;
1540 # TODO code from haspermission needs to be moved here!
1541 return C4::Auth::haspermission( $self->userid, $flagsrequired );
1544 =head3 is_superlibrarian
1546 my $is_superlibrarian = $patron->is_superlibrarian;
1548 Return true if the patron is a superlibrarian.
1552 sub is_superlibrarian {
1554 return $self->has_permission( { superlibrarian => 1 } ) ? 1 : 0;
1559 my $is_adult = $patron->is_adult
1561 Return true if the patron has a category with a type Adult (A) or Organization (I)
1567 return $self->category->category_type =~ /^(A|I)$/ ? 1 : 0;
1572 my $is_child = $patron->is_child
1574 Return true if the patron has a category with a type Child (C)
1580 return $self->category->category_type eq 'C' ? 1 : 0;
1583 =head3 has_valid_userid
1585 my $patron = Koha::Patrons->find(42);
1586 $patron->userid( $new_userid );
1587 my $has_a_valid_userid = $patron->has_valid_userid
1589 my $patron = Koha::Patron->new( $params );
1590 my $has_a_valid_userid = $patron->has_valid_userid
1592 Return true if the current userid of this patron is valid/unique, otherwise false.
1594 Note that this should be done in $self->store instead and raise an exception if needed.
1598 sub has_valid_userid {
1601 return 0 unless $self->userid;
1603 return 0 if ( $self->userid eq C4::Context->config('user') ); # DB user
1605 my $already_exists = Koha::Patrons->search(
1607 userid => $self->userid,
1610 ? ( borrowernumber => { '!=' => $self->borrowernumber } )
1615 return $already_exists ? 0 : 1;
1618 =head3 generate_userid
1620 my $patron = Koha::Patron->new( $params );
1621 $patron->generate_userid
1623 Generate a userid using the $surname and the $firstname (if there is a value in $firstname).
1625 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).
1629 sub generate_userid {
1632 my $firstname = $self->firstname // q{};
1633 my $surname = $self->surname // q{};
1634 #The script will "do" the following code and increment the $offset until the generated userid is unique
1636 $firstname =~ s/[[:digit:][:space:][:blank:][:punct:][:cntrl:]]//g;
1637 $surname =~ s/[[:digit:][:space:][:blank:][:punct:][:cntrl:]]//g;
1638 my $userid = lc(($firstname)? "$firstname.$surname" : $surname);
1639 $userid = NFKD( $userid );
1640 $userid =~ s/\p{NonspacingMark}//g;
1641 $userid .= $offset unless $offset == 0;
1642 $self->userid( $userid );
1644 } while (! $self->has_valid_userid );
1649 =head3 add_extended_attribute
1653 sub add_extended_attribute {
1654 my ($self, $attribute) = @_;
1656 return Koha::Patron::Attribute->new(
1659 ( borrowernumber => $self->borrowernumber ),
1665 =head3 extended_attributes
1667 Return object of Koha::Patron::Attributes type with all attributes set for this patron
1673 sub extended_attributes {
1674 my ( $self, $attributes ) = @_;
1675 if ($attributes) { # setter
1676 my $schema = $self->_result->result_source->schema;
1679 # Remove the existing one
1680 $self->extended_attributes->filter_by_branch_limitations->delete;
1682 # Insert the new ones
1684 for my $attribute (@$attributes) {
1685 $self->add_extended_attribute($attribute);
1686 $new_types->{$attribute->{code}} = 1;
1689 # Check globally mandatory types
1690 my @required_attribute_types =
1691 Koha::Patron::Attribute::Types->search(
1694 'borrower_attribute_types_branches.b_branchcode' =>
1697 { join => 'borrower_attribute_types_branches' }
1698 )->get_column('code');
1699 for my $type ( @required_attribute_types ) {
1700 Koha::Exceptions::Patron::MissingMandatoryExtendedAttribute->throw(
1702 ) if !$new_types->{$type};
1708 my $rs = $self->_result->borrower_attributes;
1709 # We call search to use the filters in Koha::Patron::Attributes->search
1710 return Koha::Patron::Attributes->_new_from_dbic($rs)->search;
1715 Koha::Patrons->find($id)->lock({ expire => 1, remove => 1 });
1717 Lock and optionally expire a patron account.
1718 Remove holds and article requests if remove flag set.
1719 In order to distinguish from locking by entering a wrong password, let's
1720 call this an administrative lockout.
1725 my ( $self, $params ) = @_;
1726 $self->login_attempts( ADMINISTRATIVE_LOCKOUT );
1727 if( $params->{expire} ) {
1728 $self->dateexpiry( dt_from_string->subtract(days => 1) );
1731 if( $params->{remove} ) {
1732 $self->holds->delete;
1733 $self->article_requests->delete;
1740 Koha::Patrons->find($id)->anonymize;
1742 Anonymize or clear borrower fields. Fields in BorrowerMandatoryField
1743 are randomized, other personal data is cleared too.
1744 Patrons with issues are skipped.
1750 if( $self->_result->issues->count ) {
1751 warn "Exiting anonymize: patron ".$self->borrowernumber." still has issues";
1754 # Mandatory fields come from the corresponding pref, but email fields
1755 # are removed since scrambled email addresses only generate errors
1756 my $mandatory = { map { (lc $_, 1); } grep { !/email/ }
1757 split /\s*\|\s*/, C4::Context->preference('BorrowerMandatoryField') };
1758 $mandatory->{userid} = 1; # needed since sub store does not clear field
1759 my @columns = $self->_result->result_source->columns;
1760 @columns = grep { !/borrowernumber|branchcode|categorycode|^date|password|flags|updated_on|lastseen|lang|login_attempts|anonymized/ } @columns;
1761 push @columns, 'dateofbirth'; # add this date back in
1762 foreach my $col (@columns) {
1763 $self->_anonymize_column($col, $mandatory->{lc $col} );
1765 $self->anonymized(1)->store;
1768 sub _anonymize_column {
1769 my ( $self, $col, $mandatory ) = @_;
1770 my $col_info = $self->_result->result_source->column_info($col);
1771 my $type = $col_info->{data_type};
1772 my $nullable = $col_info->{is_nullable};
1774 if( $type =~ /char|text/ ) {
1776 ? Koha::Token->new->generate({ pattern => '\w{10}' })
1780 } elsif( $type =~ /integer|int$|float|dec|double/ ) {
1781 $val = $nullable ? undef : 0;
1782 } elsif( $type =~ /date|time/ ) {
1783 $val = $nullable ? undef : dt_from_string;
1788 =head3 add_guarantor
1790 my @relationships = $patron->add_guarantor(
1792 borrowernumber => $borrowernumber,
1793 relationships => $relationship,
1797 Adds a new guarantor to a patron.
1802 my ( $self, $params ) = @_;
1804 my $guarantor_id = $params->{guarantor_id};
1805 my $relationship = $params->{relationship};
1807 return Koha::Patron::Relationship->new(
1809 guarantee_id => $self->id,
1810 guarantor_id => $guarantor_id,
1811 relationship => $relationship
1816 =head3 get_extended_attribute
1818 my $attribute_value = $patron->get_extended_attribute( $code );
1820 Return the attribute for the code passed in parameter.
1822 It not exist it returns undef
1824 Note that this will not work for repeatable attribute types.
1826 Maybe you certainly not want to use this method, it is actually only used for SHOW_BARCODE
1827 (which should be a real patron's attribute (not extended)
1831 sub get_extended_attribute {
1832 my ( $self, $code, $value ) = @_;
1833 my $rs = $self->_result->borrower_attributes;
1835 my $attribute = $rs->search({ code => $code, ( $value ? ( attribute => $value ) : () ) });
1836 return unless $attribute->count;
1837 return $attribute->next;
1842 my $json = $patron->to_api;
1844 Overloaded method that returns a JSON representation of the Koha::Patron object,
1845 suitable for API output.
1850 my ( $self, $params ) = @_;
1852 my $json_patron = $self->SUPER::to_api( $params );
1854 $json_patron->{restricted} = ( $self->is_debarred )
1856 : Mojo::JSON->false;
1858 return $json_patron;
1861 =head3 to_api_mapping
1863 This method returns the mapping for representing a Koha::Patron object
1868 sub to_api_mapping {
1870 borrowernotes => 'staff_notes',
1871 borrowernumber => 'patron_id',
1872 branchcode => 'library_id',
1873 categorycode => 'category_id',
1874 checkprevcheckout => 'check_previous_checkout',
1875 contactfirstname => undef, # Unused
1876 contactname => undef, # Unused
1877 contactnote => 'altaddress_notes',
1878 contacttitle => undef, # Unused
1879 dateenrolled => 'date_enrolled',
1880 dateexpiry => 'expiry_date',
1881 dateofbirth => 'date_of_birth',
1882 debarred => undef, # replaced by 'restricted'
1883 debarredcomment => undef, # calculated, API consumers will use /restrictions instead
1884 emailpro => 'secondary_email',
1885 flags => undef, # permissions manipulation handled in /permissions
1886 gonenoaddress => 'incorrect_address',
1887 guarantorid => 'guarantor_id',
1888 lastseen => 'last_seen',
1889 lost => 'patron_card_lost',
1890 opacnote => 'opac_notes',
1891 othernames => 'other_name',
1892 password => undef, # password manipulation handled in /password
1893 phonepro => 'secondary_phone',
1894 relationship => 'relationship_type',
1896 smsalertnumber => 'sms_number',
1897 sort1 => 'statistics_1',
1898 sort2 => 'statistics_2',
1899 autorenew_checkouts => 'autorenew_checkouts',
1900 streetnumber => 'street_number',
1901 streettype => 'street_type',
1902 zipcode => 'postal_code',
1903 B_address => 'altaddress_address',
1904 B_address2 => 'altaddress_address2',
1905 B_city => 'altaddress_city',
1906 B_country => 'altaddress_country',
1907 B_email => 'altaddress_email',
1908 B_phone => 'altaddress_phone',
1909 B_state => 'altaddress_state',
1910 B_streetnumber => 'altaddress_street_number',
1911 B_streettype => 'altaddress_street_type',
1912 B_zipcode => 'altaddress_postal_code',
1913 altcontactaddress1 => 'altcontact_address',
1914 altcontactaddress2 => 'altcontact_address2',
1915 altcontactaddress3 => 'altcontact_city',
1916 altcontactcountry => 'altcontact_country',
1917 altcontactfirstname => 'altcontact_firstname',
1918 altcontactphone => 'altcontact_phone',
1919 altcontactsurname => 'altcontact_surname',
1920 altcontactstate => 'altcontact_state',
1921 altcontactzipcode => 'altcontact_postal_code',
1922 primary_contact_method => undef,
1928 Koha::Patrons->queue_notice({ letter_params => $letter_params, message_name => 'DUE'});
1929 Koha::Patrons->queue_notice({ letter_params => $letter_params, message_transports => \@message_transports });
1930 Koha::Patrons->queue_notice({ letter_params => $letter_params, message_transports => \@message_transports, test_mode => 1 });
1932 Queue messages to a patron. Can pass a message that is part of the message_attributes
1933 table or supply the transport to use.
1935 If passed a message name we retrieve the patrons preferences for transports
1936 Otherwise we use the supplied transport. In the case of email or sms we fall back to print if
1937 we have no address/number for sending
1939 $letter_params is a hashref of the values to be passed to GetPreparedLetter
1941 test_mode will only report which notices would be sent, but nothing will be queued
1946 my ( $self, $params ) = @_;
1947 my $letter_params = $params->{letter_params};
1948 my $test_mode = $params->{test_mode};
1950 return unless $letter_params;
1951 return unless exists $params->{message_name} xor $params->{message_transports}; # We only want one of these
1953 my $library = Koha::Libraries->find( $letter_params->{branchcode} );
1954 my $from_email_address = $library->from_email_address;
1956 my @message_transports;
1958 $letter_code = $letter_params->{letter_code};
1959 if( $params->{message_name} ){
1960 my $messaging_prefs = C4::Members::Messaging::GetMessagingPreferences( {
1961 borrowernumber => $letter_params->{borrowernumber},
1962 message_name => $params->{message_name}
1964 @message_transports = ( keys %{ $messaging_prefs->{transports} } );
1965 $letter_code = $messaging_prefs->{transports}->{$message_transports[0]} unless $letter_code;
1967 @message_transports = @{$params->{message_transports}};
1969 return unless defined $letter_code;
1970 $letter_params->{letter_code} = $letter_code;
1973 foreach my $mtt (@message_transports){
1974 next if ($mtt eq 'itiva' and C4::Context->preference('TalkingTechItivaPhoneNotification') );
1975 # Notice is handled by TalkingTech_itiva_outbound.pl
1976 if ( ( $mtt eq 'email' and not $self->notice_email_address )
1977 or ( $mtt eq 'sms' and not $self->smsalertnumber )
1978 or ( $mtt eq 'phone' and not $self->phone ) )
1980 push @{ $return{fallback} }, $mtt;
1983 next if $mtt eq 'print' && $print_sent;
1984 $letter_params->{message_transport_type} = $mtt;
1985 my $letter = C4::Letters::GetPreparedLetter( %$letter_params );
1986 C4::Letters::EnqueueLetter({
1988 borrowernumber => $self->borrowernumber,
1989 from_address => $from_email_address,
1990 message_transport_type => $mtt
1991 }) unless $test_mode;
1992 push @{$return{sent}}, $mtt;
1993 $print_sent = 1 if $mtt eq 'print';
1998 =head3 safe_to_delete
2000 my $result = $patron->safe_to_delete;
2001 if ( $result eq 'has_guarantees' ) { ... }
2002 elsif ( $result ) { ... }
2003 else { # cannot delete }
2005 This method tells if the Koha:Patron object can be deleted. Possible return values
2011 =item 'has_checkouts'
2015 =item 'has_guarantees'
2017 =item 'is_anonymous_patron'
2023 sub safe_to_delete {
2026 my $anonymous_patron = C4::Context->preference('AnonymousPatron');
2030 if ( $anonymous_patron && $self->id eq $anonymous_patron ) {
2031 $error = 'is_anonymous_patron';
2033 elsif ( $self->checkouts->count ) {
2034 $error = 'has_checkouts';
2036 elsif ( $self->account->outstanding_debits->total_outstanding > 0 ) {
2037 $error = 'has_debt';
2039 elsif ( $self->guarantee_relationships->count ) {
2040 $error = 'has_guarantees';
2044 return Koha::Result::Boolean->new(0)->add_message({ message => $error });
2047 return Koha::Result::Boolean->new(1);
2050 =head2 Internal methods
2062 Kyle M Hall <kyle@bywatersolutions.com>
2063 Alex Sassmannshausen <alex.sassmannshausen@ptfs-europe.com>
2064 Martin Renvoize <martin.renvoize@ptfs-europe.com>