Attachment #159147 for bug #17385

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




use Encode;
use vars qw(@ISA @EXPORT);

my $engine;    #XSLT Handler object

our ( @ISA, @EXPORT_OK );

our (@ISA, @EXPORT_OK);
BEGIN {
    require Exporter;
    @ISA       = qw(Exporter);
    @EXPORT_OK = qw(
        buildKohaItemsNamespace
        XSLTParse4Display
        &CustomXSLTExportList
    );
    $engine = Koha::XSLT::Base->new( { do_not_return_source => 1 } );
}

=head1 NAME

=cut

sub _get_best_default_xslt_filename {
    my ( $htdocs, $theme, $lang, $base_xslfile ) = @_;

    my @candidates = (
        "$htdocs/$theme/$lang/xslt/${base_xslfile}",    # exact match
        "$htdocs/$theme/en/xslt/${base_xslfile}",       # if not, preferred theme in English
        "$htdocs/prog/$lang/xslt/${base_xslfile}",      # if not, 'prog' theme in preferred language
        "$htdocs/prog/en/xslt/${base_xslfile}",         # otherwise, prog theme in English; should always
                                                        # exist
    );
    my $xslfilename;
    foreach my $filename (@candidates) {
        $xslfilename = $filename;
        if ( -f $filename ) {
            last;                                       # we have a winner!
        }
    }
    return $xslfilename;

    return $sysxml;
}

=head2 get_xsl_filename

    return xsl filenames in CustomXSLTExportPath or in /koha-tmpl/intranet-tmpl/prog/en/xslt/biblioexport/

=cut

sub get_xsl_filename {
    my ( $xslsyspref, $xslfilename ) = @_;

    my $lang = C4::Languages::getlanguage();

    $xslfilename ||= C4::Context->preference($xslsyspref) || "default";
    my $customXSLTExportPath = C4::Context->preference('CustomXSLTExportPath');

    if ( $xslsyspref eq "XSLTCustomExport" ) {
        my $dir;
        $dir =
            $customXSLTExportPath ?
            $customXSLTExportPath :
              C4::Context->config('intrahtdocs') . '/'
            . C4::Context->preference("template") . '/'
            . $lang
            . '/xslt/biblioexport';
        $xslfilename = $dir . "/" . $xslfilename;
    } elsif ( $xslsyspref eq "OPACXSLTCustomExport" ) {
        my $dir;
        $dir =
            $customXSLTExportPath ?
            $customXSLTExportPath :
              C4::Context->config('opachtdocs') . '/'
            . C4::Context->preference("opacthemes") . '/'
            . $lang
            . '/xslt/biblioexport';
        $xslfilename = $dir . "/" . $xslfilename;
    } elsif ( $xslfilename =~ /^\s*"?default"?\s*$/i ) {

        my ( $htdocs, $theme, $xslfile );

        if ( $xslsyspref eq "XSLTDetailsDisplay" ) {
            $htdocs  = C4::Context->config('intrahtdocs');
            $theme   = C4::Context->preference("template");
            $xslfile = C4::Context->preference('marcflavour') . "slim2intranetDetail.xsl";
        } elsif ( $xslsyspref eq "XSLTResultsDisplay" ) {
        } elsif ($xslsyspref eq "XSLTResultsDisplay") {
            $htdocs  = C4::Context->config('intrahtdocs');
            $theme   = C4::Context->preference("template");
            $xslfile = C4::Context->preference('marcflavour') . "slim2intranetResults.xsl";
        } elsif ( $xslsyspref eq "OPACXSLTDetailsDisplay" ) {
        } elsif ($xslsyspref eq "OPACXSLTDetailsDisplay") {
            $htdocs  = C4::Context->config('opachtdocs');
            $theme   = C4::Context->preference("opacthemes");
            $xslfile = C4::Context->preference('marcflavour') . "slim2OPACDetail.xsl";
        } elsif ( $xslsyspref eq "OPACXSLTResultsDisplay" ) {
        } elsif ($xslsyspref eq "OPACXSLTResultsDisplay") {
            $htdocs  = C4::Context->config('opachtdocs');
            $theme   = C4::Context->preference("opacthemes");
            $xslfile = C4::Context->preference('marcflavour') . "slim2OPACResults.xsl";
        } elsif ( $xslsyspref eq 'XSLTListsDisplay' ) {

            # Lists default to *Results.xslt
            $htdocs  = C4::Context->config('intrahtdocs');
            $theme   = C4::Context->preference("template");
            $xslfile = C4::Context->preference('marcflavour') . "slim2intranetResults.xsl";
        } elsif ( $xslsyspref eq 'OPACXSLTListsDisplay' ) {

            # Lists default to *Results.xslt
            $htdocs  = C4::Context->config('opachtdocs');
            $theme   = C4::Context->preference("opacthemes");
            $xslfile = C4::Context->preference('marcflavour') . "slim2OPACResults.xsl";
                       "slim2OPACResults.xsl";
        }
        $xslfilename = _get_best_default_xslt_filename( $htdocs, $theme, $lang, $xslfile );
    }

    if ( $xslfilename =~ m/\{langcode\}/ ) {

}

sub XSLTParse4Display {
    my ($params) = @_;

    my $biblionumber = $params->{biblionumber};
    my $record       = $params->{record};

    die "Mandatory \$params->{xsl_syspref} was not provided, called with biblionumber $params->{biblionumber}"
        if not defined $params->{xsl_syspref};

    $xslfilename = get_xsl_filename( $xslsyspref, $xslfilename );

    my $frameworkcode    = GetFrameworkCode($biblionumber) || '';
    my $record_processor = Koha::RecordProcessor->new(
        {
            filters => ['ExpandCodedFields'],
            options => {
                interface     => $interface,
                frameworkcode => $frameworkcode


    # grab the XML, run it through our stylesheet, push it out to the browser
    my $itemsxml;
    if (   $xslsyspref eq "OPACXSLTDetailsDisplay"
        || $xslsyspref eq "XSLTDetailsDisplay"
        || $xslsyspref eq "XSLTResultsDisplay" )
    {
        $itemsxml = "";    #We don't use XSLT for items display on these pages
    } else {
        $itemsxml = buildKohaItemsNamespace( $biblionumber, $hidden_items, $items_rs );
    }
    my $xmlrecord = $record->as_xml( C4::Context->preference('marcflavour') );

    $variables ||= {};
    my $biblio;
    if ( $interface eq 'opac' && C4::Context->preference('OPACShowOpenURL') ) {
        my @biblio_itemtypes;
        $biblio //= Koha::Biblios->find($biblionumber);
        if ( C4::Context->preference('item-level_itypes') ) {
            @biblio_itemtypes = $biblio->items->get_column("itype");
        } else {
            push @biblio_itemtypes, $biblio->itemtype;
        }
        my @itypes   = split( /\s/, C4::Context->preference('OPACOpenURLItemTypes') );
        my %original = ();
        map { $original{$_} = 1 } @biblio_itemtypes;
        if ( grep { $original{$_} } @itypes ) {


    # embed variables
    my $varxml = "<variables>\n";
    while ( my ( $key, $value ) = each %$variables ) {
        $value //= q{};
        $varxml .= "<variable name=\"$key\">$value</variable>\n";
    }


    my $sysxml = get_xslt_sysprefs();
    $xmlrecord =~ s/\<\/record\>/$itemsxml$sysxml$varxml\<\/record\>/;
    if ($fixamps) {    # We need to correct the ampersand entities that Zebra outputs
        $xmlrecord =~ s/\&amp;amp;/\&amp;/g;
        $xmlrecord =~ s/\&amp\;lt\;/\&lt\;/g;
        $xmlrecord =~ s/\&amp\;gt\;/\&gt\;/g;

    #If the xslt should fail, we will return undef (old behavior was
    #raw MARC)
    #Note that we did set do_not_return_source at object construction
    return $engine->transform( $xmlrecord, $xslfilename );    #file or URL
}

=head2 buildKohaItemsNamespace

=cut

sub buildKohaItemsNamespace {
    my ( $biblionumber, $hidden_items, $items_rs ) = @_;

    $hidden_items ||= [];

    my $query = {};
    $query = { 'me.itemnumber' => { not_in => $hidden_items } }
        if $hidden_items;

    unless ( $items_rs && ref($items_rs) eq 'Koha::Items' ) {
        $query->{'me.biblionumber'} = $biblionumber;


    my $items = $items_rs->search( $query, { prefetch => [ 'branchtransfers', 'reserves' ] } );

    my $shelflocations = {
        map { $_->{authorised_value} => $_->{opac_description} }
            Koha::AuthorisedValues->get_descriptions_by_koha_field(
            { frameworkcode => "", kohafield => 'items.location' }
            )
    };
    my $ccodes = {
        map { $_->{authorised_value} => $_->{opac_description} }
            Koha::AuthorisedValues->get_descriptions_by_koha_field(
            { frameworkcode => "", kohafield => 'items.ccode' }
            )
    };

    my %branches =
        map { $_->branchcode => $_->branchname } Koha::Libraries->search( {}, { order_by => 'branchname' } )->as_list;

    my $itemtypes = { map { $_->{itemtype} => $_ } @{ Koha::ItemTypes->search->unblessed } };
    my $xml       = '';
    my %descs     = map { $_->{authorised_value} => $_ }
        Koha::AuthorisedValues->get_descriptions_by_koha_field( { kohafield => 'items.notforloan' } );
    my $ref_status = C4::Context->preference('Reference_NFL_Statuses') // q{};    # fallback to 1|2 removed

    while ( my $item = $items->next ) {
        my $status;

        my $recalls_count;

        if ( C4::Context->preference('UseRecalls') ) {
            $recalls_count = Koha::Recalls->search( { item_id => $item->itemnumber, status => 'waiting' } )->count;
        }

        if ($recalls_count) {

            # recalls take priority over holds
            $status    = 'other';
            $substatus = 'Recall waiting';
        } elsif ( $item->has_pending_hold ) {
            $status    = 'other';
            $status = 'other';
            $substatus = 'Pending hold';
        } elsif ( $item->holds->waiting->count ) {
            $status    = 'other';
            $status = 'other';
            $substatus = 'Hold waiting';
        } elsif ( $item->get_transfer ) {
            $status    = 'other';
            $status = 'other';
            $substatus = 'In transit';
        } elsif ( $item->damaged ) {
            $status    = 'other';
            $status = 'other';
            $substatus = "Damaged";
        } elsif ( $item->itemlost ) {
            $status    = 'other';
            $status = 'other';
            $substatus = "Lost";
        } elsif ( $item->withdrawn ) {
            $status    = 'other';
            $status = 'other';
            $substatus = "Withdrawn";
        } elsif ( $item->onloan ) {
            $status    = 'other';
            $status = 'other';
            $substatus = "Checked out";
        } elsif ( $item->notforloan ) {
            $status =
                $item->notforloan =~ /^($ref_status)$/
                ? "reference"
                : "reallynotforloan";
            $substatus =
                exists $descs{ $item->notforloan } ? $descs{ $item->notforloan }->{opac_description} : "Not for loan";
        } elsif ( exists $itemtypes->{ $item->effective_itemtype }
            && $itemtypes->{ $item->effective_itemtype }->{notforloan}
            && $itemtypes->{ $item->effective_itemtype }->{notforloan} == 1 )
        {
            $status =
                  "1" =~ /^($ref_status)$/
                ? "reference"
                : "reallynotforloan";
            $substatus = "Not for loan";
        } else {
        else {
            $status = "available";
        }
        my $homebranch    = C4::Koha::xml_escape( $branches{ $item->homebranch } );
        my $holdingbranch = C4::Koha::xml_escape( $branches{ $item->holdingbranch } );
        my $resultbranch = C4::Context->preference('OPACResultsLibrary') eq 'homebranch' ? $homebranch : $holdingbranch;
        my $location     = C4::Koha::xml_escape(
              $item->location && exists $shelflocations->{ $item->location }
            ? $shelflocations->{ $item->location }
            : $item->location
        );
        my $ccode = C4::Koha::xml_escape( $item->ccode
                && exists $ccodes->{ $item->ccode } ? $ccodes->{ $item->ccode } : $item->ccode );
        my $itemcallnumber = C4::Koha::xml_escape( $item->itemcallnumber );
        my $stocknumber    = C4::Koha::xml_escape( $item->stocknumber );
        $xml .=
              "<item>"
            . "<homebranch>$homebranch</homebranch>"
            . "<holdingbranch>$holdingbranch</holdingbranch>"
            . "<resultbranch>$resultbranch</resultbranch>"
            . "<location>$location</location>"
            . "<ccode>$ccode</ccode>"
            . "<status>"
            . ( $status // q{} )
            . "</status>"
            . "<substatus>$substatus</substatus>"
            . "<itemcallnumber>$itemcallnumber</itemcallnumber>"
            . "<stocknumber>$stocknumber</stocknumber>"
            . "</item>";
    }
    $xml = "<items xmlns=\"http://www.koha-community.org/items\">" . $xml . "</items>";
    return $xml;
}


=cut

sub CustomXSLTExportList {
    my $opac = shift;    # opac (1) vs intranet (0)
    return [] if $opac && C4::Context->preference('OpacExportOptions') !~ /custom/;

    my $customXSLTExportPath = C4::Context->preference('CustomXSLTExportPath');

    # Check the cache first
    my $cache      = Koha::Caches->get_instance;
    my $key        = $opac ? 'CustomXSLTExportListOPAC' : 'CustomXSLTExportListIntra';
    my $cached_val = $cache->get_from_cache($key);
    return $cached_val if $cached_val;

    my @tabFiles;

    my $dir =
        $customXSLTExportPath ?
        $customXSLTExportPath :
          C4::Context->config( $opac     ? 'opachtdocs' : 'intrahtdocs' ) . '/'
        . C4::Context->preference( $opac ? "opacthemes" : "template" ) . '/'
        . C4::Languages::getlanguage()
        . '/xslt/biblioexport';
    my @files = glob qq("$dir/*.xsl");
    foreach my $file (@files) {
        if ( -f "$file" ) {
            ( my $text = $file ) =~ s/.*\///g;

            ## Get title of the option
            my $dom;
            eval { $dom = XML::LibXML->load_xml( location => $file ); };
            next unless $dom;

            my $node  = $dom->documentElement();
            my $title = $node->{"title"};
            ( $title = $text ) =~ s/\.xsl// unless defined $title;

            # Get output format
            # There should only be one xsl:output node, so taking the first one only is OK
            $node = @{ $node->findnodes("xsl:output") }[0];
            my $outputformat = "";
            $outputformat = $node->{"method"} if $node;
            $outputformat = "txt"             if ( $outputformat eq "" || $outputformat eq "text" );

            my %row = (
                value    => $text,
                filename => $title,
                format   => $outputformat,
            );

            push @tabFiles, \%row;
        }
    }
    $cache->set_in_cache( $key, [@tabFiles] );
    return \@tabFiles;
}
1;

Lines 112-120 my $resultsarray = \@results; Link Here

(-)a/basket/basket.pl (-3 / +3 lines)
112		112
113	$template->param(	113	$template->param(
114	BIBLIO_RESULTS => $resultsarray,	114	BIBLIO_RESULTS => $resultsarray,
115	csv_profiles => Koha::CsvProfiles->search({ type => 'marc', used_for => 'export_records' }),	115	csv_profiles => Koha::CsvProfiles->search({ type => 'marc', used_for => 'export_records' }),
116	xsl_exports => CustomXSLTExportList(),	116	xsl_exports => CustomXSLTExportList(),
117	bib_list => $bib_list,	117	bib_list => $bib_list,
118	);	118	);
119		119
120	output_html_with_http_headers $query, $cookie, $template->output;	120	output_html_with_http_headers $query, $cookie, $template->output;




use utf8;
my $query = CGI->new;

my ( $template, $borrowernumber, $cookie ) = get_template_and_user(
    {
        template_name => "basket/downloadcart.tt",
        query         => $query,
        type          => "intranet",
        flagsrequired => { catalogue => 1 },
    }
);

my $bib_list = $query->param('bib_list');
my $format   = $query->param('format');
my $dbh      = C4::Context->dbh;

if ( $bib_list && $format ) {

    my @bibs = split( /\//, $bib_list );

    my $marcflavour = C4::Context->preference('marcflavour');
    my $output;

    # CSV
    if ( $format =~ /^\d+$/ ) {

        $output = marc2csv( \@bibs, $format );

        # Other formats
    } else {

        foreach my $biblionumber (@bibs) {

            my $biblio  = Koha::Biblios->find($biblionumber);
            my $record  = $biblio->metadata->record( { embed_items => 1 } );
            my $xslFile = $query->param("file");
            next unless $record;

            if ( $format eq 'iso2709' ) {

                #NOTE: If we don't explicitly UTF-8 encode the output,
                #the browser will guess the encoding, and it won't always choose UTF-8.
                $output .= encode( "UTF-8", $record->as_usmarc() ) // q{};
            } elsif ( $format eq 'ris' ) {
            elsif ($format eq 'ris') {
                $output .= marc2ris($record);
            } elsif ( $format eq 'bibtex' ) {
                $output .= marc2bibtex( $record, $biblionumber );
            } elsif ( $format =~ /^xsl\.(.*)$/ ) {
                $output .= XSLTParse4Display(
                    {
                        biblionumber => $biblio,
                        record       => $record,
                        xsl_syspref  => "XSLTCustomExport",
                        fix_amps     => 1,
                        hidden_items => undef,
                        xslfilename  => $xslFile,
                    }
                );
            }
        }
    }

    # If it was a CSV export we change the format after the export so the file extension is fine
    $format = "csv"  if ( $format =~ m/^\d+$/ );
    $format = "html" if ( $format =~ /^xsl\./ );

    print $query->header(
        -type                        => 'application/octet-stream',
        -'Content-Transfer-Encoding' => 'binary',
        -attachment                  => "cart.$format"
    );
    print $output;

} else {
    $template->param( csv_profiles => Koha::CsvProfiles->search( { type => 'marc', used_for => 'export_records' } ) );
    $template->param( xsl_exports  => CustomXSLTExportList() );
    $template->param( bib_list     => $bib_list );
    output_html_with_http_headers $query, $cookie, $template->output;
}

Lines 85-92 if ( C4::Context->config('enable_plugins') ) { Link Here

(-)a/catalogue/detail.pl (-2 / +2 lines)
85	);	85	);
86	}	86	}
87		87
88	##### ADD CUSTOM XSLT	88	# Add custom XSLT
89	$template->param(filesOptions => CustomXSLTExportList(0));	89	$template->param( filesOptions => CustomXSLTExportList(0) );
90		90
91	my $biblionumber = $query->param('biblionumber');	91	my $biblionumber = $query->param('biblionumber');
92	$biblionumber = HTML::Entities::encode($biblionumber);	92	$biblionumber = HTML::Entities::encode($biblionumber);




use C4::XSLT qw( XSLTParse4Display );
use Koha::Biblios;



my $query = CGI->new;
my ( $template, $loggedinuser, $cookie ) = get_template_and_user(
    {
        template_name => "tools/export.tt",
        query         => $query,
        type          => "intranet",
        flagsrequired => { catalogue => 1 },
    }
);

my $op     = $query->param("op");
my $format = $query->param("format");
my $error  = '';
if ( $op eq "export" ) {
    my $biblionumber = $query->param("bib");
    if ($biblionumber) {
        my $file_id  = $biblionumber;
        my $file_pre = "bib-";

        my $biblio = Koha::Biblios->find($biblionumber);
        my $marc   = $biblio->metadata->record( { embed_items => 1 } );

        if ( C4::Context->preference('DefaultSaveRecordFileID') eq 'controlnumber' ) {
            my $marcflavour = C4::Context->preference('marcflavour')
                ;    #FIXME This option is required but does not change control num behaviour
            my $control_num = GetMarcControlnumber( $marc, $marcflavour );
            if ($control_num) {
                $file_id  = $control_num;
                $file_pre = "record-";
            }
        }

        if ( $format =~ /endnote/ ) {
            $marc   = marc2endnote($marc);
            $format = 'endnote';
        } elsif ( $format =~ /marcxml/ ) {
            $marc   = marc2marcxml($marc);
            $format = "marcxml";
        } elsif ( $format =~ /mods/ ) {
            $marc   = marc2modsxml($marc);
            $format = "mods";
        } elsif ( $format =~ /ris/ ) {
            $marc   = marc2ris($marc);
            $format = "ris";
        } elsif ( $format =~ /bibtex/ ) {
            $marc   = marc2bibtex($marc);
            $format = "bibtex";
        } elsif ( $format =~ /dc$/ ) {
            $marc   = marc2dcxml( undef, undef, $biblionumber, $format );
            $format = "dublin-core.xml";
        } elsif ( $format =~ /marc8/ ) {
            $marc   = changeEncoding( $marc, "MARC", "MARC21", "MARC-8" );
            $marc   = $marc->as_usmarc();
            $format = "marc8";
        } elsif ( $format =~ /utf8/ ) {
            C4::Charset::SetUTF8Flag( $marc, 1 );
            $marc   = $marc->as_usmarc();
            $format = "utf8";
        } elsif ( $format =~ /marcstd/ ) {
            C4::Charset::SetUTF8Flag( $marc, 1 );
            ( $error, $marc ) = marc2marc( $marc, 'marcstd', C4::Context->preference('marcflavour') );
            $format = "marcstd";
        }
        if ( $format =~ /utf8/ or $format =~ /marcstd/ ) {
            binmode STDOUT, ':encoding(UTF-8)';
            }
            elsif ($format =~ /marcstd/) {
                C4::Charset::SetUTF8Flag($marc,1);
                ($error, $marc) = marc2marc($marc, 'marcstd', C4::Context->preference('marcflavour'));
                $format = "marcstd";
            }
            if ( $format =~ /utf8/ or $format =~ /marcstd/ ) {
                binmode STDOUT, ':encoding(UTF-8)';
            }
            print $query->header(
                -type => 'application/octet-stream',
                -attachment=>"$file_pre$file_id.$format");
            print $marc;
        }
        print $query->header(
            -type       => 'application/octet-stream',
            -attachment => "$file_pre$file_id.$format"
        );
        print $marc;
    }
} elsif ( $op eq "exportxsl" ) {
    my $biblionumber = $query->param("bib");
    if ($biblionumber) {
        my $xslFile = $query->param("file");
        my $biblio  = Koha::Biblios->find($biblionumber);
        my $marc    = $biblio->metadata->record( { embed_items => 1 } );
        my $format  = $query->param("format") || 'txt';
        my @hiddenitems;

        $marc = XSLTParse4Display(
            {
                biblionumber => $biblionumber,
                record       => $marc,
                xsl_syspref  => "XSLTCustomExport",
                fix_amps     => 1,
                hidden_items => \@hiddenitems,
                xslfilename  => $xslFile,
            }
        );
        print $query->header(
            -type       => 'application/octet-stream',
            -attachment => "bib-$biblionumber.$format"
        );
        print $marc;
    }
}




use Modern::Perl;

return {
    bug_number  => "17385",
    description => "Add a custom option for OpacExportOptions system preference",
    up          => sub {
        my ($args) = @_;
        my ( $dbh, $out ) = @$args{qw(dbh out)};

        $dbh->do(
            q{
                UPDATE systempreferences
                SET value = 'bibtex,dc,marcxml,marc8,utf8,marcstd,mods,ris,isbd,custom'
                WHERE variable = 'OpacExportOptions';
            }
        );

        $dbh->do(
            q{
                INSERT IGNORE INTO systempreferences (variable,value,options,explanation,type)
                VALUES ('CustomXSLTExportPath','','','The path to the folder containing the customized XSL files for export','');
            }
        );

        # sysprefs
        say $out "Updated system preference 'OpacExportOptions'";
        say $out "Added new system preference 'OpacCustomExportFilePath'";
    },
};

Lines 107-113 Link Here

(-)a/koha-tmpl/intranet-tmpl/prog/en/includes/cat-toolbar.inc (-1 / +1 lines)
107	<li><a href="/cgi-bin/koha/catalogue/export.pl?format=mods&op=export&bib=[% biblionumber \| uri %]">MODS (XML)</a></li>	107	<li><a href="/cgi-bin/koha/catalogue/export.pl?format=mods&op=export&bib=[% biblionumber \| uri %]">MODS (XML)</a></li>
108	<li><a href="/cgi-bin/koha/catalogue/export.pl?format=ris&op=export&bib=[% biblionumber \| uri %]">RIS</a></li>	108	<li><a href="/cgi-bin/koha/catalogue/export.pl?format=ris&op=export&bib=[% biblionumber \| uri %]">RIS</a></li>
109	[% FOREACH filesOption IN filesOptions %]	109	[% FOREACH filesOption IN filesOptions %]
110	<li><a href="/cgi-bin/koha/catalogue/export.pl?format=[% filesOption.format \| uri %]&op=exportxsl&file=[% filesOption.value \| uri %]&bib=[% biblionumber \| uri %]">XSL - [% filesOption.filename \| html %]</a></li>	110	<li><a href="/cgi-bin/koha/catalogue/export.pl?format=[% filesOption.format \| uri %]&op=exportxsl&file=[% filesOption.value \| uri %]&bib=[% biblionumber \| uri %]">[% filesOption.filename \| html %]</a></li>
111	[% END %]	111	[% END %]
112	</ul>	112	</ul>
113	</div>	113	</div>

Lines 39-45 Link Here

(-)a/koha-tmpl/intranet-tmpl/prog/en/includes/virtualshelves-toolbar.inc (-1 / +1 lines)
39	<li><a href="/cgi-bin/koha/virtualshelves/downloadshelf.pl?format=[% csv_profile.export_format_id \| uri %]&shelfid=[% shelf.shelfnumber \| uri %]">CSV - [% csv_profile.profile \| html %]</a></li>	39	<li><a href="/cgi-bin/koha/virtualshelves/downloadshelf.pl?format=[% csv_profile.export_format_id \| uri %]&shelfid=[% shelf.shelfnumber \| uri %]">CSV - [% csv_profile.profile \| html %]</a></li>
40	[% END %]	40	[% END %]
41	[% FOREACH xsl_export IN xsl_exports %]	41	[% FOREACH xsl_export IN xsl_exports %]
42	<li><a href="/cgi-bin/koha/virtualshelves/downloadshelf.pl?format=xsl.[% xsl_export.value \| uri %]&file=[% xsl_export.value \| uri %]&shelfid=[% shelf.shelfnumber \| uri %]">XSL - [% xsl_export.filename \| html %]</a></li>	42	<li><a href="/cgi-bin/koha/virtualshelves/downloadshelf.pl?format=xsl.[% xsl_export.value \| uri %]&file=[% xsl_export.value \| uri %]&shelfid=[% shelf.shelfnumber \| uri %]">[% xsl_export.filename \| html %]</a></li>
43	[% END %]	43	[% END %]
44	</ul>	44	</ul>
45	</div>	45	</div>

Lines 384-389 Cataloging: Link Here

(-)a/koha-tmpl/intranet-tmpl/prog/en/modules/admin/preferences/cataloguing.pref (+5 lines)
384	- "All values of repeating tags and subfields will be printed with the given BibTeX tag."	384	- "All values of repeating tags and subfields will be printed with the given BibTeX tag."
385	- "<br/>"	385	- "<br/>"
386	- "Use '@' ( with quotes ) as the BT_TAG to replace the bibtex record type with a field value of your choosing."	386	- "Use '@' ( with quotes ) as the BT_TAG to replace the bibtex record type with a field value of your choosing."
		387	-
		388	- "Use this"
		389	- pref: CustomXSLTExportPath
		390	class: long
		391	- "as the path containing the customized XSL files for export (write the complete path)."
387	-	392	-
388	- "Include the following fields when exporting RIS:"	393	- "Include the following fields when exporting RIS:"
389	- pref: RisExportAdditionalFields	394	- pref: RisExportAdditionalFields

Lines 280-286 OPAC: Link Here

(-)a/koha-tmpl/intranet-tmpl/prog/en/modules/admin/preferences/opac.pref (-1 / +1 lines)
280	mods: MODS	280	mods: MODS
281	ris: RIS	281	ris: RIS
282	isbd: ISBD	282	isbd: ISBD
283	custom: XSL - Simple Export	283	custom: Simple HTML formats
284	-	284	-
285	- pref: OpacSeparateHoldings	285	- pref: OpacSeparateHoldings
286	choices:	286	choices:

Lines 64-70 Link Here

(-)a/koha-tmpl/intranet-tmpl/prog/en/modules/basket/basket.tt (-1 / +1 lines)
64	<li><a href="/cgi-bin/koha/basket/downloadcart.pl?format=[% csv_profile.export_format_id \| uri %]&bib_list=[% bib_list \| uri %]">CSV - [% csv_profile.profile \| html %]</a></li>	64	<li><a href="/cgi-bin/koha/basket/downloadcart.pl?format=[% csv_profile.export_format_id \| uri %]&bib_list=[% bib_list \| uri %]">CSV - [% csv_profile.profile \| html %]</a></li>
65	[% END %]	65	[% END %]
66	[% FOREACH xsl_export IN xsl_exports %]	66	[% FOREACH xsl_export IN xsl_exports %]
67	<li><a href="/cgi-bin/koha/basket/downloadcart.pl?format=xsl.[% xsl_export.value \| uri %]&file=[% xsl_export.value \| uri %]&bib_list=[% bib_list \| uri %]">XSL - [% xsl_export.filename \| html %]</a></li>	67	<li><a href="/cgi-bin/koha/basket/downloadcart.pl?format=xsl.[% xsl_export.value \| uri %]&file=[% xsl_export.value \| uri %]&bib_list=[% bib_list \| uri %]">[% xsl_export.filename \| html %]</a></li>
68	[% END %]	68	[% END %]
69	</ul>	69	</ul>
70	</div>	70	</div>

Lines 1099-1105 Link Here

(-)a/koha-tmpl/intranet-tmpl/prog/en/modules/catalogue/detail.tt (-1 / +1 lines)
1099	<option value="marc8">MARC (non-Unicode/MARC-8)</option>	1099	<option value="marc8">MARC (non-Unicode/MARC-8)</option>
1100	<option value="utf8">MARC (Unicode/UTF-8)</option>	1100	<option value="utf8">MARC (Unicode/UTF-8)</option>
1101	[% FOREACH filesOption IN filesOptions %]	1101	[% FOREACH filesOption IN filesOptions %]
1102	<option value="[% filesOption.value \| html %]">XSL -[% filesOption.filename \| html %]</option>	1102	<option value="[% filesOption.value \| html %]">[% filesOption.filename \| html %]</option>
1103	[% END %]</select>	1103	[% END %]</select>
1104	<input type="submit" name="save" class="btn btn-primary" value="Download record" /></td>	1104	<input type="submit" name="save" class="btn btn-primary" value="Download record" /></td>
1105	</tr>	1105	</tr>

Lines 43-49 Link Here

(-)a/koha-tmpl/intranet-tmpl/prog/en/modules/virtualshelves/downloadshelf.tt (-1 / +1 lines)
43	<option value="[% csv_profile.export_format_id \| html %]">CSV - [% csv_profile.profile \| html %]</option>	43	<option value="[% csv_profile.export_format_id \| html %]">CSV - [% csv_profile.profile \| html %]</option>
44	[% END %]	44	[% END %]
45	[% FOREACH xsl_export IN xsl_exports %]	45	[% FOREACH xsl_export IN xsl_exports %]
46	<option value="xsl.[% xsl_export.value \| html %]">XSL - [% xsl_export.filename \| html %]</option>	46	<option value="xsl.[% xsl_export.value \| html %]">[% xsl_export.filename \| html %]</option>
47	[% END %]	47	[% END %]
48	</select>	48	</select>
49	</li></ol>	49	</li></ol>

Lines 1-62 Link Here

(-)a/koha-tmpl/intranet-tmpl/prog/en/xslt/biblioexport/MARC21_simple_export.xsl (-52 / +79 lines)
1	<?xml version="1.0" encoding="UTF-8"?>	1	<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
		2
		3	<!DOCTYPE stylesheet>
		4
2	<xsl:stylesheet version="1.0"	5	<xsl:stylesheet version="1.0"
3	xmlns:xsl="http://www.w3.org/1999/XSL/Transform"	6	xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
4	xmlns:marc="http://www.loc.gov/MARC21/slim"	7	xmlns:marc="http://www.loc.gov/MARC21/slim"
5	title="Simple Export">	8	exclude-result-prefixes="marc"
6	<xsl:output method="html" encoding="UTF-8"/>	9	title="Simple Export">
		10
		11	<xsl:output
		12	method="html"
		13	indent="yes"
		14	encoding="UTF-8"/>
7		15
8	<xsl:template match="/">	16	<xsl:template match="/">
9	<xsl:apply-templates/>	17	<xsl:text disable-output-escaping='yes'><!DOCTYPE html></xsl:text>
		18
		19	<html lang="en">
		20	<head>
		21	<meta http-equiv="Content-Type" content="text/html"/>
		22	<meta name="viewport" content="width=device-width, initial-scale=1.0"/>
		23	<title>Simple Export</title>
		24	</head>
		25
		26	<body>
		27	<xsl:apply-templates/>
		28	</body>
		29	</html>
10	</xsl:template>	30	</xsl:template>
11		31
12	<xsl:template match="marc:record">	32	<xsl:template match="marc:record">
13	<p>	33	<p>
14	<xsl:if test="marc:datafield[@tag=245]">	34	<xsl:if test="marc:datafield[@tag=245]">
15	<xsl:for-each select="marc:datafield[@tag=245]">	35	<xsl:for-each select="marc:datafield[@tag=245]">
16	<xsl:value-of select="marc:subfield[@code='a']"/>	36	<xsl:value-of select="marc:subfield[@code='a']"/>
17	<xsl:if test="marc:subfield[@code='b']">	37
18	<xsl:text> </xsl:text>	38	<xsl:if test="marc:subfield[@code='b']">
19	<xsl:value-of select="marc:subfield[@code='b']"></xsl:value-of>	39	<xsl:text> </xsl:text>
20	</xsl:if>	40	<xsl:value-of select="marc:subfield[@code='b']"></xsl:value-of>
21	<xsl:if test="marc:subfield[@code='c']">	41	</xsl:if>
22	<xsl:text> </xsl:text>	42
23	<xsl:value-of select="marc:subfield[@code='c']"></xsl:value-of>	43	<xsl:if test="marc:subfield[@code='c']">
24	</xsl:if>	44	<xsl:text> </xsl:text>
25	</xsl:for-each>	45	<xsl:value-of select="marc:subfield[@code='c']"></xsl:value-of>
26	</xsl:if>	46	</xsl:if>
27	<xsl:if test="marc:datafield[@tag=260]">	47	</xsl:for-each>
28	<br/>
29	<xsl:for-each select="marc:datafield[@tag=260]">
30	<xsl:if test="marc:subfield[@code='a']">
31	<xsl:value-of select="marc:subfield[@code='a']"/>
32	</xsl:if>
33	<xsl:if test="marc:subfield[@code='b']">
34	<xsl:text> </xsl:text>
35	<xsl:value-of select="marc:subfield[@code='b']"></xsl:value-of>
36	</xsl:if>
37	<xsl:if test="marc:subfield[@code='c']">
38	<xsl:text> </xsl:text>
39	<xsl:value-of select="marc:subfield[@code='c']"></xsl:value-of>
40	</xsl:if>
41	</xsl:for-each>
42	</xsl:if>
43	<xsl:if test="marc:datafield[@tag=264]">
44	<br/>
45	<xsl:for-each select="marc:datafield[@tag=264]">
46	<xsl:if test="marc:subfield[@code='a']">
47	<xsl:value-of select="marc:subfield[@code='a']"/>
48	</xsl:if>	48	</xsl:if>
49	<xsl:if test="marc:subfield[@code='b']">	49
50	<xsl:text> </xsl:text>	50	<xsl:if test="marc:datafield[@tag=260]">
51	<xsl:value-of select="marc:subfield[@code='b']"></xsl:value-of>	51	<br/>
		52	<xsl:for-each select="marc:datafield[@tag=260]">
		53	<xsl:if test="marc:subfield[@code='a']">
		54	<xsl:value-of select="marc:subfield[@code='a']"/>
		55	</xsl:if>
		56
		57	<xsl:if test="marc:subfield[@code='b']">
		58	<xsl:text> </xsl:text>
		59	<xsl:value-of select="marc:subfield[@code='b']"></xsl:value-of>
		60	</xsl:if>
		61
		62	<xsl:if test="marc:subfield[@code='c']">
		63	<xsl:text> </xsl:text>
		64	<xsl:value-of select="marc:subfield[@code='c']"></xsl:value-of>
		65	</xsl:if>
		66	</xsl:for-each>
52	</xsl:if>	67	</xsl:if>
53	<xsl:if test="marc:subfield[@code='c']">	68
54	<xsl:text> </xsl:text>	69	<xsl:if test="marc:datafield[@tag=264]">
55	<xsl:value-of select="marc:subfield[@code='c']"></xsl:value-of>	70	<br/>
		71	<xsl:for-each select="marc:datafield[@tag=264]">
		72	<xsl:if test="marc:subfield[@code='a']">
		73	<xsl:value-of select="marc:subfield[@code='a']"/>
		74	</xsl:if>
		75
		76	<xsl:if test="marc:subfield[@code='b']">
		77	<xsl:text> </xsl:text>
		78	<xsl:value-of select="marc:subfield[@code='b']"></xsl:value-of>
		79	</xsl:if>
		80
		81	<xsl:if test="marc:subfield[@code='c']">
		82	<xsl:text> </xsl:text>
		83	<xsl:value-of select="marc:subfield[@code='c']"></xsl:value-of>
		84	</xsl:if>
		85	</xsl:for-each>
56	</xsl:if>	86	</xsl:if>
57	</xsl:for-each>	87	</p>
58	</xsl:if>
59	</p>
60	</xsl:template>	88	</xsl:template>
61		89	</xsl:stylesheet>
62	</xsl:stylesheet>

Lines 87-93 Link Here

(-)a/koha-tmpl/opac-tmpl/bootstrap/en/includes/opac-detail-sidebar.inc (-1 / +1 lines)
87	</a>	87	</a>
88	[% ELSE %]	88	[% ELSE %]
89	[% FOREACH filesOption IN filesOptions %]	89	[% FOREACH filesOption IN filesOptions %]
90	<a href="/cgi-bin/koha/opac-export.pl?format=[% filesOption.format \| html %]&op=exportxsl&file=[% filesOption.value \| html %]&bib=[% biblionumber \| html %]" >XSL - [% filesOption.filename \| html %]</a>	90	<a href="/cgi-bin/koha/opac-export.pl?format=[% filesOption.format \| url %]&op=exportxsl&file=[% filesOption.value \| url %]&bib=[% biblionumber \| url %]" >[% filesOption.filename \| html %]</a>
91	[% END %]	91	[% END %]
92	[% END %]	92	[% END %]
93	[% END %]	93	[% END %]

Lines 44-50 Link Here

(-)a/koha-tmpl/opac-tmpl/bootstrap/en/modules/opac-basket.tt (-1 / +1 lines)
44	[% FOREACH option IN export_options %]	44	[% FOREACH option IN export_options %]
45	[% IF option == 'custom' %]	45	[% IF option == 'custom' %]
46	[% FOREACH xsl_export IN xsl_exports %]	46	[% FOREACH xsl_export IN xsl_exports %]
47	<a role="menuitem" class="dropdown-item" href="/cgi-bin/koha/opac-downloadcart.pl?format=xsl.[% xsl_export.value \| uri %]&file=[% xsl_export.value \| uri %]&bib_list=[% bib_list \| uri %]">XSL - [% xsl_export.filename \| html %]</a></li>	47	<a role="menuitem" class="dropdown-item" href="/cgi-bin/koha/opac-downloadcart.pl?format=xsl.[% xsl_export.value \| uri %]&file=[% xsl_export.value \| uri %]&bib_list=[% bib_list \| uri %]">[% xsl_export.filename \| html %]</a></li>
48	[% END %]	48	[% END %]
49	[% END %]	49	[% END %]
50	[% END %]	50	[% END %]

Lines 21-27 Link Here

(-)a/koha-tmpl/opac-tmpl/bootstrap/en/modules/opac-downloadcart.tt (-1 / +1 lines)
21	<option value="[% csv_profile.export_format_id \| html %]">CSV - [% csv_profile.profile \| html %]</option>	21	<option value="[% csv_profile.export_format_id \| html %]">CSV - [% csv_profile.profile \| html %]</option>
22	[% END %]	22	[% END %]
23	[% FOREACH xsl_export IN xsl_exports %]	23	[% FOREACH xsl_export IN xsl_exports %]
24	<option value="xsl.[% xsl_export.value \| html %]">XSL - [% xsl_export.filename \| html %]</option>	24	<option value="xsl.[% xsl_export.value \| html %]">[% xsl_export.filename \| html %]</option>
25	[% END %]	25	[% END %]
26	</select>	26	</select>
27	<fieldset class="action">	27	<fieldset class="action">

Lines 69-75 Link Here

(-)a/koha-tmpl/opac-tmpl/bootstrap/en/modules/opac-downloadshelf.tt (-1 / +1 lines)
69	<option value="[% csv_profile.export_format_id \| html %]">CSV - [% csv_profile.profile \| html %]</option>	69	<option value="[% csv_profile.export_format_id \| html %]">CSV - [% csv_profile.profile \| html %]</option>
70	[% END %]	70	[% END %]
71	[% FOREACH xsl_export IN xsl_exports %]	71	[% FOREACH xsl_export IN xsl_exports %]
72	<option value="xsl.[% xsl_export.value \| html %]">XSL - [% xsl_export.filename \| html %]</option>	72	<option value="xsl.[% xsl_export.value \| html %]">[% xsl_export.filename \| html %]</option>
73	[% END %]	73	[% END %]
74	</select>	74	</select>
75	<span class="required">Required</span>	75	<span class="required">Required</span>

Lines 237-243 Link Here

(-)a/koha-tmpl/opac-tmpl/bootstrap/en/modules/opac-shelves.tt (-1 / +1 lines)
237	[% FOREACH option IN export_options %]	237	[% FOREACH option IN export_options %]
238	[% IF option == 'custom' %]	238	[% IF option == 'custom' %]
239	[% FOREACH xsl_export IN xsl_exports %]	239	[% FOREACH xsl_export IN xsl_exports %]
240	<a role="menuitem" class="dropdown-item" href="/cgi-bin/koha/opac-downloadshelf.pl?format=xsl.[% xsl_export.value \| uri %]&file=[% xsl_export.value \| uri %]&shelfnumber=[% shelf.shelfnumber \| uri %]">XSL - [% xsl_export.filename \| html %]</a></li>	240	<a role="menuitem" class="dropdown-item" href="/cgi-bin/koha/opac-downloadshelf.pl?format=xsl.[% xsl_export.value \| uri %]&file=[% xsl_export.value \| uri %]&shelfnumber=[% shelf.shelfnumber \| uri %]">[% xsl_export.filename \| html %]</a></li>
241	[% END %]	241	[% END %]
242	[% END %]	242	[% END %]
243	[% END %]	243	[% END %]





my $query = CGI->new;

my ( $template, $borrowernumber, $cookie ) = get_template_and_user(
    {
        template_name   => "opac-basket.tt",
        query           => $query,

    }
);

my $bib_list = $query->param('bib_list');
my $verbose  = $query->param('verbose');

if ($verbose) { $template->param( verbose => 1 ); }

my @bibs = split( /\//, $bib_list );
my @results;

my $num         = 1;
my $marcflavour = C4::Context->preference('marcflavour');
if ( C4::Context->preference('TagsEnabled') ) {
    $template->param( TagsEnabled => 1 );
    foreach (qw(TagsShowOnList TagsInputOnList)) {
        C4::Context->preference($_) and $template->param( $_ => 1 );
    }
}

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

my $record_processor = Koha::RecordProcessor->new( { filters => 'ViewPolicy' } );
my $rules            = C4::Context->yaml_preference('OpacHiddenItems');

foreach my $biblionumber (@bibs) {
    $template->param( biblionumber => $biblionumber );

    my $biblio = Koha::Biblios->find($biblionumber) or next;
    my $dat    = { %{ $biblio->unblessed }, %{ $biblio->biblioitem->unblessed } };

    # No filtering on the item records needed for the record itself
    # since the only reason item information is grabbed is because of branchcodes.
    my $record    = $biblio->metadata->record;
    my $framework = &GetFrameworkCode($biblionumber);
    $record_processor->options(
        {
            interface     => 'opac',
            frameworkcode => $framework
        }
    );
    $record_processor->process($record);
    next unless $record;
    my $marcnotesarray   = $biblio->get_marc_notes( { opac => 1 } );
    my $marcauthorsarray = $biblio->get_marc_contributors;
    my $marcsubjctsarray = GetMarcSubjects( $record, $marcflavour );
    my $marcseriesarray  = GetMarcSeries( $record, $marcflavour );
    my $marcurlsarray    = GetMarcUrls( $record, $marcflavour );

    # If every item is hidden, then the biblio should be hidden too.
    next
        if $biblio->hidden_in_opac( { rules => $rules } );

    my $hasauthors = 0;
    if ( $dat->{'author'} || @$marcauthorsarray ) {
        $hasauthors = 1;
    }

    # COinS format FIXME: for books Only
    my $fmt = substr $record->leader(), 6, 2;
    my $fmts;
    $fmts->{'am'}         = 'book';
    $dat->{ocoins_format} = $fmts->{$fmt};

    if ( $num % 2 == 1 ) {
        $dat->{'even'} = 1;


    $num++;
    $dat->{biblionumber} = $biblionumber;
    $dat->{ITEM_RESULTS} = $biblio->items->filter_by_visible_in_opac( { patron => $logged_in_user } );
    $dat->{MARCNOTES}    = $marcnotesarray;
    $dat->{MARCSUBJCTS}  = $marcsubjctsarray;
    $dat->{MARCAUTHORS}  = $marcauthorsarray;
    $dat->{MARCSERIES}   = $marcseriesarray;
    $dat->{MARCURLS}     = $marcurlsarray;
    $dat->{HASAUTHORS}   = $hasauthors;
    my ( $host, $relatedparts, $hostinfo ) = $biblio->get_marc_host;
    $dat->{HOSTITEMENTRIES} = $host;
    $dat->{RELATEDPARTS}    = $relatedparts;
    $dat->{HOSTINFO}        = $hostinfo;

    push( @results, $dat );
}

# my $itemsarray=\@items;

$template->param(
    csv_profiles   => Koha::CsvProfiles->search( { type => 'marc', used_for => 'export_records', staff_only => 0 } ),
    bib_list       => $bib_list,
    bib_list => $bib_list,
    BIBLIO_RESULTS => $resultsarray,
    xsl_exports    => CustomXSLTExportList(),
);

output_html_with_http_headers $query, $cookie, $template->output, undef, { force_no_caching => 1 };

Lines 103-109 my ( $template, $borrowernumber, $cookie ) = get_template_and_user( Link Here

(-)a/opac/opac-detail.pl (-1 / +1 lines)
103	}	103	}
104	);	104	);
105		105
106	$template->param(filesOptions => CustomXSLTExportList(1));	106	$template->param( filesOptions => CustomXSLTExportList(1) );
107		107
108	my $patron = Koha::Patrons->find( $borrowernumber );	108	my $patron = Koha::Patrons->find( $borrowernumber );
109		109




use utf8;
my $query = CGI->new();

my ( $template, $borrowernumber, $cookie ) = get_template_and_user(
    {
        template_name   => "opac-downloadcart.tt",
        query           => $query,

);

my $bib_list = $query->param('bib_list');
my $format   = $query->param('format');
my $dbh      = C4::Context->dbh;

if ( $bib_list && $format ) {

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


    my $extension;
    my $type;

    # CSV
    if ( $format =~ /^\d+$/ ) {

        my $csv_profile = Koha::CsvProfiles->find($format);
        if ( not $csv_profile or $csv_profile->staff_only ) {

            exit;
        }

        $output = marc2csv( \@bibs, $format );

        # Other formats
    } else {
        my $record_processor = Koha::RecordProcessor->new( { filters => 'ViewPolicy' } );
            filters => 'ViewPolicy'
        });
        foreach my $biblionumber (@bibs) {

            my $biblio = Koha::Biblios->find($biblionumber);

                    patron      => $patron,
                }
            );
            my $xslFile   = $query->param("file");
            my $framework = &GetFrameworkCode($biblio);
            $record_processor->options(
                {
                    interface     => 'opac',
                    frameworkcode => $framework
                }
            );
            $record_processor->process($record);

            next unless $record;

            if ( $format eq 'iso2709' ) {

                #NOTE: If we don't explicitly UTF-8 encode the output,
                #the browser will guess the encoding, and it won't always choose UTF-8.
                $output .= encode( "UTF-8", $record->as_usmarc() ) // q{};
            } elsif ( $format eq 'ris' ) {
            elsif ($format eq 'ris') {
                $output .= marc2ris($record);
            } elsif ( $format eq 'bibtex' ) {
                $output .= marc2bibtex( $record, $biblio );
            } elsif ( $format eq 'isbd' ) {
                my $framework = GetFrameworkCode($biblio);
                $output .= GetISBDView(
                    {
                        'record'    => $record,
                        'template'  => 'opac',
                        'framework' => $framework,
                    }
                );
                $extension = "txt";
                $type      = "text/plain";
            } elsif ( $format =~ /^xsl\.(.*)$/ ) {
                $output .= XSLTParse4Display(
                    {
                        biblionumber => $biblio,
                        record       => $record,
                        xsl_syspref  => "OPACXSLTCustomExport",
                        fix_amps     => 1,
                        hidden_items => undef,
                        xslfilename  => $xslFile,
                    }
                );
            }
        }
    }

    # If it was a CSV export we change the format after the export so the file extension is fine
    $format = "csv"  if ( $format =~ m/^\d+$/ );
    $format = "html" if ( $format =~ /^xsl\./ );

    print $query->header(
        -type                        => ($type) ? $type : 'application/octet-stream',
        -'Content-Transfer-Encoding' => 'binary',
        -attachment                  => ($extension) ? "cart.$format.$extension" : "cart.$format"
    );
    print $output;

} else {
    $template->param(
        csv_profiles => Koha::CsvProfiles->search(
            {

        ),
        bib_list => $bib_list,
    );
    $template->param( bib_list    => $bib_list );
    $template->param( xsl_exports => CustomXSLTExportList() );
    output_html_with_http_headers $query, $cookie, $template->output;
}




my $query = CGI->new;

# if virtualshelves is disabled, leave immediately
if ( !C4::Context->preference('virtualshelves') ) {
    print $query->redirect("/cgi-bin/koha/errors/404.pl");
    exit;
}

my ( $template, $borrowernumber, $cookie ) = get_template_and_user(
    {
        template_name   => "opac-downloadshelf.tt",
        query           => $query,

    }
);

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

my $shelfnumber = $query->param('shelfnumber');
my $format      = $query->param('format');
my $context     = $query->param('context');

my $shelf = Koha::Virtualshelves->find($shelfnumber);
if ( $shelf and $shelf->can_be_viewed($borrowernumber) ) {

    if ( $shelfnumber && $format ) {

        my $contents    = $shelf->get_contents;
        my $contents = $shelf->get_contents;
        my $marcflavour = C4::Context->preference('marcflavour');
        my $output;
        my $extension;
        my $type;

        # CSV
        if ( $format =~ /^\d+$/ ) {

            my $csv_profile = Koha::CsvProfiles->find($format);
            if ( not $csv_profile or $csv_profile->staff_only ) {

            while ( my $content = $contents->next ) {
                push @biblios, $content->biblionumber;
            }
            $output = marc2csv( \@biblios, $format );

            # Other formats
        } else {
            my $record_processor = Koha::RecordProcessor->new( { filters => 'ViewPolicy' } );
                filters => 'ViewPolicy'
            });
            while ( my $content = $contents->next ) {
                my $biblionumber = $content->biblionumber;


                        patron      => $patron,
                    }
                );
                my $xslFile   = $query->param("file");
                my $framework = $biblio->frameworkcode;
                $record_processor->options(
                    {
                        interface     => 'opac',
                        frameworkcode => $framework
                    }
                );
                $record_processor->process($record);
                next unless $record;

                if ( $format eq 'iso2709' ) {
                    $output .= $record->as_usmarc();
                } elsif ( $format eq 'ris' ) {
                elsif ($format eq 'ris' ) {
                    $output .= marc2ris($record);
                } elsif ( $format eq 'bibtex' ) {
                    $output .= marc2bibtex( $record, $biblionumber );
                } elsif ( $format eq 'isbd' ) {
                    $output .= GetISBDView(
                        {
                            'record'    => $record,
                            'template'  => 'opac',
                            'framework' => $framework,
                        }
                    );
                    $extension = "txt";
                    $type      = "text/plain";
                } elsif ( $format =~ /^xsl\.(.*)$/ ) {
                    $output .= XSLTParse4Display(
                        {
                            biblionumber => $biblionumber,
                            record       => $record,
                            xsl_syspref  => "XSLTCustomExport",
                            fix_amps     => 1,
                            hidden_items => undef,
                            xslfilename  => $xslFile,
                        }

        }

        # If it was a CSV export we change the format after the export so the file extension is fine
        $format = "csv"  if ( $format =~ m/^\d+$/ );
        $format = "html" if ( $format =~ /^xsl\./ );
        print $query->header(
            -type                        => ($type) ? $type : 'application/octet-stream',
            -'Content-Transfer-Encoding' => 'binary',
            -attachment                  => ($extension) ? "shelf.$format.$extension" : "shelf.$format"
        );
        print $output;

    } else {

        # if modal context is passed set a variable so that page markup can be different
        if ( $context eq "modal" ) {
            $template->param( modal => 1 );
        } else {
            $template->param( fullpage => 1 );
        }
        $template->param(
            csv_profiles => Koha::CsvProfiles->search(

            ),
            shelf => $shelf,
        );
        $template->param( xsl_exports => CustomXSLTExportList() );
        $template->param( shelf       => $shelf );
        output_html_with_http_headers $query, $cookie, $template->output;
    }

} else {
    $template->param( invalidlist => 1 );
    output_html_with_http_headers $query, $cookie, $template->output;
}




use C4::XSLT qw( XSLTParse4Display );
use Koha::RecordProcessor;

my $query        = CGI->new;
my $op           = $query->param("op") || '';           #op=export is currently the only use
my $format       = $query->param("format") || 'utf8';
my $biblionumber = $query->param("bib") || 0;
$biblionumber = int($biblionumber);
my $error = q{};


if ($userenv) {
    my $borrowernumber = $userenv->{'number'};
    if ($borrowernumber) {
        $patron = Koha::Patrons->find($borrowernumber);
    }
}

my $include_items = ( $format =~ /bibtex/ ) ? 0 : 1;
my $biblio        = Koha::Biblios->find($biblionumber);
my $marc          = $biblio
    ? $biblio->metadata->record(
    {
        embed_items => 1,
        opac        => 1,
        patron      => $patron,
    }
    )
    : undef;

if ( !$marc ) {
    print $query->redirect("/cgi-bin/koha/errors/404.pl");
    exit;
}

my $file_id  = $biblionumber;
my $file_pre = "bib-";
if ( C4::Context->preference('DefaultSaveRecordFileID') eq 'controlnumber' ) {
    my $marcflavour =
        C4::Context->preference('marcflavour'); #FIXME This option is required but does not change control num behaviour
    my $control_num = GetMarcControlnumber( $marc, $marcflavour );
    if ($control_num) {
        $file_id  = $control_num;
        $file_pre = "record-";
    }
}

my $framework        = $biblio->frameworkcode;
my $record_processor = Koha::RecordProcessor->new(
    {
        filters => 'ViewPolicy',
        options => {
            interface     => 'opac',
            frameworkcode => $framework
        }
    }
);
$record_processor->process($marc);

if ( $format =~ /endnote/ ) {
    $marc   = marc2endnote($marc);
    $format = 'endnote';
} elsif ( $format =~ /marcxml/ ) {
    $marc   = marc2marcxml($marc);
    $marc = marc2marcxml($marc);
    $format = 'marcxml';
} elsif ( $format =~ /mods/ ) {
    $marc   = marc2modsxml($marc);
    $marc = marc2modsxml($marc);
    $format = 'mods';
} elsif ( $format =~ /ris/ ) {
    $marc   = marc2ris($marc);
    $marc = marc2ris($marc);
    $format = 'ris';
} elsif ( $format =~ /bibtex/ ) {
    $marc   = marc2bibtex( $marc, $biblionumber );
    $marc = marc2bibtex($marc,$biblionumber);
    $format = 'bibtex';
} elsif ( $format =~ /^(dc|oaidc|srwdc|rdfdc)$/i ) {

    # TODO: Dublin Core leaks fields marked hidden by framework.
    $marc   = marc2dcxml( $marc, undef, $biblionumber, $format );
    $format = "dublin-core.xml";
} elsif ( $format =~ /marc8/ ) {
    ( $error, $marc ) = changeEncoding( $marc, "MARC", "MARC21", "MARC-8" );
    $marc   = $marc->as_usmarc() unless $error;
    $marc = $marc->as_usmarc() unless $error;
    $format = 'marc8';
} elsif ( $format =~ /utf8/ ) {
    C4::Charset::SetUTF8Flag( $marc, 1 );
    $marc   = $marc->as_usmarc();
    $marc = $marc->as_usmarc();
    $format = 'utf8';
} elsif ( $format =~ /marcstd/ ) {
    C4::Charset::SetUTF8Flag( $marc, 1 );
    ( $error, $marc ) = marc2marc( $marc, 'marcstd', C4::Context->preference('marcflavour') );
    ($error,$marc) = marc2marc($marc, 'marcstd', C4::Context->preference('marcflavour'));
    $format = 'marcstd';
} elsif ( $format =~ /isbd/ ) {
    $marc = GetISBDView(
        {
            'record'    => $marc,
            'template'  => 'opac',
            'framework' => $framework,
        }
    );
    $format = 'isbd';
} elsif ( $format =~ /html/ ) {
    if ($biblionumber) {
    if ($biblionumber){
        my $xslFile = $query->param("file");
        my $biblio  = Koha::Biblios->find($biblionumber);
        $marc = $biblio->metadata->record;
        my @hiddenitems;

        $marc = XSLTParse4Display(
            {
                biblionumber => $biblionumber,
                record       => $marc,
                xsl_syspref  => "OPACXSLTCustomExport",
                fix_amps     => 1,
                hidden_items => \@hiddenitems,
                xslfilename  => $xslFile,
            }
        );
    }
} else {
    $error = "Format $format is not supported.";
    $error= "Format $format is not supported.";
}

if ($error) {
    print $query->header();
    print $query->start_html();
    print "<h1>An error occurred </h1>";
    print $query->escapeHTML("$error");
    print $query->end_html();
} else {
    if ( $format eq 'marc8' ) {
    if ($format eq 'marc8'){
        print $query->header(
            -type       => 'application/marc',
            -charset    => 'ISO-2022',
            -attachment => "$file_pre$file_id.$format"
        );
    } elsif ( $format eq 'isbd' ) {
        print $query->header(
            -type       => 'text/plain',
            -charset    => 'utf-8',
            -attachment => "$file_pre$file_id.txt"
        );
    } elsif ( $format eq 'ris' ) {
    elsif ( $format eq 'ris' ) {
        print $query->header(
            -type       => 'text/plain',
            -charset    => 'utf-8',
            -attachment => "$file_pre$file_id.$format"
        );
    } else {
        binmode STDOUT, ':encoding(UTF-8)';
        print $query->header(
            -type       => 'application/octet-stream',
            -charset    => 'utf-8',
            -attachment => "$file_pre$file_id.$format"
        );
    }




use Koha::Virtualshelves;
use Koha::RecordProcessor;

use constant ANYONE    => 2;
use constant STAFF     => 3;
use constant PERMITTED => 4;

my $query = CGI->new;

my $template_name = $query->param('rss') ? "opac-shelves-rss.tt" : "opac-shelves.tt";

# if virtualshelves is disabled, leave immediately
if ( !C4::Context->preference('virtualshelves') ) {
    print $query->redirect("/cgi-bin/koha/errors/404.pl");
    exit;
}

my $op = $query->param('op') || 'list';
my ( $template, $loggedinuser, $cookie );

if ( $op eq 'view' || $op eq 'list' ) {
    ( $template, $loggedinuser, $cookie ) = get_template_and_user(
        {
            template_name   => $template_name,
            query           => $query,
            type            => "opac",
            authnotrequired => ( C4::Context->preference("OpacPublic") ? 1 : 0 ),
        }
    );
} else {
    ( $template, $loggedinuser, $cookie ) = get_template_and_user(
        {
            template_name   => $template_name,
            query           => $query,
            type            => "opac",
            authnotrequired => 0,
        }
    );
}

if ( C4::Context->preference("BakerTaylorEnabled") ) {
    $template->param(
        BakerTaylorImageURL => &image_url(),
        BakerTaylorLinkURL  => &link_url(),
    );
}

my $referer = $query->param('referer') || $op;
my $public  = 0;
$public = 1 if $query->param('public') && $query->param('public') == 1;

my ( $shelf, $shelfnumber, @messages );

# PART 1: Perform a few actions
if ( $op eq 'add_form' ) {

    # Only pass default
    $shelf = { allow_change_from_owner => 1 };
} elsif ( $op eq 'edit_form' ) {
    $shelfnumber = $query->param('shelfnumber');
    $shelf       = Koha::Virtualshelves->find($shelfnumber);

    if ($shelf) {
        $public = $shelf->public;
        my $patron = Koha::Patrons->find( $shelf->owner );
        $template->param( owner => $patron, );
        unless ( $shelf->can_be_managed($loggedinuser) ) {
            push @messages, { type => 'error', code => 'unauthorized_on_update' };
            $op = 'list';
        }

        push @messages, { type => 'error', code => 'does_not_exist' };
    }
} elsif ( $op eq 'add' ) {
    if ($loggedinuser) {
        my $allow_changes_from = $query->param('allow_changes_from');
        eval {
            $shelf = Koha::Virtualshelf->new(
                {
                    shelfname                         => scalar $query->param('shelfname'),
                    sortfield                         => scalar $query->param('sortfield'),
                    public                            => $public,
                    allow_change_from_owner           => $allow_changes_from > 0,
                    allow_change_from_others          => $allow_changes_from == ANYONE,
                    allow_change_from_staff           => $allow_changes_from == STAFF,
                    allow_change_from_permitted_staff => $allow_changes_from == PERMITTED,
                    owner                             => scalar $loggedinuser,
                }
            );
            $shelf->store;

} elsif ( $op eq 'edit' ) {
    $shelfnumber = $query->param('shelfnumber');
    $shelf       = Koha::Virtualshelves->find($shelfnumber);
    if ($shelf) {
        $op = $referer;
        my $sortfield = $query->param('sortfield');
        $sortfield = 'title' unless grep { $_ eq $sortfield } qw( title author copyrightdate itemcallnumber dateadded );
        if ( $shelf->can_be_managed($loggedinuser) ) {
            $shelf->shelfname( scalar $query->param('shelfname') );
            $shelf->sortfield($sortfield);
            my $allow_changes_from = $query->param('allow_changes_from');
            $shelf->allow_change_from_owner( $allow_changes_from > 0 );
            $shelf->allow_change_from_others( $allow_changes_from == ANYONE );
            $shelf->allow_change_from_staff( $allow_changes_from == STAFF );
            $shelf->allow_change_from_permitted_staff( $allow_changes_from == PERMITTED );
            $shelf->public($public);
            eval { $shelf->store };

            if ($@) {

    $shelfnumber = $query->param('shelfnumber');
    $shelf       = Koha::Virtualshelves->find($shelfnumber);
    if ($shelf) {
        if ( $shelf->can_be_deleted($loggedinuser) ) {
            eval { $shelf->delete; };
            if ($@) {
                push @messages, { type => 'error', code => ref($@), msg => $@ };

    $op = $referer;
} elsif ( $op eq 'remove_share' ) {
    $shelfnumber = $query->param('shelfnumber');
    $shelf       = Koha::Virtualshelves->find($shelfnumber);
    if ($shelf) {
        my $removed = eval { $shelf->remove_share($loggedinuser); };
        if ($@) {
            push @messages, { type => 'error', code => ref($@), msg => $@ };
        } elsif ($removed) {
            push @messages, { type => 'message', code => 'success_on_remove_share' };
        } else {
            push @messages, { type => 'error', code => 'error_on_remove_share' };


} elsif ( $op eq 'add_biblio' ) {
    $shelfnumber = $query->param('shelfnumber');
    $shelf       = Koha::Virtualshelves->find($shelfnumber);
    if ($shelf) {
        if ( my $barcode = $query->param('barcode') ) {
            my $item = Koha::Items->find( { barcode => $barcode } );
            if ($item) {
                if ( $shelf->can_biblios_be_added($loggedinuser) ) {
                    my $added = eval { $shelf->add_biblio( $item->biblionumber, $loggedinuser ); };
                    if ($@) {
                        push @messages, { type => 'error', code => ref($@), msg => $@ };
                    } elsif ($added) {
                        push @messages, { type => 'message', code => 'success_on_add_biblio' };
                    } else {
                        push @messages, { type => 'message', code => 'error_on_add_biblio' };

    $op = $referer;
} elsif ( $op eq 'remove_biblios' ) {
    $shelfnumber = $query->param('shelfnumber');
    $shelf       = Koha::Virtualshelves->find($shelfnumber);
    my @biblionumber = $query->multi_param('biblionumber');
    if ($shelf) {
        if ( $shelf->can_biblios_be_removed($loggedinuser) ) {
            my $number_of_biblios_removed = eval {
                $shelf->remove_biblios(
                    {
                        biblionumbers  => \@biblionumber,
                        borrowernumber => $loggedinuser,
                    }
                );
            };
            if ($@) {
                push @messages, { type => 'error', code => ref($@), msg => $@ };
            } elsif ($number_of_biblios_removed) {
                push @messages, { type => 'message', code => 'success_on_remove_biblios' };
            } else {
                push @messages, { type => 'error', code => 'no_biblio_removed' };

        push @messages, { type => 'error', code => 'does_not_exist' };
    }
    $op = 'view';
} elsif ( $op eq 'transfer' ) {
    $shelfnumber = $query->param('shelfnumber');
    $shelf       = Koha::Virtualshelves->find($shelfnumber) if $shelfnumber;
    my $new_owner = $query->param('new_owner');    # borrowernumber or undef
    my $error_code =
          $shelf
        ? $shelf->cannot_be_transferred( { by => $loggedinuser, to => $new_owner, interface => 'opac' } )
        : 'does_not_exist';

    if ( !$new_owner && $error_code eq 'missing_to_parameter' ) {    # show transfer form
        my $patrons = [];
        my $shares  = $shelf->get_shares->search( { borrowernumber => { '!=' => undef } } );
        while ( my $share = $shares->next ) {
            my $email = $share->sharee->notice_email_address;
            push @$patrons, { email => $email, borrowernumber => $share->get_column('borrowernumber') } if $email;
        }
        if (@$patrons) {
            $template->param( shared_users => $patrons );
            $op = 'transfer';
        } else {
            push @messages, { type => 'error', code => 'no_email_found' };
        }
    } elsif ($error_code) {
        push @messages, { type => 'error', code => $error_code };
        $op = 'list';
    } else {    # transfer; remove new_owner from virtualshelfshares, add loggedinuser
        $shelf->_result->result_source->schema->txn_do(
            sub {
                $shelf->get_shares->search( { borrowernumber => $new_owner } )->delete;
                Koha::Virtualshelfshare->new(
                    { shelfnumber => $shelfnumber, borrowernumber => $loggedinuser, sharedate => dt_from_string } )
                    ->store;
                $shelf->owner($new_owner)->store;
            }
        );
        $op = 'list';
    }
}

if ( $op eq 'view' ) {
    $shelfnumber ||= $query->param('shelfnumber');
    $shelf = Koha::Virtualshelves->find($shelfnumber);
    if ($shelf) {
        if ( $shelf->can_be_viewed($loggedinuser) ) {
            $public = $shelf->public;

            # Sortfield param may still include sort order with :asc or :desc, but direction overrides it
            my ( $sortfield, $direction );
            if ( $query->param('sortfield') ) {
                ( $sortfield, $direction ) = split /:/, $query->param('sortfield');
            } else {
                $sortfield = $shelf->sortfield;
                $direction = 'asc';
            }
            $direction = $query->param('direction') if $query->param('direction');
            $direction = 'asc'                      if !$direction or ( $direction ne 'asc' and $direction ne 'desc' );
            $sortfield = 'title'
                if !$sortfield
                or !grep { $_ eq $sortfield } qw( title author copyrightdate itemcallnumber dateadded );

            my ( $page, $rows );
            unless ( $query->param('print') or $query->param('rss') ) {


            # get biblionumbers stored in the cart
            my @cart_list;
            if ( my $cart_list = $query->cookie('bib_list') ) {
                @cart_list = split( /\//, $cart_list );
            }

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

            my $categorycode;    # needed for may_article_request
            if ( C4::Context->preference('ArticleRequests') ) {
                $categorycode = $patron ? $patron->categorycode : undef;
            }

            my $record_processor = Koha::RecordProcessor->new( { filters => 'ViewPolicy' } );

            my $art_req_itypes;
            if ( C4::Context->preference('ArticleRequests') ) {
                $art_req_itypes = Koha::CirculationRules->guess_article_requestable_itemtypes(
                    { $patron ? ( categorycode => $patron->categorycode ) : () } );
            }

            my @items_info;

                my $framework    = GetFrameworkCode($biblionumber);
                $record_processor->options(
                    {
                        interface     => 'opac',
                        frameworkcode => $framework
                    }
                );
                $record_processor->process($record);

                my $marcflavour = C4::Context->preference("marcflavour");
                my $itemtype = Koha::Biblioitems->search( { biblionumber => $content->biblionumber } )->next->itemtype;
                $itemtype = Koha::ItemTypes->find($itemtype);
                if ($itemtype) {
                    $this_item->{imageurl} = C4::Koha::getitemtypeimagelocation( 'opac', $itemtype->imageurl );
                    $this_item->{description} = $itemtype->description;  #FIXME Should not it be translated_description?
                    $this_item->{notforloan}  = $itemtype->notforloan;
                }
                $this_item->{'coins'}           = $biblio->get_coins;
                $this_item->{'normalized_upc'}  = GetNormalizedUPC( $record, $marcflavour );
                $this_item->{'normalized_ean'}  = GetNormalizedEAN( $record, $marcflavour );
                $this_item->{'normalized_oclc'} = GetNormalizedOCLCNumber( $record, $marcflavour );
                $this_item->{'normalized_isbn'} = GetNormalizedISBN( undef, $record, $marcflavour );

                # BZ17530: 'Intelligent' guess if result can be article requested
                $this_item->{artreqpossible} =
                    ( $art_req_itypes->{ $this_item->{itemtype} // q{} } || $art_req_itypes->{'*'} ) ? 1 : q{};

                unless ( defined $this_item->{size} ) {


                    $this_item->{size} = q||;
                }

                if ( C4::Context->preference('TagsEnabled') and C4::Context->preference('TagsShowOnList') ) {
                    $this_item->{TagLoop} = get_tags(
                        {
                            biblionumber => $biblionumber, approved => 1, 'sort' => '-weight',
                            limit        => C4::Context->preference('TagsShowOnList'),
                        }
                    );
                }

                my $items = $biblio->items->filter_by_visible_in_opac( { patron => $patron } );
                my $allow_onshelf_holds;
                while ( my $item = $items->next ) {

                    # This method must take a Koha::Items rs
                    $allow_onshelf_holds ||=
                        Koha::CirculationRules->get_onshelfholds_policy( { item => $item, patron => $patron } );

                }

                $this_item->{allow_onshelf_holds} = $allow_onshelf_holds;
                $this_item->{'ITEM_RESULTS'}      = $items;

                my $variables = { anonymous_session => ($loggedinuser) ? 0 : 1 };
                    anonymous_session => ($loggedinuser) ? 0 : 1
                };
                $this_item->{XSLTBloc} = XSLTParse4Display(
                    {
                        biblionumber   => $biblionumber,

                    }
                );

                if ( grep { $_ eq $biblionumber } @cart_list ) {
                if ( grep {$_ eq $biblionumber} @cart_list) {
                    $this_item->{incart} = 1;
                }

                $this_item->{biblio_object} = $biblio;
                $this_item->{biblionumber}  = $biblionumber;
                $this_item->{shelves}       = Koha::Virtualshelves->get_shelves_containing_record(
                  Koha::Virtualshelves->get_shelves_containing_record(
                    {
                        biblionumber   => $biblionumber,
                        borrowernumber => $loggedinuser,
                    }
                );
                push @items_info, $this_item;
            }


                itemsloop          => \@items_info,
                sortfield          => $sortfield,
                direction          => $direction,
                csv_profiles       => Koha::CsvProfiles->search(
                    {
                        type       => 'marc',
                        used_for   => 'export_records',
                        staff_only => 0
                    }
                ),
            );
            if ($page) {
                my $pager = $contents->pager;
                $template->param(
                    pagination_bar => pagination_bar(
                        q||,   $pager->last_page - $pager->first_page + 1,
                        $page, "page",
                        {
                            op        => 'view', shelfnumber => $shelf->shelfnumber, sortfield => $sortfield,
                            direction => $direction,
                        }
                    ),
                );
            }

    my $shelves;
    my ( $page, $rows ) = ( $query->param('page') || 1, 20 );
    if ( !$public ) {
        $shelves = Koha::Virtualshelves->get_private_shelves(
            { page => $page, rows => $rows, borrowernumber => $loggedinuser, } );
    } else {
        $shelves = Koha::Virtualshelves->get_public_shelves( { page => $page, rows => $rows, } );
    }

    my $pager = $shelves->pager;
    $template->param(
        shelves        => $shelves,
        pagination_bar => pagination_bar(
            q||,   $pager->last_page - $pager->first_page + 1,
            $page, "page", { op => 'list', public => $public, }
        ),
    );
}

my ( $staffuser, $permitteduser );
$staffuser     = Koha::Patrons->find($loggedinuser)->can_patron_change_staff_only_lists      if $loggedinuser;
$permitteduser = Koha::Patrons->find($loggedinuser)->can_patron_change_permitted_staff_lists if $loggedinuser;

$template->param(
    op            => $op,

    listsview     => 1,
    staffuser     => $staffuser,
    permitteduser => $permitteduser,
    xsl_exports   => CustomXSLTExportList()
);

my $content_type = $query->param('rss') ? 'rss' : 'html';
output_with_http_headers $query, $cookie, $template->output, $content_type;




use Koha::ItemTypes;

BEGIN {
    use_ok( 'C4::XSLT', qw( buildKohaItemsNamespace ) );
}

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

our $cache = Koha::Caches->get_instance;

subtest 'Tests moved from t' => sub {
    plan tests => 14;
    $schema->storage->txn_begin;

    my $dir    = File::Temp->newdir();
    my @themes = ( 'prog', 'test' );
    my @langs  = ( 'en', 'es-ES' );

    # create temporary files to be tested later
    foreach my $theme (@themes) {

    }

    sub find_and_slurp {
        my ( $dir, $theme, $lang ) = @_;

        my $filename = C4::XSLT::_get_best_default_xslt_filename( $dir, $theme, $lang, 'my_file.xslt' );
        open my $fh, '<', $filename;
        my $str = <$fh>;
        close $fh;


    # These tests verify that we're finding the right XSLT file when present,
    # and falling back to the right XSLT file when an exact match is not present.
    is( find_and_slurp( $dir, 'test', 'en' ),    'Theme test, language en',    'Found test/en' );
    is( find_and_slurp( $dir, 'test', 'es-ES' ), 'Theme test, language es-ES', 'Found test/es-ES' );
    is( find_and_slurp( $dir, 'prog', 'en', ),   'Theme prog, language en',    'Found test/en' );
    is( find_and_slurp( $dir, 'prog', 'es-ES' ), 'Theme prog, language es-ES', 'Found test/es-ES' );
    is( find_and_slurp( $dir, 'test', 'fr-FR' ), 'Theme test, language en',    'Fell back to test/en for test/fr-FR' );
    is(
        find_and_slurp( $dir, 'nope', 'es-ES' ), 'Theme prog, language es-ES',
        'Fell back to prog/es-ES for nope/es-ES'
    );
    is( find_and_slurp( $dir, 'nope', 'fr-FR' ), 'Theme prog, language en', 'Fell back to prog/en for nope/fr-FR' );

    my $matching_string = q{<syspref name="singleBranchMode">[0|1]</syspref>};
    my $sysprefs_xml    = C4::XSLT::get_xslt_sysprefs();
    ok( $sysprefs_xml =~ m/$matching_string/, 'singleBranchMode has no value' );

    sub createXSLTFiles {
        my ( $path ) = @_;

        open my $fh, '>', "$path/export_01.xsl";
        print $fh qq|<?xml version="1.0" encoding="UTF-8"?>
        <xsl:stylesheet version="1.0"
        xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
        xmlns:marc="http://www.loc.gov/MARC21/slim"
        title="Export 01">
        </xsl:stylesheet>|;
        close $fh;

        # Make XSL without title
        open $fh, '>', "$path/export_02.xsl";
        print $fh qq|<?xml version="1.0" encoding="UTF-8"?>
        <xsl:stylesheet version="1.0"
        xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
        xmlns:marc="http://www.loc.gov/MARC21/slim">
        </xsl:stylesheet>|;
        close $fh;

        open $fh, '>', "$path/export_03.xsl";
        print $fh qq|<?xml version="1.0" encoding="UTF-8"?>|;
        close $fh;
    }

    t::lib::Mocks::mock_preference( 'CustomXSLTExportPath', '' );
    t::lib::Mocks::mock_config( 'opachtdocs', "$dir" );

    t::lib::Mocks::mock_config('opachtdocs', "$dir");
    make_path("$dir/bootstrap/en/xslt/biblioexport");
    createXSLTFiles("$dir/bootstrap/en/xslt/biblioexport");

    t::lib::Mocks::mock_preference( 'OpacExportOptions', 'custom' );
    my @custom_xslts = @{ C4::XSLT::CustomXSLTExportList(1) };

    ok( ( scalar @custom_xslts ) == 2,               "CustomXSLTExportList finds custom XSLTs" );
    ok( $custom_xslts[0]->{filename} eq "Export 01", "Title is specified in root node" );
    ok( $custom_xslts[1]->{filename} eq "export_02", "Title is filename if not specified" );

    # CustomXSLTExportPath
    t::lib::Mocks::mock_preference( 'CustomXSLTExportPath', "/$dir/XSLTExportFiles" );
    make_path("$dir/XSLTExportFiles");
    createXSLTFiles("$dir/XSLTExportFiles");
    @custom_xslts = @{ C4::XSLT::CustomXSLTExportList(1) };

    ok( ( scalar @custom_xslts ) == 2,               "CustomXSLTExportList finds custom XSLTs with CustomXSLTExportPath" );
    ok( $custom_xslts[0]->{filename} eq "Export 01", "Title is specified in root node with CustomXSLTExportPath" );
    ok( $custom_xslts[1]->{filename} eq "export_02", "Title is filename if not specified with CustomXSLTExportPath" );
    </xsl:stylesheet>|;
    close $fh;

    open $fh, '>', "$dir/bootstrap/en/xslt/biblioexport/export_03.xsl";
    print $fh qq|<?xml version="1.0" encoding="UTF-8"?>|;
    close $fh;

    t::lib::Mocks::mock_preference( 'OpacExportOptions', 'custom');
    my @custom_xslts = @{C4::XSLT::CustomXSLTExportList(1)};
    ok((scalar @custom_xslts) == 2, "CustomXSLTExportList finds custom XSLTs");
    ok($custom_xslts[0]->{filename} eq "Export 01", "Title is specified in root node");
    ok($custom_xslts[1]->{filename} eq "export_02", "Title is filename if not specified");

    $schema->storage->txn_rollback;
};

    plan tests => 18;
    $schema->storage->txn_begin;

    t::lib::Mocks::mock_preference( 'Reference_NFL_Statuses', '1|2' );
    t::lib::Mocks::mock_preference( 'OPACResultsLibrary',     'holdingbranch' );
    t::lib::Mocks::mock_preference( 'OPACResultsMaxItems',    '2' );

    my $itype          = $builder->build_object( { class => 'Koha::ItemTypes' } );
    my $itemtype       = $builder->build_object( { class => 'Koha::ItemTypes' } );
    my $holdinglibrary = $builder->build_object( { class => 'Koha::Libraries' } );
    my $item = $builder->build_sample_item( { itype => $itype->itemtype } );
    $item->holdingbranch( $holdinglibrary->branchcode )->store;
    $item->biblioitem->itemtype( $itemtype->itemtype )->store;

    my $xml = C4::XSLT::buildKohaItemsNamespace( $item->biblionumber, [] );
    like( $xml, qr{<status>available</status>}, "Item is available when no other status applied" );

    # notforloan
    {
        t::lib::Mocks::mock_preference( 'item-level_itypes', 0 );
        $item->notforloan(0)->store;
        Koha::ItemTypes->find( $item->itype )->notforloan(0)->store;
        Koha::ItemTypes->find( $item->biblioitem->itemtype )->notforloan(1)->store;
        $xml = C4::XSLT::buildKohaItemsNamespace( $item->biblionumber, [] );
        like( $xml, qr{<status>reference</status>}, "reference if positive itype notforloan value" );

        t::lib::Mocks::mock_preference( 'item-level_itypes', 1 );
        Koha::ItemTypes->find( $item->itype )->notforloan(1)->store;
        Koha::ItemTypes->find( $item->biblioitem->itemtype )->notforloan(0)->store;
        $xml = C4::XSLT::buildKohaItemsNamespace( $item->biblionumber, [] );
        like( $xml, qr{<status>reference</status>}, "reference if positive itemtype notforloan value" );
        Koha::ItemTypes->find( $item->itype )->notforloan(0)->store;

        my $substatus = Koha::AuthorisedValues->search( { category => 'NOT_LOAN', authorised_value => -1 } )->next->lib;
        $item->notforloan(-1)->store;
        $xml = C4::XSLT::buildKohaItemsNamespace( $item->biblionumber, [] );
        like( $xml, qr{<status>reallynotforloan</status>}, "reallynotforloan if negative notforloan value" );
        like( $xml, qr{<substatus>$substatus</substatus>}, "substatus set if negative notforloan value" );

        $item->notforloan(1)->store;
        $xml = C4::XSLT::buildKohaItemsNamespace( $item->biblionumber, [] );
        like( $xml, qr{<status>reference</status>}, "reference if positive notforloan value" );

        # But now make status notforloan==1 count under Not available
        t::lib::Mocks::mock_preference( 'Reference_NFL_Statuses', '2' );
        $xml = C4::XSLT::buildKohaItemsNamespace( $item->biblionumber, [] );
        like( $xml, qr{<status>reallynotforloan</status>}, "reallynotforloan when we change Reference_NFL_Statuses" );
        t::lib::Mocks::mock_preference( 'Reference_NFL_Statuses', q{} );    # empty, same effect
        $xml = C4::XSLT::buildKohaItemsNamespace( $item->biblionumber, [] );
        like( $xml, qr{<status>reallynotforloan</status>}, "reallynotforloan when we empty Reference_NFL_Statuses" );
        t::lib::Mocks::mock_preference( 'Reference_NFL_Statuses', '1|2' );
    }

    $item->onloan('2001-01-01')->store;
    $xml = C4::XSLT::buildKohaItemsNamespace( $item->biblionumber, [] );
    like( $xml, qr/<status>other<\/status>/,            "Checked out is part of other statuses" );
    like( $xml, qr{<substatus>Checked out</substatus>}, "Checked out status takes precedence over Not for loan" );

    $item->withdrawn(1)->store;
    $xml = C4::XSLT::buildKohaItemsNamespace( $item->biblionumber, [] );
    like( $xml, qr{<substatus>Withdrawn</substatus>}, "Withdrawn status takes precedence over Checked out" );

    $item->itemlost(1)->store;
    $xml = C4::XSLT::buildKohaItemsNamespace( $item->biblionumber, [] );
    like( $xml, qr{<substatus>Lost</substatus>}, "Lost status takes precedence over Withdrawn" );

    $item->damaged(1)->store;
    $xml = C4::XSLT::buildKohaItemsNamespace( $item->biblionumber, [] );
    like( $xml, qr{<substatus>Damaged</substatus>}, "Damaged status takes precedence over Lost" );

    $builder->build(
        {
            source => "Branchtransfer",
            value  => {
                itemnumber    => $item->itemnumber,
                datearrived   => undef,
                datecancelled => undef,
            }
        }
    );
    $xml = C4::XSLT::buildKohaItemsNamespace( $item->biblionumber, [] );
    like( $xml, qr{<substatus>In transit</substatus>}, "In-transit status takes precedence over Damaged" );

    my $hold = $builder->build_object(
        {
            class => 'Koha::Holds',
            value => {
                biblionumber => $item->biblionumber,
                itemnumber   => $item->itemnumber,
                found        => 'W',
                priority     => 0,
            }
        }
    );
    $xml = C4::XSLT::buildKohaItemsNamespace( $item->biblionumber, [] );
    like( $xml, qr{<substatus>Hold waiting</substatus>}, "Waiting status takes precedence over In transit (holds)" );
    $hold->cancel;

    $builder->build( { source => "TmpHoldsqueue", value => { itemnumber => $item->itemnumber } } );
    $xml = C4::XSLT::buildKohaItemsNamespace( $item->biblionumber, [] );
    like( $xml, qr{<substatus>Pending hold</substatus>}, "Pending status takes precedence over all" );
    });
    $xml = C4::XSLT::buildKohaItemsNamespace( $item->biblionumber,[]);
    like($xml,qr{<substatus>Pending hold</substatus>},"Pending status takes precedence over all");
    my $library_name = $holdinglibrary->branchname;
    like( $xml, qr{<resultbranch>${library_name}</resultbranch>}, "Found resultbranch / holding branch" );

    t::lib::Mocks::mock_preference( 'UseRecalls', 1 );
    my $recall = $builder->build_object(
        {
            class => 'Koha::Recalls',

        }
    );
    $recall->set_waiting;
    $xml = C4::XSLT::buildKohaItemsNamespace( $item->biblionumber, [] );
    like(
        $xml, qr{<substatus>Recall waiting</substatus>},
        "Waiting status takes precedence over In transit (recalls)"
    );
    t::lib::Mocks::mock_preference( 'UseRecalls', 0 );

    $schema->storage->txn_rollback;
};

subtest 'CustomXSLTExportList: Check export options' => sub {
    plan tests => 2;
    t::lib::Mocks::mock_preference( 'OpacExportOptions', 'custom' );
    my $list = C4::XSLT::CustomXSLTExportList(1);
    is( $list > 0, 1, 'We expect at least one result: simple export' );
    $cache->clear_from_cache('CustomXSLTExportListOPAC');
    t::lib::Mocks::mock_preference( 'OpacExportOptions', 'dc' );
    $list = C4::XSLT::CustomXSLTExportList(1);
    is( @$list, 0, 'We expect an empty list now' );
};


    $schema->storage->txn_begin;

    my $biblio  = $builder->build_sample_biblio;
    my $biblio2 = $builder->build_sample_biblio;

    # Have two known libraries for testing purposes
    my $library_1 = $builder->build_object( { class => 'Koha::Libraries' } );
    my $library_2 = $builder->build_object( { class => 'Koha::Libraries' } );
    my $library_3 = $builder->build_object( { class => 'Koha::Libraries' } );

    my $item_1 = $builder->build_sample_item( { biblionumber => $biblio->biblionumber, library => $library_1->id } );
    my $item_2 = $builder->build_sample_item( { biblionumber => $biblio->biblionumber, library => $library_2->id } );
    my $item_3 = $builder->build_sample_item( { biblionumber => $biblio->biblionumber, library => $library_3->id } );

    my $items_rs = $biblio->items->search( { "me.itemnumber" => { '!=' => $item_3->itemnumber } } );

    ## Test passing items_rs only
    my $xml = C4::XSLT::buildKohaItemsNamespace( $biblio->biblionumber, undef, $items_rs );

    my $library_2_name = $library_2->branchname;
    my $library_3_name = $library_3->branchname;

    like( $xml, qr{<homebranch>$library_1_name</homebranch>}, '$item_1 present in the XML' );
    like( $xml, qr{<homebranch>$library_2_name</homebranch>}, '$item_2 present in the XML' );
    unlike( $xml, qr{<homebranch>$library_3_name</homebranch>}, '$item_3 not present in the XML' );

    t::lib::Mocks::mock_preference( 'OpacHiddenItems', 'biblionumber: [' . $biblio2->biblionumber . ']' );
    my $hid_rs =
        $biblio->items->search( { "me.itemnumber" => { '!=' => $item_3->itemnumber } } )->filter_by_visible_in_opac();
    $xml = C4::XSLT::buildKohaItemsNamespace( $biblio->biblionumber, undef, $hid_rs );
    like( $xml, qr{<homebranch>$library_1_name</homebranch>}, '$item_1 present in the XML' );
    like( $xml, qr{<homebranch>$library_2_name</homebranch>}, '$item_2 present in the XML' );
    unlike( $xml, qr{<homebranch>$library_3_name</homebranch>}, '$item_3 not present in the XML' );

    ## Test passing one item in hidden_items and items_rs
    $xml = C4::XSLT::buildKohaItemsNamespace( $biblio->biblionumber, [ $item_1->itemnumber ], $items_rs->reset );

    unlike( $xml, qr{<homebranch>$library_1_name</homebranch>}, '$item_1 not present in the XML' );
    like( $xml, qr{<homebranch>$library_2_name</homebranch>}, '$item_2 present in the XML' );
    unlike( $xml, qr{<homebranch>$library_3_name</homebranch>}, '$item_3 not present in the XML' );

    ## Test passing both items in hidden_items and items_rs
    $xml = C4::XSLT::buildKohaItemsNamespace(
        $biblio->biblionumber, [ $item_1->itemnumber, $item_2->itemnumber ],
        $items_rs->reset
    );

    unlike( $xml, qr{<homebranch>$library_1_name</homebranch>}, '$item_1 not present in the XML' );
    unlike( $xml, qr{<homebranch>$library_2_name</homebranch>}, '$item_2 not present in the XML' );

    is( $xml, '<items xmlns="http://www.koha-community.org/items"></items>', 'Empty XML' );

    ## Test passing both items in hidden_items and no items_rs
    $xml = C4::XSLT::buildKohaItemsNamespace(
        $biblio->biblionumber,
        [ $item_1->itemnumber, $item_2->itemnumber, $item_3->itemnumber ]
    );

    unlike( $xml, qr{<homebranch>$library_1_name</homebranch>}, '$item_1 not present in the XML' );
    unlike( $xml, qr{<homebranch>$library_2_name</homebranch>}, '$item_2 not present in the XML' );

    $xml = C4::XSLT::buildKohaItemsNamespace( $biblio->biblionumber, [ $item_1->itemnumber ] );

    unlike( $xml, qr{<homebranch>$library_1_name</homebranch>}, '$item_1 not present in the XML' );
    like( $xml, qr{<homebranch>$library_2_name</homebranch>}, '$item_2 present in the XML' );
    like( $xml, qr{<homebranch>$library_3_name</homebranch>}, '$item_3 present in the XML' );

    ## Test not passing any param
    $xml = C4::XSLT::buildKohaItemsNamespace( $biblio->biblionumber );




use C4::Ris qw( marc2ris );
use C4::XSLT qw( XSLTParse4Display );


use Koha::Biblios;
use Koha::CsvProfiles;
use Koha::Virtualshelves;

use utf8;
my $query = CGI->new;

my ( $template, $loggedinuser, $cookie ) = get_template_and_user(
    {
        template_name => "virtualshelves/downloadshelf.tt",
        query         => $query,
        type          => "intranet",
        flagsrequired => { catalogue => 1 },
    }
);


my $dbh     = C4::Context->dbh;
my @messages;

if ( $shelfid && $format ) {

    my $marcflavour = C4::Context->preference('marcflavour');
    my $output      = '';

    my $shelf = Koha::Virtualshelves->find($shelfid);
    if ($shelf) {
        if ( $shelf->can_be_viewed($loggedinuser) ) {

            my $contents = $shelf->get_contents;

            # CSV
            if ( $format =~ /^\d+$/ ) {
                my @biblios;
                while ( my $content = $contents->next ) {
                    push @biblios, $content->biblionumber;
                }
                $output = marc2csv( \@biblios, $format );
            } else {    #Other formats
            else { #Other formats
                while ( my $content = $contents->next ) {
                    my $biblionumber = $content->biblionumber;
                    my $biblio       = Koha::Biblios->find($biblionumber);
                    my $record       = $biblio->metadata->record( { embed_items => 1 } );
                    my $xslFile      = $query->param("file");
                    if ( $format eq 'iso2709' ) {
                        $output .= $record->as_usmarc();
                    } elsif ( $format eq 'ris' ) {
                    elsif ($format eq 'ris') {
                        $output .= marc2ris($record);
                    } elsif ( $format eq 'bibtex' ) {
                        $output .= marc2bibtex( $record, $biblionumber );
                    } elsif ( $format =~ /^xsl\.(.*)$/ ) {
                    }
                    elsif ($format =~ /^xsl\.(.*)$/){
                        $output .= XSLTParse4Display(
                            {
                                biblionumber => $biblionumber,
                                record       => $record,
                                xsl_syspref  => 'XSLTCustomExport',
                                fix_amps     => 1,
                                hidden_items => undef,

            }

            # If it was a CSV export we change the format after the export so the file extension is fine
            $format = "csv"  if ( $format =~ m/^\d+$/ );
            $format = "html" if ( $format =~ /^xsl\./ );
            print $query->header(
                -type                        => 'application/octet-stream',
                -'Content-Transfer-Encoding' => 'binary',
                -attachment                  => "shelf.$format"
            );
            print $output;
            exit;
        } else {

    } else {
        push @messages, { type => 'error', code => 'does_not_exist' };
    }
} else {
    $template->param(
        csv_profiles => [ Koha::CsvProfiles->search( { type => 'marc', used_for => 'export_records' } )->as_list ] );
    $template->param( shelfid => $shelfid );
}
$template->param( messages => \@messages );
output_html_with_http_headers $query, $cookie, $template->output;




}

$template->param(
    op             => $op,
    referer        => $referer,
    shelf          => $shelf,
    messages       => \@messages,
    public         => $public,
    print          => scalar $query->param('print') || 0,
    csv_profiles   => [ Koha::CsvProfiles->search({ type => 'marc', used_for => 'export_records' })->as_list ],
    allow_transfer => $allow_transfer,
    xsl_exports    => CustomXSLTExportList()
);

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

Return to bug 17385

Lines 34-111 use Koha::Biblios; Link Here

(-)a/basket/downloadcart.pl (-42 / +43 lines)
34	use utf8;	34	use utf8;
35	my $query = CGI->new;	35	my $query = CGI->new;
36		36
37	my ( $template, $borrowernumber, $cookie ) = get_template_and_user (	37	my ( $template, $borrowernumber, $cookie ) = get_template_and_user(
38	{	38	{
39	template_name => "basket/downloadcart.tt",	39	template_name => "basket/downloadcart.tt",
40	query => $query,	40	query => $query,
41	type => "intranet",	41	type => "intranet",
42	flagsrequired => { catalogue => 1 },	42	flagsrequired => { catalogue => 1 },
43	}	43	}
44	);	44	);
45		45
46	my $bib_list = $query->param('bib_list');	46	my $bib_list = $query->param('bib_list');
47	my $format = $query->param('format');	47	my $format = $query->param('format');
48	my $dbh = C4::Context->dbh;	48	my $dbh = C4::Context->dbh;
49		49
50	if ($bib_list && $format) {	50	if ( $bib_list && $format ) {
51		51
52	my @bibs = split( /\//, $bib_list );	52	my @bibs = split( /\//, $bib_list );
53		53
54	my $marcflavour = C4::Context->preference('marcflavour');	54	my $marcflavour = C4::Context->preference('marcflavour');
55	my $output;	55	my $output;
56		56
57	# CSV	57	# CSV
58	if ($format =~ /^\d+$/) {	58	if ( $format =~ /^\d+$/ ) {
59		59
60	$output = marc2csv(\@bibs, $format);	60	$output = marc2csv( \@bibs, $format );
61		61
62	# Other formats	62	# Other formats
63	} else {	63	} else {
64		64
65	foreach my $biblionumber (@bibs) {	65	foreach my $biblionumber (@bibs) {
66		66
67	my $biblio = Koha::Biblios->find($biblionumber);	67	my $biblio = Koha::Biblios->find($biblionumber);
68	my $record = $biblio->metadata->record({ embed_items => 1 });	68	my $record = $biblio->metadata->record( { embed_items => 1 } );
69	my $xslFile = $query->param("file");	69	my $xslFile = $query->param("file");
70	next unless $record;	70	next unless $record;
71		71
72	if ($format eq 'iso2709') {	72	if ( $format eq 'iso2709' ) {
		73
73	#NOTE: If we don't explicitly UTF-8 encode the output,	74	#NOTE: If we don't explicitly UTF-8 encode the output,
74	#the browser will guess the encoding, and it won't always choose UTF-8.	75	#the browser will guess the encoding, and it won't always choose UTF-8.
75	$output .= encode("UTF-8", $record->as_usmarc()) // q{};	76	$output .= encode( "UTF-8", $record->as_usmarc() ) // q{};
76	}	77	} elsif ( $format eq 'ris' ) {
77	elsif ($format eq 'ris') {
78	$output .= marc2ris($record);	78	$output .= marc2ris($record);
79	}	79	} elsif ( $format eq 'bibtex' ) {
80	elsif ($format eq 'bibtex') {	80	$output .= marc2bibtex( $record, $biblionumber );
81	$output .= marc2bibtex($record, $biblionumber);	81	} elsif ( $format =~ /^xsl\.(.*)$/ ) {
82	}	82	$output .= XSLTParse4Display(
83	elsif ($format =~ /^xsl\.(.*)$/) {	83	{
84	$output .= XSLTParse4Display({	84	biblionumber => $biblio,
85	biblionumber => $biblio,	85	record => $record,
86	record => $record,	86	xsl_syspref => "XSLTCustomExport",
87	xsl_syspref => "XSLTCustomExport",	87	fix_amps => 1,
88	fix_amps => 1,	88	hidden_items => undef,
89	hidden_items => undef,	89	xslfilename => $xslFile,
90	xslfilename => $xslFile,	90	}
91	});	91	);
92	}	92	}
93	}	93	}
94	}	94	}
95		95
96	# If it was a CSV export we change the format after the export so the file extension is fine	96	# If it was a CSV export we change the format after the export so the file extension is fine
97	$format = "csv" if ($format =~ m/^\d+$/);	97	$format = "csv" if ( $format =~ m/^\d+$/ );
98	$format = "html" if ($format =~ /^xsl\./);	98	$format = "html" if ( $format =~ /^xsl\./ );
99		99
100	print $query->header(	100	print $query->header(
101	-type => 'application/octet-stream',	101	-type => 'application/octet-stream',
102	-'Content-Transfer-Encoding' => 'binary',	102	-'Content-Transfer-Encoding' => 'binary',
103	-attachment=>"cart.$format");	103	-attachment => "cart.$format"
		104	);
104	print $output;	105	print $output;
105		106
106	} else {	107	} else {
107	$template->param(csv_profiles => Koha::CsvProfiles->search({ type => 'marc', used_for => 'export_records' }));	108	$template->param( csv_profiles => Koha::CsvProfiles->search( { type => 'marc', used_for => 'export_records' } ) );
108	$template->param(xsl_exports => CustomXSLTExportList());	109	$template->param( xsl_exports => CustomXSLTExportList() );
109	$template->param(bib_list => $bib_list);	110	$template->param( bib_list => $bib_list );
110	output_html_with_http_headers $query, $cookie, $template->output;	111	output_html_with_http_headers $query, $cookie, $template->output;
111	}	112	}

Lines 10-115 use C4::Ris qw( marc2ris ); Link Here

(-)a/catalogue/export.pl (-83 / +78 lines)
10	use C4::XSLT qw( XSLTParse4Display );	10	use C4::XSLT qw( XSLTParse4Display );
11	use Koha::Biblios;	11	use Koha::Biblios;
12		12
13
14
15	my $query = CGI->new;	13	my $query = CGI->new;
16	my ( $template, $loggedinuser, $cookie ) = get_template_and_user({	14	my ( $template, $loggedinuser, $cookie ) = get_template_and_user(
17	template_name => "tools/export.tt",	15	{
18	query => $query,	16	template_name => "tools/export.tt",
19	type => "intranet",	17	query => $query,
20	flagsrequired => { catalogue => 1 },	18	type => "intranet",
21	});	19	flagsrequired => { catalogue => 1 },
		20	}
		21	);
22		22
23	my $op=$query->param("op");	23	my $op = $query->param("op");
24	my $format=$query->param("format");	24	my $format = $query->param("format");
25	my $error = '';	25	my $error = '';
26	if ($op eq "export") {	26	if ( $op eq "export" ) {
27	my $biblionumber = $query->param("bib");	27	my $biblionumber = $query->param("bib");
28	if ($biblionumber){	28	if ($biblionumber) {
29	my $file_id = $biblionumber;	29	my $file_id = $biblionumber;
30	my $file_pre = "bib-";	30	my $file_pre = "bib-";
31		31
32	my $biblio = Koha::Biblios->find($biblionumber);	32	my $biblio = Koha::Biblios->find($biblionumber);
33	my $marc = $biblio->metadata->record({ embed_items => 1 });	33	my $marc = $biblio->metadata->record( { embed_items => 1 } );
34		34
35	if( C4::Context->preference('DefaultSaveRecordFileID') eq 'controlnumber' ){	35	if ( C4::Context->preference('DefaultSaveRecordFileID') eq 'controlnumber' ) {
36	my $marcflavour = C4::Context->preference('marcflavour'); #FIXME This option is required but does not change control num behaviour	36	my $marcflavour = C4::Context->preference('marcflavour')
37	my $control_num = GetMarcControlnumber( $marc, $marcflavour );	37	; #FIXME This option is required but does not change control num behaviour
38	if( $control_num ){	38	my $control_num = GetMarcControlnumber( $marc, $marcflavour );
39	$file_id = $control_num;	39	if ($control_num) {
40	$file_pre = "record-";	40	$file_id = $control_num;
41	}	41	$file_pre = "record-";
42	}	42	}
		43	}
43		44
44	if ($format =~ /endnote/) {	45	if ( $format =~ /endnote/ ) {
45	$marc = marc2endnote($marc);	46	$marc = marc2endnote($marc);
46	$format = 'endnote';	47	$format = 'endnote';
47	}	48	} elsif ( $format =~ /marcxml/ ) {
48	elsif ($format =~ /marcxml/) {	49	$marc = marc2marcxml($marc);
49	$marc = marc2marcxml($marc);	50	$format = "marcxml";
50	$format = "marcxml";	51	} elsif ( $format =~ /mods/ ) {
51	}	52	$marc = marc2modsxml($marc);
52	elsif ($format=~ /mods/) {	53	$format = "mods";
53	$marc = marc2modsxml($marc);	54	} elsif ( $format =~ /ris/ ) {
54	$format = "mods";	55	$marc = marc2ris($marc);
55	}	56	$format = "ris";
56	elsif ($format =~ /ris/) {	57	} elsif ( $format =~ /bibtex/ ) {
57	$marc = marc2ris($marc);	58	$marc = marc2bibtex($marc);
58	$format = "ris";	59	$format = "bibtex";
59	}	60	} elsif ( $format =~ /dc$/ ) {
60	elsif ($format =~ /bibtex/) {	61	$marc = marc2dcxml( undef, undef, $biblionumber, $format );
61	$marc = marc2bibtex($marc);	62	$format = "dublin-core.xml";
62	$format = "bibtex";	63	} elsif ( $format =~ /marc8/ ) {
63	}	64	$marc = changeEncoding( $marc, "MARC", "MARC21", "MARC-8" );
64	elsif ($format =~ /dc$/) {	65	$marc = $marc->as_usmarc();
65	$marc = marc2dcxml(undef, undef, $biblionumber, $format);	66	$format = "marc8";
66	$format = "dublin-core.xml";	67	} elsif ( $format =~ /utf8/ ) {
67	}	68	C4::Charset::SetUTF8Flag( $marc, 1 );
68	elsif ($format =~ /marc8/) {	69	$marc = $marc->as_usmarc();
69	$marc = changeEncoding($marc,"MARC","MARC21","MARC-8");	70	$format = "utf8";
70	$marc = $marc->as_usmarc();	71	} elsif ( $format =~ /marcstd/ ) {
71	$format = "marc8";	72	C4::Charset::SetUTF8Flag( $marc, 1 );
72	}	73	( $error, $marc ) = marc2marc( $marc, 'marcstd', C4::Context->preference('marcflavour') );
73	elsif ($format =~ /utf8/) {	74	$format = "marcstd";
74	C4::Charset::SetUTF8Flag($marc, 1);	75	}
75	$marc = $marc->as_usmarc();	76	if ( $format =~ /utf8/ or $format =~ /marcstd/ ) {
76	$format = "utf8";	77	binmode STDOUT, ':encoding(UTF-8)';
77	}
78	elsif ($format =~ /marcstd/) {
79	C4::Charset::SetUTF8Flag($marc,1);
80	($error, $marc) = marc2marc($marc, 'marcstd', C4::Context->preference('marcflavour'));
81	$format = "marcstd";
82	}
83	if ( $format =~ /utf8/ or $format =~ /marcstd/ ) {
84	binmode STDOUT, ':encoding(UTF-8)';
85	}
86	print $query->header(
87	-type => 'application/octet-stream',
88	-attachment=>"$file_pre$file_id.$format");
89	print $marc;
90	}	78	}
91	}elsif ($op eq "exportxsl"){	79	print $query->header(
		80	-type => 'application/octet-stream',
		81	-attachment => "$file_pre$file_id.$format"
		82	);
		83	print $marc;
		84	}
		85	} elsif ( $op eq "exportxsl" ) {
92	my $biblionumber = $query->param("bib");	86	my $biblionumber = $query->param("bib");
93	if ($biblionumber){	87	if ($biblionumber) {
94	my $xslFile = $query->param("file");	88	my $xslFile = $query->param("file");
95	my $biblio = Koha::Biblios->find($biblionumber);	89	my $biblio = Koha::Biblios->find($biblionumber);
96	my $marc = $biblio->metadata->record( { embed_items => 1 } );	90	my $marc = $biblio->metadata->record( { embed_items => 1 } );
97	my $format=$query->param("format")\|\|'txt';	91	my $format = $query->param("format") \|\| 'txt';
98	my @hiddenitems;	92	my @hiddenitems;
99		93
100	$marc = XSLTParse4Display(	94	$marc = XSLTParse4Display(
101	{	95	{
102	biblionumber => $biblionumber,	96	biblionumber => $biblionumber,
103	record => $marc,	97	record => $marc,
104	xsl_syspref => "XSLTCustomExport",	98	xsl_syspref => "XSLTCustomExport",
105	fix_amps => 1,	99	fix_amps => 1,
106	hidden_items => \@hiddenitems,	100	hidden_items => \@hiddenitems,
107	xslfilename => $xslFile,	101	xslfilename => $xslFile,
108	}	102	}
109	);	103	);
110	print $query->header(	104	print $query->header(
111	-type => 'application/octet-stream',	105	-type => 'application/octet-stream',
112	-attachment=>"bib-$biblionumber.$format");	106	-attachment => "bib-$biblionumber.$format"
		107	);
113	print $marc;	108	print $marc;
114	}	109	}
115	}	110	}

Line 0 Link Here

(-)a/installer/data/mysql/atomicupdate/bug_17385-CustomOptionForOpacExportOptions_syspref.pl (+29 lines)
	1	use Modern::Perl;
	2
	3	return {
	4	bug_number => "17385",
	5	description => "Add a custom option for OpacExportOptions system preference",
	6	up => sub {
	7	my ($args) = @_;
	8	my ( $dbh, $out ) = @$args{qw(dbh out)};
	9
	10	$dbh->do(
	11	q{
	12	UPDATE systempreferences
	13	SET value = 'bibtex,dc,marcxml,marc8,utf8,marcstd,mods,ris,isbd,custom'
	14	WHERE variable = 'OpacExportOptions';
	15	}
	16	);
	17
	18	$dbh->do(
	19	q{
	20	INSERT IGNORE INTO systempreferences (variable,value,options,explanation,type)
	21	VALUES ('CustomXSLTExportPath','','','The path to the folder containing the customized XSL files for export','');
	22	}
	23	);
	24
	25	# sysprefs
	26	say $out "Updated system preference 'OpacExportOptions'";
	27	say $out "Added new system preference 'OpacCustomExportFilePath'";
	28	},
	29	};

Lines 176-181 INSERT INTO systempreferences ( `variable`, `value`, `options`, `explanation`, ` Link Here

(-)a/installer/data/mysql/mandatory/sysprefs.sql (-1 / +2 lines)
176	('CurrencyFormat','US','US\|FR\|CH','Determines the display format of currencies. eg: \'36000\' is displayed as \'360 000,00\' in \'FR\' or \'360,000.00\' in \'US\'.','Choice'),	176	('CurrencyFormat','US','US\|FR\|CH','Determines the display format of currencies. eg: \'36000\' is displayed as \'360 000,00\' in \'FR\' or \'360,000.00\' in \'US\'.','Choice'),
177	('CustomCoverImages','0',NULL,'If enabled, the custom cover images will be displayed in the staff interface. CustomCoverImagesURL must be defined.','YesNo'),	177	('CustomCoverImages','0',NULL,'If enabled, the custom cover images will be displayed in the staff interface. CustomCoverImagesURL must be defined.','YesNo'),
178	('CustomCoverImagesURL','',NULL,'Define an URL serving book cover images, using the following patterns: %issn%, %isbn%, FIXME ADD MORE (use it with CustomCoverImages and/or OPACCustomCoverImages)','free'),	178	('CustomCoverImagesURL','',NULL,'Define an URL serving book cover images, using the following patterns: %issn%, %isbn%, FIXME ADD MORE (use it with CustomCoverImages and/or OPACCustomCoverImages)','free'),
		179	('CustomXSLTExportPath','','','The path to the folder containing the customized XSL files for export',''),
179	('dateformat','us','metric\|us\|iso\|dmydot','Define global date format (us mm/dd/yyyy, metric dd/mm/yyy, ISO yyyy-mm-dd, dmydot dd.mm.yyyy)','Choice'),	180	('dateformat','us','metric\|us\|iso\|dmydot','Define global date format (us mm/dd/yyyy, metric dd/mm/yyy, ISO yyyy-mm-dd, dmydot dd.mm.yyyy)','Choice'),
180	('DebugLevel','2','0\|1\|2','Define the level of debugging information sent to the browser when errors are encountered (set to 0 in production). 0=none, 1=some, 2=most','Choice'),	181	('DebugLevel','2','0\|1\|2','Define the level of debugging information sent to the browser when errors are encountered (set to 0 in production). 0=none, 1=some, 2=most','Choice'),
181	('decreaseLoanHighHolds','0','','Decreases the loan period for items with number of holds above the threshold specified in decreaseLoanHighHoldsValue','YesNo'),	182	('decreaseLoanHighHolds','0','','Decreases the loan period for items with number of holds above the threshold specified in decreaseLoanHighHoldsValue','YesNo'),
Lines 463-469 INSERT INTO systempreferences ( `variable`, `value`, `options`, `explanation`, ` Link Here
463	('OPACdefaultSortOrder','dsc','asc\|dsc\|za\|az','Specify the default sort order','Choice'),	464	('OPACdefaultSortOrder','dsc','asc\|dsc\|za\|az','Specify the default sort order','Choice'),
464	('OPACdidyoumean','',NULL,'Did you mean? configuration for the OPAC. Do not change, as this is controlled by /cgi-bin/koha/admin/didyoumean.pl.','Free'),	465	('OPACdidyoumean','',NULL,'Did you mean? configuration for the OPAC. Do not change, as this is controlled by /cgi-bin/koha/admin/didyoumean.pl.','Free'),
465	('OPACDisplay856uAsImage','OFF','OFF\|Details\|Results\|Both','Display the URI in the 856u field as an image, the corresponding OPACXSLT option must be on','Choice'),	466	('OPACDisplay856uAsImage','OFF','OFF\|Details\|Results\|Both','Display the URI in the 856u field as an image, the corresponding OPACXSLT option must be on','Choice'),
466	('OpacExportOptions','bibtex,dc,marcxml,marc8,utf8,marcstd,mods,ris,isbd','','Define export options available on OPAC detail page.','multiple'),	467	('OpacExportOptions','bibtex,dc,marcxml,marc8,utf8,marcstd,mods,ris,isbd,custom','','Define export options available on OPAC detail page.','multiple'),
467	('OPACFallback', 'prog', 'bootstrap\|prog', 'Define the fallback theme for the OPAC interface.', 'Themes'),	468	('OPACFallback', 'prog', 'bootstrap\|prog', 'Define the fallback theme for the OPAC interface.', 'Themes'),
468	('OpacFavicon','','','Enter a complete URL to an image to replace the default Koha favicon on the OPAC','free'),	469	('OpacFavicon','','','Enter a complete URL to an image to replace the default Koha favicon on the OPAC','free'),
469	('OPACFineNoRenewals','100','','Fine limit above which user cannot renew books via OPAC','Integer'),	470	('OPACFineNoRenewals','100','','Fine limit above which user cannot renew books via OPAC','Integer'),

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

(-)a/opac/opac-basket.pl (-45 / +46 lines)
37		37
38	my $query = CGI->new;	38	my $query = CGI->new;
39		39
40	my ( $template, $borrowernumber, $cookie ) = get_template_and_user (	40	my ( $template, $borrowernumber, $cookie ) = get_template_and_user(
41	{	41	{
42	template_name => "opac-basket.tt",	42	template_name => "opac-basket.tt",
43	query => $query,	43	query => $query,
Lines 46-109 my ( $template, $borrowernumber, $cookie ) = get_template_and_user ( Link Here
46	}	46	}
47	);	47	);
48		48
49	my $bib_list = $query->param('bib_list');	49	my $bib_list = $query->param('bib_list');
50	my $verbose = $query->param('verbose');	50	my $verbose = $query->param('verbose');
51		51
52	if ($verbose) { $template->param( verbose => 1 ); }	52	if ($verbose) { $template->param( verbose => 1 ); }
53		53
54	my @bibs = split( /\//, $bib_list );	54	my @bibs = split( /\//, $bib_list );
55	my @results;	55	my @results;
56		56
57	my $num = 1;	57	my $num = 1;
58	my $marcflavour = C4::Context->preference('marcflavour');	58	my $marcflavour = C4::Context->preference('marcflavour');
59	if (C4::Context->preference('TagsEnabled')) {	59	if ( C4::Context->preference('TagsEnabled') ) {
60	$template->param(TagsEnabled => 1);	60	$template->param( TagsEnabled => 1 );
61	foreach (qw(TagsShowOnList TagsInputOnList)) {	61	foreach (qw(TagsShowOnList TagsInputOnList)) {
62	C4::Context->preference($_) and $template->param($_ => 1);	62	C4::Context->preference($_) and $template->param( $_ => 1 );
63	}	63	}
64	}	64	}
65		65
66	my $logged_in_user = Koha::Patrons->find($borrowernumber);	66	my $logged_in_user = Koha::Patrons->find($borrowernumber);
67		67
68	my $record_processor = Koha::RecordProcessor->new({ filters => 'ViewPolicy' });	68	my $record_processor = Koha::RecordProcessor->new( { filters => 'ViewPolicy' } );
69	my $rules = C4::Context->yaml_preference('OpacHiddenItems');	69	my $rules = C4::Context->yaml_preference('OpacHiddenItems');
70		70
71	foreach my $biblionumber ( @bibs ) {	71	foreach my $biblionumber (@bibs) {
72	$template->param( biblionumber => $biblionumber );	72	$template->param( biblionumber => $biblionumber );
73		73
74	my $biblio = Koha::Biblios->find( $biblionumber ) or next;	74	my $biblio = Koha::Biblios->find($biblionumber) or next;
75	my $dat = { %{$biblio->unblessed}, %{$biblio->biblioitem->unblessed} };	75	my $dat = { %{ $biblio->unblessed }, %{ $biblio->biblioitem->unblessed } };
76		76
77	# No filtering on the item records needed for the record itself	77	# No filtering on the item records needed for the record itself
78	# since the only reason item information is grabbed is because of branchcodes.	78	# since the only reason item information is grabbed is because of branchcodes.
79	my $record = $biblio->metadata->record;	79	my $record = $biblio->metadata->record;
80	my $framework = &GetFrameworkCode( $biblionumber );	80	my $framework = &GetFrameworkCode($biblionumber);
81	$record_processor->options({	81	$record_processor->options(
82	interface => 'opac',	82	{
83	frameworkcode => $framework	83	interface => 'opac',
84	});	84	frameworkcode => $framework
		85	}
		86	);
85	$record_processor->process($record);	87	$record_processor->process($record);
86	next unless $record;	88	next unless $record;
87	my $marcnotesarray = $biblio->get_marc_notes({ opac => 1 });	89	my $marcnotesarray = $biblio->get_marc_notes( { opac => 1 } );
88	my $marcauthorsarray = $biblio->get_marc_contributors;	90	my $marcauthorsarray = $biblio->get_marc_contributors;
89	my $marcsubjctsarray = GetMarcSubjects( $record, $marcflavour );	91	my $marcsubjctsarray = GetMarcSubjects( $record, $marcflavour );
90	my $marcseriesarray = GetMarcSeries ($record,$marcflavour);	92	my $marcseriesarray = GetMarcSeries( $record, $marcflavour );
91	my $marcurlsarray = GetMarcUrls ($record,$marcflavour);	93	my $marcurlsarray = GetMarcUrls( $record, $marcflavour );
92		94
93	# If every item is hidden, then the biblio should be hidden too.	95	# If every item is hidden, then the biblio should be hidden too.
94	next	96	next
95	if $biblio->hidden_in_opac({ rules => $rules });	97	if $biblio->hidden_in_opac( { rules => $rules } );
96		98
97	my $hasauthors = 0;	99	my $hasauthors = 0;
98	if($dat->{'author'} \|\| @$marcauthorsarray) {	100	if ( $dat->{'author'} \|\| @$marcauthorsarray ) {
99	$hasauthors = 1;	101	$hasauthors = 1;
100	}	102	}
101		103
102	# COinS format FIXME: for books Only	104	# COinS format FIXME: for books Only
103	my $fmt = substr $record->leader(), 6,2;	105	my $fmt = substr $record->leader(), 6, 2;
104	my $fmts;	106	my $fmts;
105	$fmts->{'am'} = 'book';	107	$fmts->{'am'} = 'book';
106	$dat->{ocoins_format} = $fmts->{$fmt};	108	$dat->{ocoins_format} = $fmts->{$fmt};
107		109
108	if ( $num % 2 == 1 ) {	110	if ( $num % 2 == 1 ) {
109	$dat->{'even'} = 1;	111	$dat->{'even'} = 1;
Lines 111-127 foreach my $biblionumber ( @bibs ) { Link Here
111		113
112	$num++;	114	$num++;
113	$dat->{biblionumber} = $biblionumber;	115	$dat->{biblionumber} = $biblionumber;
114	$dat->{ITEM_RESULTS} = $biblio->items->filter_by_visible_in_opac({ patron => $logged_in_user });	116	$dat->{ITEM_RESULTS} = $biblio->items->filter_by_visible_in_opac( { patron => $logged_in_user } );
115	$dat->{MARCNOTES} = $marcnotesarray;	117	$dat->{MARCNOTES} = $marcnotesarray;
116	$dat->{MARCSUBJCTS} = $marcsubjctsarray;	118	$dat->{MARCSUBJCTS} = $marcsubjctsarray;
117	$dat->{MARCAUTHORS} = $marcauthorsarray;	119	$dat->{MARCAUTHORS} = $marcauthorsarray;
118	$dat->{MARCSERIES} = $marcseriesarray;	120	$dat->{MARCSERIES} = $marcseriesarray;
119	$dat->{MARCURLS} = $marcurlsarray;	121	$dat->{MARCURLS} = $marcurlsarray;
120	$dat->{HASAUTHORS} = $hasauthors;	122	$dat->{HASAUTHORS} = $hasauthors;
121	my ( $host, $relatedparts, $hostinfo ) = $biblio->get_marc_host;	123	my ( $host, $relatedparts, $hostinfo ) = $biblio->get_marc_host;
122	$dat->{HOSTITEMENTRIES} = $host;	124	$dat->{HOSTITEMENTRIES} = $host;
123	$dat->{RELATEDPARTS} = $relatedparts;	125	$dat->{RELATEDPARTS} = $relatedparts;
124	$dat->{HOSTINFO} = $hostinfo;	126	$dat->{HOSTINFO} = $hostinfo;
125		127
126	push( @results, $dat );	128	push( @results, $dat );
127	}	129	}
Lines 131-141 my $resultsarray = \@results; Link Here
131	# my $itemsarray=\@items;	133	# my $itemsarray=\@items;
132		134
133	$template->param(	135	$template->param(
134	csv_profiles => Koha::CsvProfiles->search(	136	csv_profiles => Koha::CsvProfiles->search( { type => 'marc', used_for => 'export_records', staff_only => 0 } ),
135	{ type => 'marc', used_for => 'export_records', staff_only => 0 } ),	137	bib_list => $bib_list,
136	bib_list => $bib_list,
137	BIBLIO_RESULTS => $resultsarray,	138	BIBLIO_RESULTS => $resultsarray,
138	xsl_exports => CustomXSLTExportList(),	139	xsl_exports => CustomXSLTExportList(),
139	);	140	);
140		141
141	output_html_with_http_headers $query, $cookie, $template->output, undef, { force_no_caching => 1 };	142	output_html_with_http_headers $query, $cookie, $template->output, undef, { force_no_caching => 1 };

Lines 36-42 use Koha::RecordProcessor; Link Here

(-)a/opac/opac-downloadcart.pl (-48 / +49 lines)
36	use utf8;	36	use utf8;
37	my $query = CGI->new();	37	my $query = CGI->new();
38		38
39	my ( $template, $borrowernumber, $cookie ) = get_template_and_user (	39	my ( $template, $borrowernumber, $cookie ) = get_template_and_user(
40	{	40	{
41	template_name => "opac-downloadcart.tt",	41	template_name => "opac-downloadcart.tt",
42	query => $query,	42	query => $query,
Lines 46-55 my ( $template, $borrowernumber, $cookie ) = get_template_and_user ( Link Here
46	);	46	);
47		47
48	my $bib_list = $query->param('bib_list');	48	my $bib_list = $query->param('bib_list');
49	my $format = $query->param('format');	49	my $format = $query->param('format');
50	my $dbh = C4::Context->dbh;	50	my $dbh = C4::Context->dbh;
51		51
52	if ($bib_list && $format) {	52	if ( $bib_list && $format ) {
53		53
54	my $patron = Koha::Patrons->find($borrowernumber);	54	my $patron = Koha::Patrons->find($borrowernumber);
55		55
Lines 60-67 if ($bib_list && $format) { Link Here
60	my $extension;	60	my $extension;
61	my $type;	61	my $type;
62		62
63	# CSV	63	# CSV
64	if ($format =~ /^\d+$/) {	64	if ( $format =~ /^\d+$/ ) {
65		65
66	my $csv_profile = Koha::CsvProfiles->find($format);	66	my $csv_profile = Koha::CsvProfiles->find($format);
67	if ( not $csv_profile or $csv_profile->staff_only ) {	67	if ( not $csv_profile or $csv_profile->staff_only ) {
Lines 69-81 if ($bib_list && $format) { Link Here
69	exit;	69	exit;
70	}	70	}
71		71
72	$output = marc2csv(\@bibs, $format);	72	$output = marc2csv( \@bibs, $format );
73		73
74	# Other formats	74	# Other formats
75	} else {	75	} else {
76	my $record_processor = Koha::RecordProcessor->new({	76	my $record_processor = Koha::RecordProcessor->new( { filters => 'ViewPolicy' } );
77	filters => 'ViewPolicy'
78	});
79	foreach my $biblionumber (@bibs) {	77	foreach my $biblionumber (@bibs) {
80		78
81	my $biblio = Koha::Biblios->find($biblionumber);	79	my $biblio = Koha::Biblios->find($biblionumber);
Lines 86-147 if ($bib_list && $format) { Link Here
86	patron => $patron,	84	patron => $patron,
87	}	85	}
88	);	86	);
89	my $xslFile = $query->param("file");	87	my $xslFile = $query->param("file");
90	my $framework = &GetFrameworkCode( $biblio );	88	my $framework = &GetFrameworkCode($biblio);
91	$record_processor->options({	89	$record_processor->options(
92	interface => 'opac',	90	{
93	frameworkcode => $framework	91	interface => 'opac',
94	});	92	frameworkcode => $framework
		93	}
		94	);
95	$record_processor->process($record);	95	$record_processor->process($record);
96		96
97	next unless $record;	97	next unless $record;
98		98
99	if ($format eq 'iso2709') {	99	if ( $format eq 'iso2709' ) {
		100
100	#NOTE: If we don't explicitly UTF-8 encode the output,	101	#NOTE: If we don't explicitly UTF-8 encode the output,
101	#the browser will guess the encoding, and it won't always choose UTF-8.	102	#the browser will guess the encoding, and it won't always choose UTF-8.
102	$output .= encode("UTF-8", $record->as_usmarc()) // q{};	103	$output .= encode( "UTF-8", $record->as_usmarc() ) // q{};
103	}	104	} elsif ( $format eq 'ris' ) {
104	elsif ($format eq 'ris') {
105	$output .= marc2ris($record);	105	$output .= marc2ris($record);
106	}	106	} elsif ( $format eq 'bibtex' ) {
107	elsif ($format eq 'bibtex') {	107	$output .= marc2bibtex( $record, $biblio );
108	$output .= marc2bibtex($record, $biblio);	108	} elsif ( $format eq 'isbd' ) {
109	}	109	my $framework = GetFrameworkCode($biblio);
110	elsif ( $format eq 'isbd' ) {	110	$output .= GetISBDView(
111	my $framework = GetFrameworkCode( $biblio );	111	{
112	$output .= GetISBDView({	112	'record' => $record,
113	'record' => $record,	113	'template' => 'opac',
114	'template' => 'opac',	114	'framework' => $framework,
115	'framework' => $framework,	115	}
116	});	116	);
117	$extension = "txt";	117	$extension = "txt";
118	$type = "text/plain";	118	$type = "text/plain";
119	}	119	} elsif ( $format =~ /^xsl\.(.*)$/ ) {
120	elsif ($format =~ /^xsl\.(.*)$/) {	120	$output .= XSLTParse4Display(
121	$output .= XSLTParse4Display({	121	{
122	biblionumber => $biblio,	122	biblionumber => $biblio,
123	record => $record,	123	record => $record,
124	xsl_syspref => "OPACXSLTCustomExport",	124	xsl_syspref => "OPACXSLTCustomExport",
125	fix_amps => 1,	125	fix_amps => 1,
126	hidden_items => undef,	126	hidden_items => undef,
127	xslfilename => $xslFile,	127	xslfilename => $xslFile,
128	});	128	}
		129	);
129	}	130	}
130	}	131	}
131	}	132	}
132		133
133	# If it was a CSV export we change the format after the export so the file extension is fine	134	# If it was a CSV export we change the format after the export so the file extension is fine
134	$format = "csv" if ($format =~ m/^\d+$/);	135	$format = "csv" if ( $format =~ m/^\d+$/ );
135	$format = "html" if ($format =~ /^xsl\./);	136	$format = "html" if ( $format =~ /^xsl\./ );
136		137
137	print $query->header(	138	print $query->header(
138	-type => ($type) ? $type : 'application/octet-stream',	139	-type => ($type) ? $type : 'application/octet-stream',
139	-'Content-Transfer-Encoding' => 'binary',	140	-'Content-Transfer-Encoding' => 'binary',
140	-attachment => ($extension) ? "cart.$format.$extension" : "cart.$format"	141	-attachment => ($extension) ? "cart.$format.$extension" : "cart.$format"
141	);	142	);
142	print $output;	143	print $output;
143		144
144	} else {	145	} else {
145	$template->param(	146	$template->param(
146	csv_profiles => Koha::CsvProfiles->search(	147	csv_profiles => Koha::CsvProfiles->search(
147	{	148	{
Lines 152-158 if ($bib_list && $format) { Link Here
152	),	153	),
153	bib_list => $bib_list,	154	bib_list => $bib_list,
154	);	155	);
155	$template->param(bib_list => $bib_list);	156	$template->param( bib_list => $bib_list );
156	$template->param(xsl_exports => CustomXSLTExportList());	157	$template->param( xsl_exports => CustomXSLTExportList() );
157	output_html_with_http_headers $query, $cookie, $template->output;	158	output_html_with_http_headers $query, $cookie, $template->output;
158	}	159	}

Lines 37-48 use utf8; Link Here

(-)a/opac/opac-downloadshelf.pl (-48 / +47 lines)
37	my $query = CGI->new;	37	my $query = CGI->new;
38		38
39	# if virtualshelves is disabled, leave immediately	39	# if virtualshelves is disabled, leave immediately
40	if ( ! C4::Context->preference('virtualshelves') ) {	40	if ( !C4::Context->preference('virtualshelves') ) {
41	print $query->redirect("/cgi-bin/koha/errors/404.pl");	41	print $query->redirect("/cgi-bin/koha/errors/404.pl");
42	exit;	42	exit;
43	}	43	}
44		44
45	my ( $template, $borrowernumber, $cookie ) = get_template_and_user (	45	my ( $template, $borrowernumber, $cookie ) = get_template_and_user(
46	{	46	{
47	template_name => "opac-downloadshelf.tt",	47	template_name => "opac-downloadshelf.tt",
48	query => $query,	48	query => $query,
Lines 51-76 my ( $template, $borrowernumber, $cookie ) = get_template_and_user ( Link Here
51	}	51	}
52	);	52	);
53		53
54	my $patron = Koha::Patrons->find( $borrowernumber );	54	my $patron = Koha::Patrons->find($borrowernumber);
55		55
56	my $shelfnumber = $query->param('shelfnumber');	56	my $shelfnumber = $query->param('shelfnumber');
57	my $format = $query->param('format');	57	my $format = $query->param('format');
58	my $context = $query->param('context');	58	my $context = $query->param('context');
59		59
60	my $shelf = Koha::Virtualshelves->find( $shelfnumber );	60	my $shelf = Koha::Virtualshelves->find($shelfnumber);
61	if ( $shelf and $shelf->can_be_viewed( $borrowernumber ) ) {	61	if ( $shelf and $shelf->can_be_viewed($borrowernumber) ) {
62		62
63	if ($shelfnumber && $format) {	63	if ( $shelfnumber && $format ) {
64		64
65		65	my $contents = $shelf->get_contents;
66	my $contents = $shelf->get_contents;
67	my $marcflavour = C4::Context->preference('marcflavour');	66	my $marcflavour = C4::Context->preference('marcflavour');
68	my $output;	67	my $output;
69	my $extension;	68	my $extension;
70	my $type;	69	my $type;
71		70
72	# CSV	71	# CSV
73	if ($format =~ /^\d+$/) {	72	if ( $format =~ /^\d+$/ ) {
74		73
75	my $csv_profile = Koha::CsvProfiles->find($format);	74	my $csv_profile = Koha::CsvProfiles->find($format);
76	if ( not $csv_profile or $csv_profile->staff_only ) {	75	if ( not $csv_profile or $csv_profile->staff_only ) {
Lines 82-93 if ( $shelf and $shelf->can_be_viewed( $borrowernumber ) ) { Link Here
82	while ( my $content = $contents->next ) {	81	while ( my $content = $contents->next ) {
83	push @biblios, $content->biblionumber;	82	push @biblios, $content->biblionumber;
84	}	83	}
85	$output = marc2csv(\@biblios, $format);	84	$output = marc2csv( \@biblios, $format );
86	# Other formats	85
		86	# Other formats
87	} else {	87	} else {
88	my $record_processor = Koha::RecordProcessor->new({	88	my $record_processor = Koha::RecordProcessor->new( { filters => 'ViewPolicy' } );
89	filters => 'ViewPolicy'
90	});
91	while ( my $content = $contents->next ) {	89	while ( my $content = $contents->next ) {
92	my $biblionumber = $content->biblionumber;	90	my $biblionumber = $content->biblionumber;
93		91
Lines 99-137 if ( $shelf and $shelf->can_be_viewed( $borrowernumber ) ) { Link Here
99	patron => $patron,	97	patron => $patron,
100	}	98	}
101	);	99	);
102	my $xslFile = $query->param("file");	100	my $xslFile = $query->param("file");
103	my $framework = $biblio->frameworkcode;	101	my $framework = $biblio->frameworkcode;
104	$record_processor->options({	102	$record_processor->options(
105	interface => 'opac',	103	{
106	frameworkcode => $framework	104	interface => 'opac',
107	});	105	frameworkcode => $framework
		106	}
		107	);
108	$record_processor->process($record);	108	$record_processor->process($record);
109	next unless $record;	109	next unless $record;
110		110
111	if ($format eq 'iso2709') {	111	if ( $format eq 'iso2709' ) {
112	$output .= $record->as_usmarc();	112	$output .= $record->as_usmarc();
113	}	113	} elsif ( $format eq 'ris' ) {
114	elsif ($format eq 'ris' ) {
115	$output .= marc2ris($record);	114	$output .= marc2ris($record);
116	}	115	} elsif ( $format eq 'bibtex' ) {
117	elsif ($format eq 'bibtex') {	116	$output .= marc2bibtex( $record, $biblionumber );
118	$output .= marc2bibtex($record, $biblionumber);	117	} elsif ( $format eq 'isbd' ) {
119	}	118	$output .= GetISBDView(
120	elsif ( $format eq 'isbd' ) {	119	{
121	$output .= GetISBDView({	120	'record' => $record,
122	'record' => $record,	121	'template' => 'opac',
123	'template' => 'opac',	122	'framework' => $framework,
124	'framework' => $framework,	123	}
125	});	124	);
126	$extension = "txt";	125	$extension = "txt";
127	$type = "text/plain";	126	$type = "text/plain";
128	}elsif ($format =~ /^xsl\.(.*)$/){	127	} elsif ( $format =~ /^xsl\.(.*)$/ ) {
129	$output .= XSLTParse4Display(	128	$output .= XSLTParse4Display(
130	{	129	{
131	biblionumber => $biblionumber,	130	biblionumber => $biblionumber,
132	record => $record,	131	record => $record,
133	xsl_syspref => "XSLTCustomExport",	132	xsl_syspref => "XSLTCustomExport",
134	fix_amps => 1,	133	fix_amps => 1,
135	hidden_items => undef,	134	hidden_items => undef,
136	xslfilename => $xslFile,	135	xslfilename => $xslFile,
137	}	136	}
Lines 141-162 if ( $shelf and $shelf->can_be_viewed( $borrowernumber ) ) { Link Here
141	}	140	}
142		141
143	# If it was a CSV export we change the format after the export so the file extension is fine	142	# If it was a CSV export we change the format after the export so the file extension is fine
144	$format = "csv" if ($format =~ m/^\d+$/);	143	$format = "csv" if ( $format =~ m/^\d+$/ );
145	$format = "html" if ($format =~ /^xsl\./);	144	$format = "html" if ( $format =~ /^xsl\./ );
146	print $query->header(	145	print $query->header(
147	-type => ($type) ? $type : 'application/octet-stream',	146	-type => ($type) ? $type : 'application/octet-stream',
148	-'Content-Transfer-Encoding' => 'binary',	147	-'Content-Transfer-Encoding' => 'binary',
149	-attachment => ($extension) ? "shelf.$format.$extension" : "shelf.$format"	148	-attachment => ($extension) ? "shelf.$format.$extension" : "shelf.$format"
150	);	149	);
151	print $output;	150	print $output;
152		151
153	} else {	152	} else {
154		153
155	# if modal context is passed set a variable so that page markup can be different	154	# if modal context is passed set a variable so that page markup can be different
156	if($context eq "modal"){	155	if ( $context eq "modal" ) {
157	$template->param(modal => 1);	156	$template->param( modal => 1 );
158	} else {	157	} else {
159	$template->param(fullpage => 1);	158	$template->param( fullpage => 1 );
160	}	159	}
161	$template->param(	160	$template->param(
162	csv_profiles => Koha::CsvProfiles->search(	161	csv_profiles => Koha::CsvProfiles->search(
Lines 168-179 if ( $shelf and $shelf->can_be_viewed( $borrowernumber ) ) { Link Here
168	),	167	),
169	shelf => $shelf,	168	shelf => $shelf,
170	);	169	);
171	$template->param(xsl_exports => CustomXSLTExportList());	170	$template->param( xsl_exports => CustomXSLTExportList() );
172	$template->param( shelf => $shelf );	171	$template->param( shelf => $shelf );
173	output_html_with_http_headers $query, $cookie, $template->output;	172	output_html_with_http_headers $query, $cookie, $template->output;
174	}	173	}
175		174
176	} else {	175	} else {
177	$template->param(invalidlist => 1);	176	$template->param( invalidlist => 1 );
178	output_html_with_http_headers $query, $cookie, $template->output;	177	output_html_with_http_headers $query, $cookie, $template->output;
179	}	178	}

Lines 34-43 use Koha::Biblios; Link Here

(-)a/opac/opac-export.pl (-86 / +79 lines)
34	use C4::XSLT qw( XSLTParse4Display );	34	use C4::XSLT qw( XSLTParse4Display );
35	use Koha::RecordProcessor;	35	use Koha::RecordProcessor;
36		36
37	my $query = CGI->new;	37	my $query = CGI->new;
38	my $op=$query->param("op")\|\|''; #op=export is currently the only use	38	my $op = $query->param("op") \|\| ''; #op=export is currently the only use
39	my $format=$query->param("format")\|\|'utf8';	39	my $format = $query->param("format") \|\| 'utf8';
40	my $biblionumber = $query->param("bib")\|\|0;	40	my $biblionumber = $query->param("bib") \|\| 0;
41	$biblionumber = int($biblionumber);	41	$biblionumber = int($biblionumber);
42	my $error = q{};	42	my $error = q{};
43		43
Lines 48-198 my $patron; Link Here
48	if ($userenv) {	48	if ($userenv) {
49	my $borrowernumber = $userenv->{'number'};	49	my $borrowernumber = $userenv->{'number'};
50	if ($borrowernumber) {	50	if ($borrowernumber) {
51	$patron = Koha::Patrons->find( $borrowernumber );	51	$patron = Koha::Patrons->find($borrowernumber);
52	}	52	}
53	}	53	}
54		54
55	my $include_items = ($format =~ /bibtex/) ? 0 : 1;	55	my $include_items = ( $format =~ /bibtex/ ) ? 0 : 1;
56	my $biblio = Koha::Biblios->find($biblionumber);	56	my $biblio = Koha::Biblios->find($biblionumber);
57	my $marc = $biblio	57	my $marc = $biblio
58	? $biblio->metadata->record(	58	? $biblio->metadata->record(
59	{	59	{
60	embed_items => 1,	60	embed_items => 1,
61	opac => 1,	61	opac => 1,
62	patron => $patron,	62	patron => $patron,
63	}	63	}
64	)	64	)
65	: undef;	65	: undef;
66		66
67	if(!$marc) {	67	if ( !$marc ) {
68	print $query->redirect("/cgi-bin/koha/errors/404.pl");	68	print $query->redirect("/cgi-bin/koha/errors/404.pl");
69	exit;	69	exit;
70	}	70	}
71		71
72	my $file_id = $biblionumber;	72	my $file_id = $biblionumber;
73	my $file_pre = "bib-";	73	my $file_pre = "bib-";
74	if( C4::Context->preference('DefaultSaveRecordFileID') eq 'controlnumber' ){	74	if ( C4::Context->preference('DefaultSaveRecordFileID') eq 'controlnumber' ) {
75	my $marcflavour = C4::Context->preference('marcflavour'); #FIXME This option is required but does not change control num behaviour	75	my $marcflavour =
		76	C4::Context->preference('marcflavour'); #FIXME This option is required but does not change control num behaviour
76	my $control_num = GetMarcControlnumber( $marc, $marcflavour );	77	my $control_num = GetMarcControlnumber( $marc, $marcflavour );
77	if( $control_num ){	78	if ($control_num) {
78	$file_id = $control_num;	79	$file_id = $control_num;
79	$file_pre = "record-";	80	$file_pre = "record-";
80	}	81	}
81	}	82	}
82		83
83	my $framework = $biblio->frameworkcode;	84	my $framework = $biblio->frameworkcode;
84	my $record_processor = Koha::RecordProcessor->new({	85	my $record_processor = Koha::RecordProcessor->new(
85	filters => 'ViewPolicy',	86	{
86	options => {	87	filters => 'ViewPolicy',
87	interface => 'opac',	88	options => {
88	frameworkcode => $framework	89	interface => 'opac',
		90	frameworkcode => $framework
		91	}
89	}	92	}
90	});	93	);
91	$record_processor->process($marc);	94	$record_processor->process($marc);
92		95
93	if ($format =~ /endnote/) {	96	if ( $format =~ /endnote/ ) {
94	$marc = marc2endnote($marc);	97	$marc = marc2endnote($marc);
95	$format = 'endnote';	98	$format = 'endnote';
96	}	99	} elsif ( $format =~ /marcxml/ ) {
97	elsif ($format =~ /marcxml/) {	100	$marc = marc2marcxml($marc);
98	$marc = marc2marcxml($marc);
99	$format = 'marcxml';	101	$format = 'marcxml';
100	}	102	} elsif ( $format =~ /mods/ ) {
101	elsif ($format=~ /mods/) {	103	$marc = marc2modsxml($marc);
102	$marc = marc2modsxml($marc);
103	$format = 'mods';	104	$format = 'mods';
104	}	105	} elsif ( $format =~ /ris/ ) {
105	elsif ($format =~ /ris/) {	106	$marc = marc2ris($marc);
106	$marc = marc2ris($marc);
107	$format = 'ris';	107	$format = 'ris';
108	}	108	} elsif ( $format =~ /bibtex/ ) {
109	elsif ($format =~ /bibtex/) {	109	$marc = marc2bibtex( $marc, $biblionumber );
110	$marc = marc2bibtex($marc,$biblionumber);
111	$format = 'bibtex';	110	$format = 'bibtex';
112	}	111	} elsif ( $format =~ /^(dc\|oaidc\|srwdc\|rdfdc)$/i ) {
113	elsif ($format =~ /^(dc\|oaidc\|srwdc\|rdfdc)$/i ) {	112
114	# TODO: Dublin Core leaks fields marked hidden by framework.	113	# TODO: Dublin Core leaks fields marked hidden by framework.
115	$marc = marc2dcxml($marc, undef, $biblionumber, $format);	114	$marc = marc2dcxml( $marc, undef, $biblionumber, $format );
116	$format = "dublin-core.xml";	115	$format = "dublin-core.xml";
117	}	116	} elsif ( $format =~ /marc8/ ) {
118	elsif ($format =~ /marc8/) {	117	( $error, $marc ) = changeEncoding( $marc, "MARC", "MARC21", "MARC-8" );
119	($error,$marc) = changeEncoding($marc,"MARC","MARC21","MARC-8");	118	$marc = $marc->as_usmarc() unless $error;
120	$marc = $marc->as_usmarc() unless $error;
121	$format = 'marc8';	119	$format = 'marc8';
122	}	120	} elsif ( $format =~ /utf8/ ) {
123	elsif ($format =~ /utf8/) {	121	C4::Charset::SetUTF8Flag( $marc, 1 );
124	C4::Charset::SetUTF8Flag($marc,1);	122	$marc = $marc->as_usmarc();
125	$marc = $marc->as_usmarc();
126	$format = 'utf8';	123	$format = 'utf8';
127	}	124	} elsif ( $format =~ /marcstd/ ) {
128	elsif ($format =~ /marcstd/) {	125	C4::Charset::SetUTF8Flag( $marc, 1 );
129	C4::Charset::SetUTF8Flag($marc,1);	126	( $error, $marc ) = marc2marc( $marc, 'marcstd', C4::Context->preference('marcflavour') );
130	($error,$marc) = marc2marc($marc, 'marcstd', C4::Context->preference('marcflavour'));
131	$format = 'marcstd';	127	$format = 'marcstd';
132	}	128	} elsif ( $format =~ /isbd/ ) {
133	elsif ( $format =~ /isbd/ ) {	129	$marc = GetISBDView(
134	$marc = GetISBDView({	130	{
135	'record' => $marc,	131	'record' => $marc,
136	'template' => 'opac',	132	'template' => 'opac',
137	'framework' => $framework,	133	'framework' => $framework,
138	});	134	}
		135	);
139	$format = 'isbd';	136	$format = 'isbd';
140	}	137	} elsif ( $format =~ /html/ ) {
141	elsif ($format =~ /html/ ) {	138	if ($biblionumber) {
142	if ($biblionumber){
143	my $xslFile = $query->param("file");	139	my $xslFile = $query->param("file");
144	my $biblio = Koha::Biblios->find($biblionumber);	140	my $biblio = Koha::Biblios->find($biblionumber);
145	$marc = $biblio->metadata->record;	141	$marc = $biblio->metadata->record;
146	my @hiddenitems;	142	my @hiddenitems;
147		143
148	$marc = XSLTParse4Display(	144	$marc = XSLTParse4Display(
149	{	145	{
150	biblionumber => $biblionumber,	146	biblionumber => $biblionumber,
151	record => $marc,	147	record => $marc,
152	xsl_syspref => "OPACXSLTCustomExport",	148	xsl_syspref => "OPACXSLTCustomExport",
153	fix_amps => 1,	149	fix_amps => 1,
154	hidden_items => \@hiddenitems,	150	hidden_items => \@hiddenitems,
155	xslfilename => $xslFile,	151	xslfilename => $xslFile,
156	}	152	}
157	);	153	);
158	}	154	}
159	}	155	} else {
160	else {	156	$error = "Format $format is not supported.";
161	$error= "Format $format is not supported.";
162	}	157	}
163		158
164	if ($error){	159	if ($error) {
165	print $query->header();	160	print $query->header();
166	print $query->start_html();	161	print $query->start_html();
167	print "<h1>An error occurred </h1>";	162	print "<h1>An error occurred </h1>";
168	print $query->escapeHTML("$error");	163	print $query->escapeHTML("$error");
169	print $query->end_html();	164	print $query->end_html();
170	}	165	} else {
171	else {	166	if ( $format eq 'marc8' ) {
172	if ($format eq 'marc8'){
173	print $query->header(	167	print $query->header(
174	-type => 'application/marc',	168	-type => 'application/marc',
175	-charset=>'ISO-2022',	169	-charset => 'ISO-2022',
176	-attachment=>"$file_pre$file_id.$format");	170	-attachment => "$file_pre$file_id.$format"
177	}	171	);
178	elsif ( $format eq 'isbd' ) {	172	} elsif ( $format eq 'isbd' ) {
179	print $query->header(	173	print $query->header(
180	-type => 'text/plain',	174	-type => 'text/plain',
181	-charset => 'utf-8',	175	-charset => 'utf-8',
182	-attachment => "$file_pre$file_id.txt"	176	-attachment => "$file_pre$file_id.txt"
183	);	177	);
184	}	178	} elsif ( $format eq 'ris' ) {
185	elsif ( $format eq 'ris' ) {
186	print $query->header(	179	print $query->header(
187	-type => 'text/plain',	180	-type => 'text/plain',
188	-charset => 'utf-8',	181	-charset => 'utf-8',
189	-attachment => "$file_pre$file_id.$format"	182	-attachment => "$file_pre$file_id.$format"
190	);	183	);
191	} else {	184	} else {
192	binmode STDOUT, ':encoding(UTF-8)';	185	binmode STDOUT, ':encoding(UTF-8)';
193	print $query->header(	186	print $query->header(
194	-type => 'application/octet-stream',	187	-type => 'application/octet-stream',
195	-charset => 'utf-8',	188	-charset => 'utf-8',
196	-attachment => "$file_pre$file_id.$format"	189	-attachment => "$file_pre$file_id.$format"
197	);	190	);
198	}	191	}

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

(-)a/virtualshelves/downloadshelf.pl (-36 / +33 lines)
27	use C4::Ris qw( marc2ris );	27	use C4::Ris qw( marc2ris );
28	use C4::XSLT qw( XSLTParse4Display );	28	use C4::XSLT qw( XSLTParse4Display );
29		29
30
31	use Koha::Biblios;	30	use Koha::Biblios;
32	use Koha::CsvProfiles;	31	use Koha::CsvProfiles;
33	use Koha::Virtualshelves;	32	use Koha::Virtualshelves;
Lines 35-46 use Koha::Virtualshelves; Link Here
35	use utf8;	34	use utf8;
36	my $query = CGI->new;	35	my $query = CGI->new;
37		36
38	my ( $template, $loggedinuser, $cookie ) = get_template_and_user (	37	my ( $template, $loggedinuser, $cookie ) = get_template_and_user(
39	{	38	{
40	template_name => "virtualshelves/downloadshelf.tt",	39	template_name => "virtualshelves/downloadshelf.tt",
41	query => $query,	40	query => $query,
42	type => "intranet",	41	type => "intranet",
43	flagsrequired => { catalogue => 1 },	42	flagsrequired => { catalogue => 1 },
44	}	43	}
45	);	44	);
46		45
Lines 49-92 my $format = $query->param('format'); Link Here
49	my $dbh = C4::Context->dbh;	48	my $dbh = C4::Context->dbh;
50	my @messages;	49	my @messages;
51		50
52	if ($shelfid && $format) {	51	if ( $shelfid && $format ) {
53		52
54	my $marcflavour = C4::Context->preference('marcflavour');	53	my $marcflavour = C4::Context->preference('marcflavour');
55	my $output='';	54	my $output = '';
56		55
57	my $shelf = Koha::Virtualshelves->find($shelfid);	56	my $shelf = Koha::Virtualshelves->find($shelfid);
58	if ( $shelf ) {	57	if ($shelf) {
59	if ( $shelf->can_be_viewed( $loggedinuser ) ) {	58	if ( $shelf->can_be_viewed($loggedinuser) ) {
60		59
61	my $contents = $shelf->get_contents;	60	my $contents = $shelf->get_contents;
		61
62	# CSV	62	# CSV
63	if ($format =~ /^\d+$/) {	63	if ( $format =~ /^\d+$/ ) {
64	my @biblios;	64	my @biblios;
65	while ( my $content = $contents->next ) {	65	while ( my $content = $contents->next ) {
66	push @biblios, $content->biblionumber;	66	push @biblios, $content->biblionumber;
67	}	67	}
68	$output = marc2csv(\@biblios, $format);	68	$output = marc2csv( \@biblios, $format );
69	}	69	} else { #Other formats
70	else { #Other formats
71	while ( my $content = $contents->next ) {	70	while ( my $content = $contents->next ) {
72	my $biblionumber = $content->biblionumber;	71	my $biblionumber = $content->biblionumber;
73	my $biblio = Koha::Biblios->find($biblionumber);	72	my $biblio = Koha::Biblios->find($biblionumber);
74	my $record = $biblio->metadata->record({ embed_items => 1 });	73	my $record = $biblio->metadata->record( { embed_items => 1 } );
75	my $xslFile = $query->param("file");	74	my $xslFile = $query->param("file");
76	if ($format eq 'iso2709') {	75	if ( $format eq 'iso2709' ) {
77	$output .= $record->as_usmarc();	76	$output .= $record->as_usmarc();
78	}	77	} elsif ( $format eq 'ris' ) {
79	elsif ($format eq 'ris') {
80	$output .= marc2ris($record);	78	$output .= marc2ris($record);
81	}	79	} elsif ( $format eq 'bibtex' ) {
82	elsif ($format eq 'bibtex') {	80	$output .= marc2bibtex( $record, $biblionumber );
83	$output .= marc2bibtex($record, $biblionumber);	81	} elsif ( $format =~ /^xsl\.(.*)$/ ) {
84	}
85	elsif ($format =~ /^xsl\.(.*)$/){
86	$output .= XSLTParse4Display(	82	$output .= XSLTParse4Display(
87	{	83	{
88	biblionumber => $biblionumber,	84	biblionumber => $biblionumber,
89	record => $record,	85	record => $record,
90	xsl_syspref => 'XSLTCustomExport',	86	xsl_syspref => 'XSLTCustomExport',
91	fix_amps => 1,	87	fix_amps => 1,
92	hidden_items => undef,	88	hidden_items => undef,
Lines 98-109 if ($shelfid && $format) { Link Here
98	}	94	}
99		95
100	# If it was a CSV export we change the format after the export so the file extension is fine	96	# If it was a CSV export we change the format after the export so the file extension is fine
101	$format = "csv" if ($format =~ m/^\d+$/);	97	$format = "csv" if ( $format =~ m/^\d+$/ );
102	$format = "html" if ($format =~ /^xsl\./);	98	$format = "html" if ( $format =~ /^xsl\./ );
103	print $query->header(	99	print $query->header(
104	-type => 'application/octet-stream',	100	-type => 'application/octet-stream',
105	-'Content-Transfer-Encoding' => 'binary',	101	-'Content-Transfer-Encoding' => 'binary',
106	-attachment=>"shelf.$format");	102	-attachment => "shelf.$format"
		103	);
107	print $output;	104	print $output;
108	exit;	105	exit;
109	} else {	106	} else {
Lines 112-121 if ($shelfid && $format) { Link Here
112	} else {	109	} else {
113	push @messages, { type => 'error', code => 'does_not_exist' };	110	push @messages, { type => 'error', code => 'does_not_exist' };
114	}	111	}
115	}	112	} else {
116	else {	113	$template->param(
117	$template->param(csv_profiles => [ Koha::CsvProfiles->search({ type => 'marc', used_for => 'export_records' })->as_list ]);	114	csv_profiles => [ Koha::CsvProfiles->search( { type => 'marc', used_for => 'export_records' } )->as_list ] );
118	$template->param(shelfid => $shelfid);	115	$template->param( shelfid => $shelfid );
119	}	116	}
120	$template->param( messages => \@messages );	117	$template->param( messages => \@messages );
121	output_html_with_http_headers $query, $cookie, $template->output;	118	output_html_with_http_headers $query, $cookie, $template->output;

Lines 385-399 if ( $op eq 'view' ) { Link Here

(-)a/virtualshelves/shelves.pl (-9 / +8 lines)
385	}	385	}
386		386
387	$template->param(	387	$template->param(
388	op => $op,	388	op => $op,
389	referer => $referer,	389	referer => $referer,
390	shelf => $shelf,	390	shelf => $shelf,
391	messages => \@messages,	391	messages => \@messages,
392	public => $public,	392	public => $public,
393	print => scalar $query->param('print') \|\| 0,	393	print => scalar $query->param('print') \|\| 0,
394	csv_profiles => [ Koha::CsvProfiles->search({ type => 'marc', used_for => 'export_records' })->as_list ],	394	csv_profiles => [ Koha::CsvProfiles->search({ type => 'marc', used_for => 'export_records' })->as_list ],
395	allow_transfer => $allow_transfer,	395	allow_transfer => $allow_transfer,
396	xsl_exports => CustomXSLTExportList()	396	xsl_exports => CustomXSLTExportList()
397	);	397	);
398		398
399	output_html_with_http_headers $query, $cookie, $template->output;	399	output_html_with_http_headers $query, $cookie, $template->output;
400	-