DeliveryOrder: in/out weiche in transfer_stock
[kivitendo-erp.git] / SL / Helper / CreatePDF.pm
1 package SL::Helper::CreatePDF;
2
3 use strict;
4
5 use Carp;
6 use Cwd;
7 use English qw(-no_match_vars);
8 use File::Slurp ();
9 use File::Spec  ();
10 use File::Temp  ();
11 use File::Copy qw(move);
12 use List::MoreUtils qw(uniq);
13 use List::Util qw(first);
14 use Scalar::Util qw(blessed);
15 use String::ShellQuote ();
16
17 use SL::Common;
18 use SL::DB::Language;
19 use SL::DB::Printer;
20 use SL::MoreCommon;
21 use SL::System::Process;
22 use SL::Template;
23 use SL::Template::LaTeX;
24 use SL::X;
25
26 use Exporter 'import';
27 our @EXPORT_OK = qw(create_pdf merge_pdfs find_template);
28 our %EXPORT_TAGS = (
29   all => \@EXPORT_OK,
30 );
31
32 sub create_pdf {
33   my ($class, %params) = @_;
34
35   return __PACKAGE__->create_parsed_file(
36     format        => 'pdf',
37     template_type => 'LaTeX',
38     %params,
39   );
40 }
41
42 sub create_parsed_file {
43   my ($class, %params) = @_;
44
45   my $keep_temp_files = $::lx_office_conf{debug} && $::lx_office_conf{debug}->{keep_temp_files};
46   my $userspath       = SL::System::Process::exe_dir() . "/" . $::lx_office_conf{paths}->{userspath};
47   my $temp_dir        = File::Temp->newdir(
48     "kivitendo-print-XXXXXX",
49     DIR     => $userspath,
50     CLEANUP => !$keep_temp_files,
51   );
52
53   my $vars           = $params{variables} || {};
54   my $form           = Form->new('');
55   $form->{$_}        = $vars->{$_} for keys %{$vars};
56   $form->{format}    = lc($params{format} || 'pdf');
57   $form->{cwd}       = SL::System::Process::exe_dir();
58   $form->{templates} = $::instance_conf->get_templates;
59   $form->{IN}        = $params{template};
60   $form->{tmpdir}    = $temp_dir->dirname;
61   my $tmpdir         = $form->{tmpdir};
62   my ($suffix)       = $params{template} =~ m{\.(.+)};
63
64   my ($temp_fh, $tmpfile) = File::Temp::tempfile(
65     'kivitendo-printXXXXXX',
66     SUFFIX => ".${suffix}",
67     DIR    => $form->{tmpdir},
68     UNLINK => !$keep_temp_files,
69   );
70
71   $form->{tmpfile} = $tmpfile;
72   (undef, undef, $form->{template_meta}{tmpfile}) = File::Spec->splitpath($tmpfile);
73
74   my %driver_options;
75   eval {
76     %driver_options = _maybe_attach_zugferd_data($params{record});
77   };
78
79   if (my $e = SL::X::ZUGFeRDValidation->caught) {
80     $form->cleanup;
81     die $e->message;
82   }
83
84   my $parser               = SL::Template::create(
85     type                   => ($params{template_type} || 'LaTeX'),
86     source                 => $form->{IN},
87     form                   => $form,
88     myconfig               => \%::myconfig,
89     userspath              => $tmpdir,
90     variable_content_types => $params{variable_content_types},
91     %driver_options,
92   );
93
94   my $result = $parser->parse($temp_fh);
95
96   close $temp_fh;
97   chdir $form->{cwd};
98
99   if (!$result) {
100     $form->cleanup;
101     die $parser->get_error;
102   }
103
104   # SL::Template:** modify $form->{tmpfile} by removing its
105   # $form->{userspath} prefix. They also store the final file's actual
106   # file name in $form->{tmpfile} – but it is now relative to
107   # $form->{userspath}. Other modules return the full file name…
108   my ($volume, $directory, $file_name) = File::Spec->splitpath($form->{tmpfile});
109   my $full_file_name                   = File::Spec->catfile($tmpdir, $file_name);
110   if (($params{return} || 'content') eq 'file_name') {
111     my $new_name = File::Spec->catfile($userspath, 'keep-' . $form->{tmpfile});
112     rename $full_file_name, $new_name;
113
114     $form->cleanup;
115
116     return $new_name;
117   }
118
119   my $content = File::Slurp::read_file($full_file_name);
120
121   $form->cleanup;
122
123   return $content;
124 }
125
126 #
127 # Alternativen zu pdfinfo wären (aber wesentlich langamer):
128 #
129 # gs  -dBATCH -dNOPAUSE -sDEVICE=pdfwrite -sOutputFile=/dev/null $filename | grep 'Processing pages'
130 # my (undef,undef,undef,undef,$pages)  = split / +/,$shell_out;
131 #
132 # gs  -dBATCH -dNOPAUSE -q -dNODISPLAY -c "($filename) (r) file runpdfbegin pdfpagecount = quit"
133 # $pages=$shell_out;
134 #
135
136 sub has_odd_pages {
137   my ($class, $filename) = @_;
138   return 0 unless -f $filename;
139   my $shell_out = `pdfinfo $filename | grep 'Pages:'`;
140   my ($label, $pages) = split / +/, $shell_out;
141   return $pages & 1;
142 }
143
144 sub merge_pdfs {
145   my ($class, %params) = @_;
146   my $filecount = scalar(@{ $params{file_names} });
147
148   if ($params{inp_content}) {
149     return $params{inp_content} if $filecount == 0 && !$params{out_path};
150   } elsif ($params{out_path}) {
151     return 0 if $filecount == 0;
152     if ($filecount == 1) {
153       if (!rename($params{file_names}->[0], $params{out_path})) {
154         # special filesystem or cross filesystem etc
155         move($params{file_names}->[0], $params{out_path});
156       }
157       return 1;
158     }
159   } else {
160     return '' if $filecount == 0;
161     return scalar(File::Slurp::read_file($params{file_names}->[0])) if $filecount == 1;
162   }
163
164   my ($temp_fh, $temp_name) = File::Temp::tempfile(
165     'kivitendo-printXXXXXX',
166     SUFFIX => '.pdf',
167     DIR    => $::lx_office_conf{paths}->{userspath},
168     UNLINK => ($::lx_office_conf{debug} && $::lx_office_conf{debug}->{keep_temp_files})? 0 : 1,
169   );
170   close $temp_fh;
171
172   my $input_names = '';
173   my $hasodd      = 0;
174   my $emptypage   = '';
175   if ($params{bothsided}) {
176     $emptypage = $::instance_conf->get_templates . '/emptyPage.pdf';
177     unless (-f $emptypage) {
178       $emptypage = '';
179       delete $params{bothsided};
180     }
181   }
182   if ($params{inp_content}) {
183     my ($temp_fh, $inp_name) = File::Temp::tempfile(
184       'kivitendo-contentXXXXXX',
185       SUFFIX => '.pdf',
186       DIR    => $::lx_office_conf{paths}->{userspath},
187       UNLINK => ($::lx_office_conf{debug} && $::lx_office_conf{debug}->{keep_temp_files})? 0 : 1,
188     );
189     binmode $temp_fh;
190     print $temp_fh $params{inp_content};
191     close $temp_fh;
192     $input_names = $inp_name . ' ';
193     $hasodd = $params{bothsided} && __PACKAGE__->has_odd_pages($inp_name);
194   }
195   foreach (@{ $params{file_names} }) {
196     $input_names .= $emptypage . ' ' if $hasodd;
197     $input_names .= String::ShellQuote::shell_quote($_) . ' ';
198     $hasodd = $params{bothsided} && __PACKAGE__->has_odd_pages($_);
199   }
200   my $exe = $::lx_office_conf{applications}->{ghostscript} || 'gs';
201   my $output =
202     `$exe -dBATCH -dNOPAUSE -q -sDEVICE=pdfwrite -sOutputFile=${temp_name} ${input_names} 2>&1`;
203
204   die "Executing gs failed: $ERRNO" if !defined $output;
205   die $output                       if $? != 0;
206
207   if ($params{out_path}) {
208     if (!rename($temp_name, $params{out_path})) {
209
210       # special filesystem or cross filesystem etc
211       move($temp_name, $params{out_path});
212     }
213     return 1;
214   }
215   return scalar File::Slurp::read_file($temp_name);
216 }
217
218 sub find_template {
219   my ($class, %params) = @_;
220
221   $params{name} or croak "Missing parameter 'name'";
222
223   my $path                 = $::instance_conf->get_templates;
224   my $extension            = $params{extension} || "tex";
225   my ($printer, $language) = ('', '');
226
227   if ($params{printer} || $params{printer_id}) {
228     if ($params{printer} && !ref $params{printer}) {
229       $printer = '_' . $params{printer};
230     } else {
231       $printer = $params{printer} || SL::DB::Printer->new(id => $params{printer_id})->load;
232       $printer = $printer->template_code ? '_' . $printer->template_code : '';
233     }
234   }
235
236   if ($params{language} || $params{language_id}) {
237     if ($params{language} && !ref $params{language}) {
238       $language = '_' . $params{language};
239     } else {
240       $language = $params{language} || SL::DB::Language->new(id => $params{language_id})->load;
241       $language = $language->template_code ? '_' . $language->template_code : '';
242     }
243   }
244
245   my @template_files = (
246     $params{name} . "${language}${printer}",
247     $params{name} . "${language}",
248     $params{name},
249     "default",
250   );
251
252   if ($params{email}) {
253     unshift @template_files, (
254       $params{name} . "_email${language}${printer}",
255       $params{name} . "_email${language}",
256     );
257   }
258
259   @template_files = map { "${_}.${extension}" } uniq grep { $_ } @template_files;
260
261   my $template = first { -f ($path . "/$_") } @template_files;
262
263   return wantarray ? ($template, @template_files) : $template;
264 }
265
266 sub _maybe_attach_zugferd_data {
267   my ($record) = @_;
268
269   return if !blessed($record)
270     || !$record->can('customer')
271     || !$record->customer
272     || !$record->can('create_pdf_a_print_options')
273     || !$record->can('create_zugferd_data')
274     || !$record->customer->create_zugferd_invoices_for_this_customer;
275
276   my $xmlfile = File::Temp->new;
277   $xmlfile->print($record->create_zugferd_data);
278   $xmlfile->close;
279
280   my %driver_options = (
281     pdf_a           => $record->create_pdf_a_print_options(zugferd_xmp_data => $record->create_zugferd_xmp_data),
282     pdf_attachments => [
283       { source       => $xmlfile,
284         name         => 'factur-x.xml',
285         description  => $::locale->text('Factur-X/ZUGFeRD invoice'),
286         relationship => '/Alternative',
287         mime_type    => 'text/xml',
288       }
289     ],
290   );
291
292   return %driver_options;
293 }
294
295 1;
296 __END__
297
298 =pod
299
300 =encoding utf8
301
302 =head1 NAME
303
304 SL::Helper::CreatePDF - A helper for creating PDFs from template files
305
306 =head1 SYNOPSIS
307
308   # Retrieve a sales order from the database and create a PDF for
309   # it:
310   my $order               = SL::DB::Order->new(id => …)->load;
311   my $print_form          = Form->new('');
312   $print_form->{type}     = 'invoice';
313   $print_form->{formname} = 'invoice',
314   $print_form->{format}   = 'pdf',
315   $print_form->{media}    = 'file';
316
317   $order->flatten_to_form($print_form, format_amounts => 1);
318   $print_form->prepare_for_printing;
319
320   my $pdf = SL::Helper::CreatePDF->create_pdf(
321     template  => 'sales_order',
322     variables => $print_form,
323   );
324
325 =head1 FUNCTIONS
326
327 =over 4
328
329 =item C<create_pdf %params>
330
331 Parses a LaTeX template file, creates a PDF for it and returns either
332 its content or its file name. The recognized parameters are the same
333 as the ones for L</create_parsed_file> with C<format> and
334 C<template_type> being pre-set.
335
336 =item C<create_parsed_file %params>
337
338 Parses a template file and returns either its content or its file
339 name. The recognized parameters are:
340
341 =over 2
342
343 =item * C<template> – mandatory. The template file name relative to
344 the users' templates directory. Must be an existing file name,
345 e.g. one retrieved by L</find_template>.
346
347 =item * C<variables> – optional hash reference containing variables
348 available to the template.
349
350 =item * C<return> – optional scalar containing either C<content> (the
351 default) or C<file_name>. If it is set to C<file_name> then the file
352 name of the temporary file containing the PDF is returned, and the
353 caller is responsible for deleting it. Otherwise a scalar containing
354 the PDF itself is returned and all temporary files have already been
355 deleted by L</create_pdf>.
356
357 =item * C<format> – optional, defaults to C<pdf> and determines the
358 output format. Can be set to C<html> for HTML output if
359 C<template_type> is set to C<HTML> as well.
360
361 =item * C<template_type> – optional, defaults to C<LaTeX> and
362 determines the template's format. Can be set to C<HTML> for HTML
363 output if C<format> is set to C<html> as well.
364
365 =back
366
367 =item C<find_template %params>
368
369 Searches the user's templates directory for a template file name to
370 use. The file names considered depend on the parameters; they can
371 contain a template base name and suffixes for email, language and
372 printers. As a fallback the name C<default.$extension> is also
373 considered.
374
375 The return value depends on the context. In scalar context the
376 template file name that matches the given parameters is returned. It's
377 a file name relative to the user's templates directory. If no template
378 file is found then C<undef> is returned.
379
380 In list context the first element is the same value as in scalar
381 context. Additionally a list of considered template file names is
382 returned.
383
384 The recognized parameters are:
385
386 =over 2
387
388 =item * C<name> – mandatory. The template's file name basis
389 without any additional suffix or extension, e.g. C<sales_quotation>.
390
391 =item * C<extension> – optional file name extension to use without the
392 dot. Defaults to C<tex>.
393
394 =item * C<email> – optional flag indicating whether or not the
395 template is to be sent via email. If set to true then template file
396 names containing C<_email> are considered as well.
397
398 =item * C<language> and C<language_id> – optional parameters
399 indicating the language to be used. C<language> can be either a string
400 containing the language code to use or an instance of
401 C<SL::DB::Language>. C<language_id> can contain the ID of the
402 C<SL::DB:Language> instance to load and use. If given template file
403 names containing C<_language_template_code> are considered as well.
404
405 =item * C<printer> and C<printer_id> – optional parameters indicating
406 the printer to be used. C<printer> can be either a string containing
407 the printer code to use or an instance of
408 C<SL::DB::Printer>. C<printer_id> can contain the ID of the
409 C<SL::DB:Printer> instance to load and use. If given template file
410 names containing C<_printer_template_code> are considered as well.
411
412 =back
413
414 =item C<merge_pdfs %params>
415
416 Merges two or more PDFs into a single PDF by using the external
417 application ghostscript.
418
419 Normally the function returns the contents of the resulting PDF.
420 if The parameter C<out_path> is set the resulting PDF is in this file
421 and the return value is 1 if it successful or 0 if not.
422
423 The recognized parameters are:
424
425 =over 2
426
427 =item * C<file_names> – mandatory array reference containing the file
428 names to merge.
429
430 =item * C<inp_content> – optional, contents of first file to merge with C<file_names>.
431
432 =item * C<out_path> – optional, returns not the merged contents but wrote him into this file
433
434 =back
435
436 Note that this function relies on the presence of the external
437 application ghostscript. The executable to use is configured via
438 kivitendo's configuration file setting C<application.ghostscript>.
439
440 =back
441
442 =head1 BUGS
443
444 Nothing here yet.
445
446 =head1 AUTHOR
447
448 Moritz Bunkus E<lt>m.bunkus@linet-services.deE<gt>
449
450 =cut