[% IF ( uploadmarc ) %]

        [% FOREACH message IN messages %]

<div id="toolbar" class="btn-toolbar">

          [% IF message.type == 'success' %]

        <a class="btn btn-default" href="/cgi-bin/koha/tools/stage-marc-import.pl"><i class="fa fa-plus"></i> Stage MARC records</a>

            <div class="dialog message">

        <a class="btn btn-default" href="/cgi-bin/koha/tools/manage-marc-import.pl?import_batch_id=[% import_batch_id | html %]"><i class="fa fa-list-ul"></i> Manage staged records</a>

          [% ELSIF message.type == 'warning' %]

</div>

            <div class="dialog alert">

[% END %]

          [% ELSIF message.type == 'error' %]

            <div class="dialog alert" style="margin:auto;">

          [% END %]

          [% IF message.code == 'cannot_enqueue_job' %]

              <span>Cannot enqueue this job.</span>

          [% END %]

          [% IF message.error %]

            <span>(The error was: [% message.error | html %], see the Koha log file for more information).</span>

          [% END %]

          </div>

        [% END %]

[% IF ( uploadmarc ) %]

        [% IF job_enqueued %]

<h1>MARC staging results</h1>

            <div id="toolbar" class="btn-toolbar">

<ul>

                    <a class="btn btn-default" href="/cgi-bin/koha/tools/stage-marc-import.pl"><i class="fa fa-plus"></i> Stage MARC records</a>

    [% SWITCH (record_type) %]

                    <a class="btn btn-default" href="/cgi-bin/koha/tools/manage-marc-import.pl?import_batch_id=[% import_batch_id | html %]"><i class="fa fa-list-ul"></i> Manage staged records</a>

    [% CASE 'biblio' %]

            </div>

        <li>Processing bibliographic records</li>

    [% CASE 'auth' %]

            <h1>MARC staging</h1>

        <li>Processing authority records</li>

            <div class="dialog message">

    [% END %]

              <p>The job has been enqueued! It will be processed as soon as possible.</p>

	<li>[% total | html %]  records in file</li>

              <p><a href="/cgi-bin/koha/admin/background_jobs.pl?op=view&id=[% job_id | uri %]" title="View detail of the enqueued job">View detail of the enqueued job</a>

	<li>[% import_errors | html %] records not staged because of MARC error</li>

            </div>

	<li>[% staged | html %] records staged</li>

    [% IF ( checked_matches ) %]

	<li>[% matched | html %] records with at least one match in catalog per matching rule 

        &quot;[% matcher_code | html %]&quot;</li>

    [% ELSE %]

        [% IF ( matcher_failed ) %]

          <li>Record matching failed -- unable to retrieve selected matching rule.</li>

<form method="post" action="[% SCRIPT_NAME | html %]" id="uploadfile" enctype="multipart/form-data">

<form method="post" id="uploadfile" enctype="multipart/form-data">

    <form method="post" id="processfile" action="[% SCRIPT_NAME | html %]" enctype="multipart/form-data">

    <form method="post" id="processfile" enctype="multipart/form-data">

       <div id="jobpanel"><div id="jobstatus" class="progress_panel">Job progress: <div id="jobprogress"></div> <span id="jobprogresspercent">0</span>%</div>

     <div id="jobfailed"></div></div>

            $("#mainformsubmit").on("click",function(){

            $("#mainformsubmit").on("click",function(e){

                return CheckForm( document.getElementById("processfile"));

                e.preventDefault();

                if ($("#fileToUpload").value == '') {

                    alert(_("Please upload a file first."));

                    return false;

                } else {

                    $("#processfile").submit();

                    return true;

                }

    SCRIPT_NAME => '/cgi-bin/koha/tools/stage-marc-import.pl',

    basketno     => $basketno,

    uploadmarc  => $fileID,

    record_type => $record_type,

    basketno => $basketno,

my %cookies = CGI::Cookie->fetch();

if ($fileID) {

my $sessionID = $cookies{'CGISESSID'}->value;

if ($completedJobID) {

    my $job = C4::BackgroundJob->fetch($sessionID, $completedJobID);

    my $results = $job->results();

    $template->param(map { $_ => $results->{$_} } keys %{ $results });

} elsif ($fileID) {

    my $file = $upload->full_path;

    my $filepath = $upload->full_path;

    my ( $errors, $marcrecords );

    my $params = {

    if( $format eq 'MARCXML' ) {

        record_type                => $record_type,

        ( $errors, $marcrecords ) = C4::ImportBatch::RecordsFromMARCXMLFile( $file, $encoding);

        encoding                   => $encoding,

    } elsif( $format eq 'ISO2709' ) {

        format                     => $format,

        ( $errors, $marcrecords ) = C4::ImportBatch::RecordsFromISO2709File( $file, $record_type, $encoding );

        filepath                   => $filepath,

    } else { # plugin based

        filename                   => $filename,

        $errors = [];

        marc_modification_template => $marc_modification_template,

        $marcrecords = C4::ImportBatch::RecordsFromMarcPlugin( $file, $format, $encoding );

        comments                   => $comments,

    }

        parse_items                => $parse_items,

    warn "$filename: " . ( join ',', @$errors ) if @$errors;

        matcher_id                 => $matcher_id,

        # no need to exit if we have no records (or only errors) here

        overlay_action             => $overlay_action,

        # BatchStageMarcRecords can handle that

        nomatch_action             => $nomatch_action,

        item_action                => $item_action,

    my $job = undef;

    };

    if ($runinbackground) {

    try {

        my $job_size = scalar(@$marcrecords);

        my $job_id = Koha::BackgroundJob::StageMARCForImport->new->enqueue( $params );

        # if we're matching, job size is doubled

        if ($job_id) {

        $job_size *= 2 if ($matcher_id ne "");

            $template->param(

        $job = C4::BackgroundJob->new($sessionID, $filename, '/cgi-bin/koha/tools/stage-marc-import.pl', $job_size);

                job_enqueued => 1,

        my $jobID = $job->id();

                job_id => $job_id,

            );

        # fork off

        if (my $pid = fork) {

            # parent

            # return job ID as JSON

            my $reply = CGI->new("");

            print $reply->header(-type => 'text/html');

            print '{"jobID":"' . $jobID . '"}';

            exit 0;

        } elsif (defined $pid) {

            # child

            # close STDOUT/STDERR to signal to end CGI session with Apache

            # Otherwise, the AJAX request to this script won't return properly

            close STDOUT;

            close STDERR;

        } else {

            # fork failed, so exit immediately

            warn "fork failed while attempting to run tools/stage-marc-import.pl as a background job: $!";

            exit 0;

        }

        # if we get here, we're a child that has detached

        # itself from Apache

    }

    my $schema = Koha::Database->new->schema;

    $schema->storage->txn_begin;

    # FIXME branch code

    my ( $batch_id, $num_valid, $num_items, @import_errors ) =

      BatchStageMarcRecords(

        $record_type,    $encoding,

        $marcrecords,    $filename,

        $marc_modification_template,

        $comments,       '',

        $parse_items,    0,

        50, staging_progress_callback( $job )

      );

    if($profile_id) {

        my $ibatch = Koha::ImportBatches->find($batch_id);

        $ibatch->set({profile_id => $profile_id})->store;

    }

    my $num_with_matches = 0;

    my $checked_matches = 0;

    my $matcher_failed = 0;

    my $matcher_code = "";

    if ($matcher_id ne "") {

        my $matcher = C4::Matcher->fetch($matcher_id);

        if (defined $matcher) {

            $checked_matches = 1;

            $matcher_code = $matcher->code();

            $num_with_matches =

              BatchFindDuplicates( $batch_id, $matcher, 10, 50,

                matching_progress_callback($job) );

            SetImportBatchMatcher($batch_id, $matcher_id);

            SetImportBatchOverlayAction($batch_id, $overlay_action);

            SetImportBatchNoMatchAction($batch_id, $nomatch_action);

            SetImportBatchItemAction($batch_id, $item_action);

            $schema->storage->txn_commit;

        } else {

            $matcher_failed = 1;

            $schema->storage->txn_rollback;

    catch {

    my $results = {

        warn $_;

        staged          => $num_valid,

        push @messages,

        matched         => $num_with_matches,

          {

        num_items       => $num_items,

            type  => 'error',

        import_errors   => scalar(@import_errors),

            code  => 'cannot_enqueue_job',

        total           => $num_valid + scalar(@import_errors),

            error => $_,

        checked_matches => $checked_matches,

          };

        matcher_failed  => $matcher_failed,

        matcher_code    => $matcher_code,

        import_batch_id => $batch_id,

        booksellerid    => $booksellerid,

        basketno        => $basketno

output_html_with_http_headers $input, $cookie, $template->output;

$template->param( messages => \@messages );

exit 0;

sub staging_progress_callback {

output_html_with_http_headers $input, $cookie, $template->output;

    my $job = shift;

    return sub {

        my $progress = shift;

        $job->progress($progress);

    }

}

sub matching_progress_callback {

    my $job = shift;

    my $start_progress = $job->progress();

    return sub {

        my $progress = shift;

        $job->progress($start_progress + $progress);

    }

}