It returns the debit lines with outstanding amounts for the patron.

It returns the debit lines with outstanding amounts for the patron.

=cut

=cut

It returns the credit lines with outstanding amounts for the patron.

It returns the credit lines with outstanding amounts for the patron.

=cut

=cut

    # Find any applied offsets for the credit so we may reverse them

    # Find any applied offsets for the credit so we may reverse them

    my @account_offsets =

    my @account_offsets =

      Koha::Account::Offsets->search(

      Koha::Account::Offsets->search(

    my $void;

    my $void;

    $self->_result->result_source->schema->txn_do(

    $self->_result->result_source->schema->txn_do(

                    currency => { '!=' => $self->currency },

                    currency => { '!=' => $self->currency },

                    active => 1,

                    active => 1,

                }

                }

            for my $currency ( @currencies ) {

            for my $currency ( @currencies ) {

                $currency->active(0);

                $currency->active(0);

                $currency->store;

                $currency->store;

              columns => ['itemnumber'],

              columns => ['itemnumber'],

              collapse => 1,

              collapse => 1,

          }

          }

    my @waiting_holds = map { $_->itemnumber }

    my @waiting_holds = map { $_->itemnumber }

      Koha::Holds->search(

      Koha::Holds->search(

          { 'found' => 'W' },

          { 'found' => 'W' },

              columns => ['itemnumber'],

              columns => ['itemnumber'],

              collapse => 1,

              collapse => 1,

          }

          }

    return Koha::Items->search(

    return Koha::Items->search(

        {

        {

        Koha::Exceptions::BadParameter->throw( { parameter => 'only_this_guarantor' } ) unless @guarantors;

        Koha::Exceptions::BadParameter->throw( { parameter => 'only_this_guarantor' } ) unless @guarantors;

    } elsif ( $self->guarantor_relationships->count ) {

    } elsif ( $self->guarantor_relationships->count ) {

        # I am a guarantee, just get all my guarantors

        # I am a guarantee, just get all my guarantors

    } else {

    } else {

        # I am a guarantor, I need to get all the guarantors of all my guarantees

        # I am a guarantor, I need to get all the guarantors of all my guarantees

    }

    }

    my $non_issues_charges = 0;

    my $non_issues_charges = 0;

        $non_issues_charges += $guarantor->account->non_issues_charges if $include_guarantors && !$seen->{ $guarantor->id };

        $non_issues_charges += $guarantor->account->non_issues_charges if $include_guarantors && !$seen->{ $guarantor->id };

        # We've added what the guarantor owes, not added in that guarantor's guarantees as well

        # We've added what the guarantor owes, not added in that guarantor's guarantees as well

        my $guarantees_non_issues_charges = 0;

        my $guarantees_non_issues_charges = 0;

        foreach my $guarantee (@guarantees) {

        foreach my $guarantee (@guarantees) {

            next if $seen->{ $guarantee->id };

            next if $seen->{ $guarantee->id };

sub siblings {

sub siblings {

    my ($self) = @_;

    my ($self) = @_;

    return unless @guarantors;

    return unless @guarantors;

    my @siblings =

    my @siblings =

    return unless @siblings;

    return unless @siblings;

    @siblings =

    @siblings =

      grep { !$seen{ $_->id }++ && ( $_->id != $self->id ) } @siblings;

      grep { !$seen{ $_->id }++ && ( $_->id != $self->id ) } @siblings;

}

}

=head3 merge_with

=head3 merge_with

sub get_club_enrollments {

sub get_club_enrollments {

    my ( $self, $return_scalar ) = @_;

    my ( $self, $return_scalar ) = @_;

}

}

=head3 get_enrollable_clubs

=head3 get_enrollable_clubs

    $params->{borrower} = $self;

    $params->{borrower} = $self;

}

}

=head3 account_locked

=head3 account_locked

    my ( $self, $new_attributes ) = @_;

    my ( $self, $new_attributes ) = @_;

    my @existing_attributes = @{$self->unblessed};

    my @existing_attributes = @{$self->unblessed};

    my @new_attributes;

    my @new_attributes;

    for my $attr ( @$new_attributes ) {

    for my $attr ( @$new_attributes ) {

    @guarantor_ids = grep { defined $_ } @guarantor_ids;

    @guarantor_ids = grep { defined $_ } @guarantor_ids;

    @guarantor_ids = uniq( @guarantor_ids );

    @guarantor_ids = uniq( @guarantor_ids );

}

}

=head3 guarantees

=head3 guarantees

    my @guarantee_ids = uniq( $rs->get_column('guarantee_id')->all() );

    my @guarantee_ids = uniq( $rs->get_column('guarantee_id')->all() );

        { borrowernumber => \@guarantee_ids },

        { borrowernumber => \@guarantee_ids },

        {

        {

            order_by => { -asc => [ 'surname', 'firstname' ] }

            order_by => { -asc => [ 'surname', 'firstname' ] }

        },

        },

    );

    );

}

}

=head3 type

=head3 type

    my %auth_match_headings;

    my %auth_match_headings;

    if( $self->index eq 'authorities' ){

    if( $self->index eq 'authorities' ){

        %auth_match_headings = map { $_->authtypecode => $_->auth_tag_to_report } @auth_types;

        %auth_match_headings = map { $_->authtypecode => $_->auth_tag_to_report } @auth_types;

    }

    }

    # We also have some special cases, e.g. itypes that need to show the

    # We also have some special cases, e.g. itypes that need to show the

    # value rather than the code.

    # value rather than the code.

    my $library_names = { map { $_->branchcode => $_->branchname } @libraries };

    my $library_names = { map { $_->branchcode => $_->branchname } @libraries };

    my $opac = C4::Context->interface eq 'opac' ;

    my $opac = C4::Context->interface eq 'opac' ;

    my %special = (

    my %special = (

        itype    => { map { $_->itemtype         => $_->description } @itypes },

        itype    => { map { $_->itemtype         => $_->description } @itypes },

subtest 'outstanding_debits() tests' => sub {

subtest 'outstanding_debits() tests' => sub {

    $schema->storage->txn_begin;

    $schema->storage->txn_begin;

    push @generated_lines, $account->add_debit({ amount => 4, interface => 'commandline', type => 'OVERDUE' });

    push @generated_lines, $account->add_debit({ amount => 4, interface => 'commandline', type => 'OVERDUE' });

    my $lines     = $account->outstanding_debits();

    my $lines     = $account->outstanding_debits();

    is( ref($lines), 'Koha::Account::Lines', 'Called in scalar context, outstanding_debits returns a Koha::Account::Lines object' );

    is( ref($lines), 'Koha::Account::Lines', 'Called in scalar context, outstanding_debits returns a Koha::Account::Lines object' );

    is( $lines->total_outstanding, 10, 'Outstandig debits total is correctly calculated' );

    is( $lines->total_outstanding, 10, 'Outstandig debits total is correctly calculated' );

    my $patron_2 = $builder->build_object({ class => 'Koha::Patrons' });

    my $patron_2 = $builder->build_object({ class => 'Koha::Patrons' });

    Koha::Account::Line->new(

    Koha::Account::Line->new(

        {

        {

subtest 'outstanding_credits() tests' => sub {

subtest 'outstanding_credits() tests' => sub {

    $schema->storage->txn_begin;

    $schema->storage->txn_begin;

    push @generated_lines, $account->add_credit({ amount => 4, interface => 'commandline' });

    push @generated_lines, $account->add_credit({ amount => 4, interface => 'commandline' });

    my $lines     = $account->outstanding_credits();

    my $lines     = $account->outstanding_credits();

    is( ref($lines), 'Koha::Account::Lines', 'Called in scalar context, outstanding_credits returns a Koha::Account::Lines object' );

    is( ref($lines), 'Koha::Account::Lines', 'Called in scalar context, outstanding_credits returns a Koha::Account::Lines object' );

    is( $lines->total_outstanding, -10, 'Outstandig credits total is correctly calculated' );

    is( $lines->total_outstanding, -10, 'Outstandig credits total is correctly calculated' );

    my $patron_2 = $builder->build_object({ class => 'Koha::Patrons' });

    my $patron_2 = $builder->build_object({ class => 'Koha::Patrons' });

    $account  = $patron_2->account;

    $account  = $patron_2->account;

    $lines       = $account->outstanding_credits();

    $lines       = $account->outstanding_credits();

    # Re-fetch vendor

    # Re-fetch vendor

    $vendor = Koha::Acquisition::Booksellers->find( $vendor->id );

    $vendor = Koha::Acquisition::Booksellers->find( $vendor->id );

        is( ref($subscription), 'Koha::Subscription', 'Type is correct' );

        is( ref($subscription), 'Koha::Subscription', 'Type is correct' );

    }

    }

subtest 'items() tests' => sub {

subtest 'items() tests' => sub {

    $schema->storage->txn_begin;

    $schema->storage->txn_begin;

    is( ref($items), 'Koha::Items', 'Returns a Koha::Items resultset' );

    is( ref($items), 'Koha::Items', 'Returns a Koha::Items resultset' );

    is( $items->count, 2, 'Two items in resultset' );

    is( $items->count, 2, 'Two items in resultset' );

    $schema->storage->txn_rollback;

    $schema->storage->txn_rollback;

};

};

    my @hold_libraries_1 = ($library1, $library2);

    my @hold_libraries_1 = ($library1, $library2);

    my @hold_libraries_2 = ($library3, $library4, $library5);

    my @hold_libraries_2 = ($library3, $library4, $library5);

    # library1 and library2 are siblings

    # library1 and library2 are siblings

    is(scalar(@result), 2, 'get_hold_libraries returns 2 libraries');

    is(scalar(@result), 2, 'get_hold_libraries returns 2 libraries');

        ok(exists $map{$hold_library->branchcode}, 'library in hold group');

        ok(exists $map{$hold_library->branchcode}, 'library in hold group');

    }

    }

    # library3, library4 and library5 are siblings

    # library3, library4 and library5 are siblings

    is(scalar(@result), 3, 'get_hold_libraries returns 3 libraries');

    is(scalar(@result), 3, 'get_hold_libraries returns 3 libraries');

        $enrollment_fee = $patron->add_enrolment_fee_if_needed(1);

        $enrollment_fee = $patron->add_enrolment_fee_if_needed(1);

        is( $patron->account->balance * 1, 60, 'Patron charged the enrolment fees' );

        is( $patron->account->balance * 1, 60, 'Patron charged the enrolment fees' );

        is( scalar @debits, 3, '3 enrolment fees' );

        is( scalar @debits, 3, '3 enrolment fees' );

        is( $debits[0]->debit_type_code, 'ACCOUNT', 'Account type set correctly' );

        is( $debits[0]->debit_type_code, 'ACCOUNT', 'Account type set correctly' );

        is( $debits[1]->debit_type_code, 'ACCOUNT', 'Account type set correctly' );

        is( $debits[1]->debit_type_code, 'ACCOUNT', 'Account type set correctly' );

        my $account = $patron->account;

        my $account = $patron->account;

        is( $patron->account->balance, 0, 'Patron not charged anything' );

        is( $patron->account->balance, 0, 'Patron not charged anything' );

        is( scalar @debits, 0, 'no debits' );

        is( scalar @debits, 0, 'no debits' );

        $schema->storage->txn_rollback;

        $schema->storage->txn_rollback;

    my @patron_attributes

    my @patron_attributes

        = map { $_->unblessed }

        = map { $_->unblessed }

        Koha::Patron::Attributes->search(

        Koha::Patron::Attributes->search(

    is( $patron_attributes[0]->{code},

    is( $patron_attributes[0]->{code},

        'CODE_1', 'Untouched attribute type is preserved (code)' );

        'CODE_1', 'Untouched attribute type is preserved (code)' );

};

};

subtest 'guarantees' => sub {

subtest 'guarantees' => sub {

    t::lib::Mocks::mock_preference( 'borrowerRelationship', 'test|test2' );

    t::lib::Mocks::mock_preference( 'borrowerRelationship', 'test|test2' );

    my $guarantees = $new_patron_1->guarantee_relationships;

    my $guarantees = $new_patron_1->guarantee_relationships;

    is( ref($guarantees), 'Koha::Patron::Relationships', 'Koha::Patron->guarantees should return a Koha::Patrons result set in a scalar context' );

    is( ref($guarantees), 'Koha::Patron::Relationships', 'Koha::Patron->guarantees should return a Koha::Patrons result set in a scalar context' );

    is( $guarantees->count, 0, 'new_patron_1 should have 0 guarantee relationships' );

    is( $guarantees->count, 0, 'new_patron_1 should have 0 guarantee relationships' );

    my $guarantee_1 = $builder->build({ source => 'Borrower' });

    my $guarantee_1 = $builder->build({ source => 'Borrower' });

    my $relationship_1 = Koha::Patron::Relationship->new( { guarantor_id => $new_patron_1->id, guarantee_id => $guarantee_1->{borrowernumber}, relationship => 'test' } )->store();

    my $relationship_1 = Koha::Patron::Relationship->new( { guarantor_id => $new_patron_1->id, guarantee_id => $guarantee_1->{borrowernumber}, relationship => 'test' } )->store();

    $guarantees = $new_patron_1->guarantee_relationships;

    $guarantees = $new_patron_1->guarantee_relationships;

    is( ref($guarantees), 'Koha::Patron::Relationships', 'Koha::Patron->guarantee_relationships should return a Koha::Patrons result set in a scalar context' );

    is( ref($guarantees), 'Koha::Patron::Relationships', 'Koha::Patron->guarantee_relationships should return a Koha::Patrons result set in a scalar context' );

    is( $guarantees->count, 2, 'new_patron_1 should have 2 guarantees' );

    is( $guarantees->count, 2, 'new_patron_1 should have 2 guarantees' );

    #Test return order of guarantees BZ 18635

    #Test return order of guarantees BZ 18635

    my $categorycode = $builder->build({ source => 'Category' })->{categorycode};

    my $categorycode = $builder->build({ source => 'Category' })->{categorycode};

};

};

subtest 'siblings' => sub {

subtest 'siblings' => sub {

    my $siblings = $new_patron_1->siblings;

    my $siblings = $new_patron_1->siblings;

    is( $siblings, undef, 'Koha::Patron->siblings should not crashed if the patron has no guarantor' );

    is( $siblings, undef, 'Koha::Patron->siblings should not crashed if the patron has no guarantor' );

    my $guarantee_1 = $builder->build( { source => 'Borrower' } );

    my $guarantee_1 = $builder->build( { source => 'Borrower' } );

    my $retrieved_guarantee_1 = Koha::Patrons->find($guarantee_1);

    my $retrieved_guarantee_1 = Koha::Patrons->find($guarantee_1);

    $siblings = $retrieved_guarantee_1->siblings;

    $siblings = $retrieved_guarantee_1->siblings;

    is( ref($siblings), 'Koha::Patrons', 'Koha::Patron->siblings should return a Koha::Patrons result set in a scalar context' );

    is( ref($siblings), 'Koha::Patrons', 'Koha::Patron->siblings should return a Koha::Patrons result set in a scalar context' );

    is( $siblings->count,  0,       'guarantee_1 should not have siblings yet' );

    is( $siblings->count,  0,       'guarantee_1 should not have siblings yet' );

    my $guarantee_2 = $builder->build( { source => 'Borrower' } );

    my $guarantee_2 = $builder->build( { source => 'Borrower' } );

    my $relationship_2 = Koha::Patron::Relationship->new( { guarantor_id => $new_patron_1->borrowernumber, guarantee_id => $guarantee_2->{borrowernumber}, relationship => 'test' } )->store();

    my $relationship_2 = Koha::Patron::Relationship->new( { guarantor_id => $new_patron_1->borrowernumber, guarantee_id => $guarantee_2->{borrowernumber}, relationship => 'test' } )->store();