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 $uploadfilename = $input->param('uploadfile'); # obsolete?
  71 my $replace        = !C4::Context->preference("AllowMultipleCovers")
  72   || $input->param('replace');
  73 my $op        = $input->param('op');
  74
  75 my $error;
  76
  77 my $biblio;
  78 my $cover_images;
  79 my $item;
  80
  81 if ( $itemnumber ) {
  82     $item = Koha::Items->find($itemnumber);
  83     $biblionumber = $item->biblionumber;
  84     $biblio = Koha::Biblios->find( $biblionumber );
  85     $cover_images = $item->cover_images->as_list;
  86 } elsif ( $biblionumber ){
  87     $biblio = Koha::Biblios->find( $biblionumber );
  88     $cover_images = $biblio->cover_images->as_list;
  89 }
  90
  91 $template->param(
  92     filetype     => $filetype,
  93     biblio       => $biblio,
  94     biblionumber => $biblionumber,
  95     itemnumber   => $itemnumber,
  96     cover_images => $cover_images,
  97 );
  98
  99 my $total = 0;
 100 my @results;
 101
 102 if ($fileID) {
 103     my $upload = Koha::UploadedFiles->find( $fileID );
 104     if ( $filetype eq 'image' ) {
 105         my $fh       = $upload->file_handle;
 106         my $srcimage = GD::Image->new($fh);
 107         $fh->close if $fh;
 108         if ( defined $srcimage ) {
 109             eval {
 110                 if ( $replace ) {
 111                     if ( $itemnumber ) {
 112                         Koha::Items->find($itemnumber)->cover_images->delete;
 113                     } elsif ( $biblionumber ) {
 114                         Koha::Biblios->find($biblionumber)->cover_images->search({ itemnumber => undef })->delete;
 115                     }
 116                 }
 117
 118                 Koha::CoverImage->new(
 119                     {
 120                         biblionumber => $biblionumber,
 121                         itemnumber   => $itemnumber,
 122                         src_image    => $srcimage
 123                     }
 124                 )->store;
 125             };
 126
 127             if ($@) {
 128                 warn $@;
 129                 $error = 'DBERR';
 130             }
 131             else {
 132                 $total = 1;
 133             }
 134         }
 135         else {
 136             $error = 'OPNIMG';
 137         }
 138         undef $srcimage;
 139     }
 140     else {
 141         my $filename = $upload->full_path;
 142         my $dirname = File::Temp::tempdir( CLEANUP => 1 );
 143         qx/unzip $filename -d $dirname/;
 144         my $exit_code = $?;
 145         unless ( $exit_code == 0 ) {
 146             $error = 'UZIPFAIL';
 147         }
 148         else {
 149             my @directories;
 150             push @directories, "$dirname";
 151             foreach my $recursive_dir (@directories) {
 152                 my $dir;
 153                 opendir $dir, $recursive_dir;
 154                 while ( my $entry = readdir $dir ) {
 155                     push @directories, "$recursive_dir/$entry"
 156                       if ( -d "$recursive_dir/$entry" and $entry !~ /^[._]/ );
 157                 }
 158                 closedir $dir;
 159             }
 160             foreach my $dir (@directories) {
 161                 my $file;
 162                 my $idlink   = "$dir/idlink.txt";
 163                 my $datalink = "$dir/datalink.txt";
 164                 if ( -e $idlink && !-l $idlink ) {
 165                     $file = $idlink;
 166                 } elsif ( -e $datalink && !-l $datalink ) {
 167                     $file = $datalink;
 168                 }
 169                 else {
 170                     next;
 171                 }
 172                 if ( open( my $fh, '<', $file ) ) {
 173                     while ( my $line = <$fh> ) {
 174                         my $delim =
 175                             ( $line =~ /\t/ ) ? "\t"
 176                           : ( $line =~ /,/ )  ? ","
 177                           :                     "";
 178
 179                         unless ( $delim eq "," || $delim eq "\t" ) {
 180                             warn "Unrecognized or missing field delimeter. Please verify that you are using either a ',' or a 'tab'";
 181                             $error = 'DELERR';
 182                             next;
 183                         }
 184                         else {
 185                             ( $biblionumber, $filename ) = split $delim, $line, 2;
 186                             $biblionumber =~
 187                               s/[\"\r\n]//g;    # remove offensive characters
 188                             $filename =~ s/[\"\r\n]//g;
 189                             $filename =~ s/^\s+//;
 190                             $filename =~ s/\s+$//;
 191                             my $full_filename = Cwd::abs_path("$dir/$filename"); #Resolve any relative filepath references
 192                             my $srcimage;
 193                             if ( $full_filename =~ /^\Q$dir\E/ ){
 194                                 $srcimage = GD::Image->new($full_filename);
 195                             }
 196                             my $biblio;
 197                             my $item;
 198                             if ( defined $srcimage ) {
 199                                 $total++;
 200                                 eval {
 201                                     if ( $replace ) {
 202                                         if ( $biblionumber ) {
 203                                             $biblio = Koha::Biblios->find( $biblionumber );
 204                                             $biblio->cover_images->delete;
 205                                         } elsif ( $itemnumber ) {
 206                                             $item = Koha::Items->find($itemnumber);
 207                                             $item->cover_images->delete;
 208                                             $biblio = Koha::Biblios->find( $item->{biblionumber} );
 209                                         }
 210                                     } else {
 211                                         if( $biblionumber ){
 212                                             $biblio = Koha::Biblios->find( $biblionumber );
 213                                         } elsif ( $itemnumber ){
 214                                             $item = Koha::Items->find($itemnumber);
 215                                             $biblio = Koha::Biblios->find( $item->{biblionumber} );
 216                                         } else {
 217                                             warn "Problem.";
 218                                         }
 219                                     }
 220
 221                                     push @results, {
 222                                         biblionumber => $biblionumber,
 223                                         itemnumber => $itemnumber,
 224                                         title => $biblio->title
 225                                     };
 226
 227                                     Koha::CoverImage->new(
 228                                         {
 229                                             biblionumber => $biblionumber,
 230                                             itemnumber   => $itemnumber,
 231                                             src_image    => $srcimage
 232                                         }
 233                                     )->store;
 234                                 };
 235
 236                                 if ($@) {
 237                                     $error = 'DBERR';
 238                                 }
 239                             }
 240                             else {
 241                                 $error = 'OPNIMG';
 242                             }
 243                             undef $srcimage;
 244
 245                             if ( !$error && C4::Context->preference("CataloguingLog") ) {
 246                                 logaction( 'CATALOGUING', 'MODIFY', $biblionumber, "biblio cover image: $filename" );
 247                             }
 248
 249                         }
 250                     }
 251                     close($fh);
 252                 }
 253                 else {
 254                     $error = 'OPNLINK';
 255                 }
 256             }
 257         }
 258     }
 259     if( $error ){
 260         $template->param(
 261             total        => $total,
 262             uploadimage  => 1,
 263             error        => $error,
 264             biblionumber => $biblionumber || Koha::Items->find($itemnumber)->biblionumber,
 265             itemnumber   => $itemnumber,
 266         );
 267     } elsif ( @results ){
 268         $template->param(
 269             total        => $total,
 270             uploadimage  => 1,
 271             results      => \@results
 272         );
 273     } else {
 274         print $input->redirect("/cgi-bin/koha/tools/upload-cover-image.pl?biblionumber=$biblionumber&itemnumber=$itemnumber");
 275     }
 276 }
 277
 278 output_html_with_http_headers $input, $cookie, $template->output;
 279
 280 exit 0;
 281
 282 =head1 AUTHORS
 283
 284 Written by Jared Camins-Esakov of C & P Bibliography Services, in part based on
 285 code by Koustubha Kale of Anant Corporation and Chris Nighswonger of Foundation
 286 Bible College.
 287
 288 =cut