use C4::Overdues qw( parse_overdues_letter );

use C4::Overdues             qw( parse_overdues_letter );

use C4::Log qw( cronlogaction );

use C4::Log                  qw( cronlogaction );

use Koha::DateUtils qw( dt_from_string output_pref );

use Koha::DateUtils          qw( dt_from_string output_pref );

my $dbh = C4::Context->dbh();

my $dbh         = C4::Context->dbh();

my $help    = 0;

my $help        = 0;

my $man     = 0;

my $man         = 0;

my $verbose = 0;

my $verbose     = 0;

my $nomail  = 0;

my $nomail      = 0;

my $MAX     = 90;

my $MAX         = 90;

my $test_mode = 0;

my $test_mode   = 0;

my $frombranch = 'item-issuebranch';

my $frombranch  = 'item-issuebranch';

my @branchcodes; # Branch(es) passed as parameter

my $itype_level = C4::Context->preference('item-level_itypes') ? 'item' : 'biblioitem';

my @branchcodes;      # Branch(es) passed as parameter

my $triggered = 0;

my $triggered    = 0;

my $listall = 0;

my $listall      = 0;

my $command_line_options = join(" ",@ARGV);

my $command_line_options = join( " ", @ARGV );

my $owning_library = ( $frombranch eq 'item-homebranch' ) ? 1 : 0;

my $owning_library     = ( $frombranch eq 'item-homebranch' )   ? 1 : 0;

my @overduebranches    = C4::Overdues::GetBranchcodesWithOverdueRules();    # Branches with overdue rules

my @overduebranches = C4::Overdues::GetBranchcodesWithOverdueRules();  # Branches with overdue rules

my @branches;                                    # Branches passed as parameter with overdue rules

my @branches;                                                          # Branches passed as parameter with overdue rules

my $branchcodes_word = scalar @branchcodes > 1 ? 'branches' : 'branch';

my $branchcodes_word   = scalar @branchcodes > 1     ? 'branches' : 'branch';

    $verbose and warn "Found $branchcount $overduebranch_word with first message enabled: " . join( ', ', map { "'$_'" } @overduebranches ), "\n";

    $verbose

        and warn "Found $branchcount $overduebranch_word with first message enabled: "

        . join( ', ', map { "'$_'" } @overduebranches ), "\n";

    $verbose and warn "$branch_word @branches have overdue rules\n";

        $verbose and warn "$branch_word @branches have overdue rules\n";

          or die "No active overduerules for DEFAULT either!";

            or die "No active overduerules for DEFAULT either!";

if ( $date_input ){

if ($date_input) {

    eval {

    eval { $date_to_run = dt_from_string( $date_input, 'iso' ); };

        $date_to_run = dt_from_string( $date_input, 'iso' );

    };

    $date = $dbh->quote( $date_input );

    $date = $dbh->quote($date_input);

}

} else {

else {

    $date        = "NOW()";

    $date="NOW()";

    $csv = Text::CSV_XS->new( { binary => 1 , sep_char => $sep_char } );

    $csv = Text::CSV_XS->new( { binary => 1, sep_char => $sep_char } );

    if ( $csv->combine(qw(name surname address1 address2 zipcode city country email phone cardnumber itemcount itemsinfo branchname letternumber)) ) {

    if (

        $csv->combine(

            qw(name surname address1 address2 zipcode city country email phone cardnumber itemcount itemsinfo branchname letternumber)

        )

        )

    {

  if ( $htmlfilename eq '' ) {

    if ( $htmlfilename eq '' ) {

    $fh = *STDOUT;

        $fh = *STDOUT;

  } else {

    } else {

    my $today = dt_from_string();

        my $today = dt_from_string();

    open $fh, ">:encoding(UTF-8)",File::Spec->catdir ($htmlfilename,"notices-".$today->ymd().".html");

        open $fh, ">:encoding(UTF-8)", File::Spec->catdir( $htmlfilename, "notices-" . $today->ymd() . ".html" );

  }

    }

  print $fh _get_html_start();

    print $fh _get_html_start();

} elsif ( defined $text_filename ) {

    if ( $text_filename eq '' ) {

        $fh = *STDOUT;

    } else {

        my $today = dt_from_string();

        open $fh, ">:encoding(UTF-8)", File::Spec->catdir( $text_filename, "notices-" . $today->ymd() . ".txt" );

    }

}

# Setup category list

my @categories;

if (@myborcat) {

    @categories = @myborcat;

} elsif (@myborcatout) {

    @categories = Koha::Patron::Categories->search( { catagorycode => { 'not_in' => \@myborcatout } } )

        ->get_column('categorycode');

} else {

    @categories = Koha::Patron::Categories->search()->get_column('categorycode');

elsif ( defined $text_filename ) {

  if ( $text_filename eq '' ) {

# Setup itemtype list

    $fh = *STDOUT;

my @itemtypes;

  } else {

if (@myitemtypes) {

    my $today = dt_from_string();

    @itemtypes = @myitemtypes;

    open $fh, ">:encoding(UTF-8)",File::Spec->catdir ($text_filename,"notices-".$today->ymd().".txt");

} elsif (@myitemtypesout) {

  }

    @itemtypes =

        Koha::ItemTypes->search( { itemtype => { 'not_in' => \@myitemtypesout } } )->get_column('itemtype');

} else {

    @itemtypes = Koha::ItemTypes->search()->get_column('itemtype');

    my $library             = Koha::Libraries->find($branchcode);

    my $library              = Koha::Libraries->find($branchcode);

    my $admin_email_address = $library->from_email_address;

    my $admin_email_address  = $library->from_email_address;

      || $library->inbound_email_address;

        || $library->inbound_email_address;

    my @output_chunks;    # may be sent to mail or stdout or csv file.

    @output_chunks = ();    # may be sent to mail or stdout or csv file.

    my $sql2 = <<"END_SQL";

    # Work through patron categories

SELECT biblio.*, items.*, issues.*, biblioitems.itemtype, branchname

    for my $category (@categories) {

  FROM issues,items,biblio, biblioitems, branches b

  WHERE items.itemnumber=issues.itemnumber

        # Fetch all overdues for patron categories that want overdues and where the item is not lost and group by borrower

    AND biblio.biblionumber   = items.biblionumber

        my $borrower_sql = <<"END_SQL";

    AND b.branchcode = items.homebranch

SELECT

    AND biblio.biblionumber   = biblioitems.biblionumber

    issues.borrowernumber,

    AND issues.borrowernumber = ?

    borrowers.firstname,

    AND items.itemlost = 0

    borrowers.surname,

    borrowers.address,

    borrowers.address2,

    borrowers.city,

    borrowers.zipcode,

    borrowers.country,

    borrowers.email,

    borrowers.emailpro,

    borrowers.B_email,

    borrowers.smsalertnumber,

    borrowers.phone,

    borrowers.cardnumber,

    biblio.*,

    biblioitems.itemtype AS b_itemtype,

    items.*,

    issues.*,

    branches.branchname

FROM

    issues

JOIN

    borrowers ON issues.borrowernumber = borrowers.borrowernumber

JOIN

    categories ON borrowers.categorycode = categories.categorycode

JOIN

    items ON issues.itemnumber = items.itemnumber

JOIN

    biblio ON biblio.biblionumber = items.biblionumber

JOIN

    biblioitems ON biblio.biblionumber = biblioitems.biblionumber

JOIN

    branches ON branches.branchcode = items.homebranch

WHERE

    items.itemlost = 0

    if ($owning_library) {

        my @borrower_parameters;

        $sql2 .= ' AND items.homebranch = ? ' unless ($patron_homelibrary);

        if ($branchcode) {

    } else {

            if ($owning_library) {

        $sql2 .= ' AND issues.branchcode = ? ' unless ($patron_homelibrary);

                $borrower_sql .= ' AND items.homebranch=? ';

    }

            } else {

    my $sth2 = $dbh->prepare($sql2);

                $borrower_sql .= ' AND issues.branchcode=? ';

            }

    my @categories;

            push @borrower_parameters, $branchcode;

    if (@myborcat) {

        }

        @categories = @myborcat;

        if ($category) {

    } elsif (@myborcatout) {

            $borrower_sql .= ' AND borrowers.categorycode=? ';

        @categories = Koha::Patron::Categories->search( { catagorycode => { 'not_in' => \@myborcatout } } )

            push @borrower_parameters, $category;

            ->get_column('categorycode');

        }

    } else {

        if (@itemtypes) {

        @categories = Koha::Patron::Categories->search()->get_column('categorycode');

            my $placeholders = join( ", ", ("?") x @itemtypes );

    }

            if ( $itype_level eq 'item' ) {

                $borrower_sql .= " AND items.itype IN ($placeholders) ";

            } else {

                $borrower_sql .= " AND biblioitems.itemtype IN ($placeholders) ";

            }

            push @borrower_parameters, @itemtypes;

        }

        $borrower_sql .= '  AND categories.overduenoticerequired=1 ORDER BY issues.borrowernumber';

        # $sth gets borrower info if at least one overdue item has triggered the overdue action.

        my $sth = $dbh->prepare($borrower_sql);

        $sth->execute(@borrower_parameters);

        if ( $verbose > 1 ) {

            warn sprintf "--------Borrower SQL------\n";

            warn $borrower_sql

                . "\n $branchcode | "

                . "'$category' | "

                . join( "','", @itemtypes ) . " | "

                . $date_to_run->datetime() . ")\n";

            warn sprintf "--------------------------\n";

        }

        $verbose and warn sprintf "Found %s overdues for $category on $date_to_run\n", $sth->rows;

    my @itemtypes;

        my $borrowernumber;

    if (@myitemtypes) {

        my $borrower_overdues = {};

        @itemtypes = @myitemtypes;

    } elsif (@myitemtypesout) {

        @itemtypes =

            Koha::ItemTypes->search( { itemtype => { 'not_in' => \@myitemtypesout } } )->get_column('itemtype');

    } else {

        @itemtypes = Koha::ItemTypes->search()->get_column('itemtype');

    }

    # Work through category and itemtype combinations to catch overdue rules for each

        # Iterate over all overdues

    for my $category (@categories) {

    OVERDUE: while ( my $data = $sth->fetchrow_hashref ) {

        for my $itemtype (@itemtypes) {

            my $itemtype = $data->{itype} // $data->{b_itemtype};

            # Collect triggers or act on them if we're switching borrower

            if ( !defined $borrower_overdues->{borrowernumber} ) {

                if ($verbose) {

                    warn "\n-----------------------------------------\n";

                    warn "Collecting overdue triggers for borrower " . $data->{borrowernumber} . "\n";

                }

                $borrower_overdues = { borrowernumber => $data->{borrowernumber}, branchcode => $branchcode };

            } elsif ( $borrower_overdues->{borrowernumber} ne $data->{borrowernumber} ) {

                $verbose and warn "Collected overdue triggers for " . $borrower_overdues->{borrowernumber} . "\n";

                _enact_trigger($borrower_overdues);

                if ($verbose) {

                    warn "\n-----------------------------------------\n";

                    warn "Collecting overdue triggers for borrower " . $data->{borrowernumber} . "\n";

                }

                $borrower_overdues = { borrowernumber => $data->{borrowernumber}, branchcode => $branchcode };

            }

            $verbose

                and warn "\nProcessing overdue "

                . $data->{issue_id}

                . " with branch = '$branchcode', categorycode = '$category' and itemtype = '$itemtype'\n";

            # Work through triggers until we run out of rules or find a match

            # Work through triggers until we run out of rules

        PERIOD: while (1) {

            PERIOD: while (1) {

                my $ii = $i + 1;

                my $ii            = $i + 1;

                    $overdue_rules->{ "overdue_$i" . '_delay' }; # the notice will be sent after mindays days (grace period)

                    $overdue_rules->{ "overdue_$i" . '_delay' }

                    ;    # the notice will be sent after mindays days (grace period)

                );    # issues being more than maxdays late are managed somewhere else. (borrower probably suspended)

                );       # issues being more than maxdays late are managed somewhere else. (borrower probably suspended)

                next unless defined $mindays;

                if ( !$overdue_rules->{"overdue_$i".'_notice'} ) {

                if ( !$overdue_rules->{ "overdue_$i" . '_notice' } ) {

                    $verbose and warn sprintf "No letter code found for pass %s\n", $i;

                    $verbose and warn sprintf "Trigger %s skipped, No letter code found\n", $i;

            # itemcount is interpreted here as the number of items in the overdue range defined by the current notice or all overdues < max if(-list-all).

                # itemcount is interpreted here as the number of items in the overdue range defined by the current notice or all overdues < max if(-list-all).

                # Fetch all overdue issues where the item is not lost and the borrower category wants overdue notices grouping by borrower

                # Check the overdue period matches

                my $borrower_sql = <<"END_SQL";

                my $days_between;

SELECT issues.borrowernumber, firstname, surname, address, address2, city, zipcode, country, email, emailpro, B_email, smsalertnumber, phone, cardnumber, date_due

                if ( C4::Context->preference('OverdueNoticeCalendar') ) {

FROM   issues,borrowers,categories,items

                    $days_between = $calendar->days_between(

WHERE  issues.borrowernumber=borrowers.borrowernumber

                        dt_from_string( $data->{date_due} ),

AND    borrowers.categorycode=categories.categorycode

                        $date_to_run

AND    issues.itemnumber = items.itemnumber

                    );

AND    items.itemlost = 0

                } else {

AND    TO_DAYS($date)-TO_DAYS(issues.date_due) >= 0

                    $days_between =

END_SQL

                        $date_to_run->delta_days( dt_from_string( $data->{date_due} ) );

                my @borrower_parameters;

                if ($branchcode) {

            if($owning_library) {

                $borrower_sql .= ' AND items.homebranch=? ';

            } else {

                $borrower_sql .= ' AND issues.branchcode=? ';

            }

                    push @borrower_parameters, $branchcode;

                }

                if ( $category ) {

                    $borrower_sql .= ' AND borrowers.categorycode=? ';

                    push @borrower_parameters, $category;

                }

                $borrower_sql .= '  AND categories.overduenoticerequired=1 ORDER BY issues.borrowernumber';

                # $sth gets borrower info if at least one overdue item has triggered the overdue action.

                my $sth = $dbh->prepare($borrower_sql);

                $sth->execute(@borrower_parameters);

                if ( $verbose > 1 ){

                    warn sprintf "--------Borrower SQL------\n";

                    warn $borrower_sql . "\n $branchcode | " . $category . "\n ($mindays, $maxdays, ".  $date_to_run->datetime() .")\n";

                    warn sprintf "--------------------------\n";

                $verbose and warn sprintf "Found %s borrowers with overdues\n", $sth->rows;

                $days_between = $days_between->in_units('days');

                my $borrowernumber;

                if ($listall) {

                # Iterate over all overdue issues

                    unless ( $days_between >= 1 and $days_between <= $MAX ) {

                while ( my $data = $sth->fetchrow_hashref ) {

                        next;

                    # check the borrower has at least one item that matches

                    my $days_between;

                    if ( C4::Context->preference('OverdueNoticeCalendar') )

                    {

                        $days_between =

                          $calendar->days_between( dt_from_string($data->{date_due}),

                            $date_to_run );

                    }

                    else {

                        $days_between =

                          $date_to_run->delta_days( dt_from_string($data->{date_due}) );

                    $days_between = $days_between->in_units('days');

                } else {

                    }

                    } else {

                    else {

                        unless ( $days_between >= $mindays

                        unless (   $days_between >= $mindays

                    if (defined $borrowernumber && $borrowernumber eq $data->{'borrowernumber'}){

                }

# we have already dealt with this borrower

                        $verbose and warn "already dealt with this borrower $borrowernumber";

                        next;

                    }

                    $borrowernumber = $data->{'borrowernumber'};

                    # Skip duplicate borrowers as we'll have already handled them

                    next if ( $patron_homelibrary && $already_queued{"$borrowernumber$i"} );

                    my $borr = sprintf( "%s%s%s (%s)",

                if ($verbose) {

                    my $borr = sprintf(

                        "%s%s%s (%s)",

                        $borrowernumber );

                        $data->{borrowernumber}

                    $verbose and warn "borrower $borr has items triggering level $i.\n";

                    my $patron = Koha::Patrons->find( $borrowernumber );

                    if ($patron_homelibrary) {

                        $branchcode           = $patron->branchcode;

                        $library              = Koha::Libraries->find($branchcode);

                        $admin_email_address  = $library->from_email_address;

                        $branch_email_address = C4::Context->preference('AddressForFailedOverdueNotices')

                            || $library->inbound_email_address;

                    }

                    @emails_to_use = ();

                    my $notice_email = $patron->notice_email_address;

                    unless ($nomail) {

                        if (@emails) {

                            foreach (@emails) {

                                push @emails_to_use, $data->{$_} if ( $data->{$_} );

                            }

                        }

                        else {

                            push @emails_to_use, $notice_email if ($notice_email);

                        }

                    }

                    my $letter = Koha::Notice::Templates->find_effective_template(

                        {

                            module     => 'circulation',

                            code       => $overdue_rules->{"overdue_$i".'_notice'},

                            branchcode => $branchcode,

                            lang       => $patron->lang

                        }

                    unless ($letter) {

                my @message_transport_types = split( /,/, $overdue_rules->{ "overdue_$i" . '_mtt' } );

                        $verbose and warn qq|Message '$overdue_rules->{"overdue_$i"."_notice"}' content not found|;

                for my $mtt (@message_transport_types) {

                    push @{ $borrower_overdues->{triggers}->{$i}->{ $overdue_rules->{ "overdue_$i" . '_notice' } }

                        # might as well skip while PERIOD, no other borrowers are going to work.

                            ->{$mtt} }, $data;

                        # FIXME : Does this mean a letter must be defined in order to trigger a debar ?

                        next PERIOD;

                    }

                    if ( $overdue_rules->{"overdue_$i".'_restrict'} ) {

                        #action taken is debarring

                        AddUniqueDebarment(

                            {

                                borrowernumber => $borrowernumber,

                                type           => 'OVERDUES',

                                comment => "OVERDUES_PROCESS " .  output_pref( dt_from_string() ),

                            }

                        ) unless $test_mode;

                        $verbose and warn "debarring $borr\n";

                    }

                    my @params = $patron_homelibrary ? ($borrowernumber) : ( $borrowernumber, $branchcode );

                    $sth2->execute(@params);

                    my $itemcount = 0;

                    my $titles = "";

                    my @items = ();

                    my $j = 0;

                    my $exceededPrintNoticesMaxLines = 0;

                    # Get each overdue item for this patron

                    while ( my $item_info = $sth2->fetchrow_hashref() ) {

                        if ( C4::Context->preference('OverdueNoticeCalendar') ) {

                            $days_between =

                              $calendar->days_between(

                                dt_from_string( $item_info->{date_due} ), $date_to_run );

                        }

                        else {

                            $days_between =

                              $date_to_run->delta_days(

                                dt_from_string( $item_info->{date_due} ) );

                        }

                        $days_between = $days_between->in_units('days');

                        if ($listall){

                            unless ($days_between >= 1 and $days_between <= $MAX){

                                next;

                            }

                        }

                        else {

                            if ($triggered) {

                                if ( $mindays != $days_between ) {

                                    next;

                                }

                            }

                            else {

                                unless ( $days_between >= $mindays

                                    && $days_between <= $maxdays )

                                {

                                    next;

                                }

                            }

                        }

                        if ( ( scalar(@emails_to_use) == 0 || $nomail ) && $PrintNoticesMaxLines && $j >= $PrintNoticesMaxLines ) {

                          $exceededPrintNoticesMaxLines = 1;

                          last;

                        }

                        next if $patron_homelibrary and !grep { $seen{ $item_info->{branchcode} } } @branches;

                        $j++;

                        $titles .= C4::Letters::get_item_content( { item => $item_info, item_content_fields => \@item_content_fields, dateonly => 1 } );

                        $itemcount++;

                        push @items, $item_info;

                    }

                    $sth2->finish;

                    my @message_transport_types = split( /,/, $overdue_rules->{ "overdue_$i" . '_mtt' } );

                    my $print_sent = 0; # A print notice is not yet sent for this patron

                    for my $mtt ( @message_transport_types ) {

                        next if $mtt eq 'itiva';

                        my $effective_mtt = $mtt;

                        if ( ($mtt eq 'email' and not scalar @emails_to_use) or ($mtt eq 'sms' and not $data->{smsalertnumber}) ) {

                            # email or sms is requested but not exist, do a print.

                            $effective_mtt = 'print';

                        }

                        splice @items, $PrintNoticesMaxLines if $effective_mtt eq 'print' && $PrintNoticesMaxLines && scalar @items > $PrintNoticesMaxLines;

                        #catch the case where we are sending a print to someone with an email

                        my $letter_exists = Koha::Notice::Templates->find_effective_template(

                            {

                                module                 => 'circulation',

                                code                   => $overdue_rules->{ "overdue_$i" . '_notice' },

                                message_transport_type => $effective_mtt,

                                branchcode             => $branchcode,

                                lang                   => $patron->lang

                            }

                        );

                        my $letter = parse_overdues_letter(

                            {

                                letter_code    => $overdue_rules->{ "overdue_$i" . '_notice' },

                                borrowernumber => $borrowernumber,

                                branchcode     => $branchcode,

                                items          => \@items,

                                substitute => {    # this appears to be a hack to overcome incomplete features in this code.

                                    bib             => $library->branchname,    # maybe 'bib' is a typo for 'lib<rary>'?

                                    'items.content' => $titles,

                                    'count'         => $itemcount,

                                },

                                # If there is no template defined for the requested letter

                                # Fallback on the original type

                                message_transport_type => $letter_exists ? $effective_mtt : $mtt,

                            }

                        );

                        unless ( $letter && $letter->{content} ) {

                            $verbose and warn qq|Message '$overdue_rules->{"overdue_$i"."_notice"}' content not found|;

                            # this transport doesn't have a configured notice, so try another

                            next;

                        }

                        if ( $exceededPrintNoticesMaxLines ) {

                          $letter->{'content'} .= "List too long for form; please check your account online for a complete list of your overdue items.";

                        }

                        my @misses = grep { /./ } map { /^([^>]*)[>]+/; ( $1 || '' ); } split /\</, $letter->{'content'};

                        if (@misses) {

                            $verbose and warn "The following terms were not matched and replaced: \n\t" . join "\n\t", @misses;

                        }

                        if ($nomail) {

                            push @output_chunks,

                              prepare_letter_for_printing(

                              {   letter         => $letter,

                                  borrowernumber => $borrowernumber,

                                  firstname      => $data->{'firstname'},

                                  lastname       => $data->{'surname'},

                                  address1       => $data->{'address'},

                                  address2       => $data->{'address2'},

                                  city           => $data->{'city'},

                                  phone          => $data->{'phone'},

                                  cardnumber     => $data->{'cardnumber'},

                                  branchname     => $library->branchname,

                                  letternumber   => $i,

                                  postcode       => $data->{'zipcode'},

                                  country        => $data->{'country'},

                                  email          => $notice_email,

                                  itemcount      => $itemcount,

                                  titles         => $titles,

                                  outputformat   => defined $csvfilename ? 'csv' : defined $htmlfilename ? 'html' : defined $text_filename ? 'text' : '',

                                }

                              );

                        } else {

                            if ( ($mtt eq 'email' and not scalar @emails_to_use) or ($mtt eq 'sms' and not $data->{smsalertnumber}) ) {

                                push @output_chunks,

                                  prepare_letter_for_printing(

                                  {   letter         => $letter,

                                      borrowernumber => $borrowernumber,

                                      firstname      => $data->{'firstname'},

                                      lastname       => $data->{'surname'},

                                      address1       => $data->{'address'},

                                      address2       => $data->{'address2'},

                                      city           => $data->{'city'},

                                      postcode       => $data->{'zipcode'},

                                      country        => $data->{'country'},

                                      email          => $notice_email,

                                      itemcount      => $itemcount,

                                      titles         => $titles,

                                      outputformat   => defined $csvfilename ? 'csv' : defined $htmlfilename ? 'html' : defined $text_filename ? 'text' : '',

                                    }

                                  );

                            }

                            unless ( $effective_mtt eq 'print' and $print_sent == 1 ) {

                                # Just sent a print if not already done.

                                C4::Letters::EnqueueLetter(

                                    {   letter                 => $letter,

                                        borrowernumber         => $borrowernumber,

                                        message_transport_type => $effective_mtt,

                                        from_address           => $admin_email_address,

                                        to_address             => join(',', @emails_to_use),

                                        reply_address          => $library->inbound_email_address,

                                    }

                                ) unless $test_mode;

                                # A print notice should be sent only once per overdue level.

                                # Without this check, a print could be sent twice or more if the library checks sms and email and print and the patron has no email or sms number.

                                $print_sent = 1 if $effective_mtt eq 'print';

                            }

                        }

                    }

                    $already_queued{"$borrowernumber$i"} = 1;

                $sth->finish;

                if ( $overdue_rules->{ "overdue_$i" . '_restrict' } ) {

                    $borrower_overdues->{restrict} = 1;

                }

                $borrower_overdues->{'email'}          = $data->{'email'};

                $borrower_overdues->{'emailpro'}       = $data->{'emailpro'};

                $borrower_overdues->{'B_email'}        = $data->{'B_email'};

                $borrower_overdues->{'smsalertnumber'} = $data->{'smsalertnumber'};

                $borrower_overdues->{'phone'}          = $data->{'phone'};

        }

        } elsif ( defined $htmlfilename ) {

        elsif ( defined $htmlfilename ) {

        }

        } elsif ( defined $text_filename ) {

        elsif ( defined $text_filename ) {

        elsif ($nomail){

                local $, = "\f";    # pagebreak

                print @output_chunks;

        }

            $content = join($delimiter, qw(title name surname address1 address2 zipcode city country email itemcount itemsinfo due_date issue_date)) . "\n";

            $content = join(

                $delimiter,

                qw(title name surname address1 address2 zipcode city country email itemcount itemsinfo due_date issue_date)

            ) . "\n";

                filename => defined $csvfilename ? 'attachment.csv' : defined $htmlfilename ? 'attachment.html' : 'attachment.txt',

                  filename => defined $csvfilename ? 'attachment.csv'

                type => defined $htmlfilename ? 'text/html' : 'text/plain',

                : defined $htmlfilename ? 'attachment.html'

                : 'attachment.txt',

                type    => defined $htmlfilename ? 'text/html' : 'text/plain',

                {   letter                 => $letter,

                {

                    letter                 => $letter,

  print $fh _get_html_end();

    print $fh _get_html_end();

  close $fh;

    close $fh;

  close $fh;

    close $fh;

        if ($csv->combine(

        if (

                $params->{'firstname'}, $params->{'lastname'}, $params->{'address1'},  $params->{'address2'}, $params->{'postcode'},

            $csv->combine(

                $params->{'city'}, $params->{'country'}, $params->{'email'}, $params->{'phone'}, $params->{'cardnumber'},

                $params->{'firstname'}, $params->{'lastname'}, $params->{'address1'}, $params->{'address2'},

                $params->{'postcode'},

                $params->{'city'}, $params->{'country'}, $params->{'email'}, $params->{'phone'},

                $params->{'cardnumber'},

          ) {

            )

        {

      $return = "<pre>\n";

        $return = "<pre>\n";

      $return .= "$params->{'letter'}->{'content'}\n";

        $return .= "$params->{'letter'}->{'content'}\n";

      $return .= "\n</pre>\n";

        $return .= "\n</pre>\n";

cronlogaction({ action => 'End', info => "COMPLETED" });

cronlogaction( { action => 'End', info => "COMPLETED" } );