Attachment #137516 for bug #30718

View | Details | Raw Unified | Return to bug 30718
Collapse All | Expand All




use C4::Contract qw( GetContract );
use C4::Log qw( logaction );
use C4::Templates qw(gettemplate);
use Koha::DateUtils qw( dt_from_string );
use Koha::Acquisition::Baskets;
use Koha::Acquisition::Booksellers;
use Koha::Acquisition::Orders;

    my $received_items = $params->{received_items};

    my $dbh = C4::Context->dbh;
    $datereceived = $datereceived ? dt_from_string( $datereceived ) : dt_from_string;
    $datereceived = $datereceived->ymd;
            dt => ( $datereceived ? dt_from_string( $datereceived ) : dt_from_string ),
            dateformat => 'iso',
            dateonly => 1,
        }
    );

    my $suggestionid = GetSuggestionFromBiblionumber( $biblionumber );
    if ($suggestionid) {


Reopen an invoice

Equivalent to ModInvoice(invoiceid => $invoiceid, closedate => $closedate );

=cut


Lines 24-29 use Carp qw( carp ); Link Here

(-)a/C4/Barcodes/annual.pm (+1 lines)
24		24
25	use C4::Context;	25	use C4::Context;
26		26
		27	# FIXME We should certainly remove output_pref from here
27	use Koha::DateUtils qw( dt_from_string output_pref );	28	use Koha::DateUtils qw( dt_from_string output_pref );
28		29
29	use vars qw(@ISA);	30	use vars qw(@ISA);

Lines 23-28 use Carp qw( carp ); Link Here

(-)a/C4/Barcodes/hbyymmincr.pm (+1 lines)
23		23
24	use C4::Context;	24	use C4::Context;
25		25
		26	# FIXME We should certainly remove output_pref from here
26	use Koha::DateUtils qw( dt_from_string output_pref );	27	use Koha::DateUtils qw( dt_from_string output_pref );
27		28
28	use constant WIDTH => 4; # FIXME: too small for sizeable or multi-branch libraries?	29	use constant WIDTH => 4; # FIXME: too small for sizeable or multi-branch libraries?




use YAML::XS;
use Encode;

use Koha::DateUtils qw( dt_from_string output_pref );
use C4::Context;
use C4::Stats qw( UpdateStats );
use C4::Reserves qw( CheckReserves CanItemBeReserved MoveReserve ModReserve ModReserveMinusPriority RevertWaitingStatus IsItemOnHoldAndFound IsAvailableForItemLevelRequest ItemsAnyAvailableAndNotRestricted );

use Koha::AuthorisedValues;
use Koha::BackgroundJob::BatchUpdateBiblioHoldsQueue;
use Koha::Biblioitems;
use Koha::DateUtils qw( dt_from_string );
use Koha::Calendar;
use Koha::Checkouts;
use Koha::Illrequests;

    my $now = dt_from_string();
    $duedate ||= CalcDateDue( $now, $effective_itemtype, $circ_library->branchcode, $patron_unblessed );
    if (DateTime->compare($duedate,$now) == -1 ) { # duedate cannot be before now
         $needsconfirmation{INVALID_DATE} = $duedate;
    }

    my $fees = Koha::Charges::Fees->new(

        my $check = checkHighHolds( $item_object, $patron );

        if ( $check->{exceeded} ) {
            my $highholds = {
                num_holds  => $check->{outstanding},
                duration   => $check->{duration},
                returndate => $check->{due_date},
            };
            if ($override_high_holds) {
                $alerts{HIGHHOLDS} = $highholds;
                    num_holds  => $check->{outstanding},
                    duration   => $check->{duration},
                    returndate => output_pref( { dt => dt_from_string($check->{due_date}), dateformat => 'iso', timeformat => '24hr' }),
                };
            }
            else {
                $needsconfirmation{HIGHHOLDS} = $highholds;
                    num_holds  => $check->{outstanding},
                    duration   => $check->{duration},
                    returndate => output_pref( { dt => dt_from_string($check->{due_date}), dateformat => 'iso', timeformat => '24hr' }),
                };
            }
        }
    }


=item C<$cancelreserve> is 1 to override and cancel any pending reserves for the item (optional).

=item C<$issuedate> is a DateTime object for the date to issue the item (optional).
Defaults to today.

AddIssue does the following things :



            my $issue_attributes = {
                borrowernumber  => $borrower->{'borrowernumber'},
                issuedate       => $issuedate,
                date_due        => $datedue,
                branchcode      => C4::Context->userenv->{'branch'},
                onsite_checkout => $onsite_checkout,
                auto_renew      => $auto_renew ? 1 : 0,

                itemnumber     => $issue->itemnumber,
                borrowernumber => $issue->borrowernumber,
                amount         => $amount,
                due            => $datedue,
            });
        }
        elsif ($return_date) {

                itemnumber     => $issue->itemnumber,
                borrowernumber => $issue->borrowernumber,
                amount         => 0,
                due            => $datedue,
            });
        }
    }




    # Hashref building
    my $out;
    $out->{'renewals'} = $issue->renewals_count;
    # FIXME Unusual date formatting
    $out->{date_due}   = dt_from_string($issue->date_due)->strftime('%Y-%m-%d %H:%M');
    $out->{'success'}  = $renewal[0];
    $out->{'error'}    = $renewal[1];

    return { code => 'libraryNotPickupLocation' } unless $destination->pickup_location;
    return { code => 'cannotBeTransferred' } unless $biblio->can_be_transferred({ to => $destination });

    my $resdate = $cgi->param('start_date');
    my $expdate = $cgi->param('expiry_date');
        $resdate = $cgi->param('start_date');
    }

    my $expdate;
    if ( $cgi->param('expiry_date') ) {
        $expdate = $cgi->param('expiry_date');
    }

    # Add the reserve
    #    $branch,    $borrowernumber, $biblionumber,

    my $canitembereserved = C4::Reserves::CanItemBeReserved( $patron, $item, $branch )->{status};
    return { code => $canitembereserved } unless $canitembereserved eq 'OK';

    my $resdate = $cgi->param('start_date');
    my $expdate = $cgi->param('expiry_date');
        $resdate = $cgi->param('start_date');
    }

    my $expdate;
    if ( $cgi->param('expiry_date') ) {
        $expdate = $cgi->param('expiry_date');
    }

    # Add the reserve
    my $priority = C4::Reserves::CalculatePriority($biblionumber);




use C4::Context;
use C4::Koha;
use C4::Biblio qw( GetMarcStructure TransformMarcToKoha );
use Koha::DateUtils qw( dt_from_string output_pref );
use MARC::Record;
use C4::ClassSource qw( GetClassSort GetClassSources GetClassSource );
use C4::Log qw( logaction );

                  # debugging; so please don't remove this

use Koha::AuthorisedValues;
use Koha::DateUtils qw( dt_from_string );
use Koha::Database;

use Koha::Biblioitems;

sub ModDateLastSeen {
    my ( $itemnumber, $leave_item_lost, $params ) = @_;

    my $today = output_pref({ dt => dt_from_string, dateformat => 'iso', dateonly => 1 });

    my $item = Koha::Items->find($itemnumber);
    $item->datelastseen(dt_from_string);
    $item->itemlost(0) unless $leave_item_lost;
    $item->store({ log_action => 0, skip_record_index => $params->{skip_record_index}, skip_holds_queue => $params->{skip_holds_queue} });
}

    }

    if ($datelastseen) {
        $datelastseen = output_pref({ str => $datelastseen, dateformat => 'iso', dateonly => 1 });
        push @where_strings, '(datelastseen < ? OR datelastseen IS NULL)';
        push @bind_params, $datelastseen;
    }

Lines 29-35 use C4::Members; Link Here

(-)a/C4/Letters.pm (-1 / +1 lines)
29	use C4::Log qw( logaction );	29	use C4::Log qw( logaction );
30	use C4::SMS;	30	use C4::SMS;
31	use C4::Templates;	31	use C4::Templates;
32	use Koha::DateUtils qw( dt_from_string output_pref );
33	use Koha::SMS::Providers;	32	use Koha::SMS::Providers;
34		33
35	use Koha::Email;	34	use Koha::Email;
Lines 783-788 sub _parseletter { Link Here
783	# in callers ( by changing / formatting values )	782	# in callers ( by changing / formatting values )
784	my $values = $values_in ? { %$values_in } : {};	783	my $values = $values_in ? { %$values_in } : {};
785		784
		785	# FIXME Dates formatting must be done in notice's templates
786	if ( $table eq 'borrowers' && $values->{'dateexpiry'} ){	786	if ( $table eq 'borrowers' && $values->{'dateexpiry'} ){
787	$values->{'dateexpiry'} = output_pref({ dt => dt_from_string( $values->{'dateexpiry'} ), dateonly => 1 });	787	$values->{'dateexpiry'} = output_pref({ dt => dt_from_string( $values->{'dateexpiry'} ), dateonly => 1 });
788	}	788	}

Lines 596-601 sub IssueSlip { Link Here

(-)a/C4/Members.pm (+1 lines)
596		596
597	# FIXME We keep newdate and timestamp for backward compatibility (from GetNewsToDisplay)	597	# FIXME We keep newdate and timestamp for backward compatibility (from GetNewsToDisplay)
598	# But we should remove them and adjust the existing templates in a db rev	598	# But we should remove them and adjust the existing templates in a db rev
		599	# FIXME This must be formatted in the notice template
599	my $published_on_dt = output_pref({ dt => dt_from_string( $all->{published_on} ), dateonly => 1 });	600	my $published_on_dt = output_pref({ dt => dt_from_string( $all->{published_on} ), dateonly => 1 });
600	$all->{newdate} = $published_on_dt;	601	$all->{newdate} = $published_on_dt;
601	$all->{timestamp} = $published_on_dt;	602	$all->{timestamp} = $published_on_dt;




use C4::Context;
use Koha::Account::Lines;
use Koha::Account::Offsets;
use Koha::DateUtils qw( output_pref );
use Koha::Libraries;
use Koha::Recalls;
use Koha::Logger;


C<$amount> is the current amount owed by the patron.

C<$due> is the date

C<&UpdateFine> looks up the amount currently owed on the given item
and sets it to C<$amount>, creating, if necessary, a new entry in the


    my $accountline;
    my $total_amount_other = 0.00;
    my $due_qr = qr/$due/;
    # Cycle through the fines and
    # - find line that relates to the requested $itemnum
    # - accumulate fines for other items

                    items     => $itemnum,
                },
            ) };
            my $desc = $letter ? $letter->{content} : sprintf("Item %s - due %s", $itemnum, output_pref($due) );

            my $account = Koha::Account->new({ patron_id => $borrowernumber });
            $accountline = $account->add_debit(

Lines 25-31 use JSON qw( from_json ); Link Here

(-)a/C4/Reports/Guided.pm (-2 / +1 lines)
25	use C4::Context;	25	use C4::Context;
26	use C4::Templates qw/themelanguage/;	26	use C4::Templates qw/themelanguage/;
27	use C4::Koha qw( GetAuthorisedValues );	27	use C4::Koha qw( GetAuthorisedValues );
28	use Koha::DateUtils qw( dt_from_string output_pref );	28	use Koha::DateUtils qw( dt_from_string );
29	use Koha::Patrons;	29	use Koha::Patrons;
30	use Koha::Reports;	30	use Koha::Reports;
31	use C4::Output;	31	use C4::Output;
Lines 753-759 sub get_saved_reports { Link Here
753	my (@cond,@args);	753	my (@cond,@args);
754	if ($filter) {	754	if ($filter) {
755	if (my $date = $filter->{date}) {	755	if (my $date = $filter->{date}) {
756	$date = eval { output_pref( { dt => dt_from_string( $date ), dateonly => 1, dateformat => 'iso' }); };
757	push @cond, "DATE(last_modified) = ? OR	756	push @cond, "DATE(last_modified) = ? OR
758	DATE(last_run) = ?";	757	DATE(last_run) = ?";
759	push @args, $date, $date;	758	push @args, $date, $date;




use Koha::Calendar;
use Koha::CirculationRules;
use Koha::Database;
use Koha::DateUtils qw( dt_from_string );
use Koha::Hold;
use Koha::Holds;
use Koha::ItemTypes;

    my $itemtype       = $params->{itemtype};
    my $non_priority   = $params->{non_priority};

    $resdate ||= dt_from_string;
        or output_pref({ dt => dt_from_string, dateonly => 1, dateformat => 'iso' });

    $patron_expiration_date = output_pref({ str => $patron_expiration_date, dateonly => 1, dateformat => 'iso' });

    # if we have an item selectionned, and the pickup branch is the same as the holdingbranch
    # of the document, we force the value $priority and $found .

            if C4::Context->preference('HoldsLog');

        # The only column that can be updated for a found hold is the expiration date
        $hold->expirationdate($date)->store();
    }
    elsif ($rank =~ /^\d+/ and $rank > 0) {
        logaction( 'HOLDS', 'MODIFY', $hold->reserve_id, $hold )


        if ( defined( $suspend_until ) ) {
            if ( $suspend_until ) {
                $suspend_until = eval { dt_from_string( $suspend_until ) };
                $hold->suspend_hold( $suspend_until );
            } else {
                # If the hold is suspended leave the hold suspended, but convert it to an indefinite hold.

sub ToggleSuspend {
    my ( $reserve_id, $suspend_until ) = @_;

    $suspend_until = dt_from_string($suspend_until) if ($suspend_until);

    my $hold = Koha::Holds->find( $reserve_id );

    if ( $hold->is_suspended ) {

    my $suspend_until  = $params{'suspend_until'}  || undef;
    my $suspend = defined( $params{'suspend'} ) ? $params{'suspend'} : 1;

    $suspend_until = eval { dt_from_string($suspend_until) }
      if ( defined($suspend_until) );

    return unless ( $borrowernumber || $biblionumber );

    my $params;

Lines 51-56 sub add_to_session { Link Here

(-)a/C4/Search/History.pm (+1 lines)
51	query_cgi => $query_cgi,	51	query_cgi => $query_cgi,
52	total => "$total",	52	total => "$total",
53	type => $type,	53	type => $type,
		54	# FIXME We shouldn't store the formatted date
54	time => output_pref( { dt => $now, dateformat => 'iso', timeformat => '24hr' } ),	55	time => output_pref( { dt => $now, dateformat => 'iso', timeformat => '24hr' } ),
55	id => $id,	56	id => $id,
56	};	57	};




use C4::Serials::Frequency qw( GetSubscriptionFrequency );
use C4::Serials::Numberpattern;
use Koha::AdditionalFieldValues;
use Koha::DateUtils qw( dt_from_string output_pref );
use Koha::Serial;
use Koha::Subscriptions;
use Koha::Subscription::Histories;

    $sth->execute($biblionumber);
    my @res;
    while ( my $subs = $sth->fetchrow_hashref ) {
        $subs->{startdate}     = output_pref( { dt => dt_from_string( $subs->{startdate} ),     dateonly => 1 } );
        $subs->{histstartdate} = output_pref( { dt => dt_from_string( $subs->{histstartdate} ), dateonly => 1 } );
        if ( defined $subs->{histenddate} ) {
           $subs->{histenddate}   = output_pref( { dt => dt_from_string( $subs->{histenddate} ),   dateonly => 1 } );
        } else {
            $subs->{histenddate} = "";
        }
        $subs->{opacnote}     //= "";
        $subs->{ "periodicity" . $subs->{periodicity} }     = 1;
        $subs->{ "numberpattern" . $subs->{numberpattern} } = 1;
        $subs->{ "status" . $subs->{'status'} }             = 1;

        if (not defined $subs->{enddate} ) {
            $subs->{enddate} = '';
        } else {
            $subs->{enddate} = output_pref( { dt => dt_from_string( $subs->{enddate}), dateonly => 1 } );
        }
        $subs->{'abouttoexpire'}       = abouttoexpire( $subs->{'subscriptionid'} );
        $subs->{'subscriptionexpired'} = HasSubscriptionExpired( $subs->{'subscriptionid'} );
        $subs->{cannotedit} = not can_edit_subscription( $subs );


    while ( my $line = $sth->fetchrow_hashref ) {
        $line->{ "status" . $line->{status} } = 1;                                         # fills a "statusX" value, used for template status select list
        for my $datefield ( qw( planneddate publisheddate) ) {
            if ($line->{$datefield} && $line->{$datefield}!~m/^00/) {
                $line->{$datefield} =  output_pref( { dt => dt_from_string( $line->{$datefield} ), dateonly => 1 } );
            } else {
                $line->{$datefield} = q{};
            }
        }
        push @serials, $line;
    }


    while ( ( my $line = $sth->fetchrow_hashref ) && $counter < $count ) {
        $counter++;
        $line->{ "status" . $line->{status} } = 1;                                         # fills a "statusX" value, used for template status select list
        for my $datefield ( qw( planneddate publisheddate) ) {
            if ($line->{$datefield} && $line->{$datefield}!~m/^00/) {
                $line->{$datefield} = output_pref( { dt => dt_from_string( $line->{$datefield} ), dateonly => 1 } );
            } else {
                $line->{$datefield} = q{};
            }
        }

        push @serials, $line;
    }


    while ( my $line = $sth->fetchrow_hashref ) {
        $line->{ "status" . $line->{status} } = 1; # fills a "statusX" value, used for template status select list
        # Format dates for display
        for my $datefield ( qw( planneddate publisheddate ) ) {
            if (!defined($line->{$datefield}) || $line->{$datefield} =~m/^00/) {
                $line->{$datefield} = q{};
            }
            else {
                $line->{$datefield} = output_pref( { dt => dt_from_string( $line->{$datefield} ), dateonly => 1 } );
            }
        }
        push @serials, $line;
    }
    return @serials;

    $sth->execute( EXPECTED, LATE, CLAIMED );
    my @issuelist;
    while ( my $line = $sth->fetchrow_hashref ) {

        if ($line->{planneddate} && $line->{planneddate} !~/^0+\-/) {
            $line->{planneddateISO} = $line->{planneddate};
            $line->{planneddate} = output_pref( { dt => dt_from_string( $line->{"planneddate"} ), dateonly => 1 } );
        }
        if ($line->{claimdate} && $line->{claimdate} !~/^0+\-/) {
            $line->{claimdateISO} = $line->{claimdate};
            $line->{claimdate}   = output_pref( { dt => dt_from_string( $line->{"claimdate"} ), dateonly => 1 } );
        }
        $line->{"status".$line->{status}}   = 1;

        my $subscription_object = Koha::Subscriptions->find($line->{subscriptionid});





=head3 suspend_hold

my $hold = $hold->suspend_hold( $suspend_until );

=cut

sub suspend_hold {
    my ( $self, $date ) = @_;

    $date &&= dt_from_string($date)->truncate( to => 'day' )->datetime;

    if ( $self->is_found ) {    # We can't suspend found holds
        if ( $self->is_waiting ) {

Lines 163-173 sub store { Link Here

(-)a/Koha/Item.pm (-5 / +1 lines)
163	&& !$pre_mod_item->$field )	163	&& !$pre_mod_item->$field )
164	{	164	{
165	my $field_on = "${field}_on";	165	my $field_on = "${field}_on";
166	$self->$field_on(	166	$self->$field_on(dt_from_string);
167	DateTime::Format::MySQL->format_datetime(
168	dt_from_string()
169	)
170	);
171	}	167	}
172	}	168	}
173		169

Lines 57-62 Further pod documentation needed here. Link Here

(-)a/Koha/Patrons/Import.pm (+1 lines)
57	=cut	57	=cut
58		58
59	has 'today_iso' => ( is => 'ro', lazy => 1,	59	has 'today_iso' => ( is => 'ro', lazy => 1,
		60	# FIXME We shouldn't need to call output_pref here, passing a DateTime object should work
60	default => sub { output_pref( { dt => dt_from_string(), dateonly => 1, dateformat => 'iso' } ); }, );	61	default => sub { output_pref( { dt => dt_from_string(), dateonly => 1, dateformat => 'iso' } ); }, );
61		62
62	has 'text_csv' => ( is => 'rw', lazy => 1,	63	has 'text_csv' => ( is => 'rw', lazy => 1,




use Koha::Holds;
use Koha::Clubs;
use Koha::Club::Hold;
use Koha::DateUtils qw( dt_from_string output_pref );

use Scalar::Util qw( blessed );
use Try::Tiny qw( catch try );

            );
        }

        # AddReserve expects date to be in syspref format
        if ($expiration_date) {
            $expiration_date = output_pref( dt_from_string( $expiration_date, 'rfc3339' ) );
        }

        my $club_hold = Koha::Club::Hold::add(
            {
                club_id             => $club_id,




use Koha::Items;
use Koha::Patrons;
use Koha::Holds;
use Koha::DateUtils qw( dt_from_string );

use List::MoreUtils qw( any );
use Try::Tiny qw( catch try );


        my $priority = C4::Reserves::CalculatePriority($biblio_id);

        # AddReserve expects date to be in syspref format
        if ($expiration_date) {
            $expiration_date = output_pref( { dt => dt_from_string($expiration_date, 'iso'), dateformat => 'iso', dateonly => 1 } );
        }

        my $hold_id = C4::Reserves::AddReserve(
            {
                branchcode       => $pickup_library_id,

        $pickup_library_id //= $hold->branchcode;
        my $priority         = $body->{priority} // $hold->priority;
        # suspended_until can also be set to undef
        my $suspended_until = $body->{suspended_until} || $hold->suspend_until;
          exists $body->{suspended_until}
          ? dt_from_string( $body->{suspended_until}, 'rfc3339' )
          : $hold->suspend_until     && dt_from_string( $hold->suspend_until,     'iso' );

        my $params = {
            reserve_id    => $hold_id,
            branchcode    => $pickup_library_id,
            rank          => $priority,
            suspend_until => $suspended_until,
            itemnumber    => $hold->itemnumber,
              : '',
            itemnumber    => $hold->itemnumber
        };

        C4::Reserves::ModReserve($params);

    }

    return try {
        $hold->suspend_hold($end_date);
        $hold->suspend_hold($date);
        $hold->discard_changes;
        $c->res->headers->location( $c->req->url->to_string );

        my $suspend_until = $end_date ? dt_from_string($hold->suspend_until)->ymd : undef;
            $suspend_end_date = output_pref({
                dt         => dt_from_string( $hold->suspend_until, 'iso' ),
                dateformat => 'iso',
                dateonly   => 1
                }
            );
        }
        return $c->render(
            status  => 201,
            openapi => {
                end_date => $suspend_until,
            }
        );
    }





use Koha::Database;
use Koha::Reports;
#use Koha::DateUtils qw( dt_from_string output_pref );

use base qw(Koha::Object);
#


        # if there are special regexp chars, we must \ them
        $split[ $i * 2 + 1 ] =~ s/(\||\?|\.|\*|\(|\)|\%)/\\$1/g;
        #if ( $split[ $i * 2 + 1 ] =~ /\|\s*date\s*$/ ) {
        #    $quoted = output_pref(
        #        {
        #            dt         => dt_from_string($quoted),
        #            dateformat => 'iso',
        #            dateonly   => 1
        #        }
        #    ) if $quoted;
        #}
        unless ( $split[ $i * 2 + 1 ] =~ /\|\s*list\s*$/ && $quoted ) {
            $quoted = C4::Context->dbh->quote($quoted);
        }




use Koha::Acquisition::Baskets;
use Koha::Acquisition::Currencies;
use Koha::Acquisition::Orders;
use Koha::DateUtils qw( dt_from_string );

my $input    = CGI->new;
my $basketno = $input->param('basketno');

    # Fill the form with year-1
    $from_placed_on->set_time_zone('floating')->subtract( years => 1 );
}
$filters->{from_placed_on} = $from_placed_on;
$filters->{to_placed_on}   = $to_placed_on;
  $filters->{to_placed_on} =
  output_pref( { dt => $to_placed_on, dateformat => 'iso', dateonly => 1 } ),

  my ( @result_order_loop, @selected_order_loop );
my @ordernumbers = split ',', scalar $input->param('ordernumbers') || '';

Lines 55-61 use C4::Auth qw( get_template_and_user ); Link Here

(-)a/acqui/histsearch.pl (-3 / +3 lines)
55	use C4::Output qw( output_html_with_http_headers );	55	use C4::Output qw( output_html_with_http_headers );
56	use C4::Acquisition qw( GetHistory );	56	use C4::Acquisition qw( GetHistory );
57	use Koha::AdditionalFields;	57	use Koha::AdditionalFields;
58	use Koha::DateUtils qw( dt_from_string output_pref );	58	use Koha::DateUtils qw( dt_from_string );
59		59
60	my $input = CGI->new;	60	my $input = CGI->new;
61	my $do_search = $input->param('do_search') \|\| 0;	61	my $do_search = $input->param('do_search') \|\| 0;
Lines 97-104 unless ( $input->param('from') ) { Link Here
97	# Fill the form with year-1	97	# Fill the form with year-1
98	$from_placed_on->set_time_zone('floating')->subtract( years => 1 );	98	$from_placed_on->set_time_zone('floating')->subtract( years => 1 );
99	}	99	}
100	$filters->{from_placed_on} = output_pref( { dt => $from_placed_on, dateformat => 'iso', dateonly => 1 } );	100	$filters->{from_placed_on} = $from_placed_on;
101	$filters->{to_placed_on} = output_pref( { dt => $to_placed_on, dateformat => 'iso', dateonly => 1 } );	101	$filters->{to_placed_on} = $to_placed_on;
102	my $additional_fields = Koha::AdditionalFields->search( { tablename => 'aqbasket', searchable => 1 } );	102	my $additional_fields = Koha::AdditionalFields->search( { tablename => 'aqbasket', searchable => 1 } );
103	$template->param( available_additional_fields => $additional_fields );	103	$template->param( available_additional_fields => $additional_fields );
104	my @additional_field_filters;	104	my @additional_field_filters;

Lines 102-109 elsif ( $op && $op eq 'mod' ) { Link Here

(-)a/acqui/invoice.pl (-2 / +2 lines)
102	ModInvoice(	102	ModInvoice(
103	invoiceid => $invoiceid,	103	invoiceid => $invoiceid,
104	invoicenumber => $invoicenumber,	104	invoicenumber => $invoicenumber,
105	shipmentdate => scalar output_pref( { str => scalar $input->param('shipmentdate'), dateformat => 'iso', dateonly => 1 } ),	105	shipmentdate => scalar $input->param('shipmentdate'),
106	billingdate => scalar output_pref( { str => scalar $input->param('billingdate'), dateformat => 'iso', dateonly => 1 } ),	106	billingdate => scalar $input->param('billingdate'),
107	shipmentcost => $shipmentcost,	107	shipmentcost => $shipmentcost,
108	shipmentcost_budgetid => $shipment_budget_id	108	shipmentcost_budgetid => $shipment_budget_id
109	);	109	);





use C4::Acquisition qw( GetInvoices GetInvoice );
use C4::Budgets qw( GetBudget GetBudgets CanUserUseBudget );
use Koha::DateUtils qw( dt_from_string );
use Koha::Acquisition::Booksellers;

my $input = CGI->new;

my $message_id       = $input->param('message_id');
my $op               = $input->param('op');

$shipmentdatefrom and $shipmentdatefrom = eval { dt_from_string( $shipmentdatefrom ) };
$shipmentdateto   and $shipmentdateto   = eval { dt_from_string( $shipmentdateto ) };
$billingdatefrom  and $billingdatefrom  = eval { dt_from_string( $billingdatefrom ) };
$billingdateto    and $billingdateto    = eval { dt_from_string( $billingdateto ) };

my $invoices = [];
if ( $op and $op eq 'do_search' ) {
    @{$invoices} = GetInvoices(
        invoicenumber    => $invoicenumber,
        supplierid       => $supplierid,
        shipmentdatefrom => $shipmentdatefrom,
        shipmentdateto   => $shipmentdateto,
        billingdatefrom  => $billingdatefrom,
        billingdateto    => $billingdateto,
        isbneanissn      => $isbneanissn,
        title            => $title,
        author           => $author,




use C4::Output qw( output_html_with_http_headers );
use C4::Context;
use C4::Letters qw( SendAlerts GetLetters );
use Koha::DateUtils qw( dt_from_string );
use Koha::Acquisition::Orders qw( filter_by_lates );
use Koha::CsvProfiles;


my $estimateddeliverydatefrom = $input->param('estimateddeliverydatefrom');
my $estimateddeliverydateto   = $input->param('estimateddeliverydateto');

my $estimateddeliverydatefrom_dt =
  $estimateddeliverydatefrom
  ? dt_from_string($estimateddeliverydatefrom)
  : undef;

# Get the "date to" param. If it is not defined and $delay is not defined too, it is the today's date.
$estimateddeliverydateto ||=
  ( not defined $delay and not defined $estimateddeliverydatefrom )
  ? dt_from_string()
  : undef;
        : undef;

# Format the output of "date from" and "date to"
if ($estimateddeliverydatefrom_dt) {
    $estimateddeliverydatefrom = output_pref({dt => $estimateddeliverydatefrom_dt, dateonly => 1});
}
if ($estimateddeliverydateto_dt) {
    $estimateddeliverydateto = output_pref({dt => $estimateddeliverydateto_dt, dateonly => 1});
}

my $branch     = $input->param('branch');
my $op         = $input->param('op');

    {
        delay        => $delay,
        (
            $estimateddeliverydatefrom
            ? ( estimated_from => $estimateddeliverydatefrom )
            : ()
        ),
        (
            $estimateddeliverydateto
            ? ( estimated_to => $estimateddeliverydateto )
            : ()
        )
    },

Lines 119-125 my $creator = Koha::Patrons->find( $order->created_by ); Link Here

(-)a/acqui/orderreceive.pl (-1 / +1 lines)
119		119
120	my $budget = GetBudget( $order->budget_id );	120	my $budget = GetBudget( $order->budget_id );
121		121
122	my $datereceived = $order->datereceived ? dt_from_string( $order->datereceived ) : dt_from_string;	122	my $datereceived = $order->datereceived \|\| dt_from_string;
123		123
124	# get option values for TaxRates syspref	124	# get option values for TaxRates syspref
125	my @gst_values = map {	125	my @gst_values = map {




use C4::Budgets qw( GetBudgetHierarchy GetBudget CanUserUseBudget );

use Koha::Acquisition::Booksellers;
use Koha::DateUtils qw( dt_from_string );

my $input          = CGI->new;
my $booksellerid     = $input->param('booksellerid');

my $shipmentcost = $input->param('shipmentcost');
my $shipmentcost_budgetid = $input->param('shipmentcost_budgetid');
my $shipmentdate = $input->param('shipmentdate');
$shipmentdate and $shipmentdate = output_pref({ str => $shipmentdate, dateformat => 'iso', dateonly => 1 });

if ( $op and $op eq 'new' ) {
    if ( C4::Context->preference('AcqWarnOnDuplicateInvoice') ) {

my @parcels = GetInvoices(
    supplierid => $booksellerid,
    invoicenumber => $code,
    ( $datefrom ? ( shipmentdatefrom => $datefrom ) : () ),
    ( $dateto   ? ( shipmentdateto   => $dateto   ) : () ),
    order_by => $order
);
my $count_parcels = @parcels;




use Modern::Perl;

use CGI qw ( -utf8 );
use Koha::DateUtils qw( dt_from_string );
use JSON qw( encode_json );
use Koha::Database;
use C4::Koha;

# get only the columns of aqbudgetperiods in budget_period_hashref
my @columns = Koha::Database->new()->schema->source('Aqbudgetperiod')->columns;
my $budget_period_hashref = { map { join(' ',@columns) =~ /$_/ ? ( $_ => scalar $input->param($_) )  : () } keys( %{$input->Vars()} ) } ;
$budget_period_hashref->{budget_period_startdate} = $input->param('budget_period_startdate');
$budget_period_hashref->{budget_period_enddate}   = $input->param('budget_period_enddate');

$searchfield =~ s/\,//g;


elsif ( $op eq 'duplicate_budget' ){
    die "please specify a budget period id\n" if( !defined $budget_period_id || $budget_period_id eq '' );

    my $budget_period_startdate = $input->param('budget_period_startdate');
    my $budget_period_enddate   = $input->param('budget_period_enddate');
    my $budget_period_description = $input->param('budget_period_description');
    my $amount_change_percentage = $input->param('amount_change_percentage');
    my $amount_change_round_increment = $input->param('amount_change_round_increment');




    GetContracts
    ModContract
);
use Koha::DateUtils qw( dt_from_string );

use Koha::Acquisition::Booksellers;



    my $is_a_modif = $input->param("is_a_modif");

    my $contractstart_dt = $input->param('contractstartdate');
    my $contractend_dt = $input->param('contractenddate');
    unless ( $contractstart_dt and $contractend_dt ) {
        my $today = dt_from_string;
        $contractstart_dt ||= $today;


    if ( $is_a_modif ) {
        ModContract({
            contractstartdate   => $contractstart_dt,
            contractenddate     => $contractend_dt,
            contractname        => scalar $input->param('contractname'),
            contractdescription => scalar $input->param('contractdescription'),
            booksellerid        => scalar $input->param('booksellerid'),

            contractname        => scalar $input->param('contractname'),
            contractdescription => scalar $input->param('contractdescription'),
            booksellerid        => scalar $input->param('booksellerid'),
            contractstartdate   => scalar $input->param('contractstartdate'),
            contractenddate     => scalar $input->param('contractenddate'),
        });
    }


    # get contracts
    my @contracts = @{GetContracts( { booksellerid => $booksellerid } )};

    # format dates
    for my $contract ( @contracts ) {
        $contract->{contractstartdate} =  output_pref({ dt => dt_from_string( $contract->{contractstartdate} ), dateonly => 1 });
        $contract->{contractenddate}   =  output_pref({ dt => dt_from_string( $contract->{contractenddate} ), dateonly => 1 }),
    }

    $template->param(loop => \@contracts);

    #---- END $OP eq DEFAULT




use C4::Form::MessagingPreferences;
use Koha::Patrons;
use Koha::Database;
use Koha::DateUtils qw( dt_from_string output_pref );
use Koha::Patron::Categories;
use Koha::Libraries;



    my $is_a_modif = $input->param("is_a_modif");

    if ($enrolmentperioddate) {
        $enrolmentperioddate = output_pref(
            {
                dt         => dt_from_string($enrolmentperioddate),
                dateformat => 'iso',
                dateonly   => 1,
            }
        );
    }

    if ($is_a_modif) {
        my $category = Koha::Patron::Categories->find( $categorycode );
        $category->categorycode($categorycode);




use C4::Output qw( output_html_with_http_headers );
use C4::Auth qw( get_template_and_user );
use Koha::Exception;
use Koha::DateUtils qw( dt_from_string output_pref );
use Koha::Database;
use Koha::Logger;
use Koha::Libraries;

    my $no_auto_renewal_after = $input->param('no_auto_renewal_after');
    $no_auto_renewal_after = '' if $no_auto_renewal_after =~ /^\s*$/;
    my $no_auto_renewal_after_hard_limit = $input->param('no_auto_renewal_after_hard_limit') || '';
    $no_auto_renewal_after_hard_limit = eval { dt_from_string( scalar $no_auto_renewal_after_hard_limit ) } if ( $no_auto_renewal_after_hard_limit );
    $no_auto_renewal_after_hard_limit = output_pref( { dt => $no_auto_renewal_after_hard_limit, dateonly => 1, dateformat => 'iso' } ) if ( $no_auto_renewal_after_hard_limit );
    my $reservesallowed  = strip_non_numeric( scalar $input->param('reservesallowed') );
    my $holds_per_record = strip_non_numeric( scalar $input->param('holds_per_record') );
    my $holds_per_day    = strip_non_numeric( scalar $input->param('holds_per_day') );

    my $daysmode = $input->param('daysmode');
    my $lengthunit  = $input->param('lengthunit');
    my $hardduedate = $input->param('hardduedate') || undef;
    $hardduedate = eval { dt_from_string( scalar $hardduedate ) } if ( $hardduedate );
    $hardduedate = output_pref( { dt => $hardduedate, dateonly => 1, dateformat => 'iso' } ) if ( $hardduedate );
    my $hardduedatecompare = $input->param('hardduedatecompare');
    my $rentaldiscount = $input->param('rentaldiscount');
    my $opacitemholds = $input->param('opacitemholds') || 0;

Lines 36-42 use C4::Context; Link Here

(-)a/cataloguing/additem.pl (-1 lines)
36	use C4::Circulation qw( barcodedecode LostItem );	36	use C4::Circulation qw( barcodedecode LostItem );
37	use C4::Barcodes;	37	use C4::Barcodes;
38	use C4::Barcodes::ValueBuilder;	38	use C4::Barcodes::ValueBuilder;
39	use Koha::DateUtils qw( dt_from_string );
40	use Koha::Items;	39	use Koha::Items;
41	use Koha::ItemTypes;	40	use Koha::ItemTypes;
42	use Koha::Libraries;	41	use Koha::Libraries;

Lines 25-31 use Modern::Perl; Link Here

(-)a/cataloguing/value_builder/barcode.pl (-2 / +2 lines)
25	use C4::Context;	25	use C4::Context;
26	use C4::Barcodes::ValueBuilder;	26	use C4::Barcodes::ValueBuilder;
27	use C4::Biblio qw( GetMarcFromKohaField );	27	use C4::Biblio qw( GetMarcFromKohaField );
28	use Koha::DateUtils qw( dt_from_string output_pref );	28	use Koha::DateUtils qw( dt_from_string );
29		29
30	use Algorithm::CheckDigits qw( CheckDigits );	30	use Algorithm::CheckDigits qw( CheckDigits );
31		31
Lines 35-41 my $builder = sub { Link Here
35	my %args;	35	my %args;
36		36
37	# find today's date	37	# find today's date
38	($args{year}, $args{mon}, $args{day}) = split('-', output_pref({ dt => dt_from_string, dateformat => 'iso', dateonly => 1 }));	38	($args{year}, $args{mon}, $args{day}) = split('-', dt_from_string()->ymd());
39	($args{tag},$args{subfield}) = GetMarcFromKohaField( "items.barcode" );	39	($args{tag},$args{subfield}) = GetMarcFromKohaField( "items.barcode" );
40		40
41	my $nextnum;	41	my $nextnum;

Lines 25-31 use Modern::Perl; Link Here

(-)a/cataloguing/value_builder/barcode_manual.pl (-2 / +2 lines)
25	use C4::Context;	25	use C4::Context;
26	use C4::Barcodes::ValueBuilder;	26	use C4::Barcodes::ValueBuilder;
27	use C4::Biblio qw( GetMarcFromKohaField );	27	use C4::Biblio qw( GetMarcFromKohaField );
28	use Koha::DateUtils qw( dt_from_string output_pref );	28	use Koha::DateUtils qw( dt_from_string );
29		29
30	my $builder = sub {	30	my $builder = sub {
31	my ( $params ) = @_;	31	my ( $params ) = @_;
Lines 36-42 my $builder = sub { Link Here
36	$args{dbh} = $dbh;	36	$args{dbh} = $dbh;
37		37
38	# find today's date	38	# find today's date
39	($args{year}, $args{mon}, $args{day}) = split('-', output_pref({ dt => dt_from_string, dateformat => 'iso', dateonly => 1 }));	39	($args{year}, $args{mon}, $args{day}) = split('-', dt_from_string()->ymd());
40	($args{tag},$args{subfield}) = GetMarcFromKohaField( "items.barcode" );	40	($args{tag},$args{subfield}) = GetMarcFromKohaField( "items.barcode" );
41		41
42	my $nextnum;	42	my $nextnum;




# along with Koha; if not, see <http://www.gnu.org/licenses>.

use Modern::Perl;
use Koha::DateUtils qw( flatpickr_date_format );

my $builder = sub {
    my ( $params ) = @_;
    my $function_name = $params->{id};

    my $date = output_pref({ dt => dt_from_string, dateonly => 1 });
    my $dateformat = flatpickr_date_format();

    my $res  = <<END_OF_JS;

Lines 24-30 use C4::Auth qw( get_template_and_user ); Link Here

(-)a/circ/branchoverdues.pl (-3 / +1 lines)
24	use C4::Overdues qw( GetOverduesForBranch );	24	use C4::Overdues qw( GetOverduesForBranch );
25	use C4::Biblio qw( GetMarcFromKohaField GetMarcStructure );	25	use C4::Biblio qw( GetMarcFromKohaField GetMarcStructure );
26	use C4::Koha qw( GetAuthorisedValues );	26	use C4::Koha qw( GetAuthorisedValues );
27	use Koha::DateUtils qw( dt_from_string output_pref );
28	use Koha::BiblioFrameworks;	27	use Koha::BiblioFrameworks;
29		28
30	=head1 branchoverdues.pl	29	=head1 branchoverdues.pl
Lines 71-78 if ($tagslib->{$tag}->{$subfield}->{authorised_value}) { Link Here
71	# now display infos	70	# now display infos
72	foreach my $num (@getoverdues) {	71	foreach my $num (@getoverdues) {
73	my %overdueforbranch;	72	my %overdueforbranch;
74	my $dt = dt_from_string($num->{date_due}, 'sql');	73	$overdueforbranch{'date_due'} = $num->{date_due};
75	$overdueforbranch{'date_due'} = output_pref($dt);
76	$overdueforbranch{'title'} = $num->{'title'};	74	$overdueforbranch{'title'} = $num->{'title'};
77	$overdueforbranch{'subtitle'} = $num->{'subtitle'};	75	$overdueforbranch{'subtitle'} = $num->{'subtitle'};
78	$overdueforbranch{'medium'} = $num->{'medium'};	76	$overdueforbranch{'medium'} = $num->{'medium'};




use Koha::CsvProfiles;
use Koha::Patrons;
use Koha::Patron::Debarments qw( GetDebarments );
use Koha::DateUtils qw( dt_from_string );
use Koha::Plugins;
use Koha::Database;
use Koha::BiblioFrameworks;


my $stickyduedate  = $query->param('stickyduedate') || $session->param('stickyduedate');
my $duedatespec    = $query->param('duedatespec')   || $session->param('stickyduedate');
$duedatespec = eval { output_pref( { dt => dt_from_string( $duedatespec ), dateformat => 'iso' }); }
    if ( $duedatespec );
my $restoreduedatespec  = $query->param('restoreduedatespec') || $duedatespec || $session->param('stickyduedate');
if ( $restoreduedatespec && $restoreduedatespec eq "highholds_empty" ) {
    undef $restoreduedatespec;

    SpecifyDueDate            => $duedatespec_allow,
    PatronAutoComplete      => C4::Context->preference("PatronAutoComplete"),
    debarments                => scalar GetDebarments({ borrowernumber => $borrowernumber }),
    todaysdate                => dt_from_string()->set(hour => 23)->set(minute => 59),
    has_modifications         => $has_modifications,
    override_high_holds       => $override_high_holds,
    nopermission              => scalar $query->param('nopermission'),




use CGI qw(-oldstyle_urls -utf8);
use C4::Auth qw( get_template_and_user );
use Text::CSV_XS;
use Koha::DateUtils qw( dt_from_string );
use Koha::Patron::Attribute::Types;
use DateTime;
use DateTime::Format::MySQL;

            branchcode             => $data->{branchcode},
            barcode                => $data->{barcode},
            itemnum                => $data->{itemnumber},
            issuedate              => $data->{issuedate},
            biblionumber           => $data->{biblionumber},
            title                  => $data->{title},
            subtitle               => $data->{subtitle},

    $new_cgi->delete('op');

    $template->param(
        todaysdate              => $today_dt,
        overdueloop             => \@overduedata,
        nnoverdue               => scalar(@overduedata),
        noverdue_is_plural      => scalar(@overduedata) != 1,




use C4::Auth qw( get_template_and_user );
use C4::Output qw( output_html_with_http_headers );
use C4::Circulation qw( barcodedecode CanBookBeRenewed GetLatestAutoRenewDate AddRenewal );
use Koha::DateUtils qw( dt_from_string );
use Koha::Database;
use Koha::BiblioFrameworks;


                }
                if ($can_renew) {
                    my $branchcode = C4::Context->userenv ? C4::Context->userenv->{'branch'} : undef;
                    my $date_due =
                      ( C4::Context->preference('SpecifyDueDate')
                          && $hard_due_date )
                      ? $hard_due_date
                      : $cgi->param('renewonholdduedate');

                    }
                    $date_due = AddRenewal(
                        undef,
                        $item->itemnumber(),

    );
}

$template->param( hard_due_date => $hard_due_date );
# Checking if there is a Fast Cataloging Framework
$template->param( fast_cataloging => 1 ) if Koha::BiblioFrameworks->find( 'FA' );





use C4::Output qw( output_html_with_http_headers );
use C4::Auth qw( get_template_and_user );
use C4::Acquisition qw/GetOrdersByBiblionumber/;
use Koha::DateUtils qw( dt_from_string );
use Koha::Acquisition::Baskets;

my $input = CGI->new;

    }
}

$startdate = eval { dt_from_string( $startdate ) } if $startdate;
$enddate = eval { dt_from_string( $enddate ) } if $enddate;

my $todaysdate = dt_from_string;

#    A default of the prior years's holds is a reasonable way to pull holds

my @query_params = ();

$sqldatewhere .= " AND reservedate >= ?";
push @query_params, $startdate;
$sqldatewhere .= " AND reservedate <= ?";
push @query_params, $enddate;

my $include_aqorders_qty =
  $effective_create_items eq 'receiving'




use Koha::BiblioFrameworks;
use Koha::Calendar;
use Koha::Checkouts;
use Koha::DateUtils qw( dt_from_string );
use Koha::Holds;
use Koha::Items;
use Koha::Item::Transfers;

#dropbox: get last open day (today - 1)
my $dropboxdate = Koha::Checkouts::calculate_dropbox_date();

my $return_date_override = $query->param('return_date_override') || q{};
my $return_date_override_dt;
my $return_date_override_remember =
  $query->param('return_date_override_remember');
if ($return_date_override) {
    if ( C4::Context->preference('SpecifyReturnDate') ) {
        $return_date_override_dt = eval {dt_from_string( $return_date_override ) };
        if ( $return_date_override_dt ) {
            # note that we've overriden the return date
            $template->param( return_date_was_overriden => 1);
            # Save the original format if we are remembering for this series
            $template->param(
                return_date_override          => $return_date_override,
                return_date_override_remember => 1
            ) if ($return_date_override_remember);

        # note that we've overriden the return date
        $template->param( return_date_was_overriden => 1 );

        my $return_date_override_remember =
          $query->param('return_date_override_remember');

        # Save the original format if we are remembering for this series
        $template->param(
            return_date_override          => $return_date_override,
            return_date_override_remember => 1
        ) if ($return_date_override_remember);
    }
}


        barcode => $barcode,
    );

    my $return_date =
        $dropboxmode
      ? $dropboxdate
      : dt_from_string( $return_date_override );

    # Block return if multi-part and confirm has not been received
    my $needs_confirm =

            $ri{day}   = $duedate->day();
            $ri{hour}   = $duedate->hour();
            $ri{minute}   = $duedate->minute();
            $ri{duedate} = $duedate;
            my $patron = Koha::Patrons->find( $riborrowernumber{$_} );
            unless ( $dropboxmode ) {
                $ri{return_overdue} = 1 if (DateTime->compare($duedate, dt_from_string()) == -1);

Lines 31-37 use C4::Reserves; Link Here

(-)a/circ/transferstoreceive.pl (-2 / +2 lines)
31	use Koha::Items;	31	use Koha::Items;
32	use Koha::ItemTypes;	32	use Koha::ItemTypes;
33	use Koha::Libraries;	33	use Koha::Libraries;
34	use Koha::DateUtils qw( dt_from_string output_pref );	34	use Koha::DateUtils qw( dt_from_string );
35	use Koha::BiblioFrameworks;	35	use Koha::BiblioFrameworks;
36	use Koha::Patrons;	36	use Koha::Patrons;
37		37
Lines 129-135 while ( my $library = $libraries->next ) { Link Here
129		129
130	$template->param(	130	$template->param(
131	branchesloop => \@branchesloop,	131	branchesloop => \@branchesloop,
132	show_date => output_pref({ dt => dt_from_string, dateformat => 'iso', dateonly => 1 }),	132	show_date => dt_from_string,
133	TransfersMaxDaysWarning => C4::Context->preference('TransfersMaxDaysWarning'),	133	TransfersMaxDaysWarning => C4::Context->preference('TransfersMaxDaysWarning'),
134	latetransfers => $latetransfers ? 1 : 0,	134	latetransfers => $latetransfers ? 1 : 0,
135	);	135	);

Lines 26-32 use C4::Auth qw( get_template_and_user ); Link Here

(-)a/circ/waitingreserves.pl (-2 / +2 lines)
26	use C4::Items qw( ModItemTransfer );	26	use C4::Items qw( ModItemTransfer );
27	use Date::Calc qw( Date_to_Days Today );	27	use Date::Calc qw( Date_to_Days Today );
28	use C4::Reserves qw( ModReserve ModReserveCancelAll );	28	use C4::Reserves qw( ModReserve ModReserveCancelAll );
29	use Koha::DateUtils qw( dt_from_string output_pref );	29	use Koha::DateUtils qw( dt_from_string );
30	use Koha::BiblioFrameworks;	30	use Koha::BiblioFrameworks;
31	use Koha::Items;	31	use Koha::Items;
32	use Koha::ItemTypes;	32	use Koha::ItemTypes;
Lines 123-129 $template->param( Link Here
123	reservecount => scalar @reserve_loop,	123	reservecount => scalar @reserve_loop,
124	overloop => \@over_loop,	124	overloop => \@over_loop,
125	overcount => scalar @over_loop,	125	overcount => scalar @over_loop,
126	show_date => output_pref({ dt => dt_from_string, dateformat => 'iso', dateonly => 1 }),	126	show_date => dt_from_string,
127	tab => $tab,	127	tab => $tab,
128	);	128	);
129		129

Lines 55-64 my $club_template_id = $cgi->param('club_template_id'); Link Here

(-)a/clubs/clubs-add-modify.pl (-4 / +2 lines)
55	my $club_template = $club->club_template() \|\| Koha::Club::Templates->find($club_template_id);	55	my $club_template = $club->club_template() \|\| Koha::Club::Templates->find($club_template_id);
56	$club_template_id \|\|= $club_template->id();	56	$club_template_id \|\|= $club_template->id();
57		57
58	my $date_start = $cgi->param('date_start');	58	my $date_start = $cgi->param('date_start') \|\| undef;
59	$date_start = $date_start ? dt_from_string($date_start) : undef;	59	my $date_end = $cgi->param('date_end') \|\| undef;
60	my $date_end = $cgi->param('date_end');
61	$date_end = $date_end ? dt_from_string($date_end) : undef;
62		60
63	if ( $cgi->param('name') ) { # Update or create club	61	if ( $cgi->param('name') ) { # Update or create club
64	$club->set(	62	$club->set(




use Koha::Patrons;
use Koha::Libraries;
use Koha::Database;
use Koha::DateUtils qw( dt_from_string output_pref );
use Koha::Patrons;
use Koha::Patron::Categories;
use Koha::ItemTypes;

        my $enrolmentperiod       = $input->param('enrolmentperiod');
        my $enrolmentperioddate = $input->param('enrolmentperioddate') || undef;

        #Converts the string into a date format
        if ($enrolmentperioddate) {
            $enrolmentperioddate = output_pref(
                {
                    dt         => dt_from_string($enrolmentperioddate),
                    dateformat => 'DateTime',
                    dateonly   => 1,
                }
            );
        }

        #Adds a new patron category to the database
        $category = Koha::Patron::Category->new(
            {

Lines 35-41 Link Here

(-)a/koha-tmpl/intranet-tmpl/prog/en/includes/calendar.inc (-2 / +5 lines)
35	flatpickr.l10ns.default.months = flatpickr_months;	35	flatpickr.l10ns.default.months = flatpickr_months;
36	flatpickr.setDefaults({	36	flatpickr.setDefaults({
37	allowInput: true,	37	allowInput: true,
38	dateFormat: flatpickr_dateformat_string,	38	dateFormat: "Y-m-d",
		39	altInput: true,
		40	altFormat: flatpickr_dateformat_string,
		41	altInputClass: 'flatpickr-input',
39	nextArrow: '<i class="fa fa-fw fa-arrow-right"></i>',	42	nextArrow: '<i class="fa fa-fw fa-arrow-right"></i>',
40	prevArrow: '<i class="fa fa-fw fa-arrow-left"></i>',	43	prevArrow: '<i class="fa fa-fw fa-arrow-left"></i>',
41	time_24hr: flatpickr_timeformat,	44	time_24hr: flatpickr_timeformat,
Lines 46-52 Link Here
46	},	49	},
47	onReady: function( selectedDates, dateStr, instance ){	50	onReady: function( selectedDates, dateStr, instance ){
48	/* When flatpickr instance is created, automatically append a "clear date" link */	51	/* When flatpickr instance is created, automatically append a "clear date" link */
49	$(instance.input)	52	$(instance.input).siblings('input.flatpickr')
50	/* Add a wrapper element so that we can prevent the clear button from wrapping */	53	/* Add a wrapper element so that we can prevent the clear button from wrapping */
51	.wrap("<span class='flatpickr_wrapper'></span>")	54	.wrap("<span class='flatpickr_wrapper'></span>")
52	.attr("autocomplete", "off")	55	.attr("autocomplete", "off")




[% USE Koha %]
[% USE Branches %]
[% USE KohaDates %]
[% PROCESS 'html_helpers.inc' %]
<ol>
    <li><label for="title">Title: </label> <input type="text" name="title" id="title" value="[% filters.title | html %]" /></li>

    </li>

    <li><label for="from">From: </label>
        <input type="text" size="10" id="from" name="from" value="[% filters.from_placed_on | html %]" class="flatpickr" data-date_to="to" />
        <div class="hint">[% INCLUDE 'date-format.inc' %]</div>
    </li>
    <li><label for="to">To: </label>
        <input type="text" size="10" id="to" name="to" value="[% filters.to_placed_on | html %]" class="flatpickr" />
        <div class="hint">[% INCLUDE 'date-format.inc' %]</div>
    </li>
</ol>




            <td>[% hold.notes | html | html_line_break %]</td>
            <td>
                [% IF Koha.Preference('AllowHoldDateInFuture') %]
                    <input type="text" class="flatpickr" value="[% hold.date | html %]" required="required" size="10" name="reservedate" />
                [% ELSE %]
                    [% hold.date | $KohaDates %]
                [% END %]
            </td>
            <td>
                <input type="text" class="flatpickr" data-flatpickr-futuredate="true" value="[% hold.expirationdate | html %]" size="10" name="expirationdate" />
            </td>
            <td>
                [%- IF ( hold.found ) -%]


                        [% IF Koha.Preference('AutoResumeSuspendedHolds') %]
                            <label for="suspend_until_[% hold.reserve_id | html %]">[% IF ( hold.suspend ) %] on [% ELSE %] until [% END %]</label>
                            <input type="text" name="suspend_until_[% hold.reserve_id | html %]" id="suspend_until_[% hold.reserve_id | html %]" size="10" value="[% hold.suspend_until | html %]" class="flatpickr" data-flatpickr-futuredate="true" />
                        [%- ELSE -%]
                            <input type="hidden" name="suspend_until_[% hold.reserve_id | html %]" id="suspend_until_[% hold.reserve_id | html %]" value=""/>
                        [%- END -%]

Lines 69-75 Link Here

(-)a/koha-tmpl/intranet-tmpl/prog/en/modules/acqui/invoice.tt (-2 / +2 lines)
69	[% IF readonly %]	69	[% IF readonly %]
70	[% shipmentdate \| $KohaDates %]	70	[% shipmentdate \| $KohaDates %]
71	[% ELSE %]	71	[% ELSE %]
72	<input type="text" size="10" id="shipmentdate" name="shipmentdate" value="[% shipmentdate \| $KohaDates %]" class="flatpickr" />	72	<input type="text" size="10" id="shipmentdate" name="shipmentdate" value="[% shipmentdate \| html %]" class="flatpickr" />
73	<div class="hint">[% INCLUDE 'date-format.inc' %]</div>	73	<div class="hint">[% INCLUDE 'date-format.inc' %]</div>
74	[% END %]	74	[% END %]
75	</li>	75	</li>
Lines 79-85 Link Here
79	[% IF readonly %]	79	[% IF readonly %]
80	[% billingdate \| $KohaDates %]	80	[% billingdate \| $KohaDates %]
81	[% ELSE %]	81	[% ELSE %]
82	<input type="text" size="10" id="billingdate" name="billingdate" value="[% billingdate \| $KohaDates %]" class="flatpickr" />	82	<input type="text" size="10" id="billingdate" name="billingdate" value="[% billingdate \| html %]" class="flatpickr" />
83	<div class="hint">[% INCLUDE 'date-format.inc' %]</div>	83	<div class="hint">[% INCLUDE 'date-format.inc' %]</div>
84	[% END %]	84	[% END %]
85	</li>	85	</li>




                                    <ol>
                                        <li>
                                            <label for="shipmentdatefrom">From:</label>
                                            <input type="text" id="shipmentdatefrom" name="shipmentdatefrom" size="10" value="[% shipmentdatefrom | html %]" class="flatpickr" data-date_to="shipmentdateto" />
                                            <div class="hint">[% INCLUDE 'date-format.inc' %]</div>
                                        </li>
                                        <li>
                                            <label for="shipmentdateto">To:</label>
                                            <input type="text" id="shipmentdateto" name="shipmentdateto" size="10" value="[% shipmentdateto | html %]" class="flatpickr" />
                                            <div class="hint">[% INCLUDE 'date-format.inc' %]</div>
                                        </li>
                                    </ol>

                                    <ol>
                                        <li>
                                            <label for="billingdatefrom">From:</label>
                                            <input type="text" id="billingdatefrom" name="billingdatefrom" size="10" value="[% billingdatefrom | html %]" class="flatpickr" data-date_to="billingdateto" />
                                            <div class="hint">[% INCLUDE 'date-format.inc' %]</div>
                                        </li>
                                        <li>
                                            <label for="billingdateto">To:</label>
                                            <input type="text" id="billingdateto" name="billingdateto" size="10" value="[% billingdateto | html %]" class="flatpickr" />
                                            <div class="hint">[% INCLUDE 'date-format.inc' %]</div>
                                        </li>
                                    </ol>

Lines 277-283 Link Here

(-)a/koha-tmpl/intranet-tmpl/prog/en/modules/acqui/orderreceive.tt (-1 / +1 lines)
277	<ol>	277	<ol>
278	<li>	278	<li>
279	<label for="datereceived">Date received: </label>	279	<label for="datereceived">Date received: </label>
280	<input type="text" size="10" id="datereceived" name="datereceived" value="[% datereceived \| $KohaDates %]" class="flatpickr" />	280	<input type="text" size="10" id="datereceived" name="datereceived" value="[% datereceived \| html %]" class="flatpickr" />
281	<div class="hint">[% INCLUDE 'date-format.inc' %]</div>	281	<div class="hint">[% INCLUDE 'date-format.inc' %]</div>
282	</li>	282	</li>
283	<li><label for="bookfund">Fund: </label><select id="bookfund" name="bookfund">	283	<li><label for="bookfund">Fund: </label><select id="bookfund" name="bookfund">

Lines 163-169 Link Here

(-)a/koha-tmpl/intranet-tmpl/prog/en/modules/acqui/parcels.tt (-1 / +1 lines)
163	</li> -->	163	</li> -->
164	<li>	164	<li>
165	<label for="shipmentdate">Shipment date: </label>	165	<label for="shipmentdate">Shipment date: </label>
166	<input type="text" id="shipmentdate" name="shipmentdate" maxlength="10" size="10" value="[% shipmentdate_today \| $KohaDates %]" class="flatpickr" />	166	<input type="text" id="shipmentdate" name="shipmentdate" maxlength="10" size="10" value="[% shipmentdate_today \| html %]" class="flatpickr" />
167	<div class="hint">[% INCLUDE 'date-format.inc' %]</div>	167	<div class="hint">[% INCLUDE 'date-format.inc' %]</div>
168	</li>	168	</li>
169	<li>	169	<li>





    <li>
    <label class="required" for="from">Start date: </label>
    <input type="text" size="10" id="from" name="budget_period_startdate" value="[% budget_period_startdate | html %]" class="flatpickr" data-date_to="to" />
        <span class="required">Required</span>
        <div class="hint">[% INCLUDE 'date-format.inc' %]</div>
    </li>
    <li>

    <label class="required" for="to">End date: </label>
    <input type="text" size="10" id="to" name="budget_period_enddate" value="[% budget_period_enddate | html %]" class="flatpickr" />
        <span class="required">Required</span>
        <div class="hint">[% INCLUDE 'date-format.inc' %]</div>
    </li>

    <ol>
    <li>
    <label class="required" for="from">Start date: </label>
    <input type="text" size="10" id="from" name="budget_period_startdate" value="[% budget_period_startdate | html %]" class="flatpickr" data-date_to="to" />
        <span class="required">Required</span>
        <div class="hint">[% INCLUDE 'date-format.inc' %]</div>
    </li>
    <li>

    <label class="required" for="to">End date: </label>
    <input type="text" size="10" id="to" name="budget_period_enddate" value="[% budget_period_enddate | html %]" class="flatpickr" />
        <span class="required">Required</span>
        <div class="hint">[% INCLUDE 'date-format.inc' %]</div>
    </li>




                                        <input type="text" name="contractdescription" id="contractdescription" size="40" maxlength="80" value="[% contractdescription | html %]" />
                                </li>
                                <li><label for="from" class="required">Start date:</label> &nbsp;
                                        <input type="text" name="contractstartdate" id="from" value="[% contractstartdate | html %]" maxlength="10" size="10" class="flatpickr" data-date_to="to" />
                                        <span class="required">Required</span>
                                    <div class="hint">[% INCLUDE 'date-format.inc' %]</div>
                                </li>
                                <li><label for="to" class="required">End date:</label> &nbsp;
                                        <input type="text" name="contractenddate" id="to" value="[% contractenddate | html %]" maxlength="10"  size="10" class="flatpickr" />
                                        <span class="required">Required</span>
                                    <div class="hint">[% INCLUDE 'date-format.inc' %]</div>
                                </li>

Lines 157-163 Link Here

(-)a/koha-tmpl/intranet-tmpl/prog/en/modules/admin/categories.tt (-1 / +1 lines)
157	</li>	157	</li>
158	<li>	158	<li>
159	<label for="enrolmentperioddate">Until date: </label>	159	<label for="enrolmentperioddate">Until date: </label>
160	<input type="text" class="enrollmentperiod flatpickr" data-flatpickr-futuredate="true" name="enrolmentperioddate" id="enrolmentperioddate" value="[% category.enrolmentperioddate \| $KohaDates %]" />	160	<input type="text" class="enrollmentperiod flatpickr" data-flatpickr-futuredate="true" name="enrolmentperioddate" id="enrolmentperioddate" value="[% category.enrolmentperioddate \| html %]" />
161	</li>	161	</li>
162	</ol>	162	</ol>
163	</fieldset>	163	</fieldset>

Lines 420-426 Link Here

(-)a/koha-tmpl/intranet-tmpl/prog/en/modules/circ/circulation.tt (-2 / +2 lines)
420	[% END %]	420	[% END %]
421		421
422	[% IF ( INVALID_DATE ) %]	422	[% IF ( INVALID_DATE ) %]
423	<li>The due date "[% INVALID_DATE \| html %]" is invalid</li>	423	<li>The due date "[% INVALID_DATE \| $KohaDates %]" is invalid</li>
424	[% END %]	424	[% END %]
425		425
426	[% IF ( UNKNOWN_BARCODE ) %]	426	[% IF ( UNKNOWN_BARCODE ) %]
Lines 680-686 Link Here
680	<div id="specify-due-date" class="circ-setting">	680	<div id="specify-due-date" class="circ-setting">
681	<div class="hint">Specify due date [% INCLUDE 'date-format.inc' %]: </div>	681	<div class="hint">Specify due date [% INCLUDE 'date-format.inc' %]: </div>
682	[% IF ( duedatespec ) %]	682	[% IF ( duedatespec ) %]
683	<input type="text" size="20" id="duedatespec" name="duedatespec" value="[% duedatespec \| $KohaDates with_hours => 1 %]" />	683	<input type="text" size="20" id="duedatespec" name="duedatespec" value="[% duedatespec \| html %]" />
684	[% ELSE %]	684	[% ELSE %]
685	<input type="text" size="20" id="duedatespec" name="duedatespec" value="" />	685	<input type="text" size="20" id="duedatespec" name="duedatespec" value="" />
686	[% END %]	686	[% END %]

Lines 113-119 Link Here

(-)a/koha-tmpl/intranet-tmpl/prog/en/modules/circ/circulation_batch_checkouts.tt (-1 / +1 lines)
113	<fieldset class="rows">	113	<fieldset class="rows">
114	<legend>Due date: </legend>	114	<legend>Due date: </legend>
115	<label for="duedatespec">Hard due date [% INCLUDE 'date-format.inc' %]:</label>	115	<label for="duedatespec">Hard due date [% INCLUDE 'date-format.inc' %]:</label>
116	<input type="text" size="20" id="duedatespec" name="duedatespec" value="[% duedatespec \| $KohaDates with_hours => 1 %]" class="flatpickr" data-flatpickr-enable-time="true" />	116	<input type="text" size="20" id="duedatespec" name="duedatespec" value="[% duedatespec \| html %]" class="flatpickr" data-flatpickr-enable-time="true" />
117	</fieldset>	117	</fieldset>
118	[% END %]	118	[% END %]
119	<input type="hidden" name="op" value="show" />	119	<input type="hidden" name="op" value="show" />

Lines 157-167 Link Here

(-)a/koha-tmpl/intranet-tmpl/prog/en/modules/circ/overdue.tt (-2 / +2 lines)
157		157
158	<li class="date_due_filter">	158	<li class="date_due_filter">
159	<label for="from">From:</label>	159	<label for="from">From:</label>
160	<input type="text" id="from" name="dateduefrom" size="10" value="[% filters.dateduefrom \| $KohaDates %]" class="flatpickr" data-date_to="to" />	160	<input type="text" id="from" name="dateduefrom" size="10" value="[% filters.dateduefrom \| html %]" class="flatpickr" data-date_to="to" />
161	</li>	161	</li>
162	<li class="date_due_filter">	162	<li class="date_due_filter">
163	<label for="to">To:</label>	163	<label for="to">To:</label>
164	<input type="text" id="to" name="datedueto" size="10" value="[% filters.datedueto \| $KohaDates %]" class="flatpickr" />	164	<input type="text" id="to" name="datedueto" size="10" value="[% filters.datedueto \| html %]" class="flatpickr" />
165	</li>	165	</li>
166	</ol>	166	</ol>
167	</fieldset>	167	</fieldset>




<label for="from">
    Start date:
</label>
<input type="text" size="10" id="from" name="from" value="[% from | html %]" class="flatpickr" data-date_to="to" />
</li>
<li><label for="to">
    End date:
</label>
<input type="text" size="10" id="to" name="to" value="[% to | html %]" class="flatpickr" />
</li>
</ol>


Lines 223-229 Link Here

(-)a/koha-tmpl/intranet-tmpl/prog/en/modules/circ/renew.tt (-1 / +1 lines)
223	<div class="circ-settings show">	223	<div class="circ-settings show">
224	<div class="date-select" id="renew_date_override_fields">	224	<div class="date-select" id="renew_date_override_fields">
225	<div><label for="hard_due_date" class="hint">Renewal due date [% INCLUDE 'date-format.inc' %]:</label></div>	225	<div><label for="hard_due_date" class="hint">Renewal due date [% INCLUDE 'date-format.inc' %]:</label></div>
226	<input type="text" size="20" id="hard_due_date" name="hard_due_date" value="[% hard_due_date \| $KohaDates with_hours => 1 %]" class="flatpickr" data-flatpickr-futuredate="true" data-flatpickr-enable-time="true" />	226	<input type="text" size="20" id="hard_due_date" name="hard_due_date" value="[% hard_due_date \| html %]" class="flatpickr" data-flatpickr-futuredate="true" data-flatpickr-enable-time="true" />
227	</div> <!-- /.date-select -->	227	</div> <!-- /.date-select -->
228	</div>	228	</div>
229	</fieldset>	229	</fieldset>





    <li>
        <label for="from">Start date:</label>
        <input type="text" size="10" id="from" name="from" value="[% from | html %]" class="flatpickr" data-date_to="to" />
    </li>

    <li>
        <label for="to">End date:</label>
        <input size="10" id="to" name="to" value="[% to | html %]" type="text" class="flatpickr" />
    </li>
</ol>
(inclusive)

Lines 1076-1084 Link Here

(-)a/koha-tmpl/intranet-tmpl/prog/en/modules/circ/returns.tt (-2 / +2 lines)
1076	<td class="ci-duedate">	1076	<td class="ci-duedate">
1077	[% IF ( riloo.duedate ) %]	1077	[% IF ( riloo.duedate ) %]
1078	[% IF ( riloo.return_overdue ) %]	1078	[% IF ( riloo.return_overdue ) %]
1079	<span class="overdue">[% riloo.duedate \| html %] (overdue)</span>	1079	<span class="overdue">[% riloo.duedate \| $KohaDates as_due_date => 1 %] (overdue)</span>
1080	[% ELSE %]	1080	[% ELSE %]
1081	[% riloo.duedate \| html %]	1081	[% riloo.duedate \| $KohaDates as_due_date => 1 %]
1082	[% END %]	1082	[% END %]
1083	[% ELSE %]	1083	[% ELSE %]
1084	<span>Not checked out</span>	1084	<span>Not checked out</span>





                        <li>
                            <label for="from">Start date:</label>
                            <input name="date_start" id="from" size="10" class="flatpickr" data-date_to="to" value="[% club.date_start | html %]">
                        </li>

                        <li>
                            <label for="to">End date:</label>
                            <input name="date_end" id="to" size="10" class="flatpickr" value="[% club.date_end | html %]" >
                        </li>

                        <li>




                <br>
                <li>
                    <label for="from">From: </label>
                    <input type="text" size="10" id="from" name="from" value="[% beginDate | html %]" class="flatpickr" data-date_to="to" />
                    <div class="hint">[% INCLUDE 'date-format.inc' %]</div>
                </li>
                <li>
                    <label for="to">To: </label>
                    <input type="text" size="10" id="to" name="to" value="[% endDate | html %]" class="flatpickr" />
                    <div class="hint">[% INCLUDE 'date-format.inc' %]</div>
                </li>


Lines 793-799 Link Here

(-)a/koha-tmpl/intranet-tmpl/prog/en/modules/reserve/request.tt (-2 / +2 lines)
793	<td>	793	<td>
794	[% IF ( itemloo.transfertwhen ) %]	794	[% IF ( itemloo.transfertwhen ) %]
795	<span>In transit from [% Branches.GetName( itemloo.transfertfrom ) \| html %],	795	<span>In transit from [% Branches.GetName( itemloo.transfertfrom ) \| html %],
796	to [% Branches.GetName( itemloo.transfertto ) \| html %], since [% itemloo.transfertwhen \| html %]</span>	796	to [% Branches.GetName( itemloo.transfertto ) \| html %], since [% itemloo.transfertwhen \| $KohaDates %]</span>
797	[% END %]	797	[% END %]
798	[% END %]	798	[% END %]
799		799
Lines 811-817 Link Here
811	[% itemloo.waitingdate \| $KohaDates %]	811	[% itemloo.waitingdate \| $KohaDates %]
812	[% ELSE %]	812	[% ELSE %]
813	[% IF ( itemloo.reservedate ) %]	813	[% IF ( itemloo.reservedate ) %]
814	[% itemloo.reservedate \| html %]	814	[% itemloo.reservedate \| $KohaDates %]
815	[% END %]	815	[% END %]
816	[% END %].	816	[% END %].
817	<a class="info cancel-hold" href="modrequest.pl?CancelBiblioNumber=[% itemloo.biblionumber \| html %]&CancelBorrowerNumber=[% itemloo.ReservedFor.borrowernumber \| html %]&CancelItemnumber=[% itemloo.itemnumber \| html %]">Cancel hold</a>	817	<a class="info cancel-hold" href="modrequest.pl?CancelBiblioNumber=[% itemloo.biblionumber \| html %]&CancelBorrowerNumber=[% itemloo.ReservedFor.borrowernumber \| html %]&CancelItemnumber=[% itemloo.itemnumber \| html %]">Cancel hold</a>

Lines 54-60 Link Here

(-)a/koha-tmpl/intranet-tmpl/prog/en/modules/serials/checkexpiration.tt (-1 / +1 lines)
54	[% END %]	54	[% END %]
55		55
56	<li><label for="date" class="required">Expiring before:</label>	56	<li><label for="date" class="required">Expiring before:</label>
57	<input id="date" type="text" name="date" size="10" value="[% date \| $KohaDates %]" class="required focus flatpickr" required="required" />	57	<input id="date" type="text" name="date" size="10" value="[% date \| html %]" class="required focus flatpickr" required="required" />
58	<span class="required">Required</span>	58	<span class="required">Required</span>
59	<div class="hint">[% INCLUDE 'date-format.inc' %]</div></li>	59	<div class="hint">[% INCLUDE 'date-format.inc' %]</div></li>
60	</ol>	60	</ol>




                                                [% IF ( missingissue.status44 ) %]<span class="status-missing_lost">Missing (lost)</span>[% END %]
                                                [% IF ( missingissue.status7 ) %]<span class="status-claimed">Claimed</span>[% END %]
                                            </td>
                                            <td class="planneddate" data-order="[% missingissue.planneddate | html %]">
                                                [% missingissue.planneddate | $KohaDates %]
                                            </td>
                                            <td>[% missingissue.claims_count | html %]</td>
                                            <td data-order="[% missingissue.claimdate | html %]">
                                                [% missingissue.claimdate | $KohaDates %]
                                            </td>
                                            [% FOR field IN additional_fields_for_subscription %]
                                                [% IF field.authorised_value_category %]

Lines 289-295 Link Here

(-)a/koha-tmpl/intranet-tmpl/prog/en/modules/serials/serials-search.tt (-2 / +2 lines)
289	</li>	289	</li>
290	<li class="local">	290	<li class="local">
291	<label for="to">Expires before:</label>	291	<label for="to">Expires before:</label>
292	<input type="text" id="to" name="expiration_date_filter" value="[% expiration_date_filter \| $KohaDates %]" size="10" maxlength="10" class="flatpickr" />	292	<input type="text" id="to" name="expiration_date_filter" value="[% expiration_date_filter \| html %]" size="10" maxlength="10" class="flatpickr" />
293	</li>	293	</li>
294	[% INCLUDE 'additional-fields-entry.inc' available=additional_fields_for_subscription values=additional_field_filters wrap_fieldset=0 %]	294	[% INCLUDE 'additional-fields-entry.inc' available=additional_fields_for_subscription values=additional_field_filters wrap_fieldset=0 %]
295	</ol>	295	</ol>
Lines 404-410 Link Here
404	</li>	404	</li>
405	<li>	405	<li>
406	<label for="to">Expires before:</label>	406	<label for="to">Expires before:</label>
407	<input type="text" id="to" name="expiration_date_filter" value="[% expiration_date_filter \| $KohaDates %]" size="10" maxlength="10" class="flatpickr" />	407	<input type="text" id="to" name="expiration_date_filter" value="[% expiration_date_filter \| html %]" size="10" maxlength="10" class="flatpickr" />
408	</li>	408	</li>
409		409
410	[% FOR field IN additional_fields_for_subscription %]	410	[% FOR field IN additional_fields_for_subscription %]




                                    <li>
                                        <label for="acqui_date" class="required">First issue publication date:</label>
                                        [% UNLESS (more_than_one_serial) %]
                                          <input type="text" size="10" id="acqui_date" name="firstacquidate" value="[% firstacquidate | html %]" class="flatpickr required" required="required" />
                                        [% ELSE %]
                                          [% firstacquidate | $KohaDates %]
                                          <input type="hidden" id="acqui_date" name="firstacquidate" value="[% firstacquidate | $KohaDates %]"/>

                                    [% IF (more_than_one_serial) %]
                                      <li>
                                        <label for="nextacquidate">Next issue publication date:</label>
                                        <input type="text" size="10" id="nextacquidate" name="nextacquidate" value="[% nextacquidate | html %]" class="flatpickr" />
                                      </li>
                                    [% END %]
                                    <li>

                                    </li>
                                    <li>
                                        <label for="from" class="required"> Subscription start date:</label>
                                        <input type="text" size="10" id="from" name="startdate" value="[% startdate | html %]" class="flatpickr required" data-date_to="to" required="required" />
                                    </li>
                                    <li>
                                        <label for="to">Subscription end date:</label>
                                        <input type="text" size="10" id="to" name="enddate" value="[% enddate | html %]" class="flatpickr" />
                                    </li>
                                    <li>
                                        <label for="numberpattern" class="required">Numbering pattern:</label>




              <tr>
                <td>Subscription start date</td>
                <td>
                    <input type="text" size="10" name="histstartdate" value="[% histstartdate | html %]" class="flatpickr" data-date_to="histenddate" /> (start date of the 1st subscription)
                    <div class="hint">[% INCLUDE 'date-format.inc' %]</div>
                </td>
              </tr>
              <tr>
                <td>Subscription end date</td>
                <td>
                    <input type="text" size="10" id="histenddate" name="histenddate" value="[% histenddate | html %]" class="flatpickr" />(if empty, subscription is still active)
                    <div class="hint">[% INCLUDE 'date-format.inc' %]</div>
                </td>
              </tr>




                                            <label for="suggesteddate">[% tp('purchase suggestion created by', 'Created by:') | html %]</label>
                                        </th>
                                        <td>
                                            <input type="text" id="suggesteddate" name="suggesteddate" class="flatpickr" size="10" maxlength="10" value="[% suggesteddate | html %]"/> [% INCLUDE 'date-format.inc' %]
                                        </td>
                                        <td id="tdsuggestedby">
                                            <input type="hidden" id="suggestedby" name="suggestedby" value="[% suggestedby | html %]"/>

                                            <label for="accepteddate">Accepted on:</label>
                                        </th>
                                        <td>
                                            <input type="text" id="accepteddate" name="accepteddate" class="flatpickr" size="10" maxlength="10" value="[% accepteddate | html %]" />[% INCLUDE 'date-format.inc' %]
                                        </td>
                                        <td>
                                            <input type="hidden" id="acceptedby" name="acceptedby" value="[% acceptedby | html %]"/>

                        </li>
                        <li>
                            <label for="managedon">Managed on:</label>
                            <input type="text" id="managedon" name="manageddate" class="flatpickr" size="10" maxlength="10" value="[% manageddate | html %]" />[% INCLUDE 'date-format.inc' %]
                        </li>
                        <li>
                            <label for="managedby_name">by:</label>

Lines 64-72 tr > td input,td input[type="submit"] { font-size: 85%; padding: 1px; } Link Here

(-)a/koha-tmpl/intranet-tmpl/prog/en/modules/tags/review.tt (-3 / +1 lines)
64	[% IF ( message_loop ) %]	64	[% IF ( message_loop ) %]
65	<div class="dialog alert" id="main_error">	65	<div class="dialog alert" id="main_error">
66	[% FOREACH message_loo IN message_loop %]	66	[% FOREACH message_loo IN message_loop %]
67	[% IF ( message_loo.date_from ) %]<strong>Error: </strong><span>"Date from" is not a legal value ("[% message_loo.date_from \| html %]").</span>	67	[% IF ( message_loo.failed_ok ) %]<strong>Error: </strong><span>Failed to approve term ([% message_loo.failed_ok \| html %]).</span>
68	[% ELSIF ( message_loo.date_to ) %]<strong>Error: </strong><span>"Date to" is not a legal value ("[% message_loo.date_to \| html %]").</span>
69	[% ELSIF ( message_loo.failed_ok ) %]<strong>Error: </strong><span>Failed to approve term ([% message_loo.failed_ok \| html %]).</span>
70	[% ELSIF ( message_loo.failed_rej ) %]<strong>Error: </strong><span>Failed to reject term ([% message_loo.failed_rej \| html %]).</span>	68	[% ELSIF ( message_loo.failed_rej ) %]<strong>Error: </strong><span>Failed to reject term ([% message_loo.failed_rej \| html %]).</span>
71	[% ELSIF ( message_loo.approver ) %]<span>No match for user ([% message_loo.approver \| html %]). FILTER REQUIRES BORROWERNUMBER (not name).</span>	69	[% ELSIF ( message_loo.approver ) %]<span>No match for user ([% message_loo.approver \| html %]). FILTER REQUIRES BORROWERNUMBER (not name).</span>
72	[% ELSIF ( message_loo.approved_by ) %]<strong>Error: </strong><span>No match for borrowernumber ([% message_loo.approved_by \| html %]).</span>	70	[% ELSIF ( message_loo.approved_by ) %]<strong>Error: </strong><span>No match for borrowernumber ([% message_loo.approved_by \| html %]).</span>




                [% END %]
                <li>
                    <label for="from">Publication date: </label>
                    <input id="from" type="text" name="published_on" size="15" value="[% additional_content.published_on | html %]" class="flatpickr" data-date_to="to" />
                    <div class="hint">[% INCLUDE 'date-format.inc' %]</div>
                </li>
                <li>
                    <label for="to">Expiration date: </label>
                    <input id="to" type="text" name="expirationdate" size="15" value="[% additional_content.expirationdate | html %]" class="flatpickr" />
                    <div class="hint">
                        [% INCLUDE 'date-format.inc' %]
                        [% IF category == 'news' %]

Lines 484-490 Link Here

(-)a/koha-tmpl/intranet-tmpl/prog/en/modules/tools/holidays.tt (-1 / +1 lines)
484		484
485	function changeBranch () {	485	function changeBranch () {
486	var branch = $("#branch option:selected").val();	486	var branch = $("#branch option:selected").val();
487	location.href='/cgi-bin/koha/tools/holidays.pl?branch=' + branch + '&calendardate=' + "[% calendardate \| html %]";	487	location.href='/cgi-bin/koha/tools/holidays.pl?branch=' + branch + '&calendardate=' + "[% calendardate \| $KohaDates %]";
488	}	488	}
489		489
490	/**	490	/**

Lines 85-91 Link Here

(-)a/koha-tmpl/intranet-tmpl/prog/en/modules/tools/inventory.tt (-2 / +2 lines)
85	<fieldset class="rows">	85	<fieldset class="rows">
86	<legend>Parameters</legend>	86	<legend>Parameters</legend>
87	<ol>	87	<ol>
88	<li><label for="setdate">Set inventory date to:</label> <input type="text" id="setdate" name="setdate" value="[% today \| $KohaDates %]" class="flatpickr" /></li>	88	<li><label for="setdate">Set inventory date to:</label> <input type="text" id="setdate" name="setdate" value="[% today \| html %]" class="flatpickr" /></li>
89	<li><label for="compareinv2barcd">Compare barcodes list to results: </label><input type="checkbox" name="compareinv2barcd" id="compareinv2barcd" disabled /></li>	89	<li><label for="compareinv2barcd">Compare barcodes list to results: </label><input type="checkbox" name="compareinv2barcd" id="compareinv2barcd" disabled /></li>
90	<li><label for="dont_checkin">Do not check in items scanned during inventory: </label><input type="checkbox" name="dont_checkin" id="dont_checkin" disabled /></li>	90	<li><label for="dont_checkin">Do not check in items scanned during inventory: </label><input type="checkbox" name="dont_checkin" id="dont_checkin" disabled /></li>
91	<li><label for="out_of_order">Check barcodes list for items shelved out of order: </label><input type="checkbox" name="out_of_order" id="out_of_order" disabled /></li>	91	<li><label for="out_of_order">Check barcodes list for items shelved out of order: </label><input type="checkbox" name="out_of_order" id="out_of_order" disabled /></li>
Lines 185-191 Link Here
185	<li>	185	<li>
186	<br/>	186	<br/>
187	<label for="datelastseen">Last inventory date:</label>	187	<label for="datelastseen">Last inventory date:</label>
188	<input type="text" id="datelastseen" name="datelastseen" value="[% datelastseen \| $KohaDates %]" class="flatpickr" />	188	<input type="text" id="datelastseen" name="datelastseen" value="[% datelastseen \| html %]" class="flatpickr" />
189	(Skip records marked as seen on or after this date.)	189	(Skip records marked as seen on or after this date.)
190	</li>	190	</li>
191	<li>	191	<li>

Lines 128-134 function select_user(borrowernumber, borrower, relationship) { Link Here

(-)a/koha-tmpl/intranet-tmpl/prog/js/members.js (-1 / +1 lines)
128		128
129	function CalculateAge(dateofbirth) {	129	function CalculateAge(dateofbirth) {
130	var today = new Date();	130	var today = new Date();
131	var dob = Date_from_syspref(dateofbirth);	131	var dob = new Date(dateofbirth);
132	var age = {};	132	var age = {};
133		133
134	age.year = today.getFullYear() - dob.getFullYear();	134	age.year = today.getFullYear() - dob.getFullYear();




                                                            </td>
                                                            <td class="information">
                                                                [% IF ( itemLoo.dateDue ) %]
                                                                    <span class="checkedout">Due [% itemLoo.dateDue | $KohaDates as_due_date => 1 %]</span>
                                                                [% ELSIF ( itemLoo.transfertwhen ) %]
                                                                    <span class="intransit">In transit from [% Branches.GetName( itemLoo.transfertfrom ) | html %] to [% Branches.GetName( itemLoo.transfertto ) | html %] since [% itemLoo.transfertwhen | $KohaDates %]</span>
                                                                [% END %]

                                                                [% IF ( itemLoo.message ) %]

                                                                            [% itemLoo.waitingdate | $KohaDates %]
                                                                        [% ELSE %]
                                                                            [% IF ( itemLoo.reservedate ) %]
                                                                                [% itemLoo.reservedate | $KohaDates %]
                                                                            [% END %]
                                                                        [% END %].
                                                                    </span>




use C4::Creators::Lib qw( html_table );

use Koha::Logger;
use Koha::DateUtils qw( dt_from_string output_pref );
use Koha::Items;
use Koha::ItemTypes;
use Koha::SearchEngine::Search;

    $dateto   = $query->param('dateto');

    if ($datefrom) {
        $ccl_query .= ' AND ' if $ccl_textbox;
        $ccl_query .= "acqdate,ge,st-date-normalized=" . $datefrom;
            $datefrom = output_pref( { dt => $datefrom, dateonly => 1, dateformat => 'iso' } );
            $ccl_query .= ' AND ' if $ccl_textbox;
            $ccl_query .= "acqdate,ge,st-date-normalized=" . $datefrom;
        }
    }

    if ($dateto) {
        $ccl_query .= ' AND ' if ( $ccl_textbox || $datefrom );
        $ccl_query .= "acqdate,le,st-date-normalized=" . $dateto;
           $dateto = output_pref( { dt => $dateto, dateonly => 1, dateformat => 'iso' } );
            $ccl_query .= ' AND ' if ( $ccl_textbox || $datefrom );
            $ccl_query .= "acqdate,le,st-date-normalized=" . $dateto;
        }
    }

    my $offset = $startfrom > 1 ? $startfrom - 1 : 0;




use C4::Context;
use C4::Output qw( output_and_exit_if_error output_and_exit output_html_with_http_headers );
use DateTime;
use Koha::DateUtils qw( dt_from_string );
use Koha::Libraries;
use Koha::Patrons;
use Koha::Patron::Categories;

    # simple display.
    $visit->set({
        borrowernumber      => scalar $input->param('borrowernumber')      // q{},
        appointment_date    => scalar $input->param('date')                // q{},
        day_segment         => scalar $input->param('segment')             // q{},
        chooser_brwnumber   => scalar $input->param('chooser')             // q{},
        deliverer_brwnumber => scalar $input->param('deliverer')           // q{},

    # to simple display.
    my $visit = Koha::Patron::HouseboundVisit->new({
        borrowernumber      => scalar $input->param('borrowernumber')      // q{},
        appointment_date    => scalar $input->param('date')                // q{},
        day_segment         => scalar $input->param('segment')             // q{},
        chooser_brwnumber   => scalar $input->param('chooser')             // q{},
        deliverer_brwnumber => scalar $input->param('deliverer')           // q{},




use Koha::Email;
use Koha::Patron::Debarments qw( AddDebarment DelDebarment GetDebarments );
use Koha::Cities;
use Koha::DateUtils qw( dt_from_string );
use Koha::Libraries;
use Koha::Patrons;
use Koha::Patron::Attribute::Types;

        }
    }

    foreach (qw(dateenrolled dateexpiry dateofbirth password_expiration_date)) {
        next unless exists $newdata{$_};
        my $userdate = $newdata{$_} or next;

        my $formatteddate = eval { output_pref({ dt => dt_from_string( $userdate ), dateformat => 'iso', dateonly => 1 } ); };
        if ( $formatteddate ) {
            $newdata{$_} = $formatteddate;
        } else {
            $template->param( "ERROR_$_" => 1 );
            push(@errors,"ERROR_$_");
        }
    }

    # check permission to modify login info.
    if (ref($borrower_data) && ($borrower_data->{'category_type'} eq 'S') && ! (C4::Auth::haspermission($userenv->{'id'},{'staffaccess'=>1})) )  {
        $NoUpdateLogin = 1;

  #Formatting data for display    
  
if (!defined($data{'dateenrolled'}) or $data{'dateenrolled'} eq ''){
  $data{'dateenrolled'} = dt_from_string;
}
if ( $op eq 'duplicate' ) {
    $data{'dateenrolled'} = dt_from_string;
    my $patron_category = Koha::Patron::Categories->find( $data{categorycode} );
    $data{dateexpiry} = $patron_category->get_expiry_date( $data{dateenrolled} );
}

    $data{'contactname'} &&= uc( $data{'contactname'} );
}

foreach (qw(dateenrolled dateexpiry dateofbirth password_expiration_date)) {
    if ( $data{$_} ) {
       $data{$_} = eval { output_pref({ dt => dt_from_string( $data{$_} ), dateonly => 1 } ); };  # back to syspref for display
    }
    $template->param( $_ => $data{$_});
}

if ( C4::Context->preference('ExtendedPatronAttributes') ) {
    patron_attributes_form( $template, $extended_patron_attributes, $op );
}

Lines 163-169 for my $overdue ( @{$overdues} ) { Link Here

(-)a/misc/cronjobs/fines.pl (-1 / +1 lines)
163	itemnumber => $overdue->{itemnumber},	163	itemnumber => $overdue->{itemnumber},
164	borrowernumber => $overdue->{borrowernumber},	164	borrowernumber => $overdue->{borrowernumber},
165	amount => $amount,	165	amount => $amount,
166	due => output_pref($datedue),	166	due => $datedue,
167	}	167	}
168	);	168	);
169	$updated++;	169	$updated++;

Lines 25-31 use C4::Context; Link Here

(-)a/misc/cronjobs/serialsUpdate.pl (-2 / +2 lines)
25	use C4::Serials qw( GetSubscription GetNextDate ModSerialStatus );	25	use C4::Serials qw( GetSubscription GetNextDate ModSerialStatus );
26	use C4::Serials::Frequency;	26	use C4::Serials::Frequency;
27	use C4::Log qw( cronlogaction );	27	use C4::Log qw( cronlogaction );
28	use Koha::DateUtils qw( dt_from_string output_pref );	28	use Koha::DateUtils qw( dt_from_string );
29		29
30	use Date::Calc qw( check_date Date_to_Days );	30	use Date::Calc qw( check_date Date_to_Days );
31	use Getopt::Long qw( GetOptions );	31	use Getopt::Long qw( GetOptions );
Lines 113-119 while ( my $issue = $sth->fetchrow_hashref ) { Link Here
113	if ( $subscription && $publisheddate ) {	113	if ( $subscription && $publisheddate ) {
114	my $freqdata = GetSubscriptionFrequency($subscription->{'periodicity'});	114	my $freqdata = GetSubscriptionFrequency($subscription->{'periodicity'});
115	my $nextpublisheddate = GetNextDate( $subscription, $publisheddate, $freqdata );	115	my $nextpublisheddate = GetNextDate( $subscription, $publisheddate, $freqdata );
116	my $today = output_pref({ dt => dt_from_string, dateformat => 'iso', dateonly => 1 });	116	my $today = dt_from_string->ymd;
117		117
118	if ( $nextpublisheddate && $today ) {	118	if ( $nextpublisheddate && $today ) {
119	my ( $year, $month, $day ) = split( /-/, $nextpublisheddate );	119	my ( $year, $month, $day ) = split( /-/, $nextpublisheddate );

Lines 36-42 use C4::Calendar qw(); # don't need any exports from Calendar Link Here

(-)a/misc/cronjobs/staticfines.pl (-2 / +2 lines)
36	use C4::Log qw( cronlogaction );	36	use C4::Log qw( cronlogaction );
37	use Getopt::Long qw( GetOptions );	37	use Getopt::Long qw( GetOptions );
38	use List::MoreUtils qw( none );	38	use List::MoreUtils qw( none );
39	use Koha::DateUtils qw( dt_from_string output_pref );	39	use Koha::DateUtils qw( dt_from_string );
40	use Koha::Patrons;	40	use Koha::Patrons;
41		41
42	my $help = 0;	42	my $help = 0;
Lines 126-132 if (defined $borrowernumberlimit) { Link Here
126	my $overdueItemsCounted = 0;	126	my $overdueItemsCounted = 0;
127	my %calendars = ();	127	my %calendars = ();
128	$today = dt_from_string;	128	$today = dt_from_string;
129	$today_iso = output_pref( { dt => $today, dateonly => 1, dateformat => 'iso' } );	129	$today_iso = $today->ymd;
130	my ($tyear, $tmonth, $tday) = split( /-/, $today_iso );	130	my ($tyear, $tmonth, $tday) = split( /-/, $today_iso );
131	$today_days = Date_to_Days( $tyear, $tmonth, $tday );	131	$today_days = Date_to_Days( $tyear, $tmonth, $tday );
132		132




use Koha::Patron::Modification;
use Koha::Patron::Modifications;
use C4::Scrubber;
use Koha::DateUtils qw( dt_from_string );
use Koha::Email;
use Koha::Libraries;
use Koha::Patron::Attribute::Types;

        }
    }

    if ( defined $borrower{'dateofbirth'} ) {
        my $dob_dt;
        $dob_dt = eval { dt_from_string( $borrower{'dateofbirth'} ); }
            if ( $borrower{'dateofbirth'} );

        if ( $dob_dt ) {
            $borrower{'dateofbirth'} = output_pref( { dt => $dob_dt, dateonly => 1, dateformat => 'iso' } );
        }
        else {
            # Trigger validation
            $borrower{'dateofbirth'} = undef;
        }
    }

    # Replace checkbox 'agreed' by datetime in gdpr_proc_consent
    $borrower{gdpr_proc_consent} = dt_from_string if  $borrower{gdpr_proc_consent} && $borrower{gdpr_proc_consent} eq 'agreed';






use Koha::AuthorisedValues;
use Koha::Biblios;
use Koha::DateUtils qw( dt_from_string output_pref );
use Koha::CirculationRules;
use Koha::Items;
use Koha::ItemTypes;

        # change the background color.
        my $issue = Koha::Checkouts->find( { itemnumber => $itemNum } );
        if ( $issue ) {
            $itemLoopIter->{dateDue} = $issue->date_due;
            $itemLoopIter->{onloan} = 'onloan';
        }



        if ( my $first_hold = $holds->next ) {
            $itemLoopIter->{backgroundcolor} = 'reserved';
            $itemLoopIter->{reservedate}     = $first_hold->reservedate;
            $itemLoopIter->{ExpectedAtLibrary}         = $first_hold->branchcode;
            $itemLoopIter->{waitingdate} = $first_hold->waitingdate;
        }

        my ( $transfertwhen, $transfertfrom, $transfertto ) =
          GetTransfers($itemNum);
        if ( $transfertwhen && ($transfertwhen ne '') ) {
            $itemLoopIter->{transfertwhen} = $transfertwhen;
            $itemLoopIter->{transfertfrom} = $transfertfrom;
            $itemLoopIter->{transfertto} = $transfertto;
            $itemLoopIter->{nocancel} = 1;

Lines 37-43 use Koha::AuthorisedValues; Link Here

(-)a/opac/opac-suggestions.pl (-2 / +1 lines)
37	use Koha::Libraries;	37	use Koha::Libraries;
38	use Koha::Patrons;	38	use Koha::Patrons;
39		39
40	use Koha::DateUtils qw( dt_from_string output_pref );	40	use Koha::DateUtils qw( dt_from_string );
41		41
42	my $input = CGI->new;	42	my $input = CGI->new;
43	my $op = $input->param('op') \|\| 'else';	43	my $op = $input->param('op') \|\| 'else';
Lines 151-157 my $patrons_total_suggestions_count = 0; Link Here
151	if ( $borrowernumber ){	151	if ( $borrowernumber ){
152	if ( C4::Context->preference("MaxTotalSuggestions") ne '' && C4::Context->preference("NumberOfSuggestionDays") ne '' ) {	152	if ( C4::Context->preference("MaxTotalSuggestions") ne '' && C4::Context->preference("NumberOfSuggestionDays") ne '' ) {
153	my $suggesteddate_from = dt_from_string()->subtract(days=>C4::Context->preference("NumberOfSuggestionDays"));	153	my $suggesteddate_from = dt_from_string()->subtract(days=>C4::Context->preference("NumberOfSuggestionDays"));
154	$suggesteddate_from = output_pref({ dt => $suggesteddate_from, dateformat => 'iso', dateonly => 1 });
155	$patrons_total_suggestions_count = Koha::Suggestions->search({ suggestedby => $borrowernumber, suggesteddate => { '>=' => $suggesteddate_from } })->count;	154	$patrons_total_suggestions_count = Koha::Suggestions->search({ suggestedby => $borrowernumber, suggesteddate => { '>=' => $suggesteddate_from } })->count;
156		155
157	}	156	}

Lines 26-32 use C4::Context; Link Here

(-)a/pos/register.pl (-4 / +6 lines)
26	use Koha::Account::Lines;	26	use Koha::Account::Lines;
27	use Koha::Cash::Registers;	27	use Koha::Cash::Registers;
28	use Koha::Database;	28	use Koha::Database;
29	use Koha::DateUtils qw( dt_from_string output_pref );	29	use Koha::DateUtils qw( dt_from_string );
30		30
31	my $input = CGI->new();	31	my $input = CGI->new();
32		32
Lines 96-105 else { Link Here
96	}	96	}
97	}	97	}
98	);	98	);
99	$template->param( past_accountlines => $past_accountlines );	99	$template->param(
100	$template->param( trange_f => output_pref({dt => $start, dateonly => 1}));	100	past_accountlines => $past_accountlines,
		101	trange_f => $start,
		102	);
101	}	103	}
102	$template->param( trange_t => output_pref({dt => $end, dateonly => 1}));	104	$template->param( trange_t => $end, );
103		105
104	my $op = $input->param('op') // '';	106	my $op = $input->param('op') // '';
105	if ( $op eq 'cashup' ) {	107	if ( $op eq 'cashup' ) {




use C4::Koha qw( GetAuthorisedValues );
use C4::Biblio qw( GetMarcSubfieldStructureFromKohaField );
use Koha::ItemTypes;
use Koha::DateUtils qw( dt_from_string output_pref );
use Koha::Libraries;

=head1 NAME

my $line           = $input->param("Line");
my $column         = $input->param("Column");
my @filters        = $input->multi_param("Filter");
$filters[0] = eval { output_pref( { dt => dt_from_string( $filters[0]), dateonly => 1, dateformat => 'iso' } ); }
    if ( $filters[0] );
$filters[1] = eval { output_pref( { dt => dt_from_string( $filters[1]), dateonly => 1, dateformat => 'iso' } ); }
    if ( $filters[1] );
$filters[2] = eval { output_pref( { dt => dt_from_string( $filters[2]), dateonly => 1, dateformat => 'iso' } ); }
    if ( $filters[2] );
$filters[3] = eval { output_pref( { dt => dt_from_string( $filters[3]), dateonly => 1, dateformat => 'iso' } ); }
    if ( $filters[3] );
my $podsp          = $input->param("PlacedOnDisplay");
my $rodsp          = $input->param("ReceivedOnDisplay");
my $calc           = $input->param("Cellvalue");

            if ( ( ( $i == 1 ) or ( $i == 3 ) ) and ( @$filters[ $i - 1 ] ) ) {
                $cell{err} = 1 if ( @$filters[$i] lt @$filters[ $i - 1 ] );
            }
            $cell{filter} = @$filters[$i];
            if ($i >= 4) {
                $cell{filter} = @$filters[$i];
            } else {
                $cell{filter} = eval { output_pref( { dt => dt_from_string( @$filters[$i] ), dateonly => 1 }); }
                   if ( @$filters[$i] );
            }
            $cell{crit} = $i;
            push @loopfilter, \%cell;
        }




use C4::Context;
use C4::Reports qw( GetDelimiterChoices );

use Koha::DateUtils qw( dt_from_string output_pref );
use Koha::ItemTypes;
use Koha::Patron::Categories;


my $limit   = $input->param("Limit");
my $column  = $input->param("Criteria");
my @filters = $input->multi_param("Filter");
foreach ( @filters[0..3] ) {
    $_ and $_ = eval { output_pref( { dt => dt_from_string ( $_ ), dateonly => 1, dateformat => 'iso' }); };
}
my $output   = $input->param("output");
my $basename = $input->param("basename");
my ($template, $borrowernumber, $cookie)

            if (($i==1) and (@$filters[$i-1])) {
                $cell{err} = 1 if (@$filters[$i]<@$filters[$i-1]) ;
            }
            # format the dates filters, otherwise just fill as is
            $cell{filter} .= @$filters[$i];
			defined ($cellmap[$i]) and
				$cell{crit} .= $cellmap[$i];

Lines 25-31 use C4::Context; Link Here

(-)a/reports/borrowers_out.pl (-3 lines)
25	use C4::Output qw( output_html_with_http_headers );	25	use C4::Output qw( output_html_with_http_headers );
26	use C4::Reports qw( GetDelimiterChoices );	26	use C4::Reports qw( GetDelimiterChoices );
27		27
28	use Koha::DateUtils qw( dt_from_string output_pref );
29	use Koha::Patron::Categories;	28	use Koha::Patron::Categories;
30		29
31	=head1 NAME	30	=head1 NAME
Lines 44-51 my $fullreportname = "reports/borrowers_out.tt"; Link Here
44	my $limit = $input->param("Limit");	43	my $limit = $input->param("Limit");
45	my $column = $input->param("Criteria");	44	my $column = $input->param("Criteria");
46	my @filters = $input->multi_param("Filter");	45	my @filters = $input->multi_param("Filter");
47	$filters[1] = eval { output_pref( { dt => dt_from_string( $filters[1]), dateonly => 1, dateformat => 'iso' } ); }
48	if ( $filters[1] );
49		46
50	my $output = $input->param("output");	47	my $output = $input->param("output");
51	my $basename = $input->param("basename");	48	my $basename = $input->param("basename");




use C4::Reports qw( GetDelimiterChoices );

use Koha::AuthorisedValues;
use Koha::DateUtils qw( dt_from_string output_pref );
use Koha::Libraries;
use Koha::Patron::Attribute::Types;
use Koha::Patron::Categories;

my $line = $input->param("Line");
my $column = $input->param("Column");
my @filters = $input->multi_param("Filter");
$filters[3] = eval { output_pref( { dt => dt_from_string( $filters[3]), dateonly => 1, dateformat => 'iso' } ); }
    if ( $filters[3] );
$filters[4] = eval { output_pref ({ dt => dt_from_string( $filters[4]), dateonly => 1, dateformat => 'iso' } ); }
    if ( $filters[4] );
my $digits = $input->param("digits");
our $period = $input->param("period");
my $borstat = $input->param("status");

    foreach my $i (0 .. scalar @$filters) {
        my %cell;
        if ( @$filters[$i] ) {
            if ($i == 3 or $i == 4) {
                $cell{filter} = eval { output_pref( { dt => dt_from_string( @$filters[$i] ), dateonly => 1 }); }
                    if ( @$filters[$i] );
            } else {
                $cell{filter} = @$filters[$i];
            }

            if    ( $i == 0)  { $cell{crit} = "Cat code"; }
            elsif ( $i == 1 ) { $cell{crit} = "ZIP/Postal code"; }
            elsif ( $i == 2 ) { $cell{crit} = "Branch code"; }




use C4::Reports qw( GetDelimiterChoices );
use C4::Output qw( output_html_with_http_headers );
use DateTime;
use Koha::DateUtils qw( dt_from_string );
use Text::CSV::Encoded;
use List::Util qw( any );


);

#Initialize date pickers to today
my $fromDate = $input->param("from") || dt_from_string;
my $toDate   = $input->param("to")   || dt_from_string;

my @debit_types =
  Koha::Account::DebitTypes->search()->as_list;


if ($do_it) {

    $fromDate = output_pref({ dt => eval { dt_from_string(scalar $input->param("from")) } || dt_from_string,
            dateformat => 'sql', dateonly => 1 }); #for sql query
    $toDate   = output_pref({ dt => eval { dt_from_string(scalar $input->param("to")) } || dt_from_string,
            dateformat => 'sql', dateonly => 1 }); #for sql query

    my $whereTType = q{};
    my @extra_params; # if we add conditions to the select we need extra params




use C4::Output qw( output_html_with_http_headers );
use C4::Koha qw( GetAuthorisedValues );
use C4::Reports qw( GetDelimiterChoices );
use Koha::DateUtils qw( dt_from_string output_pref );
use Koha::ItemTypes;

=head1 NAME

my $limit = $input->param("Limit");
my $column = $input->param("Criteria");
my @filters = $input->multi_param("Filter");
foreach ( @filters[0..3] ) {
    $_ and $_ = eval { output_pref( { dt => dt_from_string ( $_ ), dateonly => 1, dateformat => 'iso' } ); };
}

my $output = $input->param("output");
my $basename = $input->param("basename");

            if (($i==1) and (@$filters[$i-1])) {
                $cell{err} = 1 if (@$filters[$i]<@$filters[$i-1]) ;
            }
            $cell{filter} .= @$filters[$i];
            if ($i>=2) {
                $cell{filter} .= @$filters[$i];
            } else {
                $cell{filter} .= eval { output_pref( { dt => dt_from_string( @$filters[$i] ), dateonly => 1 }); }
                   if ( @$filters[$i] );
            }
            $cell{crit} .="Issue From" if ($i==0);
            $cell{crit} .="Issue To" if ($i==1);
            $cell{crit} .="Return From" if ($i==2);




            $tmp_hash{'name'}  = $crit;
            $tmp_hash{'value'} = $value;
            push @criteria_loop, \%tmp_hash;
            my $value_dt = eval { dt_from_string( $value ) };
            $value = output_pref( { dt => $value_dt, dateonly => 1, dateformat => 'iso' } )
                if ( $value_dt );

            $query_criteria .= " AND $crit='$value'";
        }

                    $tmp_hash{'name'}  = "$crit Start";
                    $tmp_hash{'value'} = $value;
                    push @criteria_loop, \%tmp_hash;
                    my $value_dt = eval { dt_from_string( $value ) };
                    $value = output_pref( { dt => $value_dt, dateonly => 1, dateformat => 'iso' } )
                        if ( $value_dt );

                    $query_criteria .= " AND $crit >= '$value'";
                }

                    $tmp_hash{'name'}  = "$crit End";
                    $tmp_hash{'value'} = $value;
                    push @criteria_loop, \%tmp_hash;
                    my $value_dt = eval { dt_from_string( $value ) };
                    $value = output_pref( { dt => $value_dt, dateonly => 1, dateformat => 'iso' } )
                        if ( $value_dt );

                    $query_criteria .= " AND $crit <= '$value'";
                }




use C4::Context;
use Koha::Caches;
use C4::Log qw( logaction );
use Koha::DateUtils qw( dt_from_string output_pref );
use Koha::AuthorisedValue;
use Koha::AuthorisedValues;
use Koha::BiblioFrameworks;


        # If value is not defined, then it may be range values
        if (!defined $value) {

            my $fromvalue = $input->param( "from_" . $crit . "_value" );
            my $tovalue   = $input->param( "to_"   . $crit . "_value" );

            # If the range values are dates
            my $fromvalue_dt;
            $fromvalue_dt = eval { dt_from_string( $fromvalue ); } if ( $fromvalue );
            my $tovalue_dt;
            $tovalue_dt = eval { dt_from_string( $tovalue ); } if ($tovalue);
            if ( $fromvalue_dt && $tovalue_dt ) {
                $fromvalue = output_pref( { dt => dt_from_string( $fromvalue_dt ), dateonly => 1, dateformat => 'iso' } );
                $tovalue   = output_pref( { dt => dt_from_string( $tovalue_dt ), dateonly => 1, dateformat => 'iso' } );
            }

            if ($fromvalue && $tovalue) {
                $query_criteria .= " AND $crit >= '$fromvalue' AND $crit <= '$tovalue'";
            }

        } else {

            # If value is a date
            my $value_dt;
            $value_dt  =  eval { dt_from_string( $value ); } if ( $value );
            if ( $value_dt ) {
                $value = output_pref( { dt => dt_from_string( $value_dt ), dateonly => 1, dateformat => 'iso' } );
            }
            # don't escape runtime parameters, they'll be at runtime
            if ($value =~ /<<.*>>/) {
                $query_criteria .= " AND $crit=$value";




use C4::Context;
use C4::Output qw( output_html_with_http_headers );
use C4::Reports qw( GetDelimiterChoices );
use Koha::DateUtils qw( dt_from_string output_pref );
use Koha::ItemTypes;
use Koha::Patron::Categories;
use Date::Calc qw( Delta_Days );

my $line = $input->param("Line");
my $column = $input->param("Column");
my @filters = $input->multi_param("Filter");
$filters[0] = eval { output_pref( { dt => dt_from_string( $filters[0]), dateonly => 1, dateformat => 'iso' } ); }
    if ( $filters[0] );
$filters[1] = eval { output_pref( { dt => dt_from_string( $filters[1]), dateonly => 1, dateformat => 'iso' } ); }
    if ( $filters[1] );
$filters[2] = eval { output_pref( { dt => dt_from_string( $filters[2]), dateonly => 1, dateformat => 'iso' } ); }
    if ( $filters[2] );
$filters[3] = eval { output_pref( { dt => dt_from_string( $filters[3]), dateonly => 1, dateformat => 'iso' } ); }
    if ( $filters[3] );


my $podsp = $input->param("IssueDisplay");
my $rodsp = $input->param("ReturnDisplay");

            if (($i==1) and (@$filters[$i-1])) {
                $cell{err} = 1 if (@$filters[$i]<@$filters[$i-1]) ;
            }
            $cell{filter} .= @$filters[$i];
            if ($i>=4) {
                $cell{filter} .= @$filters[$i];
            } else {
                $cell{filter} .= eval { output_pref( { dt => dt_from_string( @$filters[$i] ), dateonly => 1 }); }
                   if ( @$filters[$i] );
            }
            $cell{crit} .="Issue From" if ($i==0);
            $cell{crit} .="Issue To" if ($i==1);
            $cell{crit} .="Issue Month" if ($i==2);




use C4::Reports qw( GetDelimiterChoices );

use Koha::AuthorisedValues;
use Koha::DateUtils qw( dt_from_string output_pref );
use Koha::ItemTypes;
use Koha::Patron::Attribute::Types;


my $line     = $input->param("Line");
my $column   = $input->param("Column");
my @filters  = $input->multi_param("Filter");
$filters[0] = eval { output_pref( { dt => dt_from_string( $filters[0]), dateonly => 1, dateformat => 'iso' } ); }
    if ( $filters[0] );
$filters[1] = eval { output_pref( { dt => dt_from_string( $filters[1]), dateonly => 1, dateformat => 'iso' } ); }
    if ( $filters[1] );
my $podsp    = $input->param("DisplayBy");
my $type     = $input->param("PeriodTypeSel");
my $daysel   = $input->param("PeriodDaySel");

            $cell{err} = 1 if ( @$filters[$i] < @$filters[ $i - 1 ] );
        }
            # format the dates filters, otherwise just fill as is
        $cell{filter} = @$filters[$i];
            $cell{filter} = @$filters[$i];
        } else {
            $cell{filter} = eval { output_pref( { dt => dt_from_string( @$filters[$i] ), dateonly => 1 }); }
              if ( @$filters[$i] );
        }
        $cell{crit} = $i;

        push @loopfilter, \%cell;




use C4::Budgets qw( GetBudgetsReport GetBudgetHierarchy );
use C4::Acquisition qw( GetBasket get_rounded_price );
use Koha::Biblios;
use Koha::DateUtils qw( dt_from_string output_pref );

my $query = CGI->new;
my ( $template, $loggedinuser, $cookie ) = get_template_and_user(

        $order->{'total_rrp'} = get_rounded_price($order->{'quantity'}) * $order->{'rrp'};
        $order->{'total_ecost'} = get_rounded_price($order->{'quantity'}) * $order->{'ecost'};

        # Format the currencies correctly
        $order->{'datereceived'} = output_pref(dt_from_string($order->{'datereceived'}));
        $order->{'entrydate'} = output_pref(dt_from_string($order->{'entrydate'}));
        $total_quantity += $order->{'quantity'};
        $total_rrp += $order->{'total_rrp'};
        $total_ecost += $order->{'total_ecost'};




use C4::Reports qw( GetDelimiterChoices );
use C4::Members;
use Koha::AuthorisedValues;
use Koha::DateUtils qw( dt_from_string output_pref );
use Koha::ItemTypes;
use Koha::Libraries;
use Koha::Patron::Categories;

    my @loopfilter;
    foreach my $filter ( keys %$filters_hashref ) {
        $filters_hashref->{$filter} =~ s/\*/%/;
        if ( $filter =~ /date/ ) {
            $filters_hashref->{$filter} =
                eval { output_pref( { dt => dt_from_string( $filters_hashref->{$filter} ), dateonly => 1, dateformat => 'iso' }); };
        }
    }

    #display
    @loopfilter = map {
        {
            crit   => $_,
            filter => $filters_hashref->{$_},
                $_ =~ /date/
                ? eval { output_pref( { dt => dt_from_string( $filters_hashref->{$_} ), dateonly => 1 }); }
                : $filters_hashref->{$_}
            )
        }
    } sort keys %$filters_hashref;





use C4::Output;
use C4::Reserves qw( ModReserve ModReserveCancelAll );
use C4::Auth qw( get_template_and_user );
use Koha::DateUtils qw( dt_from_string );
use Koha::BackgroundJob::BatchUpdateBiblioHoldsQueue;

my $query = CGI->new;

        my $params = {
            rank => $rank[$i],
            reserve_id => $reserve_id[$i],
            expirationdate => $expirationdates[$i] || undef,
            branchcode => $branch[$i],
            itemnumber => $itemnumber[$i],
            defined $suspend_until ? ( suspend_until => $suspend_until ) : (),
            cancellation_reason => $cancellation_reason,
        };
        if (C4::Context->preference('AllowHoldDateInFuture')) {
            $params->{reservedate} = $reservedates[$i] || undef;
        }

        try {




use C4::Koha qw( getitemtypeimagelocation );
use C4::Serials qw( CountSubscriptionFromBiblionumber );
use C4::Circulation qw( GetTransfers _GetCircControlBranch GetBranchItemRule );
use Koha::DateUtils qw( dt_from_string );
use C4::Search qw( enabled_staff_search_views );

use Koha::Biblios;
use Koha::DateUtils qw( dt_from_string output_pref );
use Koha::Checkouts;
use Koha::Holds;
use Koha::CirculationRules;

my $exceeded_maxreserves;
my $exceeded_holds_per_record;

my $date = output_pref({ dt => dt_from_string, dateformat => 'iso', dateonly => 1 });
my $action = $input->param('action');
$action ||= q{};


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

                    $item->{backgroundcolor} = 'reserved';
                    $item->{reservedate}     = $first_hold->reservedate;
                    $item->{ReservedFor}     = $p;
                    $item->{ExpectedAtLibrary}     = $first_hold->branchcode;
                    $item->{waitingdate} = $first_hold->waitingdate;

                  GetTransfers($item_object->itemnumber); # FIXME replace with get_transfer

                if ( defined $transfertwhen && $transfertwhen ne '' ) {
                    $item->{transfertwhen} = $transfertwhen;
                    $item->{transfertfrom} = $transfertfrom;
                    $item->{transfertto} = $transfertto;
                    $item->{nocancel} = 1;

        $template->param(
                         itemdata_enumchron => $itemdata_enumchron,
                         itemdata_ccode    => $itemdata_ccode,
                         date              => dt_from_string,
                         biblionumber      => $biblionumber,
                         findborrower      => $findborrower,
                         biblio            => $biblio,




use C4::Serials qw( GetSerials GetSerials2 GetSerialInformation HasSubscriptionExpired GetSubscription abouttoexpire NewIssue ModSerialStatus GetPreviousSerialid AddItem2Serial );
use C4::Search qw( enabled_staff_search_views );

use Koha::DateUtils qw( dt_from_string );
use Koha::Items;
use Koha::Serial::Items;


my @serialdatalist;
my %processedserialid;

my $today = dt_from_string;

foreach my $serialid (@serialids) {


    {
        my $serinfo = GetSerialInformation($serialid); #TODO duplicates work done by GetSerials2 above

        for my $d ( qw( publisheddate planneddate )){
            if ( $serinfo->{$d} =~m/^00/ ) {
                $serinfo->{$d} = q{};
            }
            else {
                $serinfo->{$d} = output_pref( { dt => dt_from_string( $serinfo->{$d} ), dateonly => 1 } );
            }
        }
        $serinfo->{arriveddate} = $today;

        $serinfo->{'editdisable'} = (

        my ($plan_date, $pub_date);

        if (defined $planneddates[$i] && $planneddates[$i] ne 'XXX') {
            $plan_date = $planneddates[$i];
        }
        if (defined $publisheddates[$i] && $publisheddates[$i] ne 'XXX') {
            $pub_date = $publisheddates[$i];
        }

        if ( $serialids[$i] && $serialids[$i] eq 'NEW' ) {




    }
}

my $expiration_date_dt = $expiration_date ? dt_from_string( $expiration_date ) : undef;
my @subscriptions;
my $mana_statuscode;
if ($searched){

            branch       => $branch,
            additional_fields => \@additional_field_filters,
            location     => $location,
            expiration_date => $expiration_date,
        });
    }
}

        bookseller_filter  => $bookseller,
        branch_filter => $branch,
        location_filter => $location,
        expiration_date_filter => $expiration_date,
        done_searched => $searched,
        routing       => $routing,
        additional_field_filters => \@additional_field_filters,

        bookseller_filter  => $bookseller,
        branch_filter => $branch,
        location_filter => $location,
        expiration_date_filter => $expiration_date,
        branches_loop => \@branches_loop,
        done_searched => $searched,
        routing       => $routing,




use C4::Output qw( output_html_with_http_headers );
use C4::Serials qw( GetSubscription GetFictiveIssueNumber GetSeq GetSubscriptionIrregularities GetNextDate GetNextSeq );
use C4::Serials::Frequency;
use Koha::DateUtils qw( dt_from_string );

my $input = CGI->new;
my ($template, $loggedinuser, $cookie, $flags) = get_template_and_user( {

    every3          => scalar $input->param('every3') // '',
);

$firstacquidate = $firstacquidate ? dt_from_string($firstacquidate)->ymd : dt_from_string->ymd;
    or output_pref( { dt => dt_from_string, dateonly => 1, dateformat => 'iso' } );

$enddate = dt_from_string($enddate)->ymd;

$nextacquidate = $nextacquidate ? dt_from_string($nextacquidate)->ymd : $firstacquidate;
    $nextacquidate =  eval { output_pref( { str => $nextacquidate, dateonly => 1, dateformat => 'iso' } ); };
} else {
    $nextacquidate = $firstacquidate;
}
my $date = $nextacquidate;

my %subscription = (

    innerloop3      => scalar $input->param('innerloop3') // '',
    irregularity    => '',
    countissuesperunit  => 1,
    firstacquidate  => $firstacquidate->ymd,
);

my $issuenumber;

Lines 165-170 if ( $op =~ /save/i ) { Link Here

(-)a/suggestion/suggestion.pl (+1 lines)
165	else {	165	else {
166		166
167	for my $date_key ( qw( suggesteddate manageddate accepteddate rejecteddate ) ) {	167	for my $date_key ( qw( suggesteddate manageddate accepteddate rejecteddate ) ) {
		168	# FIXME Do we need this?
168	$suggestion_only->{$date_key} = dt_from_string( $suggestion_only->{$date_key} )	169	$suggestion_only->{$date_key} = dt_from_string( $suggestion_only->{$date_key} )
169	if $suggestion_only->{$date_key};	170	if $suggestion_only->{$date_key};
170	}	171	}




t::lib::Mocks::mock_preference('AllowHoldDateInFuture', 1);
my $resdate= dt_from_string();
$resdate->add_duration(DateTime::Duration->new(days => 4));
$resdate=output_pref($resdate);
my $reserve_id = AddReserve(
    {
        branchcode       => $branch_1,

        borrowernumber   => $requesters{$branch_1},
        biblionumber     => $bibnum,
        priority         => 2,
        reservation_date => dt_from_string(),
    }
);
my $which_highest;

t::lib::Mocks::mock_preference('AllowHoldDateInFuture', 1);
$resdate= dt_from_string();
$resdate->add_duration(DateTime::Duration->new(days => 2));
$resdate=output_pref($resdate);
AddReserve(
    {
        branchcode       => $branch_1,

        borrowernumber => $requesters{'CPL2'},
        biblionumber   => $bibnum,
        priority       => $p,
        reservation_date => $resdate,
    }
);
$p = C4::Reserves::CalculatePriority($bibnum);

    borrowernumber => $borrowernumber_tmp_1,
    biblionumber => $bibnum,
    priority => 3,
    reservation_date => $date_in_future
});
AddReserve({
    branch => 'CPL',
    borrowernumber => $borrowernumber_tmp_2,
    biblionumber => $bibnum,
    priority => 4,
    reservation_date => $date_in_future
});
my @r1 = Koha::Holds->search({ borrowernumber => $borrowernumber_tmp_1 })->as_list;
my @r2 = Koha::Holds->search({ borrowernumber => $borrowernumber_tmp_2 })->as_list;

#   hold from A pos 1, tomorrow, no fut holds: not filled
$resdate= dt_from_string();
$resdate->add_duration(DateTime::Duration->new(days => 1));
$resdate=output_pref($resdate);
AddReserve(
    {
        branchcode     => $branch_1,

#   hold from A pos 1, today+3, fut holds=2: MoveReserve should not fill it
$resdate= dt_from_string();
$resdate->add_duration(DateTime::Duration->new(days => 3));
$resdate=output_pref($resdate);
AddReserve(
    {
        branchcode     => $branch_1,




    is($result_1, 2, 'Got the expected 2 from update claim with 2 serial ids');

    my @late_or_missing_issues_1_0 = C4::Serials::GetLateOrMissingIssues(undef, $serial1->serialid);
    is(output_pref({str => $late_or_missing_issues_1_0[0]->{claimdate}, dateonly => 1}), $today, 'Got the expected first different claim date from update claim');
    is($late_or_missing_issues_1_0[0]->{claims_count}, $claim_count_1+1, 'Got the expected first claim count from update claim');
    is($late_or_missing_issues_1_0[0]->{status}, 7, 'Got the expected first claim status from update claim');

    my @late_or_missing_issues_1_1 = C4::Serials::GetLateOrMissingIssues(undef, $serial2->serialid);
    is(output_pref({str => $late_or_missing_issues_1_1[0]->{claimdate}, dateonly => 1}), $today, 'Got the expected second different claim date from update claim');
    is($late_or_missing_issues_1_1[0]->{claims_count}, $claim_count_1+1, 'Got the expected second claim count from update claim');
    is($late_or_missing_issues_1_1[0]->{status}, 7, 'Got the expected second claim status from update claim');

    my @late_or_missing_issues_1_2 = C4::Serials::GetLateOrMissingIssues(undef, $serial3->serialid);
    is(output_pref({str => $late_or_missing_issues_1_2[0]->{claimdate}, dateonly => 1}), output_pref({ dt => $claimdate_1, dateonly => 1}), 'Got the expected unchanged claim date from update claim');
    is($late_or_missing_issues_1_2[0]->{claims_count}, $claim_count_1, 'Got the expected unchanged claim count from update claim');
    is($late_or_missing_issues_1_2[0]->{status}, 3, 'Got the expected unchanged claim status from update claim');
};




use URI::Escape qw( uri_escape_utf8 );
use C4::Auth qw( check_cookie_auth get_template_and_user );
use C4::Context;
use Koha::DateUtils qw( dt_from_string output_pref );
use C4::Output qw( output_with_http_headers is_ajax pagination_bar output_html_with_http_headers );
use C4::Tags qw(
    approval_counts

    $template->param(filter_tag=>$filter);
    $filters{term} = $filter;
}
if ( $filter = $input->param('from') ) {
    $date_from = $filter;
    $template->param( filter_date_approved_from => $filter );
    $filters{date_approved} = ">=$date_from";
        $filters{date_approved} = ">=$date_from";
    } else {
        push @errors, {date_from=>$filter};
    }
}
if ( $filter = $input->param('to') ) {
    $date_to = $filter;
    $template->param( filter_date_approved_to => $filter );
    $filters{date_approved} = "<=$date_to";
        $filters{date_approved} = "<=$date_to";
    } else {
        push @errors, {date_to=>$filter};
    }
}
if ($filter = $input->param('approver')) {      # name (or borrowernumber) from input box
    if ($filter =~ /^\d+$/ and $filter > 0) {

Lines 91-101 elsif ( $op eq 'add_validate' ) { Link Here

(-)a/tools/additional-contents.pl (-5 / +2 lines)
91		91
92	my @lang = $cgi->multi_param('lang');	92	my @lang = $cgi->multi_param('lang');
93		93
94	my $expirationdate;	94	my $expirationdate = $cgi->param('expirationdate');
95	if ( $cgi->param('expirationdate') ) {	95	my $published_on = $cgi->param('published_on');
96	$expirationdate = dt_from_string( scalar $cgi->param('expirationdate') );
97	}
98	my $published_on = dt_from_string( scalar $cgi->param('published_on') );
99	my $number = $cgi->param('number');	96	my $number = $cgi->param('number');
100		97
101	my $original_default = $idnew ? Koha::AdditionalContents->find($idnew) : undef;	98	my $original_default = $idnew ? Koha::AdditionalContents->find($idnew) : undef;

Lines 31-37 use List::MoreUtils qw( uniq ); Link Here

(-)a/tools/batchMod.pl (-1 lines)
31	use Encode qw( encode_utf8 );	31	use Encode qw( encode_utf8 );
32		32
33	use Koha::Database;	33	use Koha::Database;
34	use Koha::DateUtils qw( dt_from_string );
35	use Koha::Exception;	34	use Koha::Exception;
36	use Koha::Biblios;	35	use Koha::Biblios;
37	use Koha::Items;	36	use Koha::Items;




use C4::Auth qw( get_template_and_user );
use C4::Output qw( output_html_with_http_headers );
use Koha::Checkouts;
use Koha::DateUtils qw( dt_from_string );

my $input = CGI->new;
my $op = $input->param('op') // q|form|;

        if ($preview_results) {
            push(
                @new_due_dates,
                calc_new_due_date(
                    {
                        due_date => dt_from_string( $checkout->date_due ),
                        new_hard_due_date => $new_hard_due_date,
                        add_days          => $due_date_days
                                  dt_from_string( $checkout->date_due ),
                                new_hard_due_date => $new_hard_due_date,
                                add_days          => $due_date_days
                            }
                        ),
                        dateformat => 'iso'
                    }
                ),
            );
        } else {
            push( @issue_ids, $checkout->id );

    if ( $preview_results ) {
        $template->param(
            checkouts         => $checkouts,
            new_hard_due_date => $new_hard_due_date,
            ? dt_from_string($new_hard_due_date)
            : undef,
            due_date_days => $due_date_days,
            new_due_dates => \@new_due_dates,
            view          => 'list',




use C4::Auth qw( get_template_and_user );
use C4::Output qw( output_html_with_http_headers );
use C4::Members qw( GetBorrowersToExpunge );
use Koha::DateUtils qw( dt_from_string output_pref );
use Koha::Old::Checkouts;
use Koha::Patron::Categories;
use Koha::Patrons;


my $step = $params->{step} || 1;
my $not_borrowed_since =    # the date which filter on issue history.
  $params->{not_borrowed_since};
  ? dt_from_string $params->{not_borrowed_since}
  : undef;
my $last_issue_date =         # the date which filter on borrowers last issue.
  $params->{last_issue_date};
  ? dt_from_string $params->{last_issue_date}
  : undef;
my $borrower_dateexpiry =
  $params->{borrower_dateexpiry}
  ? dt_from_string $params->{borrower_dateexpiry}
  : undef;
my $borrower_lastseen =
  $params->{borrower_lastseen}
  ? dt_from_string $params->{borrower_lastseen}
  : undef;
my $patron_list_id = $params->{patron_list_id};
my $borrower_dateexpiry = $params->{borrower_dateexpiry};
my $borrower_lastseen = $params->{borrower_lastseen};

my $borrower_categorycode = $params->{'borrower_categorycode'} || q{};


        $borrower_categorycode, $patron_list_id, $branch) = @_;

    my $params = {};
    $params->{not_borrowed_since} = $not_borrowed_since;
    $params->{expired_before} = $borrower_dateexpiry;
    $params->{last_seen} = $borrower_lastseen;
        dateonly   => 1
    }) if $not_borrowed_since;
    $params->{expired_before} = output_pref({
        dt         => $borrower_dateexpiry,
        dateformat => 'iso',
        dateonly   => 1
    }) if $borrower_dateexpiry;
    $params->{last_seen} = output_pref({
        dt         => $borrower_lastseen,
        dateformat => 'iso',
        dateonly   => 1
    }) if $borrower_lastseen;
    $params->{category_code} = $borrower_categorycode if $borrower_categorycode;
    $params->{patron_list_id} = $patron_list_id if $patron_list_id;


Lines 39-44 my ($template, $loggedinuser, $cookie) Link Here

(-)a/tools/holidays.pl (+1 lines)
39		39
40	# calendardate - date passed in url for human readability (syspref)	40	# calendardate - date passed in url for human readability (syspref)
41	# if the url has an invalid date default to 'now.'	41	# if the url has an invalid date default to 'now.'
		42	# FIXME There is something to improve in the date handling here
42	my $calendarinput_dt = eval { dt_from_string( scalar $input->param('calendardate') ); } \|\| dt_from_string;	43	my $calendarinput_dt = eval { dt_from_string( scalar $input->param('calendardate') ); } \|\| dt_from_string;
43	my $calendardate = output_pref( { dt => $calendarinput_dt, dateonly => 1 } );	44	my $calendardate = output_pref( { dt => $calendarinput_dt, dateonly => 1 } );
44		45

Lines 36-42 use C4::Reports::Guided qw( ); Link Here

(-)a/tools/inventory.pl (-2 / +2 lines)
36	use C4::Charset qw( NormalizeString );	36	use C4::Charset qw( NormalizeString );
37		37
38	use Koha::Biblios;	38	use Koha::Biblios;
39	use Koha::DateUtils qw( dt_from_string output_pref );	39	use Koha::DateUtils qw( dt_from_string );
40	use Koha::Database::Columns;	40	use Koha::Database::Columns;
41	use Koha::AuthorisedValues;	41	use Koha::AuthorisedValues;
42	use Koha::BiblioFrameworks;	42	use Koha::BiblioFrameworks;
Lines 247-253 if ( ($uploadbarcodes && length($uploadbarcodes) > 0) \|\| ($barcodelist && length Link Here
247	}	247	}
248	}	248	}
249	}	249	}
250	$template->param( date => output_pref ( { str => $date, dateformat => 'iso' } ) );	250	$template->param( date => $date );
251	$template->param( errorloop => \@errorloop ) if (@errorloop);	251	$template->param( errorloop => \@errorloop ) if (@errorloop);
252	}	252	}
253		253




use C4::Auth qw( get_template_and_user );
use CGI qw ( -utf8 );
use C4::Output qw( output_html_with_http_headers );
use Koha::DateUtils qw( dt_from_string );;

my $input = CGI->new;
my $base;


if ( $mode eq 'job_add' ) {

    my $startdate = dt_from_string( scalar $input->param('startdate') )->ymd;
    my $c4date = output_pref({ dt => dt_from_string( scalar $input->param('startdate') ), dateformat => 'iso', dateonly => 1 });

    # Formatting it for Schedule::At
    my $startdate = join('', (split /-/, $c4date));

    my $starttime = $input->param('starttime');
    $starttime =~ s/\://g;
- 

Return to bug 30718

Lines 698-703 sub RenewLoan { Link Here

(-)a/C4/ILSDI/Services.pm (-18 / +5 lines)
698	# Hashref building	698	# Hashref building
699	my $out;	699	my $out;
700	$out->{'renewals'} = $issue->renewals_count;	700	$out->{'renewals'} = $issue->renewals_count;
		701	# FIXME Unusual date formatting
701	$out->{date_due} = dt_from_string($issue->date_due)->strftime('%Y-%m-%d %H:%M');	702	$out->{date_due} = dt_from_string($issue->date_due)->strftime('%Y-%m-%d %H:%M');
702	$out->{'success'} = $renewal[0];	703	$out->{'success'} = $renewal[0];
703	$out->{'error'} = $renewal[1];	704	$out->{'error'} = $renewal[1];
Lines 778-792 sub HoldTitle { Link Here
778	return { code => 'libraryNotPickupLocation' } unless $destination->pickup_location;	779	return { code => 'libraryNotPickupLocation' } unless $destination->pickup_location;
779	return { code => 'cannotBeTransferred' } unless $biblio->can_be_transferred({ to => $destination });	780	return { code => 'cannotBeTransferred' } unless $biblio->can_be_transferred({ to => $destination });
780		781
781	my $resdate;	782	my $resdate = $cgi->param('start_date');
782	if ( $cgi->param('start_date') ) {	783	my $expdate = $cgi->param('expiry_date');
783	$resdate = $cgi->param('start_date');
784	}
785
786	my $expdate;
787	if ( $cgi->param('expiry_date') ) {
788	$expdate = $cgi->param('expiry_date');
789	}
790		784
791	# Add the reserve	785	# Add the reserve
792	# $branch, $borrowernumber, $biblionumber,	786	# $branch, $borrowernumber, $biblionumber,
Lines 880-894 sub HoldItem { Link Here
880	my $canitembereserved = C4::Reserves::CanItemBeReserved( $patron, $item, $branch )->{status};	874	my $canitembereserved = C4::Reserves::CanItemBeReserved( $patron, $item, $branch )->{status};
881	return { code => $canitembereserved } unless $canitembereserved eq 'OK';	875	return { code => $canitembereserved } unless $canitembereserved eq 'OK';
882		876
883	my $resdate;	877	my $resdate = $cgi->param('start_date');
884	if ( $cgi->param('start_date') ) {	878	my $expdate = $cgi->param('expiry_date');
885	$resdate = $cgi->param('start_date');
886	}
887
888	my $expdate;
889	if ( $cgi->param('expiry_date') ) {
890	$expdate = $cgi->param('expiry_date');
891	}
892		879
893	# Add the reserve	880	# Add the reserve
894	my $priority = C4::Reserves::CalculatePriority($biblionumber);	881	my $priority = C4::Reserves::CalculatePriority($biblionumber);

Lines 38-44 use Koha::Biblios; Link Here

(-)a/C4/Reserves.pm (-12 / +3 lines)
38	use Koha::Calendar;	38	use Koha::Calendar;
39	use Koha::CirculationRules;	39	use Koha::CirculationRules;
40	use Koha::Database;	40	use Koha::Database;
41	use Koha::DateUtils qw( dt_from_string output_pref );	41	use Koha::DateUtils qw( dt_from_string );
42	use Koha::Hold;	42	use Koha::Hold;
43	use Koha::Holds;	43	use Koha::Holds;
44	use Koha::ItemTypes;	44	use Koha::ItemTypes;
Lines 194-203 sub AddReserve { Link Here
194	my $itemtype = $params->{itemtype};	194	my $itemtype = $params->{itemtype};
195	my $non_priority = $params->{non_priority};	195	my $non_priority = $params->{non_priority};
196		196
197	$resdate = output_pref( { str => dt_from_string( $resdate ), dateonly => 1, dateformat => 'iso' })	197	$resdate \|\|= dt_from_string;
198	or output_pref({ dt => dt_from_string, dateonly => 1, dateformat => 'iso' });
199
200	$patron_expiration_date = output_pref({ str => $patron_expiration_date, dateonly => 1, dateformat => 'iso' });
201		198
202	# if we have an item selectionned, and the pickup branch is the same as the holdingbranch	199	# if we have an item selectionned, and the pickup branch is the same as the holdingbranch
203	# of the document, we force the value $priority and $found .	200	# of the document, we force the value $priority and $found .
Lines 1123-1129 sub ModReserve { Link Here
1123	if C4::Context->preference('HoldsLog');	1120	if C4::Context->preference('HoldsLog');
1124		1121
1125	# The only column that can be updated for a found hold is the expiration date	1122	# The only column that can be updated for a found hold is the expiration date
1126	$hold->expirationdate(dt_from_string($date))->store();	1123	$hold->expirationdate($date)->store();
1127	}	1124	}
1128	elsif ($rank =~ /^\d+/ and $rank > 0) {	1125	elsif ($rank =~ /^\d+/ and $rank > 0) {
1129	logaction( 'HOLDS', 'MODIFY', $hold->reserve_id, $hold )	1126	logaction( 'HOLDS', 'MODIFY', $hold->reserve_id, $hold )
Lines 1147-1153 sub ModReserve { Link Here
1147		1144
1148	if ( defined( $suspend_until ) ) {	1145	if ( defined( $suspend_until ) ) {
1149	if ( $suspend_until ) {	1146	if ( $suspend_until ) {
1150	$suspend_until = eval { dt_from_string( $suspend_until ) };
1151	$hold->suspend_hold( $suspend_until );	1147	$hold->suspend_hold( $suspend_until );
1152	} else {	1148	} else {
1153	# If the hold is suspended leave the hold suspended, but convert it to an indefinite hold.	1149	# If the hold is suspended leave the hold suspended, but convert it to an indefinite hold.
Lines 1520-1527 be cleared when it is unsuspended. Link Here
1520	sub ToggleSuspend {	1516	sub ToggleSuspend {
1521	my ( $reserve_id, $suspend_until ) = @_;	1517	my ( $reserve_id, $suspend_until ) = @_;
1522		1518
1523	$suspend_until = dt_from_string($suspend_until) if ($suspend_until);
1524
1525	my $hold = Koha::Holds->find( $reserve_id );	1519	my $hold = Koha::Holds->find( $reserve_id );
1526		1520
1527	if ( $hold->is_suspended ) {	1521	if ( $hold->is_suspended ) {
Lines 1555-1563 sub SuspendAll { Link Here
1555	my $suspend_until = $params{'suspend_until'} \|\| undef;	1549	my $suspend_until = $params{'suspend_until'} \|\| undef;
1556	my $suspend = defined( $params{'suspend'} ) ? $params{'suspend'} : 1;	1550	my $suspend = defined( $params{'suspend'} ) ? $params{'suspend'} : 1;
1557		1551
1558	$suspend_until = eval { dt_from_string($suspend_until) }
1559	if ( defined($suspend_until) );
1560
1561	return unless ( $borrowernumber \|\| $biblionumber );	1552	return unless ( $borrowernumber \|\| $biblionumber );
1562		1553
1563	my $params;	1554	my $params;

Lines 27-33 use C4::Biblio qw( GetMarcFromKohaField GetMarcStructure IsMarcStructureInternal Link Here

(-)a/C4/Acquisition.pm (-9 / +4 lines)
27	use C4::Contract qw( GetContract );	27	use C4::Contract qw( GetContract );
28	use C4::Log qw( logaction );	28	use C4::Log qw( logaction );
29	use C4::Templates qw(gettemplate);	29	use C4::Templates qw(gettemplate);
30	use Koha::DateUtils qw( dt_from_string output_pref );	30	use Koha::DateUtils qw( dt_from_string );
31	use Koha::Acquisition::Baskets;	31	use Koha::Acquisition::Baskets;
32	use Koha::Acquisition::Booksellers;	32	use Koha::Acquisition::Booksellers;
33	use Koha::Acquisition::Orders;	33	use Koha::Acquisition::Orders;
Lines 1372-1384 sub ModReceiveOrder { Link Here
1372	my $received_items = $params->{received_items};	1372	my $received_items = $params->{received_items};
1373		1373
1374	my $dbh = C4::Context->dbh;	1374	my $dbh = C4::Context->dbh;
1375	$datereceived = output_pref(	1375	$datereceived = $datereceived ? dt_from_string( $datereceived ) : dt_from_string;
1376	{	1376	$datereceived = $datereceived->ymd;
1377	dt => ( $datereceived ? dt_from_string( $datereceived ) : dt_from_string ),
1378	dateformat => 'iso',
1379	dateonly => 1,
1380	}
1381	);
1382		1377
1383	my $suggestionid = GetSuggestionFromBiblionumber( $biblionumber );	1378	my $suggestionid = GetSuggestionFromBiblionumber( $biblionumber );
1384	if ($suggestionid) {	1379	if ($suggestionid) {
Lines 2704-2710 sub CloseInvoice { Link Here
2704		2699
2705	Reopen an invoice	2700	Reopen an invoice
2706		2701
2707	Equivalent to ModInvoice(invoiceid => $invoiceid, closedate => output_pref({ dt=>dt_from_string, dateonly=>1, otputpref=>'iso' }))	2702	Equivalent to ModInvoice(invoiceid => $invoiceid, closedate => $closedate );
2708		2703
2709	=cut	2704	=cut
2710		2705

Lines 24-30 use POSIX qw( floor ); Link Here

(-)a/C4/Circulation.pm (-19 / +15 lines)
24	use YAML::XS;	24	use YAML::XS;
25	use Encode;	25	use Encode;
26		26
27	use Koha::DateUtils qw( dt_from_string output_pref );
28	use C4::Context;	27	use C4::Context;
29	use C4::Stats qw( UpdateStats );	28	use C4::Stats qw( UpdateStats );
30	use C4::Reserves qw( CheckReserves CanItemBeReserved MoveReserve ModReserve ModReserveMinusPriority RevertWaitingStatus IsItemOnHoldAndFound IsAvailableForItemLevelRequest ItemsAnyAvailableAndNotRestricted );	29	use C4::Reserves qw( CheckReserves CanItemBeReserved MoveReserve ModReserve ModReserveMinusPriority RevertWaitingStatus IsItemOnHoldAndFound IsAvailableForItemLevelRequest ItemsAnyAvailableAndNotRestricted );
Lines 43-49 use Koha::Account; Link Here
43	use Koha::AuthorisedValues;	42	use Koha::AuthorisedValues;
44	use Koha::BackgroundJob::BatchUpdateBiblioHoldsQueue;	43	use Koha::BackgroundJob::BatchUpdateBiblioHoldsQueue;
45	use Koha::Biblioitems;	44	use Koha::Biblioitems;
46	use Koha::DateUtils qw( dt_from_string output_pref );	45	use Koha::DateUtils qw( dt_from_string );
47	use Koha::Calendar;	46	use Koha::Calendar;
48	use Koha::Checkouts;	47	use Koha::Checkouts;
49	use Koha::Illrequests;	48	use Koha::Illrequests;
Lines 798-804 sub CanBookBeIssued { Link Here
798	my $now = dt_from_string();	797	my $now = dt_from_string();
799	$duedate \|\|= CalcDateDue( $now, $effective_itemtype, $circ_library->branchcode, $patron_unblessed );	798	$duedate \|\|= CalcDateDue( $now, $effective_itemtype, $circ_library->branchcode, $patron_unblessed );
800	if (DateTime->compare($duedate,$now) == -1 ) { # duedate cannot be before now	799	if (DateTime->compare($duedate,$now) == -1 ) { # duedate cannot be before now
801	$needsconfirmation{INVALID_DATE} = output_pref($duedate);	800	$needsconfirmation{INVALID_DATE} = $duedate;
802	}	801	}
803		802
804	my $fees = Koha::Charges::Fees->new(	803	my $fees = Koha::Charges::Fees->new(
Lines 1235-1253 sub CanBookBeIssued { Link Here
1235	my $check = checkHighHolds( $item_object, $patron );	1234	my $check = checkHighHolds( $item_object, $patron );
1236		1235
1237	if ( $check->{exceeded} ) {	1236	if ( $check->{exceeded} ) {
		1237	my $highholds = {
		1238	num_holds => $check->{outstanding},
		1239	duration => $check->{duration},
		1240	returndate => $check->{due_date},
		1241	};
1238	if ($override_high_holds) {	1242	if ($override_high_holds) {
1239	$alerts{HIGHHOLDS} = {	1243	$alerts{HIGHHOLDS} = $highholds;
1240	num_holds => $check->{outstanding},
1241	duration => $check->{duration},
1242	returndate => output_pref( { dt => dt_from_string($check->{due_date}), dateformat => 'iso', timeformat => '24hr' }),
1243	};
1244	}	1244	}
1245	else {	1245	else {
1246	$needsconfirmation{HIGHHOLDS} = {	1246	$needsconfirmation{HIGHHOLDS} = $highholds;
1247	num_holds => $check->{outstanding},
1248	duration => $check->{duration},
1249	returndate => output_pref( { dt => dt_from_string($check->{due_date}), dateformat => 'iso', timeformat => '24hr' }),
1250	};
1251	}	1247	}
1252	}	1248	}
1253	}	1249	}
Lines 1462-1469 Calculated if empty. Link Here
1462		1458
1463	=item C<$cancelreserve> is 1 to override and cancel any pending reserves for the item (optional).	1459	=item C<$cancelreserve> is 1 to override and cancel any pending reserves for the item (optional).
1464		1460
1465	=item C<$issuedate> is the date to issue the item in iso (YYYY-MM-DD) format (optional).	1461	=item C<$issuedate> is a DateTime object for the date to issue the item (optional).
1466	Defaults to today. Unlike C<$datedue>, NOT a DateTime object, unfortunately.	1462	Defaults to today.
1467		1463
1468	AddIssue does the following things :	1464	AddIssue does the following things :
1469		1465
Lines 1635-1642 sub AddIssue { Link Here
1635		1631
1636	my $issue_attributes = {	1632	my $issue_attributes = {
1637	borrowernumber => $borrower->{'borrowernumber'},	1633	borrowernumber => $borrower->{'borrowernumber'},
1638	issuedate => $issuedate->strftime('%Y-%m-%d %H:%M:%S'),	1634	issuedate => $issuedate,
1639	date_due => $datedue->strftime('%Y-%m-%d %H:%M:%S'),	1635	date_due => $datedue,
1640	branchcode => C4::Context->userenv->{'branch'},	1636	branchcode => C4::Context->userenv->{'branch'},
1641	onsite_checkout => $onsite_checkout,	1637	onsite_checkout => $onsite_checkout,
1642	auto_renew => $auto_renew ? 1 : 0,	1638	auto_renew => $auto_renew ? 1 : 0,
Lines 4417-4423 sub _CalculateAndUpdateFine { Link Here
4417	itemnumber => $issue->itemnumber,	4413	itemnumber => $issue->itemnumber,
4418	borrowernumber => $issue->borrowernumber,	4414	borrowernumber => $issue->borrowernumber,
4419	amount => $amount,	4415	amount => $amount,
4420	due => output_pref($datedue),	4416	due => $datedue,
4421	});	4417	});
4422	}	4418	}
4423	elsif ($return_date) {	4419	elsif ($return_date) {
Lines 4430-4436 sub _CalculateAndUpdateFine { Link Here
4430	itemnumber => $issue->itemnumber,	4426	itemnumber => $issue->itemnumber,
4431	borrowernumber => $issue->borrowernumber,	4427	borrowernumber => $issue->borrowernumber,
4432	amount => 0,	4428	amount => 0,
4433	due => output_pref($datedue),	4429	due => $datedue,
4434	});	4430	});
4435	}	4431	}
4436	}	4432	}

Lines 52-58 use Carp qw( croak ); Link Here

(-)a/C4/Items.pm (-6 / +2 lines)
52	use C4::Context;	52	use C4::Context;
53	use C4::Koha;	53	use C4::Koha;
54	use C4::Biblio qw( GetMarcStructure TransformMarcToKoha );	54	use C4::Biblio qw( GetMarcStructure TransformMarcToKoha );
55	use Koha::DateUtils qw( dt_from_string output_pref );
56	use MARC::Record;	55	use MARC::Record;
57	use C4::ClassSource qw( GetClassSort GetClassSources GetClassSource );	56	use C4::ClassSource qw( GetClassSort GetClassSources GetClassSource );
58	use C4::Log qw( logaction );	57	use C4::Log qw( logaction );
Lines 61-67 use DateTime::Format::MySQL; Link Here
61	# debugging; so please don't remove this	60	# debugging; so please don't remove this
62		61
63	use Koha::AuthorisedValues;	62	use Koha::AuthorisedValues;
64	use Koha::DateUtils qw( dt_from_string output_pref );	63	use Koha::DateUtils qw( dt_from_string );
65	use Koha::Database;	64	use Koha::Database;
66		65
67	use Koha::Biblioitems;	66	use Koha::Biblioitems;
Lines 403-412 The last optional parameter allows for passing skip_record_index through to the Link Here
403	sub ModDateLastSeen {	402	sub ModDateLastSeen {
404	my ( $itemnumber, $leave_item_lost, $params ) = @_;	403	my ( $itemnumber, $leave_item_lost, $params ) = @_;
405		404
406	my $today = output_pref({ dt => dt_from_string, dateformat => 'iso', dateonly => 1 });
407
408	my $item = Koha::Items->find($itemnumber);	405	my $item = Koha::Items->find($itemnumber);
409	$item->datelastseen($today);	406	$item->datelastseen(dt_from_string);
410	$item->itemlost(0) unless $leave_item_lost;	407	$item->itemlost(0) unless $leave_item_lost;
411	$item->store({ log_action => 0, skip_record_index => $params->{skip_record_index}, skip_holds_queue => $params->{skip_holds_queue} });	408	$item->store({ log_action => 0, skip_record_index => $params->{skip_record_index}, skip_holds_queue => $params->{skip_holds_queue} });
412	}	409	}
Lines 587-593 sub GetItemsForInventory { Link Here
587	}	584	}
588		585
589	if ($datelastseen) {	586	if ($datelastseen) {
590	$datelastseen = output_pref({ str => $datelastseen, dateformat => 'iso', dateonly => 1 });
591	push @where_strings, '(datelastseen < ? OR datelastseen IS NULL)';	587	push @where_strings, '(datelastseen < ? OR datelastseen IS NULL)';
592	push @bind_params, $datelastseen;	588	push @bind_params, $datelastseen;
593	}	589	}

Lines 31-36 use C4::Accounts; Link Here

(-)a/C4/Overdues.pm (-3 / +3 lines)
31	use C4::Context;	31	use C4::Context;
32	use Koha::Account::Lines;	32	use Koha::Account::Lines;
33	use Koha::Account::Offsets;	33	use Koha::Account::Offsets;
		34	use Koha::DateUtils qw( output_pref );
34	use Koha::Libraries;	35	use Koha::Libraries;
35	use Koha::Recalls;	36	use Koha::Recalls;
36	use Koha::Logger;	37	use Koha::Logger;
Lines 512-518 has the book on loan. Link Here
512		513
513	C<$amount> is the current amount owed by the patron.	514	C<$amount> is the current amount owed by the patron.
514		515
515	C<$due> is the due date formatted to the currently specified date format	516	C<$due> is the date
516		517
517	C<&UpdateFine> looks up the amount currently owed on the given item	518	C<&UpdateFine> looks up the amount currently owed on the given item
518	and sets it to C<$amount>, creating, if necessary, a new entry in the	519	and sets it to C<$amount>, creating, if necessary, a new entry in the
Lines 552-558 sub UpdateFine { Link Here
552		553
553	my $accountline;	554	my $accountline;
554	my $total_amount_other = 0.00;	555	my $total_amount_other = 0.00;
555	my $due_qr = qr/$due/;
556	# Cycle through the fines and	556	# Cycle through the fines and
557	# - find line that relates to the requested $itemnum	557	# - find line that relates to the requested $itemnum
558	# - accumulate fines for other items	558	# - accumulate fines for other items
Lines 610-616 sub UpdateFine { Link Here
610	items => $itemnum,	610	items => $itemnum,
611	},	611	},
612	) };	612	) };
613	my $desc = $letter ? $letter->{content} : "Item $itemnum - due $due";	613	my $desc = $letter ? $letter->{content} : sprintf("Item %s - due %s", $itemnum, output_pref($due) );
614		614
615	my $account = Koha::Account->new({ patron_id => $borrowernumber });	615	my $account = Koha::Account->new({ patron_id => $borrowernumber });
616	$accountline = $account->add_debit(	616	$accountline = $account->add_debit(

Lines 37-43 use C4::Log qw( logaction ); # logaction Link Here

(-)a/C4/Serials.pm (-45 lines)
37	use C4::Serials::Frequency qw( GetSubscriptionFrequency );	37	use C4::Serials::Frequency qw( GetSubscriptionFrequency );
38	use C4::Serials::Numberpattern;	38	use C4::Serials::Numberpattern;
39	use Koha::AdditionalFieldValues;	39	use Koha::AdditionalFieldValues;
40	use Koha::DateUtils qw( dt_from_string output_pref );
41	use Koha::Serial;	40	use Koha::Serial;
42	use Koha::Subscriptions;	41	use Koha::Subscriptions;
43	use Koha::Subscription::Histories;	42	use Koha::Subscription::Histories;
Lines 426-448 sub GetSubscriptionsFromBiblionumber { Link Here
426	$sth->execute($biblionumber);	425	$sth->execute($biblionumber);
427	my @res;	426	my @res;
428	while ( my $subs = $sth->fetchrow_hashref ) {	427	while ( my $subs = $sth->fetchrow_hashref ) {
429	$subs->{startdate} = output_pref( { dt => dt_from_string( $subs->{startdate} ), dateonly => 1 } );
430	$subs->{histstartdate} = output_pref( { dt => dt_from_string( $subs->{histstartdate} ), dateonly => 1 } );
431	if ( defined $subs->{histenddate} ) {
432	$subs->{histenddate} = output_pref( { dt => dt_from_string( $subs->{histenddate} ), dateonly => 1 } );
433	} else {
434	$subs->{histenddate} = "";
435	}
436	$subs->{opacnote} //= "";	428	$subs->{opacnote} //= "";
437	$subs->{ "periodicity" . $subs->{periodicity} } = 1;	429	$subs->{ "periodicity" . $subs->{periodicity} } = 1;
438	$subs->{ "numberpattern" . $subs->{numberpattern} } = 1;	430	$subs->{ "numberpattern" . $subs->{numberpattern} } = 1;
439	$subs->{ "status" . $subs->{'status'} } = 1;	431	$subs->{ "status" . $subs->{'status'} } = 1;
440		432
441	if (not defined $subs->{enddate} ) {
442	$subs->{enddate} = '';
443	} else {
444	$subs->{enddate} = output_pref( { dt => dt_from_string( $subs->{enddate}), dateonly => 1 } );
445	}
446	$subs->{'abouttoexpire'} = abouttoexpire( $subs->{'subscriptionid'} );	433	$subs->{'abouttoexpire'} = abouttoexpire( $subs->{'subscriptionid'} );
447	$subs->{'subscriptionexpired'} = HasSubscriptionExpired( $subs->{'subscriptionid'} );	434	$subs->{'subscriptionexpired'} = HasSubscriptionExpired( $subs->{'subscriptionid'} );
448	$subs->{cannotedit} = not can_edit_subscription( $subs );	435	$subs->{cannotedit} = not can_edit_subscription( $subs );
Lines 676-688 sub GetSerials { Link Here
676		663
677	while ( my $line = $sth->fetchrow_hashref ) {	664	while ( my $line = $sth->fetchrow_hashref ) {
678	$line->{ "status" . $line->{status} } = 1; # fills a "statusX" value, used for template status select list	665	$line->{ "status" . $line->{status} } = 1; # fills a "statusX" value, used for template status select list
679	for my $datefield ( qw( planneddate publisheddate) ) {
680	if ($line->{$datefield} && $line->{$datefield}!~m/^00/) {
681	$line->{$datefield} = output_pref( { dt => dt_from_string( $line->{$datefield} ), dateonly => 1 } );
682	} else {
683	$line->{$datefield} = q{};
684	}
685	}
686	push @serials, $line;	666	push @serials, $line;
687	}	667	}
688		668
Lines 699-711 sub GetSerials { Link Here
699	while ( ( my $line = $sth->fetchrow_hashref ) && $counter < $count ) {	679	while ( ( my $line = $sth->fetchrow_hashref ) && $counter < $count ) {
700	$counter++;	680	$counter++;
701	$line->{ "status" . $line->{status} } = 1; # fills a "statusX" value, used for template status select list	681	$line->{ "status" . $line->{status} } = 1; # fills a "statusX" value, used for template status select list
702	for my $datefield ( qw( planneddate publisheddate) ) {
703	if ($line->{$datefield} && $line->{$datefield}!~m/^00/) {
704	$line->{$datefield} = output_pref( { dt => dt_from_string( $line->{$datefield} ), dateonly => 1 } );
705	} else {
706	$line->{$datefield} = q{};
707	}
708	}
709		682
710	push @serials, $line;	683	push @serials, $line;
711	}	684	}
Lines 750-764 sub GetSerials2 { Link Here
750		723
751	while ( my $line = $sth->fetchrow_hashref ) {	724	while ( my $line = $sth->fetchrow_hashref ) {
752	$line->{ "status" . $line->{status} } = 1; # fills a "statusX" value, used for template status select list	725	$line->{ "status" . $line->{status} } = 1; # fills a "statusX" value, used for template status select list
753	# Format dates for display
754	for my $datefield ( qw( planneddate publisheddate ) ) {
755	if (!defined($line->{$datefield}) \|\| $line->{$datefield} =~m/^00/) {
756	$line->{$datefield} = q{};
757	}
758	else {
759	$line->{$datefield} = output_pref( { dt => dt_from_string( $line->{$datefield} ), dateonly => 1 } );
760	}
761	}
762	push @serials, $line;	726	push @serials, $line;
763	}	727	}
764	return @serials;	728	return @serials;
Lines 1899-1913 sub GetLateOrMissingIssues { Link Here
1899	$sth->execute( EXPECTED, LATE, CLAIMED );	1863	$sth->execute( EXPECTED, LATE, CLAIMED );
1900	my @issuelist;	1864	my @issuelist;
1901	while ( my $line = $sth->fetchrow_hashref ) {	1865	while ( my $line = $sth->fetchrow_hashref ) {
1902
1903	if ($line->{planneddate} && $line->{planneddate} !~/^0+\-/) {
1904	$line->{planneddateISO} = $line->{planneddate};
1905	$line->{planneddate} = output_pref( { dt => dt_from_string( $line->{"planneddate"} ), dateonly => 1 } );
1906	}
1907	if ($line->{claimdate} && $line->{claimdate} !~/^0+\-/) {
1908	$line->{claimdateISO} = $line->{claimdate};
1909	$line->{claimdate} = output_pref( { dt => dt_from_string( $line->{"claimdate"} ), dateonly => 1 } );
1910	}
1911	$line->{"status".$line->{status}} = 1;	1866	$line->{"status".$line->{status}} = 1;
1912		1867
1913	my $subscription_object = Koha::Subscriptions->find($line->{subscriptionid});	1868	my $subscription_object = Koha::Subscriptions->find($line->{subscriptionid});

Lines 82-95 sub age { Link Here

(-)a/Koha/Hold.pm (-3 / +3 lines)
82		82
83	=head3 suspend_hold	83	=head3 suspend_hold
84		84
85	my $hold = $hold->suspend_hold( $suspend_until_dt );	85	my $hold = $hold->suspend_hold( $suspend_until );
86		86
87	=cut	87	=cut
88		88
89	sub suspend_hold {	89	sub suspend_hold {
90	my ( $self, $dt ) = @_;	90	my ( $self, $date ) = @_;
91		91
92	my $date = $dt ? $dt->clone()->truncate( to => 'day' )->datetime : undef;	92	$date &&= dt_from_string($date)->truncate( to => 'day' )->datetime;
93		93
94	if ( $self->is_found ) { # We can't suspend found holds	94	if ( $self->is_found ) { # We can't suspend found holds
95	if ( $self->is_waiting ) {	95	if ( $self->is_waiting ) {

Lines 26-32 use Koha::Patrons; Link Here

(-)a/Koha/REST/V1/Clubs/Holds.pm (-6 lines)
26	use Koha::Holds;	26	use Koha::Holds;
27	use Koha::Clubs;	27	use Koha::Clubs;
28	use Koha::Club::Hold;	28	use Koha::Club::Hold;
29	use Koha::DateUtils qw( dt_from_string output_pref );
30		29
31	use Scalar::Util qw( blessed );	30	use Scalar::Util qw( blessed );
32	use Try::Tiny qw( catch try );	31	use Try::Tiny qw( catch try );
Lines 103-113 sub add { Link Here
103	);	102	);
104	}	103	}
105		104
106	# AddReserve expects date to be in syspref format
107	if ($expiration_date) {
108	$expiration_date = output_pref( dt_from_string( $expiration_date, 'rfc3339' ) );
109	}
110
111	my $club_hold = Koha::Club::Hold::add(	105	my $club_hold = Koha::Club::Hold::add(
112	{	106	{
113	club_id => $club_id,	107	club_id => $club_id,

Lines 26-32 use C4::Reserves; Link Here

(-)a/Koha/REST/V1/Holds.pm (-26 / +8 lines)
26	use Koha::Items;	26	use Koha::Items;
27	use Koha::Patrons;	27	use Koha::Patrons;
28	use Koha::Holds;	28	use Koha::Holds;
29	use Koha::DateUtils qw( dt_from_string output_pref );	29	use Koha::DateUtils qw( dt_from_string );
30		30
31	use List::MoreUtils qw( any );	31	use List::MoreUtils qw( any );
32	use Try::Tiny qw( catch try );	32	use Try::Tiny qw( catch try );
Lines 183-193 sub add { Link Here
183		183
184	my $priority = C4::Reserves::CalculatePriority($biblio_id);	184	my $priority = C4::Reserves::CalculatePriority($biblio_id);
185		185
186	# AddReserve expects date to be in syspref format
187	if ($expiration_date) {
188	$expiration_date = output_pref( { dt => dt_from_string($expiration_date, 'iso'), dateformat => 'iso', dateonly => 1 } );
189	}
190
191	my $hold_id = C4::Reserves::AddReserve(	186	my $hold_id = C4::Reserves::AddReserve(
192	{	187	{
193	branchcode => $pickup_library_id,	188	branchcode => $pickup_library_id,
Lines 280-298 sub edit { Link Here
280	$pickup_library_id //= $hold->branchcode;	275	$pickup_library_id //= $hold->branchcode;
281	my $priority = $body->{priority} // $hold->priority;	276	my $priority = $body->{priority} // $hold->priority;
282	# suspended_until can also be set to undef	277	# suspended_until can also be set to undef
283	my $suspended_until =	278	my $suspended_until = $body->{suspended_until} \|\| $hold->suspend_until;
284	exists $body->{suspended_until}
285	? dt_from_string( $body->{suspended_until}, 'rfc3339' )
286	: $hold->suspend_until && dt_from_string( $hold->suspend_until, 'iso' );
287		279
288	my $params = {	280	my $params = {
289	reserve_id => $hold_id,	281	reserve_id => $hold_id,
290	branchcode => $pickup_library_id,	282	branchcode => $pickup_library_id,
291	rank => $priority,	283	rank => $priority,
292	suspend_until => $suspended_until	284	suspend_until => $suspended_until,
293	? output_pref({ dt => $suspended_until, dateformat => 'iso', dateonly => 1 })	285	itemnumber => $hold->itemnumber,
294	: '',
295	itemnumber => $hold->itemnumber
296	};	286	};
297		287
298	C4::Reserves::ModReserve($params);	288	C4::Reserves::ModReserve($params);
Lines 356-378 sub suspend { Link Here
356	}	346	}
357		347
358	return try {	348	return try {
359	my $date = ($end_date) ? dt_from_string( $end_date, 'iso' ) : undef;	349	$hold->suspend_hold($end_date);
360	$hold->suspend_hold($date);
361	$hold->discard_changes;	350	$hold->discard_changes;
362	$c->res->headers->location( $c->req->url->to_string );	351	$c->res->headers->location( $c->req->url->to_string );
363	my $suspend_end_date;	352
364	if ($hold->suspend_until) {	353	my $suspend_until = $end_date ? dt_from_string($hold->suspend_until)->ymd : undef;
365	$suspend_end_date = output_pref({
366	dt => dt_from_string( $hold->suspend_until, 'iso' ),
367	dateformat => 'iso',
368	dateonly => 1
369	}
370	);
371	}
372	return $c->render(	354	return $c->render(
373	status => 201,	355	status => 201,
374	openapi => {	356	openapi => {
375	end_date => $suspend_end_date	357	end_date => $suspend_until,
376	}	358	}
377	);	359	);
378	}	360	}

Lines 20-26 use Modern::Perl; Link Here

(-)a/Koha/Report.pm (-10 / +10 lines)
20		20
21	use Koha::Database;	21	use Koha::Database;
22	use Koha::Reports;	22	use Koha::Reports;
23	use Koha::DateUtils qw( dt_from_string output_pref );	23	#use Koha::DateUtils qw( dt_from_string output_pref );
24		24
25	use base qw(Koha::Object);	25	use base qw(Koha::Object);
26	#	26	#
Lines 159-173 sub prep_report { Link Here
159		159
160	# if there are special regexp chars, we must \ them	160	# if there are special regexp chars, we must \ them
161	$split[ $i * 2 + 1 ] =~ s/(\\|\|\?\|\.\|\*\|\(\|\)\|\%)/\\$1/g;	161	$split[ $i * 2 + 1 ] =~ s/(\\|\|\?\|\.\|\*\|\(\|\)\|\%)/\\$1/g;
162	if ( $split[ $i * 2 + 1 ] =~ /\\|\sdate\s$/ ) {	162	#if ( $split[ $i * 2 + 1 ] =~ /\\|\sdate\s$/ ) {
163	$quoted = output_pref(	163	# $quoted = output_pref(
164	{	164	# {
165	dt => dt_from_string($quoted),	165	# dt => dt_from_string($quoted),
166	dateformat => 'iso',	166	# dateformat => 'iso',
167	dateonly => 1	167	# dateonly => 1
168	}	168	# }
169	) if $quoted;	169	# ) if $quoted;
170	}	170	#}
171	unless ( $split[ $i * 2 + 1 ] =~ /\\|\slist\s$/ && $quoted ) {	171	unless ( $split[ $i * 2 + 1 ] =~ /\\|\slist\s$/ && $quoted ) {
172	$quoted = C4::Context->dbh->quote($quoted);	172	$quoted = C4::Context->dbh->quote($quoted);
173	}	173	}

Lines 28-34 use C4::Budgets qw( GetBudgetHierarchy GetBudget CanUserUseBudget GetBudgetPerio Link Here

(-)a/acqui/duplicate_orders.pl (-5 / +3 lines)
28	use Koha::Acquisition::Baskets;	28	use Koha::Acquisition::Baskets;
29	use Koha::Acquisition::Currencies;	29	use Koha::Acquisition::Currencies;
30	use Koha::Acquisition::Orders;	30	use Koha::Acquisition::Orders;
31	use Koha::DateUtils qw( dt_from_string output_pref );	31	use Koha::DateUtils qw( dt_from_string );
32		32
33	my $input = CGI->new;	33	my $input = CGI->new;
34	my $basketno = $input->param('basketno');	34	my $basketno = $input->param('basketno');
Lines 76-85 unless ( $input->param('from') ) { Link Here
76	# Fill the form with year-1	76	# Fill the form with year-1
77	$from_placed_on->set_time_zone('floating')->subtract( years => 1 );	77	$from_placed_on->set_time_zone('floating')->subtract( years => 1 );
78	}	78	}
79	$filters->{from_placed_on} =	79	$filters->{from_placed_on} = $from_placed_on;
80	output_pref( { dt => $from_placed_on, dateformat => 'iso', dateonly => 1 } ),	80	$filters->{to_placed_on} = $to_placed_on;
81	$filters->{to_placed_on} =
82	output_pref( { dt => $to_placed_on, dateformat => 'iso', dateonly => 1 } ),
83		81
84	my ( @result_order_loop, @selected_order_loop );	82	my ( @result_order_loop, @selected_order_loop );
85	my @ordernumbers = split ',', scalar $input->param('ordernumbers') \|\| '';	83	my @ordernumbers = split ',', scalar $input->param('ordernumbers') \|\| '';

Lines 34-40 use C4::Output qw( output_html_with_http_headers ); Link Here

(-)a/acqui/invoices.pl (-10 / +5 lines)
34		34
35	use C4::Acquisition qw( GetInvoices GetInvoice );	35	use C4::Acquisition qw( GetInvoices GetInvoice );
36	use C4::Budgets qw( GetBudget GetBudgets CanUserUseBudget );	36	use C4::Budgets qw( GetBudget GetBudgets CanUserUseBudget );
37	use Koha::DateUtils qw( dt_from_string output_pref );	37	use Koha::DateUtils qw( dt_from_string );
38	use Koha::Acquisition::Booksellers;	38	use Koha::Acquisition::Booksellers;
39		39
40	my $input = CGI->new;	40	my $input = CGI->new;
Lines 62-81 my $branch = $input->param('branch'); Link Here
62	my $message_id = $input->param('message_id');	62	my $message_id = $input->param('message_id');
63	my $op = $input->param('op');	63	my $op = $input->param('op');
64		64
65	$shipmentdatefrom and $shipmentdatefrom = eval { dt_from_string( $shipmentdatefrom ) };
66	$shipmentdateto and $shipmentdateto = eval { dt_from_string( $shipmentdateto ) };
67	$billingdatefrom and $billingdatefrom = eval { dt_from_string( $billingdatefrom ) };
68	$billingdateto and $billingdateto = eval { dt_from_string( $billingdateto ) };
69
70	my $invoices = [];	65	my $invoices = [];
71	if ( $op and $op eq 'do_search' ) {	66	if ( $op and $op eq 'do_search' ) {
72	@{$invoices} = GetInvoices(	67	@{$invoices} = GetInvoices(
73	invoicenumber => $invoicenumber,	68	invoicenumber => $invoicenumber,
74	supplierid => $supplierid,	69	supplierid => $supplierid,
75	shipmentdatefrom => $shipmentdatefrom ? output_pref( { str => $shipmentdatefrom, dateformat => 'iso' } ) : undef,	70	shipmentdatefrom => $shipmentdatefrom,
76	shipmentdateto => $shipmentdateto ? output_pref( { str => $shipmentdateto, dateformat => 'iso' } ) : undef,	71	shipmentdateto => $shipmentdateto,
77	billingdatefrom => $billingdatefrom ? output_pref( { str => $billingdatefrom, dateformat => 'iso' } ) : undef,	72	billingdatefrom => $billingdatefrom,
78	billingdateto => $billingdateto ? output_pref( { str => $billingdateto, dateformat => 'iso' } ) : undef,	73	billingdateto => $billingdateto,
79	isbneanissn => $isbneanissn,	74	isbneanissn => $isbneanissn,
80	title => $title,	75	title => $title,
81	author => $author,	76	author => $author,

Lines 49-55 use C4::Auth qw( get_template_and_user ); Link Here

(-)a/acqui/lateorders.pl (-23 / +9 lines)
49	use C4::Output qw( output_html_with_http_headers );	49	use C4::Output qw( output_html_with_http_headers );
50	use C4::Context;	50	use C4::Context;
51	use C4::Letters qw( SendAlerts GetLetters );	51	use C4::Letters qw( SendAlerts GetLetters );
52	use Koha::DateUtils qw( dt_from_string output_pref );	52	use Koha::DateUtils qw( dt_from_string );
53	use Koha::Acquisition::Orders qw( filter_by_lates );	53	use Koha::Acquisition::Orders qw( filter_by_lates );
54	use Koha::CsvProfiles;	54	use Koha::CsvProfiles;
55		55
Lines 70-94 my $delay = $input->param('delay') // 0; Link Here
70	my $estimateddeliverydatefrom = $input->param('estimateddeliverydatefrom');	70	my $estimateddeliverydatefrom = $input->param('estimateddeliverydatefrom');
71	my $estimateddeliverydateto = $input->param('estimateddeliverydateto');	71	my $estimateddeliverydateto = $input->param('estimateddeliverydateto');
72		72
73	my $estimateddeliverydatefrom_dt =
74	$estimateddeliverydatefrom
75	? dt_from_string($estimateddeliverydatefrom)
76	: undef;
77
78	# Get the "date to" param. If it is not defined and $delay is not defined too, it is the today's date.	73	# Get the "date to" param. If it is not defined and $delay is not defined too, it is the today's date.
79	my $estimateddeliverydateto_dt = $estimateddeliverydateto	74	$estimateddeliverydateto \|\|=
80	? dt_from_string($estimateddeliverydateto)	75	( not defined $delay and not defined $estimateddeliverydatefrom )
81	: ( not defined $delay and not defined $estimateddeliverydatefrom)	76	? dt_from_string()
82	? dt_from_string()	77	: undef;
83	: undef;
84
85	# Format the output of "date from" and "date to"
86	if ($estimateddeliverydatefrom_dt) {
87	$estimateddeliverydatefrom = output_pref({dt => $estimateddeliverydatefrom_dt, dateonly => 1});
88	}
89	if ($estimateddeliverydateto_dt) {
90	$estimateddeliverydateto = output_pref({dt => $estimateddeliverydateto_dt, dateonly => 1});
91	}
92		78
93	my $branch = $input->param('branch');	79	my $branch = $input->param('branch');
94	my $op = $input->param('op');	80	my $op = $input->param('op');
Lines 123-135 my @lateorders = Koha::Acquisition::Orders->filter_by_lates( Link Here
123	{	109	{
124	delay => $delay,	110	delay => $delay,
125	(	111	(
126	$estimateddeliverydatefrom_dt	112	$estimateddeliverydatefrom
127	? ( estimated_from => $estimateddeliverydatefrom_dt )	113	? ( estimated_from => $estimateddeliverydatefrom )
128	: ()	114	: ()
129	),	115	),
130	(	116	(
131	$estimateddeliverydateto_dt	117	$estimateddeliverydateto
132	? ( estimated_to => $estimateddeliverydateto_dt )	118	? ( estimated_to => $estimateddeliverydateto )
133	: ()	119	: ()
134	)	120	)
135	},	121	},

Lines 75-81 use C4::Acquisition qw( GetInvoices GetInvoice AddInvoice ); Link Here

(-)a/acqui/parcels.pl (-4 / +3 lines)
75	use C4::Budgets qw( GetBudgetHierarchy GetBudget CanUserUseBudget );	75	use C4::Budgets qw( GetBudgetHierarchy GetBudget CanUserUseBudget );
76		76
77	use Koha::Acquisition::Booksellers;	77	use Koha::Acquisition::Booksellers;
78	use Koha::DateUtils qw( output_pref dt_from_string );	78	use Koha::DateUtils qw( dt_from_string );
79		79
80	my $input = CGI->new;	80	my $input = CGI->new;
81	my $booksellerid = $input->param('booksellerid');	81	my $booksellerid = $input->param('booksellerid');
Lines 100-106 my $invoicenumber = $input->param('invoice'); Link Here
100	my $shipmentcost = $input->param('shipmentcost');	100	my $shipmentcost = $input->param('shipmentcost');
101	my $shipmentcost_budgetid = $input->param('shipmentcost_budgetid');	101	my $shipmentcost_budgetid = $input->param('shipmentcost_budgetid');
102	my $shipmentdate = $input->param('shipmentdate');	102	my $shipmentdate = $input->param('shipmentdate');
103	$shipmentdate and $shipmentdate = output_pref({ str => $shipmentdate, dateformat => 'iso', dateonly => 1 });
104		103
105	if ( $op and $op eq 'new' ) {	104	if ( $op and $op eq 'new' ) {
106	if ( C4::Context->preference('AcqWarnOnDuplicateInvoice') ) {	105	if ( C4::Context->preference('AcqWarnOnDuplicateInvoice') ) {
Lines 140-147 my $bookseller = Koha::Acquisition::Booksellers->find( $booksellerid ); Link Here
140	my @parcels = GetInvoices(	139	my @parcels = GetInvoices(
141	supplierid => $booksellerid,	140	supplierid => $booksellerid,
142	invoicenumber => $code,	141	invoicenumber => $code,
143	( $datefrom ? ( shipmentdatefrom => output_pref({ dt => dt_from_string($datefrom), dateformat => 'iso' }) ) : () ),	142	( $datefrom ? ( shipmentdatefrom => $datefrom ) : () ),
144	( $dateto ? ( shipmentdateto => output_pref({ dt => dt_from_string($dateto), dateformat => 'iso' }) ) : () ),	143	( $dateto ? ( shipmentdateto => $dateto ) : () ),
145	order_by => $order	144	order_by => $order
146	);	145	);
147	my $count_parcels = @parcels;	146	my $count_parcels = @parcels;

Lines 47-53 script to administer the budget periods table Link Here

(-)a/admin/aqbudgetperiods.pl (-5 / +4 lines)
47	use Modern::Perl;	47	use Modern::Perl;
48		48
49	use CGI qw ( -utf8 );	49	use CGI qw ( -utf8 );
50	use Koha::DateUtils qw( dt_from_string );
51	use JSON qw( encode_json );	50	use JSON qw( encode_json );
52	use Koha::Database;	51	use Koha::Database;
53	use C4::Koha;	52	use C4::Koha;
Lines 72-79 my $op = $input->param('op')\|\|"else"; Link Here
72	# get only the columns of aqbudgetperiods in budget_period_hashref	71	# get only the columns of aqbudgetperiods in budget_period_hashref
73	my @columns = Koha::Database->new()->schema->source('Aqbudgetperiod')->columns;	72	my @columns = Koha::Database->new()->schema->source('Aqbudgetperiod')->columns;
74	my $budget_period_hashref = { map { join(' ',@columns) =~ /$_/ ? ( $_ => scalar $input->param($_) ) : () } keys( %{$input->Vars()} ) } ;	73	my $budget_period_hashref = { map { join(' ',@columns) =~ /$_/ ? ( $_ => scalar $input->param($_) ) : () } keys( %{$input->Vars()} ) } ;
75	$budget_period_hashref->{budget_period_startdate} = dt_from_string( scalar $input->param('budget_period_startdate') );	74	$budget_period_hashref->{budget_period_startdate} = $input->param('budget_period_startdate');
76	$budget_period_hashref->{budget_period_enddate} = dt_from_string( scalar $input->param('budget_period_enddate') );	75	$budget_period_hashref->{budget_period_enddate} = $input->param('budget_period_enddate');
77		76
78	$searchfield =~ s/\,//g;	77	$searchfield =~ s/\,//g;
79		78
Lines 190-197 elsif ( $op eq 'duplicate_form'){ Link Here
190	elsif ( $op eq 'duplicate_budget' ){	189	elsif ( $op eq 'duplicate_budget' ){
191	die "please specify a budget period id\n" if( !defined $budget_period_id \|\| $budget_period_id eq '' );	190	die "please specify a budget period id\n" if( !defined $budget_period_id \|\| $budget_period_id eq '' );
192		191
193	my $budget_period_startdate = dt_from_string scalar $input->param('budget_period_startdate');	192	my $budget_period_startdate = $input->param('budget_period_startdate');
194	my $budget_period_enddate = dt_from_string scalar $input->param('budget_period_enddate');	193	my $budget_period_enddate = $input->param('budget_period_enddate');
195	my $budget_period_description = $input->param('budget_period_description');	194	my $budget_period_description = $input->param('budget_period_description');
196	my $amount_change_percentage = $input->param('amount_change_percentage');	195	my $amount_change_percentage = $input->param('amount_change_percentage');
197	my $amount_change_round_increment = $input->param('amount_change_round_increment');	196	my $amount_change_round_increment = $input->param('amount_change_round_increment');

Lines 32-38 use C4::Contract qw( Link Here

(-)a/admin/aqcontract.pl (-13 / +7 lines)
32	GetContracts	32	GetContracts
33	ModContract	33	ModContract
34	);	34	);
35	use Koha::DateUtils qw( dt_from_string output_pref );	35	use Koha::DateUtils qw( dt_from_string );
36		36
37	use Koha::Acquisition::Booksellers;	37	use Koha::Acquisition::Booksellers;
38		38
Lines 96-103 elsif ( $op eq 'add_validate' ) { Link Here
96		96
97	my $is_a_modif = $input->param("is_a_modif");	97	my $is_a_modif = $input->param("is_a_modif");
98		98
99	my $contractstart_dt = eval { dt_from_string( scalar $input->param('contractstartdate') ); };	99	my $contractstart_dt = $input->param('contractstartdate');
100	my $contractend_dt = eval { dt_from_string( scalar $input->param('contractenddate') ); };	100	my $contractend_dt = $input->param('contractenddate');
101	unless ( $contractstart_dt and $contractend_dt ) {	101	unless ( $contractstart_dt and $contractend_dt ) {
102	my $today = dt_from_string;	102	my $today = dt_from_string;
103	$contractstart_dt \|\|= $today;	103	$contractstart_dt \|\|= $today;
Lines 106-113 elsif ( $op eq 'add_validate' ) { Link Here
106		106
107	if ( $is_a_modif ) {	107	if ( $is_a_modif ) {
108	ModContract({	108	ModContract({
109	contractstartdate => eval { output_pref({ dt => dt_from_string( $contractstart_dt ), dateformat => 'iso', dateonly => 1 } ); },	109	contractstartdate => $contractstart_dt,
110	contractenddate => eval { output_pref({ dt => dt_from_string( $contractend_dt ), dateformat => 'iso', dateonly => 1 } ); },	110	contractenddate => $contractend_dt,
111	contractname => scalar $input->param('contractname'),	111	contractname => scalar $input->param('contractname'),
112	contractdescription => scalar $input->param('contractdescription'),	112	contractdescription => scalar $input->param('contractdescription'),
113	booksellerid => scalar $input->param('booksellerid'),	113	booksellerid => scalar $input->param('booksellerid'),
Lines 118-125 elsif ( $op eq 'add_validate' ) { Link Here
118	contractname => scalar $input->param('contractname'),	118	contractname => scalar $input->param('contractname'),
119	contractdescription => scalar $input->param('contractdescription'),	119	contractdescription => scalar $input->param('contractdescription'),
120	booksellerid => scalar $input->param('booksellerid'),	120	booksellerid => scalar $input->param('booksellerid'),
121	contractstartdate => eval { output_pref({ dt => dt_from_string( scalar $input->param('contractstartdate') ), dateformat => 'iso', dateonly => 1 } ); },	121	contractstartdate => scalar $input->param('contractstartdate'),
122	contractenddate => eval { output_pref({ dt => dt_from_string( scalar $input->param('contractenddate') ), dateformat => 'iso', dateonly => 1 } ); },	122	contractenddate => scalar $input->param('contractenddate'),
123	});	123	});
124	}	124	}
125		125
Lines 165-176 if ( $op eq 'list' ) { Link Here
165	# get contracts	165	# get contracts
166	my @contracts = @{GetContracts( { booksellerid => $booksellerid } )};	166	my @contracts = @{GetContracts( { booksellerid => $booksellerid } )};
167		167
168	# format dates
169	for my $contract ( @contracts ) {
170	$contract->{contractstartdate} = output_pref({ dt => dt_from_string( $contract->{contractstartdate} ), dateonly => 1 });
171	$contract->{contractenddate} = output_pref({ dt => dt_from_string( $contract->{contractenddate} ), dateonly => 1 }),
172	}
173
174	$template->param(loop => \@contracts);	168	$template->param(loop => \@contracts);
175		169
176	#---- END $OP eq DEFAULT	170	#---- END $OP eq DEFAULT

Lines 27-33 use C4::Output qw( output_html_with_http_headers ); Link Here

(-)a/admin/categories.pl (-11 lines)
27	use C4::Form::MessagingPreferences;	27	use C4::Form::MessagingPreferences;
28	use Koha::Patrons;	28	use Koha::Patrons;
29	use Koha::Database;	29	use Koha::Database;
30	use Koha::DateUtils qw( dt_from_string output_pref );
31	use Koha::Patron::Categories;	30	use Koha::Patron::Categories;
32	use Koha::Libraries;	31	use Koha::Libraries;
33		32
Lines 89-104 elsif ( $op eq 'add_validate' ) { Link Here
89		88
90	my $is_a_modif = $input->param("is_a_modif");	89	my $is_a_modif = $input->param("is_a_modif");
91		90
92	if ($enrolmentperioddate) {
93	$enrolmentperioddate = output_pref(
94	{
95	dt => dt_from_string($enrolmentperioddate),
96	dateformat => 'iso',
97	dateonly => 1,
98	}
99	);
100	}
101
102	if ($is_a_modif) {	91	if ($is_a_modif) {
103	my $category = Koha::Patron::Categories->find( $categorycode );	92	my $category = Koha::Patron::Categories->find( $categorycode );
104	$category->categorycode($categorycode);	93	$category->categorycode($categorycode);

Lines 23-29 use C4::Context; Link Here

(-)a/admin/smart-rules.pl (-5 lines)
23	use C4::Output qw( output_html_with_http_headers );	23	use C4::Output qw( output_html_with_http_headers );
24	use C4::Auth qw( get_template_and_user );	24	use C4::Auth qw( get_template_and_user );
25	use Koha::Exception;	25	use Koha::Exception;
26	use Koha::DateUtils qw( dt_from_string output_pref );
27	use Koha::Database;	26	use Koha::Database;
28	use Koha::Logger;	27	use Koha::Logger;
29	use Koha::Libraries;	28	use Koha::Libraries;
Lines 272-279 elsif ($op eq 'add') { Link Here
272	my $no_auto_renewal_after = $input->param('no_auto_renewal_after');	271	my $no_auto_renewal_after = $input->param('no_auto_renewal_after');
273	$no_auto_renewal_after = '' if $no_auto_renewal_after =~ /^\s*$/;	272	$no_auto_renewal_after = '' if $no_auto_renewal_after =~ /^\s*$/;
274	my $no_auto_renewal_after_hard_limit = $input->param('no_auto_renewal_after_hard_limit') \|\| '';	273	my $no_auto_renewal_after_hard_limit = $input->param('no_auto_renewal_after_hard_limit') \|\| '';
275	$no_auto_renewal_after_hard_limit = eval { dt_from_string( scalar $no_auto_renewal_after_hard_limit ) } if ( $no_auto_renewal_after_hard_limit );
276	$no_auto_renewal_after_hard_limit = output_pref( { dt => $no_auto_renewal_after_hard_limit, dateonly => 1, dateformat => 'iso' } ) if ( $no_auto_renewal_after_hard_limit );
277	my $reservesallowed = strip_non_numeric( scalar $input->param('reservesallowed') );	274	my $reservesallowed = strip_non_numeric( scalar $input->param('reservesallowed') );
278	my $holds_per_record = strip_non_numeric( scalar $input->param('holds_per_record') );	275	my $holds_per_record = strip_non_numeric( scalar $input->param('holds_per_record') );
279	my $holds_per_day = strip_non_numeric( scalar $input->param('holds_per_day') );	276	my $holds_per_day = strip_non_numeric( scalar $input->param('holds_per_day') );
Lines 283-290 elsif ($op eq 'add') { Link Here
283	my $daysmode = $input->param('daysmode');	280	my $daysmode = $input->param('daysmode');
284	my $lengthunit = $input->param('lengthunit');	281	my $lengthunit = $input->param('lengthunit');
285	my $hardduedate = $input->param('hardduedate') \|\| undef;	282	my $hardduedate = $input->param('hardduedate') \|\| undef;
286	$hardduedate = eval { dt_from_string( scalar $hardduedate ) } if ( $hardduedate );
287	$hardduedate = output_pref( { dt => $hardduedate, dateonly => 1, dateformat => 'iso' } ) if ( $hardduedate );
288	my $hardduedatecompare = $input->param('hardduedatecompare');	283	my $hardduedatecompare = $input->param('hardduedatecompare');
289	my $rentaldiscount = $input->param('rentaldiscount');	284	my $rentaldiscount = $input->param('rentaldiscount');
290	my $opacitemholds = $input->param('opacitemholds') \|\| 0;	285	my $opacitemholds = $input->param('opacitemholds') \|\| 0;

Lines 21-33 Link Here

(-)a/cataloguing/value_builder/dateaccessioned.pl (-2 / +1 lines)
21	# along with Koha; if not, see <http://www.gnu.org/licenses>.	21	# along with Koha; if not, see <http://www.gnu.org/licenses>.
22		22
23	use Modern::Perl;	23	use Modern::Perl;
24	use Koha::DateUtils qw( dt_from_string output_pref flatpickr_date_format );	24	use Koha::DateUtils qw( flatpickr_date_format );
25		25
26	my $builder = sub {	26	my $builder = sub {
27	my ( $params ) = @_;	27	my ( $params ) = @_;
28	my $function_name = $params->{id};	28	my $function_name = $params->{id};
29		29
30	my $date = output_pref({ dt => dt_from_string, dateonly => 1 });
31	my $dateformat = flatpickr_date_format();	30	my $dateformat = flatpickr_date_format();
32		31
33	my $res = <<END_OF_JS;	32	my $res = <<END_OF_JS;

Lines 45-51 use Koha::AuthorisedValues; Link Here

(-)a/circ/circulation.pl (-4 / +2 lines)
45	use Koha::CsvProfiles;	45	use Koha::CsvProfiles;
46	use Koha::Patrons;	46	use Koha::Patrons;
47	use Koha::Patron::Debarments qw( GetDebarments );	47	use Koha::Patron::Debarments qw( GetDebarments );
48	use Koha::DateUtils qw( dt_from_string output_pref );	48	use Koha::DateUtils qw( dt_from_string );
49	use Koha::Plugins;	49	use Koha::Plugins;
50	use Koha::Database;	50	use Koha::Database;
51	use Koha::BiblioFrameworks;	51	use Koha::BiblioFrameworks;
Lines 159-166 for my $barcode ( @$barcodes ) { Link Here
159		159
160	my $stickyduedate = $query->param('stickyduedate') \|\| $session->param('stickyduedate');	160	my $stickyduedate = $query->param('stickyduedate') \|\| $session->param('stickyduedate');
161	my $duedatespec = $query->param('duedatespec') \|\| $session->param('stickyduedate');	161	my $duedatespec = $query->param('duedatespec') \|\| $session->param('stickyduedate');
162	$duedatespec = eval { output_pref( { dt => dt_from_string( $duedatespec ), dateformat => 'iso' }); }
163	if ( $duedatespec );
164	my $restoreduedatespec = $query->param('restoreduedatespec') \|\| $duedatespec \|\| $session->param('stickyduedate');	162	my $restoreduedatespec = $query->param('restoreduedatespec') \|\| $duedatespec \|\| $session->param('stickyduedate');
165	if ( $restoreduedatespec && $restoreduedatespec eq "highholds_empty" ) {	163	if ( $restoreduedatespec && $restoreduedatespec eq "highholds_empty" ) {
166	undef $restoreduedatespec;	164	undef $restoreduedatespec;
Lines 625-631 $template->param( Link Here
625	SpecifyDueDate => $duedatespec_allow,	623	SpecifyDueDate => $duedatespec_allow,
626	PatronAutoComplete => C4::Context->preference("PatronAutoComplete"),	624	PatronAutoComplete => C4::Context->preference("PatronAutoComplete"),
627	debarments => scalar GetDebarments({ borrowernumber => $borrowernumber }),	625	debarments => scalar GetDebarments({ borrowernumber => $borrowernumber }),
628	todaysdate => output_pref( { dt => dt_from_string()->set(hour => 23)->set(minute => 59), dateformat => 'sql' } ),	626	todaysdate => dt_from_string()->set(hour => 23)->set(minute => 59),
629	has_modifications => $has_modifications,	627	has_modifications => $has_modifications,
630	override_high_holds => $override_high_holds,	628	override_high_holds => $override_high_holds,
631	nopermission => scalar $query->param('nopermission'),	629	nopermission => scalar $query->param('nopermission'),

Lines 25-31 use C4::Output qw( output_html_with_http_headers ); Link Here

(-)a/circ/overdue.pl (-3 / +3 lines)
25	use CGI qw(-oldstyle_urls -utf8);	25	use CGI qw(-oldstyle_urls -utf8);
26	use C4::Auth qw( get_template_and_user );	26	use C4::Auth qw( get_template_and_user );
27	use Text::CSV_XS;	27	use Text::CSV_XS;
28	use Koha::DateUtils qw( dt_from_string output_pref );	28	use Koha::DateUtils qw( dt_from_string );
29	use Koha::Patron::Attribute::Types;	29	use Koha::Patron::Attribute::Types;
30	use DateTime;	30	use DateTime;
31	use DateTime::Format::MySQL;	31	use DateTime::Format::MySQL;
Lines 334-340 if ($noreport) { Link Here
334	branchcode => $data->{branchcode},	334	branchcode => $data->{branchcode},
335	barcode => $data->{barcode},	335	barcode => $data->{barcode},
336	itemnum => $data->{itemnumber},	336	itemnum => $data->{itemnumber},
337	issuedate => output_pref({ dt => dt_from_string( $data->{issuedate} ), dateonly => 1 }),	337	issuedate => $data->{issuedate},
338	biblionumber => $data->{biblionumber},	338	biblionumber => $data->{biblionumber},
339	title => $data->{title},	339	title => $data->{title},
340	subtitle => $data->{subtitle},	340	subtitle => $data->{subtitle},
Lines 369-375 if ($noreport) { Link Here
369	$new_cgi->delete('op');	369	$new_cgi->delete('op');
370		370
371	$template->param(	371	$template->param(
372	todaysdate => output_pref($today_dt),	372	todaysdate => $today_dt,
373	overdueloop => \@overduedata,	373	overdueloop => \@overduedata,
374	nnoverdue => scalar(@overduedata),	374	nnoverdue => scalar(@overduedata),
375	noverdue_is_plural => scalar(@overduedata) != 1,	375	noverdue_is_plural => scalar(@overduedata) != 1,

Lines 24-30 use C4::Context; Link Here

(-)a/circ/renew.pl (-9 / +8 lines)
24	use C4::Auth qw( get_template_and_user );	24	use C4::Auth qw( get_template_and_user );
25	use C4::Output qw( output_html_with_http_headers );	25	use C4::Output qw( output_html_with_http_headers );
26	use C4::Circulation qw( barcodedecode CanBookBeRenewed GetLatestAutoRenewDate AddRenewal );	26	use C4::Circulation qw( barcodedecode CanBookBeRenewed GetLatestAutoRenewDate AddRenewal );
27	use Koha::DateUtils qw( dt_from_string output_pref );	27	use Koha::DateUtils qw( dt_from_string );
28	use Koha::Database;	28	use Koha::Database;
29	use Koha::BiblioFrameworks;	29	use Koha::BiblioFrameworks;
30		30
Lines 92-104 if ($barcode) { Link Here
92	}	92	}
93	if ($can_renew) {	93	if ($can_renew) {
94	my $branchcode = C4::Context->userenv ? C4::Context->userenv->{'branch'} : undef;	94	my $branchcode = C4::Context->userenv ? C4::Context->userenv->{'branch'} : undef;
95	my $date_due;	95	my $date_due =
96	if ( $cgi->param('renewonholdduedate') ) {	96	( C4::Context->preference('SpecifyDueDate')
97	$date_due = dt_from_string( scalar $cgi->param('renewonholdduedate'));	97	&& $hard_due_date )
98	}	98	? $hard_due_date
99	if ( C4::Context->preference('SpecifyDueDate') && $hard_due_date ) {	99	: $cgi->param('renewonholdduedate');
100	$date_due = dt_from_string( $hard_due_date );	100
101	}
102	$date_due = AddRenewal(	101	$date_due = AddRenewal(
103	undef,	102	undef,
104	$item->itemnumber(),	103	$item->itemnumber(),
Lines 133-139 if ($barcode) { Link Here
133	);	132	);
134	}	133	}
135		134
136	$template->param( hard_due_date => ($hard_due_date ? output_pref({ str => $hard_due_date, dateformat => 'iso' }) : undef) );	135	$template->param( hard_due_date => $hard_due_date );
137	# Checking if there is a Fast Cataloging Framework	136	# Checking if there is a Fast Cataloging Framework
138	$template->param( fast_cataloging => 1 ) if Koha::BiblioFrameworks->find( 'FA' );	137	$template->param( fast_cataloging => 1 ) if Koha::BiblioFrameworks->find( 'FA' );
139		138

Lines 27-33 use C4::Context; Link Here

(-)a/circ/reserveratios.pl (-6 / +3 lines)
27	use C4::Output qw( output_html_with_http_headers );	27	use C4::Output qw( output_html_with_http_headers );
28	use C4::Auth qw( get_template_and_user );	28	use C4::Auth qw( get_template_and_user );
29	use C4::Acquisition qw/GetOrdersByBiblionumber/;	29	use C4::Acquisition qw/GetOrdersByBiblionumber/;
30	use Koha::DateUtils qw( dt_from_string output_pref );	30	use Koha::DateUtils qw( dt_from_string );
31	use Koha::Acquisition::Baskets;	31	use Koha::Acquisition::Baskets;
32		32
33	my $input = CGI->new;	33	my $input = CGI->new;
Lines 62-70 if ( $basketno ){ Link Here
62	}	62	}
63	}	63	}
64		64
65	$startdate = eval { dt_from_string( $startdate ) } if $startdate;
66	$enddate = eval { dt_from_string( $enddate ) } if $enddate;
67
68	my $todaysdate = dt_from_string;	65	my $todaysdate = dt_from_string;
69		66
70	# A default of the prior years's holds is a reasonable way to pull holds	67	# A default of the prior years's holds is a reasonable way to pull holds
Lines 85-93 my $sqldatewhere = ""; Link Here
85	my @query_params = ();	82	my @query_params = ();
86		83
87	$sqldatewhere .= " AND reservedate >= ?";	84	$sqldatewhere .= " AND reservedate >= ?";
88	push @query_params, output_pref({ dt => $startdate, dateformat => 'iso' }) ;	85	push @query_params, $startdate;
89	$sqldatewhere .= " AND reservedate <= ?";	86	$sqldatewhere .= " AND reservedate <= ?";
90	push @query_params, output_pref({ dt => $enddate, dateformat => 'iso' });	87	push @query_params, $enddate;
91		88
92	my $include_aqorders_qty =	89	my $include_aqorders_qty =
93	$effective_create_items eq 'receiving'	90	$effective_create_items eq 'receiving'

Lines 47-53 use Koha::AuthorisedValues; Link Here

(-)a/circ/returns.pl (-22 / +18 lines)
47	use Koha::BiblioFrameworks;	47	use Koha::BiblioFrameworks;
48	use Koha::Calendar;	48	use Koha::Calendar;
49	use Koha::Checkouts;	49	use Koha::Checkouts;
50	use Koha::DateUtils qw( dt_from_string output_pref );	50	use Koha::DateUtils qw( dt_from_string );
51	use Koha::Holds;	51	use Koha::Holds;
52	use Koha::Items;	52	use Koha::Items;
53	use Koha::Item::Transfers;	53	use Koha::Item::Transfers;
Lines 215-242 my $dest = $query->param('dest'); Link Here
215	#dropbox: get last open day (today - 1)	215	#dropbox: get last open day (today - 1)
216	my $dropboxdate = Koha::Checkouts::calculate_dropbox_date();	216	my $dropboxdate = Koha::Checkouts::calculate_dropbox_date();
217		217
218	my $return_date_override = $query->param('return_date_override');	218	my $return_date_override = $query->param('return_date_override') \|\| q{};
219	my $return_date_override_dt;
220	my $return_date_override_remember =
221	$query->param('return_date_override_remember');
222	if ($return_date_override) {	219	if ($return_date_override) {
223	if ( C4::Context->preference('SpecifyReturnDate') ) {	220	if ( C4::Context->preference('SpecifyReturnDate') ) {
224	$return_date_override_dt = eval {dt_from_string( $return_date_override ) };
225	if ( $return_date_override_dt ) {
226	# note that we've overriden the return date
227	$template->param( return_date_was_overriden => 1);
228	# Save the original format if we are remembering for this series
229	$template->param(
230	return_date_override => $return_date_override,
231	return_date_override_remember => 1
232	) if ($return_date_override_remember);
233		221
234	$return_date_override =	222	# note that we've overriden the return date
235	DateTime::Format::MySQL->format_datetime( $return_date_override_dt );	223	$template->param( return_date_was_overriden => 1 );
236	}	224
237	}	225	my $return_date_override_remember =
238	else {	226	$query->param('return_date_override_remember');
239	$return_date_override = q{};	227
		228	# Save the original format if we are remembering for this series
		229	$template->param(
		230	return_date_override => $return_date_override,
		231	return_date_override_remember => 1
		232	) if ($return_date_override_remember);
240	}	233	}
241	}	234	}
242		235
Lines 327-333 if ($barcode) { Link Here
327	barcode => $barcode,	320	barcode => $barcode,
328	);	321	);
329		322
330	my $return_date = $dropboxmode ? $dropboxdate : $return_date_override_dt;	323	my $return_date =
		324	$dropboxmode
		325	? $dropboxdate
		326	: dt_from_string( $return_date_override );
331		327
332	# Block return if multi-part and confirm has not been received	328	# Block return if multi-part and confirm has not been received
333	my $needs_confirm =	329	my $needs_confirm =
Lines 659-665 foreach ( sort { $a <=> $b } keys %returneditems ) { Link Here
659	$ri{day} = $duedate->day();	655	$ri{day} = $duedate->day();
660	$ri{hour} = $duedate->hour();	656	$ri{hour} = $duedate->hour();
661	$ri{minute} = $duedate->minute();	657	$ri{minute} = $duedate->minute();
662	$ri{duedate} = output_pref($duedate);	658	$ri{duedate} = $duedate;
663	my $patron = Koha::Patrons->find( $riborrowernumber{$_} );	659	my $patron = Koha::Patrons->find( $riborrowernumber{$_} );
664	unless ( $dropboxmode ) {	660	unless ( $dropboxmode ) {
665	$ri{return_overdue} = 1 if (DateTime->compare($duedate, dt_from_string()) == -1);	661	$ri{return_overdue} = 1 if (DateTime->compare($duedate, dt_from_string()) == -1);

Lines 26-32 use C4::Members qw( checkcardnumber ); Link Here

(-)a/installer/onboarding.pl (-12 lines)
26	use Koha::Patrons;	26	use Koha::Patrons;
27	use Koha::Libraries;	27	use Koha::Libraries;
28	use Koha::Database;	28	use Koha::Database;
29	use Koha::DateUtils qw( dt_from_string output_pref );
30	use Koha::Patrons;	29	use Koha::Patrons;
31	use Koha::Patron::Categories;	30	use Koha::Patron::Categories;
32	use Koha::ItemTypes;	31	use Koha::ItemTypes;
Lines 100-116 if ( $step == 2 ) { Link Here
100	my $enrolmentperiod = $input->param('enrolmentperiod');	99	my $enrolmentperiod = $input->param('enrolmentperiod');
101	my $enrolmentperioddate = $input->param('enrolmentperioddate') \|\| undef;	100	my $enrolmentperioddate = $input->param('enrolmentperioddate') \|\| undef;
102		101
103	#Converts the string into a date format
104	if ($enrolmentperioddate) {
105	$enrolmentperioddate = output_pref(
106	{
107	dt => dt_from_string($enrolmentperioddate),
108	dateformat => 'DateTime',
109	dateonly => 1,
110	}
111	);
112	}
113
114	#Adds a new patron category to the database	102	#Adds a new patron category to the database
115	$category = Koha::Patron::Category->new(	103	$category = Koha::Patron::Category->new(
116	{	104	{

Lines 1-6 Link Here

(-)a/koha-tmpl/intranet-tmpl/prog/en/includes/filter-orders.inc (-3 / +2 lines)
1	[% USE Koha %]	1	[% USE Koha %]
2	[% USE Branches %]	2	[% USE Branches %]
3	[% USE KohaDates %]
4	[% PROCESS 'html_helpers.inc' %]	3	[% PROCESS 'html_helpers.inc' %]
5	<ol>	4	<ol>
6	<li><label for="title">Title: </label> <input type="text" name="title" id="title" value="[% filters.title \| html %]" /></li>	5	<li><label for="title">Title: </label> <input type="text" name="title" id="title" value="[% filters.title \| html %]" /></li>
Lines 105-115 Link Here
105	</li>	104	</li>
106		105
107	<li><label for="from">From: </label>	106	<li><label for="from">From: </label>
108	<input type="text" size="10" id="from" name="from" value="[% filters.from_placed_on \| $KohaDates %]" class="flatpickr" data-date_to="to" />	107	<input type="text" size="10" id="from" name="from" value="[% filters.from_placed_on \| html %]" class="flatpickr" data-date_to="to" />
109	<div class="hint">[% INCLUDE 'date-format.inc' %]</div>	108	<div class="hint">[% INCLUDE 'date-format.inc' %]</div>
110	</li>	109	</li>
111	<li><label for="to">To: </label>	110	<li><label for="to">To: </label>
112	<input type="text" size="10" id="to" name="to" value="[% filters.to_placed_on \| $KohaDates %]" class="flatpickr" />	111	<input type="text" size="10" id="to" name="to" value="[% filters.to_placed_on \| html %]" class="flatpickr" />
113	<div class="hint">[% INCLUDE 'date-format.inc' %]</div>	112	<div class="hint">[% INCLUDE 'date-format.inc' %]</div>
114	</li>	113	</li>
115	</ol>	114	</ol>

Lines 114-126 Link Here

(-)a/koha-tmpl/intranet-tmpl/prog/en/includes/holds_table.inc (-3 / +3 lines)
114	<td>[% hold.notes \| html \| html_line_break %]</td>	114	<td>[% hold.notes \| html \| html_line_break %]</td>
115	<td>	115	<td>
116	[% IF Koha.Preference('AllowHoldDateInFuture') %]	116	[% IF Koha.Preference('AllowHoldDateInFuture') %]
117	<input type="text" class="flatpickr" value="[% hold.date \| $KohaDates %]" required="required" size="10" name="reservedate" />	117	<input type="text" class="flatpickr" value="[% hold.date \| html %]" required="required" size="10" name="reservedate" />
118	[% ELSE %]	118	[% ELSE %]
119	[% hold.date \| $KohaDates %]	119	[% hold.date \| $KohaDates %]
120	[% END %]	120	[% END %]
121	</td>	121	</td>
122	<td>	122	<td>
123	<input type="text" class="flatpickr" data-flatpickr-futuredate="true" value="[% hold.expirationdate \| $KohaDates %]" size="10" name="expirationdate" />	123	<input type="text" class="flatpickr" data-flatpickr-futuredate="true" value="[% hold.expirationdate \| html %]" size="10" name="expirationdate" />
124	</td>	124	</td>
125	<td>	125	<td>
126	[%- IF ( hold.found ) -%]	126	[%- IF ( hold.found ) -%]
Lines 221-227 Link Here
221		221
222	[% IF Koha.Preference('AutoResumeSuspendedHolds') %]	222	[% IF Koha.Preference('AutoResumeSuspendedHolds') %]
223	<label for="suspend_until_[% hold.reserve_id \| html %]">[% IF ( hold.suspend ) %] on [% ELSE %] until [% END %]</label>	223	<label for="suspend_until_[% hold.reserve_id \| html %]">[% IF ( hold.suspend ) %] on [% ELSE %] until [% END %]</label>
224	<input type="text" name="suspend_until_[% hold.reserve_id \| html %]" id="suspend_until_[% hold.reserve_id \| html %]" size="10" value="[% hold.suspend_until \| $KohaDates %]" class="flatpickr" data-flatpickr-futuredate="true" />	224	<input type="text" name="suspend_until_[% hold.reserve_id \| html %]" id="suspend_until_[% hold.reserve_id \| html %]" size="10" value="[% hold.suspend_until \| html %]" class="flatpickr" data-flatpickr-futuredate="true" />
225	[%- ELSE -%]	225	[%- ELSE -%]
226	<input type="hidden" name="suspend_until_[% hold.reserve_id \| html %]" id="suspend_until_[% hold.reserve_id \| html %]" value=""/>	226	<input type="hidden" name="suspend_until_[% hold.reserve_id \| html %]" id="suspend_until_[% hold.reserve_id \| html %]" value=""/>
227	[%- END -%]	227	[%- END -%]

Lines 132-143 Link Here

(-)a/koha-tmpl/intranet-tmpl/prog/en/modules/admin/aqcontract.tt (-2 / +2 lines)
132	<input type="text" name="contractdescription" id="contractdescription" size="40" maxlength="80" value="[% contractdescription \| html %]" />	132	<input type="text" name="contractdescription" id="contractdescription" size="40" maxlength="80" value="[% contractdescription \| html %]" />
133	</li>	133	</li>
134	<li><label for="from" class="required">Start date:</label>	134	<li><label for="from" class="required">Start date:</label>
135	<input type="text" name="contractstartdate" id="from" value="[% contractstartdate \| $KohaDates %]" maxlength="10" size="10" class="flatpickr" data-date_to="to" />	135	<input type="text" name="contractstartdate" id="from" value="[% contractstartdate \| html %]" maxlength="10" size="10" class="flatpickr" data-date_to="to" />
136	<span class="required">Required</span>	136	<span class="required">Required</span>
137	<div class="hint">[% INCLUDE 'date-format.inc' %]</div>	137	<div class="hint">[% INCLUDE 'date-format.inc' %]</div>
138	</li>	138	</li>
139	<li><label for="to" class="required">End date:</label>	139	<li><label for="to" class="required">End date:</label>
140	<input type="text" name="contractenddate" id="to" value="[% contractenddate \| $KohaDates %]" maxlength="10" size="10" class="flatpickr" />	140	<input type="text" name="contractenddate" id="to" value="[% contractenddate \| html %]" maxlength="10" size="10" class="flatpickr" />
141	<span class="required">Required</span>	141	<span class="required">Required</span>
142	<div class="hint">[% INCLUDE 'date-format.inc' %]</div>	142	<div class="hint">[% INCLUDE 'date-format.inc' %]</div>
143	</li>	143	</li>

Lines 271-282 Link Here

(-)a/koha-tmpl/intranet-tmpl/prog/en/modules/circ/pendingreserves.tt (-2 / +2 lines)
271	<label for="from">	271	<label for="from">
272	Start date:	272	Start date:
273	</label>	273	</label>
274	<input type="text" size="10" id="from" name="from" value="[% from \| $KohaDates %]" class="flatpickr" data-date_to="to" />	274	<input type="text" size="10" id="from" name="from" value="[% from \| html %]" class="flatpickr" data-date_to="to" />
275	</li>	275	</li>
276	<li><label for="to">	276	<li><label for="to">
277	End date:	277	End date:
278	</label>	278	</label>
279	<input type="text" size="10" id="to" name="to" value="[% to \| $KohaDates %]" class="flatpickr" />	279	<input type="text" size="10" id="to" name="to" value="[% to \| html %]" class="flatpickr" />
280	</li>	280	</li>
281	</ol>	281	</ol>
282		282

Lines 58-69 Link Here

(-)a/koha-tmpl/intranet-tmpl/prog/en/modules/reports/cash_register_stats.tt (-2 / +2 lines)
58	<br>	58	<br>
59	<li>	59	<li>
60	<label for="from">From: </label>	60	<label for="from">From: </label>
61	<input type="text" size="10" id="from" name="from" value="[% beginDate \| $KohaDates %]" class="flatpickr" data-date_to="to" />	61	<input type="text" size="10" id="from" name="from" value="[% beginDate \| html %]" class="flatpickr" data-date_to="to" />
62	<div class="hint">[% INCLUDE 'date-format.inc' %]</div>	62	<div class="hint">[% INCLUDE 'date-format.inc' %]</div>
63	</li>	63	</li>
64	<li>	64	<li>
65	<label for="to">To: </label>	65	<label for="to">To: </label>
66	<input type="text" size="10" id="to" name="to" value="[% endDate \| $KohaDates %]" class="flatpickr" />	66	<input type="text" size="10" id="to" name="to" value="[% endDate \| html %]" class="flatpickr" />
67	<div class="hint">[% INCLUDE 'date-format.inc' %]</div>	67	<div class="hint">[% INCLUDE 'date-format.inc' %]</div>
68	</li>	68	</li>
69		69

Lines 164-175 Link Here

(-)a/koha-tmpl/intranet-tmpl/prog/en/modules/serials/claims.tt (-4 / +4 lines)
164	[% IF ( missingissue.status44 ) %]<span class="status-missing_lost">Missing (lost)</span>[% END %]	164	[% IF ( missingissue.status44 ) %]<span class="status-missing_lost">Missing (lost)</span>[% END %]
165	[% IF ( missingissue.status7 ) %]<span class="status-claimed">Claimed</span>[% END %]	165	[% IF ( missingissue.status7 ) %]<span class="status-claimed">Claimed</span>[% END %]
166	</td>	166	</td>
167	<td class="planneddate" data-order="[% missingissue.planneddateISO \| html %]">	167	<td class="planneddate" data-order="[% missingissue.planneddate \| html %]">
168	[% missingissue.planneddate \| html %]	168	[% missingissue.planneddate \| $KohaDates %]
169	</td>	169	</td>
170	<td>[% missingissue.claims_count \| html %]</td>	170	<td>[% missingissue.claims_count \| html %]</td>
171	<td data-order="[% missingissue.claimdateISO \| html %]">	171	<td data-order="[% missingissue.claimdate \| html %]">
172	[% missingissue.claimdate \| html %]	172	[% missingissue.claimdate \| $KohaDates %]
173	</td>	173	</td>
174	[% FOR field IN additional_fields_for_subscription %]	174	[% FOR field IN additional_fields_for_subscription %]
175	[% IF field.authorised_value_category %]	175	[% IF field.authorised_value_category %]