tools/upload-cover-image.pl

   1 #!/usr/bin/perl
   2 #
   3 # Copyright 2011 C & P Bibliography Services
   4 #
   5 # This file is part of Koha.
   6 #
   7 # Koha is free software; you can redistribute it and/or modify it
   8 # under the terms of the GNU General Public License as published by
   9 # the Free Software Foundation; either version 3 of the License, or
  10 # (at your option) any later version.
  11 #
  12 # Koha is distributed in the hope that it will be useful, but
  13 # WITHOUT ANY WARRANTY; without even the implied warranty of
  14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  15 # GNU General Public License for more details.
  16 #
  17 # You should have received a copy of the GNU General Public License
  18 # along with Koha; if not, see <http://www.gnu.org/licenses>.
  19 #
  20 #
  21 #
  22
  23 =head1 NAME
  24
  25 upload-cover-image.pl - Script for handling uploading of both single and bulk coverimages and importing them into the database.
  26
  27 =head1 SYNOPSIS
  28
  29 upload-cover-image.pl
  30
  31 =head1 DESCRIPTION
  32
  33 This script is called and presents the user with an interface allowing him/her to upload a single cover image or bulk cover images via a zip file.
  34 Images will be resized into thumbnails of 140x200 pixels and larger images of
  35 800x600 pixels. If the images that are uploaded are larger, they will be
  36 resized, maintaining aspect ratio.
  37
  38 =cut
  39
  40 use Modern::Perl;
  41 use Cwd;
  42
  43 use File::Temp;
  44 use CGI qw ( -utf8 );
  45 use GD;
  46 use C4::Context;
  47 use C4::Auth qw( get_template_and_user );
  48 use C4::Output qw( output_html_with_http_headers );
  49 use Koha::Biblios;
  50 use Koha::CoverImages;
  51 use Koha::Items;
  52 use Koha::UploadedFiles;
  53 use C4::Log qw( logaction );
  54
  55 my $input = CGI->new;
  56
  57 my $fileID = $input->param('uploadedfileid');
  58 my ( $template, $loggedinuser, $cookie ) = get_template_and_user(
  59     {
  60         template_name   => "tools/upload-images.tt",
  61         query           => $input,
  62         type            => "intranet",
  63         flagsrequired   => { tools => 'upload_local_cover_images' },
  64     }
  65 );
  66
  67 my $filetype       = $input->param('filetype');
  68 my $biblionumber   = $input->param('biblionumber');
  69 my $itemnumber     = $input->param('itemnumber');
  70 my $replace = !C4::Context->preference("AllowMultipleCovers")
  71     || $input->param('replace');
  72 my $op = $input->param('op') // q{};
  73
  74 my $error;
  75
  76 my $biblio;
  77 my $cover_images;
  78 my $item;
  79
  80 if ( $itemnumber ) {
  81     $item = Koha::Items->find($itemnumber);
  82     $biblionumber = $item->biblionumber;
  83     $biblio = Koha::Biblios->find( $biblionumber );
  84     $cover_images = $item->cover_images->as_list;
  85 } elsif ( $biblionumber ){
  86     $biblio = Koha::Biblios->find( $biblionumber );
  87     $cover_images = $biblio->cover_images->as_list;
  88 }
  89
  90 $template->param(
  91     filetype     => $filetype,
  92     biblio       => $biblio,
  93     biblionumber => $biblionumber,
  94     itemnumber   => $itemnumber,
  95     cover_images => $cover_images,
  96 );
  97
  98 my $total = 0;
  99 my @results;
 100
 101 if ( $op eq 'cud-process' & $fileID ) {
 102     my $upload = Koha::UploadedFiles->find( $fileID );
 103     if ( $filetype eq 'image' ) {
 104         my $fh       = $upload->file_handle;
 105         my $srcimage = GD::Image->new($fh);
 106         $fh->close if $fh;
 107         if ( defined $srcimage ) {
 108             eval {
 109                 if ( $replace ) {
 110                     if ( $itemnumber ) {
 111                         Koha::Items->find($itemnumber)->cover_images->delete;
 112                     } elsif ( $biblionumber ) {
 113                         Koha::Biblios->find($biblionumber)->cover_images->search({ itemnumber => undef })->delete;
 114                     }
 115                 }
 116
 117                 Koha::CoverImage->new(
 118                     {
 119                         biblionumber => $biblionumber,
 120                         itemnumber   => $itemnumber,
 121                         src_image    => $srcimage
 122                     }
 123                 )->store;
 124             };
 125
 126             if ($@) {
 127                 warn $@;
 128                 $error = 'DBERR';
 129             }
 130             else {
 131                 $total = 1;
 132             }
 133         }
 134         else {
 135             $error = 'OPNIMG';
 136         }
 137         undef $srcimage;
 138     }
 139     else {
 140         my $filename = $upload->full_path;
 141         my $dirname = File::Temp::tempdir( CLEANUP => 1 );
 142         qx/unzip $filename -d $dirname/;
 143         my $exit_code = $?;
 144         unless ( $exit_code == 0 ) {
 145             $error = 'UZIPFAIL';
 146         }
 147         else {
 148             my @directories;
 149             push @directories, "$dirname";
 150             foreach my $recursive_dir (@directories) {
 151                 my $dir;
 152                 opendir $dir, $recursive_dir;
 153                 while ( my $entry = readdir $dir ) {
 154                     push @directories, "$recursive_dir/$entry"
 155                       if ( -d "$recursive_dir/$entry" and $entry !~ /^[._]/ );
 156                 }
 157                 closedir $dir;
 158             }
 159             foreach my $dir (@directories) {
 160                 my $file;
 161                 my $idlink   = "$dir/idlink.txt";
 162                 my $datalink = "$dir/datalink.txt";
 163                 if ( -e $idlink && !-l $idlink ) {
 164                     $file = $idlink;
 165                 } elsif ( -e $datalink && !-l $datalink ) {
 166                     $file = $datalink;
 167                 }
 168                 else {
 169                     next;
 170                 }
 171                 if ( open( my $fh, '<', $file ) ) {
 172                     while ( my $line = <$fh> ) {
 173                         my $delim =
 174                             ( $line =~ /\t/ ) ? "\t"
 175                           : ( $line =~ /,/ )  ? ","
 176                           :                     "";
 177
 178                         unless ( $delim eq "," || $delim eq "\t" ) {
 179                             warn "Unrecognized or missing field delimeter. Please verify that you are using either a ',' or a 'tab'";
 180                             $error = 'DELERR';
 181                             next;
 182                         }
 183                         else {
 184                             ( $biblionumber, $filename ) = split $delim, $line, 2;
 185                             $biblionumber =~
 186                               s/[\"\r\n]//g;    # remove offensive characters
 187                             $filename =~ s/[\"\r\n]//g;
 188                             $filename =~ s/^\s+//;
 189                             $filename =~ s/\s+$//;
 190                             my $full_filename = Cwd::abs_path("$dir/$filename"); #Resolve any relative filepath references
 191                             my $srcimage;
 192                             if ( $full_filename =~ /^\Q$dir\E/ ){
 193                                 $srcimage = GD::Image->new($full_filename);
 194                             }
 195                             my $biblio;
 196                             my $item;
 197                             if ( defined $srcimage ) {
 198                                 $total++;
 199                                 eval {
 200                                     if ( $replace ) {
 201                                         if ( $biblionumber ) {
 202                                             $biblio = Koha::Biblios->find( $biblionumber );
 203                                             $biblio->cover_images->delete;
 204                                         } elsif ( $itemnumber ) {
 205                                             $item = Koha::Items->find($itemnumber);
 206                                             $item->cover_images->delete;
 207                                             $biblio = Koha::Biblios->find( $item->{biblionumber} );
 208                                         }
 209                                     } else {
 210                                         if( $biblionumber ){
 211                                             $biblio = Koha::Biblios->find( $biblionumber );
 212                                         } elsif ( $itemnumber ){
 213                                             $item = Koha::Items->find($itemnumber);
 214                                             $biblio = Koha::Biblios->find( $item->{biblionumber} );
 215                                         } else {
 216                                             warn "Problem.";
 217                                         }
 218                                     }
 219
 220                                     push @results, {
 221                                         biblionumber => $biblionumber,
 222                                         itemnumber => $itemnumber,
 223                                         title => $biblio->title
 224                                     };
 225
 226                                     Koha::CoverImage->new(
 227                                         {
 228                                             biblionumber => $biblionumber,
 229                                             itemnumber   => $itemnumber,
 230                                             src_image    => $srcimage
 231                                         }
 232                                     )->store;
 233                                 };
 234
 235                                 if ($@) {
 236                                     $error = 'DBERR';
 237                                 }
 238                             }
 239                             else {
 240                                 $error = 'OPNIMG';
 241                             }
 242                             undef $srcimage;
 243
 244                             if ( !$error && C4::Context->preference("CataloguingLog") ) {
 245                                 logaction( 'CATALOGUING', 'MODIFY', $biblionumber, "biblio cover image: $filename" );
 246                             }
 247
 248                         }
 249                     }
 250                     close($fh);
 251                 }
 252                 else {
 253                     $error = 'OPNLINK';
 254                 }
 255             }
 256         }
 257     }
 258     if( $error ){
 259         $template->param(
 260             total        => $total,
 261             uploadimage  => 1,
 262             error        => $error,
 263             biblionumber => $biblionumber || Koha::Items->find($itemnumber)->biblionumber,
 264             itemnumber   => $itemnumber,
 265         );
 266     } elsif ( @results ){
 267         $template->param(
 268             total        => $total,
 269             uploadimage  => 1,
 270             results      => \@results
 271         );
 272     } else {
 273         print $input->redirect("/cgi-bin/koha/tools/upload-cover-image.pl?biblionumber=$biblionumber&itemnumber=$itemnumber");
 274     }
 275 }
 276
 277 output_html_with_http_headers $input, $cookie, $template->output;
 278
 279 exit 0;
 280
 281 =head1 AUTHORS
 282
 283 Written by Jared Camins-Esakov of C & P Bibliography Services, in part based on
 284 code by Koustubha Kale of Anant Corporation and Chris Nighswonger of Foundation
 285 Bible College.
 286
 287 =cut