SL/Form.pm

   1 #=====================================================================
   2 # LX-Office ERP
   3 # Copyright (C) 2004
   4 # Based on SQL-Ledger Version 2.1.9
   5 # Web http://www.lx-office.org
   6 #
   7 #=====================================================================
   8 # SQL-Ledger Accounting
   9 # Copyright (C) 1998-2002
  10 #
  11 #  Author: Dieter Simader
  12 #   Email: dsimader@sql-ledger.org
  13 #     Web: http://www.sql-ledger.org
  14 #
  15 # Contributors: Thomas Bayen <bayen@gmx.de>
  16 #               Antti Kaihola <akaihola@siba.fi>
  17 #               Moritz Bunkus (tex code)
  18 #
  19 # This program is free software; you can redistribute it and/or modify
  20 # it under the terms of the GNU General Public License as published by
  21 # the Free Software Foundation; either version 2 of the License, or
  22 # (at your option) any later version.
  23 #
  24 # This program is distributed in the hope that it will be useful,
  25 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  26 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  27 # GNU General Public License for more details.
  28 # You should have received a copy of the GNU General Public License
  29 # along with this program; if not, write to the Free Software
  30 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  31 # MA 02110-1335, USA.
  32 #======================================================================
  33 # Utilities for parsing forms
  34 # and supporting routines for linking account numbers
  35 # used in AR, AP and IS, IR modules
  36 #
  37 #======================================================================
  38
  39 package Form;
  40
  41 use Carp;
  42 use Data::Dumper;
  43
  44 use Carp;
  45 use Config;
  46 use CGI;
  47 use Cwd;
  48 use Encode;
  49 use File::Copy;
  50 use IO::File;
  51 use Math::BigInt;
  52 use POSIX qw(strftime);
  53 use SL::Auth;
  54 use SL::Auth::DB;
  55 use SL::Auth::LDAP;
  56 use SL::AM;
  57 use SL::Common;
  58 use SL::CVar;
  59 use SL::DB;
  60 use SL::DBConnect;
  61 use SL::DBUtils;
  62 use SL::DB::Customer;
  63 use SL::DB::Default;
  64 use SL::DB::PaymentTerm;
  65 use SL::DB::Vendor;
  66 use SL::DO;
  67 use SL::Helper::Flash qw();
  68 use SL::IC;
  69 use SL::IS;
  70 use SL::Layout::Dispatcher;
  71 use SL::Locale;
  72 use SL::Locale::String;
  73 use SL::Mailer;
  74 use SL::Menu;
  75 use SL::MoreCommon qw(uri_encode uri_decode);
  76 use SL::OE;
  77 use SL::PrefixedNumber;
  78 use SL::Request;
  79 use SL::Template;
  80 use SL::User;
  81 use SL::Util;
  82 use SL::Version;
  83 use SL::X;
  84 use Template;
  85 use URI;
  86 use List::Util qw(first max min sum);
  87 use List::MoreUtils qw(all any apply);
  88 use SL::DB::Tax;
  89 use SL::Helper::File qw(:all);
  90 use SL::Helper::CreatePDF qw(merge_pdfs);
  91
  92 use strict;
  93
  94 sub read_version {
  95   SL::Version->get_version;
  96 }
  97
  98 sub new {
  99   $main::lxdebug->enter_sub();
 100
 101   my $type = shift;
 102
 103   my $self = {};
 104
 105   no warnings 'once';
 106   if ($LXDebug::watch_form) {
 107     require SL::Watchdog;
 108     tie %{ $self }, 'SL::Watchdog';
 109   }
 110
 111   bless $self, $type;
 112
 113   $main::lxdebug->leave_sub();
 114
 115   return $self;
 116 }
 117
 118 sub _flatten_variables_rec {
 119   $main::lxdebug->enter_sub(2);
 120
 121   my $self   = shift;
 122   my $curr   = shift;
 123   my $prefix = shift;
 124   my $key    = shift;
 125
 126   my @result;
 127
 128   if ('' eq ref $curr->{$key}) {
 129     @result = ({ 'key' => $prefix . $key, 'value' => $curr->{$key} });
 130
 131   } elsif ('HASH' eq ref $curr->{$key}) {
 132     foreach my $hash_key (sort keys %{ $curr->{$key} }) {
 133       push @result, $self->_flatten_variables_rec($curr->{$key}, $prefix . $key . '.', $hash_key);
 134     }
 135
 136   } else {
 137     foreach my $idx (0 .. scalar @{ $curr->{$key} } - 1) {
 138       my $first_array_entry = 1;
 139
 140       my $element = $curr->{$key}[$idx];
 141
 142       if ('HASH' eq ref $element) {
 143         foreach my $hash_key (sort keys %{ $element }) {
 144           push @result, $self->_flatten_variables_rec($element, $prefix . $key . ($first_array_entry ? '[+].' : '[].'), $hash_key);
 145           $first_array_entry = 0;
 146         }
 147       } else {
 148         push @result, { 'key' => $prefix . $key . '[]', 'value' => $element };
 149       }
 150     }
 151   }
 152
 153   $main::lxdebug->leave_sub(2);
 154
 155   return @result;
 156 }
 157
 158 sub flatten_variables {
 159   $main::lxdebug->enter_sub(2);
 160
 161   my $self = shift;
 162   my @keys = @_;
 163
 164   my @variables;
 165
 166   foreach (@keys) {
 167     push @variables, $self->_flatten_variables_rec($self, '', $_);
 168   }
 169
 170   $main::lxdebug->leave_sub(2);
 171
 172   return @variables;
 173 }
 174
 175 sub flatten_standard_variables {
 176   $main::lxdebug->enter_sub(2);
 177
 178   my $self      = shift;
 179   my %skip_keys = map { $_ => 1 } (qw(login password header stylesheet titlebar), @_);
 180
 181   my @variables;
 182
 183   foreach (grep { ! $skip_keys{$_} } keys %{ $self }) {
 184     push @variables, $self->_flatten_variables_rec($self, '', $_);
 185   }
 186
 187   $main::lxdebug->leave_sub(2);
 188
 189   return @variables;
 190 }
 191
 192 sub escape {
 193   my ($self, $str) = @_;
 194
 195   return uri_encode($str);
 196 }
 197
 198 sub unescape {
 199   my ($self, $str) = @_;
 200
 201   return uri_decode($str);
 202 }
 203
 204 sub quote {
 205   $main::lxdebug->enter_sub();
 206   my ($self, $str) = @_;
 207
 208   if ($str && !ref($str)) {
 209     $str =~ s/\"/&quot;/g;
 210   }
 211
 212   $main::lxdebug->leave_sub();
 213
 214   return $str;
 215 }
 216
 217 sub unquote {
 218   $main::lxdebug->enter_sub();
 219   my ($self, $str) = @_;
 220
 221   if ($str && !ref($str)) {
 222     $str =~ s/&quot;/\"/g;
 223   }
 224
 225   $main::lxdebug->leave_sub();
 226
 227   return $str;
 228 }
 229
 230 sub hide_form {
 231   $main::lxdebug->enter_sub();
 232   my $self = shift;
 233
 234   if (@_) {
 235     map({ print($::request->{cgi}->hidden("-name" => $_, "-default" => $self->{$_}) . "\n"); } @_);
 236   } else {
 237     for (sort keys %$self) {
 238       next if (($_ eq "header") || (ref($self->{$_}) ne ""));
 239       print($::request->{cgi}->hidden("-name" => $_, "-default" => $self->{$_}) . "\n");
 240     }
 241   }
 242   $main::lxdebug->leave_sub();
 243 }
 244
 245 sub throw_on_error {
 246   my ($self, $code) = @_;
 247   local $self->{__ERROR_HANDLER} = sub { SL::X::FormError->throw(error => $_[0]) };
 248   $code->();
 249 }
 250
 251 sub error {
 252   $main::lxdebug->enter_sub();
 253
 254   $main::lxdebug->show_backtrace();
 255
 256   my ($self, $msg) = @_;
 257
 258   if ($self->{__ERROR_HANDLER}) {
 259     $self->{__ERROR_HANDLER}->($msg);
 260
 261   } elsif ($ENV{HTTP_USER_AGENT}) {
 262     $msg =~ s/\n/<br>/g;
 263     $self->show_generic_error($msg);
 264
 265   } else {
 266     confess "Error: $msg\n";
 267   }
 268
 269   $main::lxdebug->leave_sub();
 270 }
 271
 272 sub info {
 273   $main::lxdebug->enter_sub();
 274
 275   my ($self, $msg) = @_;
 276
 277   if ($ENV{HTTP_USER_AGENT}) {
 278     $self->header;
 279     print $self->parse_html_template('generic/form_info', { message => $msg });
 280
 281   } elsif ($self->{info_function}) {
 282     &{ $self->{info_function} }($msg);
 283   } else {
 284     print "$msg\n";
 285   }
 286
 287   $main::lxdebug->leave_sub();
 288 }
 289
 290 # calculates the number of rows in a textarea based on the content and column number
 291 # can be capped with maxrows
 292 sub numtextrows {
 293   $main::lxdebug->enter_sub();
 294   my ($self, $str, $cols, $maxrows, $minrows) = @_;
 295
 296   $minrows ||= 1;
 297
 298   my $rows   = sum map { int((length() - 2) / $cols) + 1 } split /\r/, $str;
 299   $maxrows ||= $rows;
 300
 301   $main::lxdebug->leave_sub();
 302
 303   return max(min($rows, $maxrows), $minrows);
 304 }
 305
 306 sub dberror {
 307   my ($self, $msg) = @_;
 308
 309   SL::X::DBError->throw(
 310     msg      => $msg,
 311     db_error => $DBI::errstr,
 312   );
 313 }
 314
 315 sub isblank {
 316   $main::lxdebug->enter_sub();
 317
 318   my ($self, $name, $msg) = @_;
 319
 320   my $curr = $self;
 321   foreach my $part (split m/\./, $name) {
 322     if (!$curr->{$part} || ($curr->{$part} =~ /^\s*$/)) {
 323       $self->error($msg);
 324     }
 325     $curr = $curr->{$part};
 326   }
 327
 328   $main::lxdebug->leave_sub();
 329 }
 330
 331 sub _get_request_uri {
 332   my $self = shift;
 333
 334   return URI->new($ENV{HTTP_REFERER})->canonical() if $ENV{HTTP_X_FORWARDED_FOR};
 335   return URI->new                                  if !$ENV{REQUEST_URI}; # for testing
 336
 337   my $scheme =  $::request->is_https ? 'https' : 'http';
 338   my $port   =  $ENV{SERVER_PORT};
 339   $port      =  undef if (($scheme eq 'http' ) && ($port == 80))
 340                       || (($scheme eq 'https') && ($port == 443));
 341
 342   my $uri    =  URI->new("${scheme}://");
 343   $uri->scheme($scheme);
 344   $uri->port($port);
 345   $uri->host($ENV{HTTP_HOST} || $ENV{SERVER_ADDR});
 346   $uri->path_query($ENV{REQUEST_URI});
 347   $uri->query('');
 348
 349   return $uri;
 350 }
 351
 352 sub _add_to_request_uri {
 353   my $self              = shift;
 354
 355   my $relative_new_path = shift;
 356   my $request_uri       = shift || $self->_get_request_uri;
 357   my $relative_new_uri  = URI->new($relative_new_path);
 358   my @request_segments  = $request_uri->path_segments;
 359
 360   my $new_uri           = $request_uri->clone;
 361   $new_uri->path_segments(@request_segments[0..scalar(@request_segments) - 2], $relative_new_uri->path_segments);
 362
 363   return $new_uri;
 364 }
 365
 366 sub create_http_response {
 367   $main::lxdebug->enter_sub();
 368
 369   my $self     = shift;
 370   my %params   = @_;
 371
 372   my $cgi      = $::request->{cgi};
 373
 374   my $session_cookie;
 375   if (defined $main::auth) {
 376     my $uri      = $self->_get_request_uri;
 377     my @segments = $uri->path_segments;
 378     pop @segments;
 379     $uri->path_segments(@segments);
 380
 381     my $session_cookie_value = $main::auth->get_session_id();
 382
 383     if ($session_cookie_value) {
 384       $session_cookie = $cgi->cookie('-name'   => $main::auth->get_session_cookie_name(),
 385                                      '-value'  => $session_cookie_value,
 386                                      '-path'   => $uri->path,
 387                                      '-secure' => $::request->is_https);
 388     }
 389   }
 390
 391   my %cgi_params = ('-type' => $params{content_type});
 392   $cgi_params{'-charset'} = $params{charset} if ($params{charset});
 393   $cgi_params{'-cookie'}  = $session_cookie  if ($session_cookie);
 394
 395   map { $cgi_params{'-' . $_} = $params{$_} if exists $params{$_} } qw(content_disposition content_length status);
 396
 397   my $output = $cgi->header(%cgi_params);
 398
 399   $main::lxdebug->leave_sub();
 400
 401   return $output;
 402 }
 403
 404 sub header {
 405   $::lxdebug->enter_sub;
 406
 407   my ($self, %params) = @_;
 408   my @header;
 409
 410   $::lxdebug->leave_sub and return if !$ENV{HTTP_USER_AGENT} || $self->{header}++;
 411
 412   if ($params{no_layout}) {
 413     $::request->{layout} = SL::Layout::Dispatcher->new(style => 'none');
 414   }
 415
 416   my $layout = $::request->{layout};
 417
 418   # standard css for all
 419   # this should gradually move to the layouts that need it
 420   $layout->use_stylesheet("$_.css") for qw(
 421     common main menu list_accounts jquery.autocomplete
 422     jquery.multiselect2side
 423     ui-lightness/jquery-ui
 424     jquery-ui.custom
 425     tooltipster themes/tooltipster-light
 426   );
 427
 428   $layout->use_javascript("$_.js") for (qw(
 429     jquery jquery-ui jquery.cookie jquery.checkall jquery.download
 430     jquery/jquery.form jquery/fixes client_js
 431     jquery/jquery.tooltipster.min
 432     common part_selection
 433   ), "jquery/ui/i18n/jquery.ui.datepicker-$::myconfig{countrycode}");
 434
 435   $self->{favicon} ||= "favicon.ico";
 436   $self->{titlebar} = join ' - ', grep $_, $self->{title}, $self->{login}, $::myconfig{dbname}, $self->read_version if $self->{title} || !$self->{titlebar};
 437
 438   # build includes
 439   if ($self->{refresh_url} || $self->{refresh_time}) {
 440     my $refresh_time = $self->{refresh_time} || 3;
 441     my $refresh_url  = $self->{refresh_url}  || $ENV{REFERER};
 442     push @header, "<meta http-equiv='refresh' content='$refresh_time;$refresh_url'>";
 443   }
 444
 445   my $auto_reload_resources_param = $layout->auto_reload_resources_param;
 446
 447   push @header, map { qq|<link rel="stylesheet" href="${_}${auto_reload_resources_param}" type="text/css" title="Stylesheet">| } $layout->stylesheets;
 448   push @header, "<style type='text/css'>\@page { size:landscape; }</style> "                     if $self->{landscape};
 449   push @header, "<link rel='shortcut icon' href='$self->{favicon}' type='image/x-icon'>"         if -f $self->{favicon};
 450   push @header, map { qq|<script type="text/javascript" src="${_}${auto_reload_resources_param}"></script>| }                    $layout->javascripts;
 451   push @header, $self->{javascript} if $self->{javascript};
 452   push @header, map { $_->show_javascript } @{ $self->{AJAX} || [] };
 453
 454   my  %doctypes = (
 455     strict       => qq|<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">|,
 456     transitional => qq|<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">|,
 457     frameset     => qq|<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Frameset//EN" "http://www.w3.org/TR/html4/frameset.dtd">|,
 458     html5        => qq|<!DOCTYPE html>|,
 459   );
 460
 461   # output
 462   print $self->create_http_response(content_type => 'text/html', charset => 'UTF-8');
 463   print $doctypes{$params{doctype} || 'transitional'}, $/;
 464   print <<EOT;
 465 <html>
 466  <head>
 467   <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 468   <title>$self->{titlebar}</title>
 469 EOT
 470   print "  $_\n" for @header;
 471   print <<EOT;
 472   <meta name="robots" content="noindex,nofollow">
 473  </head>
 474  <body>
 475
 476 EOT
 477   print $::request->{layout}->pre_content;
 478   print $::request->{layout}->start_content;
 479
 480   $layout->header_done;
 481
 482   $::lxdebug->leave_sub;
 483 }
 484
 485 sub footer {
 486   return unless $::request->{layout}->need_footer;
 487
 488   print $::request->{layout}->end_content;
 489   print $::request->{layout}->post_content;
 490
 491   if (my @inline_scripts = $::request->{layout}->javascripts_inline) {
 492     print "<script type='text/javascript'>" . join("; ", @inline_scripts) . "</script>\n";
 493   }
 494
 495   print <<EOL
 496  </body>
 497 </html>
 498 EOL
 499 }
 500
 501 sub ajax_response_header {
 502   $main::lxdebug->enter_sub();
 503
 504   my ($self) = @_;
 505
 506   my $output = $::request->{cgi}->header('-charset' => 'UTF-8');
 507
 508   $main::lxdebug->leave_sub();
 509
 510   return $output;
 511 }
 512
 513 sub redirect_header {
 514   my $self     = shift;
 515   my $new_url  = shift;
 516
 517   my $base_uri = $self->_get_request_uri;
 518   my $new_uri  = URI->new_abs($new_url, $base_uri);
 519
 520   die "Headers already sent" if $self->{header};
 521   $self->{header} = 1;
 522
 523   return $::request->{cgi}->redirect($new_uri);
 524 }
 525
 526 sub set_standard_title {
 527   $::lxdebug->enter_sub;
 528   my $self = shift;
 529
 530   $self->{titlebar}  = "kivitendo " . $::locale->text('Version') . " " . $self->read_version;
 531   $self->{titlebar} .= "- $::myconfig{name}"   if $::myconfig{name};
 532   $self->{titlebar} .= "- $::myconfig{dbname}" if $::myconfig{name};
 533
 534   $::lxdebug->leave_sub;
 535 }
 536
 537 sub _prepare_html_template {
 538   $main::lxdebug->enter_sub();
 539
 540   my ($self, $file, $additional_params) = @_;
 541   my $language;
 542
 543   if (!%::myconfig || !$::myconfig{"countrycode"}) {
 544     $language = $::lx_office_conf{system}->{language};
 545   } else {
 546     $language = $main::myconfig{"countrycode"};
 547   }
 548   $language = "de" unless ($language);
 549
 550   if (-f "templates/webpages/${file}.html") {
 551     $file = "templates/webpages/${file}.html";
 552
 553   } elsif (ref $file eq 'SCALAR') {
 554     # file is a scalarref, use inline mode
 555   } else {
 556     my $info = "Web page template '${file}' not found.\n";
 557     $::form->header;
 558     print qq|<pre>$info</pre>|;
 559     $::dispatcher->end_request;
 560   }
 561
 562   $additional_params->{AUTH}          = $::auth;
 563   $additional_params->{INSTANCE_CONF} = $::instance_conf;
 564   $additional_params->{LOCALE}        = $::locale;
 565   $additional_params->{LXCONFIG}      = \%::lx_office_conf;
 566   $additional_params->{LXDEBUG}       = $::lxdebug;
 567   $additional_params->{MYCONFIG}      = \%::myconfig;
 568
 569   $main::lxdebug->leave_sub();
 570
 571   return $file;
 572 }
 573
 574 sub parse_html_template {
 575   $main::lxdebug->enter_sub();
 576
 577   my ($self, $file, $additional_params) = @_;
 578
 579   $additional_params ||= { };
 580
 581   my $real_file = $self->_prepare_html_template($file, $additional_params);
 582   my $template  = $self->template;
 583
 584   map { $additional_params->{$_} ||= $self->{$_} } keys %{ $self };
 585
 586   my $output;
 587   $template->process($real_file, $additional_params, \$output) || die $template->error;
 588
 589   $main::lxdebug->leave_sub();
 590
 591   return $output;
 592 }
 593
 594 sub template { $::request->presenter->get_template }
 595
 596 sub show_generic_error {
 597   $main::lxdebug->enter_sub();
 598
 599   my ($self, $error, %params) = @_;
 600
 601   if ($self->{__ERROR_HANDLER}) {
 602     $self->{__ERROR_HANDLER}->($error);
 603     $main::lxdebug->leave_sub();
 604     return;
 605   }
 606
 607   if ($::request->is_ajax) {
 608     SL::ClientJS->new
 609       ->error($error)
 610       ->render(SL::Controller::Base->new);
 611     $::dispatcher->end_request;
 612   }
 613
 614   my $add_params = {
 615     'title_error' => $params{title},
 616     'label_error' => $error,
 617   };
 618
 619   $self->{title} = $params{title} if $params{title};
 620
 621   for my $bar ($::request->layout->get('actionbar')) {
 622     $bar->add(
 623       action => [
 624         t8('Back'),
 625         call      => [ 'kivi.history_back' ],
 626         accesskey => 'enter',
 627       ],
 628     );
 629   }
 630
 631   $self->header();
 632   print $self->parse_html_template("generic/error", $add_params);
 633
 634   print STDERR "Error: $error\n";
 635
 636   $main::lxdebug->leave_sub();
 637
 638   $::dispatcher->end_request;
 639 }
 640
 641 sub show_generic_information {
 642   $main::lxdebug->enter_sub();
 643
 644   my ($self, $text, $title) = @_;
 645
 646   my $add_params = {
 647     'title_information' => $title,
 648     'label_information' => $text,
 649   };
 650
 651   $self->{title} = $title if ($title);
 652
 653   $self->header();
 654   print $self->parse_html_template("generic/information", $add_params);
 655
 656   $main::lxdebug->leave_sub();
 657
 658   $::dispatcher->end_request;
 659 }
 660
 661 sub _store_redirect_info_in_session {
 662   my ($self) = @_;
 663
 664   return unless $self->{callback} =~ m:^ ( [^\?/]+ \.pl ) \? (.+) :x;
 665
 666   my ($controller, $params) = ($1, $2);
 667   my $form                  = { map { map { $self->unescape($_) } split /=/, $_, 2 } split m/\&/, $params };
 668   $self->{callback}         = "${controller}?RESTORE_FORM_FROM_SESSION_ID=" . $::auth->save_form_in_session(form => $form);
 669 }
 670
 671 sub redirect {
 672   $main::lxdebug->enter_sub();
 673
 674   my ($self, $msg) = @_;
 675
 676   if (!$self->{callback}) {
 677     $self->info($msg);
 678
 679   } else {
 680     SL::Helper::Flash::flash_later('info', $msg) if $msg;
 681     $self->_store_redirect_info_in_session;
 682     print $::form->redirect_header($self->{callback});
 683   }
 684
 685   $::dispatcher->end_request;
 686
 687   $main::lxdebug->leave_sub();
 688 }
 689
 690 # sort of columns removed - empty sub
 691 sub sort_columns {
 692   $main::lxdebug->enter_sub();
 693
 694   my ($self, @columns) = @_;
 695
 696   $main::lxdebug->leave_sub();
 697
 698   return @columns;
 699 }
 700 #
 701 sub format_amount {
 702   $main::lxdebug->enter_sub(2);
 703
 704   my ($self, $myconfig, $amount, $places, $dash) = @_;
 705   $amount ||= 0;
 706   $dash   ||= '';
 707   my $neg = $amount < 0;
 708   my $force_places = defined $places && $places >= 0;
 709
 710   $amount = $self->round_amount($amount, abs $places) if $force_places;
 711   $neg    = 0 if $amount == 0; # don't show negative zero
 712   $amount = sprintf "%.*f", ($force_places ? $places : 10), abs $amount; # 6 is default for %fa
 713
 714   # before the sprintf amount was a number, afterwards it's a string. because of the dynamic nature of perl
 715   # this is easy to confuse, so keep in mind: before this comment no s///, m//, concat or other strong ops on
 716   # $amount. after this comment no +,-,*,/,abs. it will only introduce subtle bugs.
 717
 718   $amount =~ s/0*$// unless defined $places && $places == 0;             # cull trailing 0s
 719
 720   my @d = map { s/\d//g; reverse split // } my $tmp = $myconfig->{numberformat}; # get delim chars
 721   my @p = split(/\./, $amount);                                          # split amount at decimal point
 722
 723   $p[0] =~ s/\B(?=(...)*$)/$d[1]/g if $d[1];                             # add 1,000 delimiters
 724   $amount = $p[0];
 725   if ($places || $p[1]) {
 726     $amount .= $d[0]
 727             .  ( $p[1] || '' )
 728             .  (0 x max(abs($places || 0) - length ($p[1]||''), 0));     # pad the fraction
 729   }
 730
 731   $amount = do {
 732     ($dash =~ /-/)    ? ($neg ? "($amount)"                            : "$amount" )                              :
 733     ($dash =~ /DRCR/) ? ($neg ? "$amount " . $main::locale->text('DR') : "$amount " . $main::locale->text('CR') ) :
 734                         ($neg ? "-$amount"                             : "$amount" )                              ;
 735   };
 736
 737   $main::lxdebug->leave_sub(2);
 738   return $amount;
 739 }
 740
 741 sub format_amount_units {
 742   $main::lxdebug->enter_sub();
 743
 744   my $self             = shift;
 745   my %params           = @_;
 746
 747   my $myconfig         = \%main::myconfig;
 748   my $amount           = $params{amount} * 1;
 749   my $places           = $params{places};
 750   my $part_unit_name   = $params{part_unit};
 751   my $amount_unit_name = $params{amount_unit};
 752   my $conv_units       = $params{conv_units};
 753   my $max_places       = $params{max_places};
 754
 755   if (!$part_unit_name) {
 756     $main::lxdebug->leave_sub();
 757     return '';
 758   }
 759
 760   my $all_units        = AM->retrieve_all_units;
 761
 762   if (('' eq ref $conv_units) && ($conv_units =~ /convertible/)) {
 763     $conv_units = AM->convertible_units($all_units, $part_unit_name, $conv_units eq 'convertible_not_smaller');
 764   }
 765
 766   if (!scalar @{ $conv_units }) {
 767     my $result = $self->format_amount($myconfig, $amount, $places, undef, $max_places) . " " . $part_unit_name;
 768     $main::lxdebug->leave_sub();
 769     return $result;
 770   }
 771
 772   my $part_unit  = $all_units->{$part_unit_name};
 773   my $conv_unit  = ($amount_unit_name && ($amount_unit_name ne $part_unit_name)) ? $all_units->{$amount_unit_name} : $part_unit;
 774
 775   $amount       *= $conv_unit->{factor};
 776
 777   my @values;
 778   my $num;
 779
 780   foreach my $unit (@$conv_units) {
 781     my $last = $unit->{name} eq $part_unit->{name};
 782     if (!$last) {
 783       $num     = int($amount / $unit->{factor});
 784       $amount -= $num * $unit->{factor};
 785     }
 786
 787     if ($last ? $amount : $num) {
 788       push @values, { "unit"   => $unit->{name},
 789                       "amount" => $last ? $amount / $unit->{factor} : $num,
 790                       "places" => $last ? $places : 0 };
 791     }
 792
 793     last if $last;
 794   }
 795
 796   if (!@values) {
 797     push @values, { "unit"   => $part_unit_name,
 798                     "amount" => 0,
 799                     "places" => 0 };
 800   }
 801
 802   my $result = join " ", map { $self->format_amount($myconfig, $_->{amount}, $_->{places}, undef, $max_places), $_->{unit} } @values;
 803
 804   $main::lxdebug->leave_sub();
 805
 806   return $result;
 807 }
 808
 809 sub format_string {
 810   $main::lxdebug->enter_sub(2);
 811
 812   my $self  = shift;
 813   my $input = shift;
 814
 815   $input =~ s/(^|[^\#]) \#  (\d+)  /$1$_[$2 - 1]/gx;
 816   $input =~ s/(^|[^\#]) \#\{(\d+)\}/$1$_[$2 - 1]/gx;
 817   $input =~ s/\#\#/\#/g;
 818
 819   $main::lxdebug->leave_sub(2);
 820
 821   return $input;
 822 }
 823
 824 #
 825
 826 sub parse_amount {
 827   $main::lxdebug->enter_sub(2);
 828
 829   my ($self, $myconfig, $amount) = @_;
 830
 831   if (!defined($amount) || ($amount eq '')) {
 832     $main::lxdebug->leave_sub(2);
 833     return 0;
 834   }
 835
 836   if (   ($myconfig->{numberformat} eq '1.000,00')
 837       || ($myconfig->{numberformat} eq '1000,00')) {
 838     $amount =~ s/\.//g;
 839     $amount =~ s/,/\./g;
 840   }
 841
 842   if ($myconfig->{numberformat} eq "1'000.00") {
 843     $amount =~ s/\'//g;
 844   }
 845
 846   $amount =~ s/,//g;
 847
 848   $main::lxdebug->leave_sub(2);
 849
 850   # Make sure no code wich is not a math expression ends up in eval().
 851   return 0 unless $amount =~ /^ [\s \d \( \) \- \+ \* \/ \. ]* $/x;
 852
 853   # Prevent numbers from being parsed as octals;
 854   $amount =~ s{ (?<! [\d.] ) 0+ (?= [1-9] ) }{}gx;
 855
 856   return scalar(eval($amount)) * 1 ;
 857 }
 858
 859 sub round_amount {
 860   my ($self, $amount, $places, $adjust) = @_;
 861
 862   return 0 if !defined $amount;
 863
 864   $places //= 0;
 865
 866   if ($adjust) {
 867     my $precision = $::instance_conf->get_precision || 0.01;
 868     return $self->round_amount( $self->round_amount($amount / $precision, 0) * $precision, $places);
 869   }
 870
 871   # We use Perl's knowledge of string representation for
 872   # rounding. First, convert the floating point number to a string
 873   # with a high number of places. Then split the string on the decimal
 874   # sign and use integer calculation for rounding the decimal places
 875   # part. If an overflow occurs then apply that overflow to the part
 876   # before the decimal sign as well using integer arithmetic again.
 877
 878   my $int_amount = int(abs $amount);
 879   my $str_places = max(min(10, 16 - length("$int_amount") - $places), $places);
 880   my $amount_str = sprintf '%.*f', $places + $str_places, abs($amount);
 881
 882   return $amount unless $amount_str =~ m{^(\d+)\.(\d+)$};
 883
 884   my ($pre, $post)      = ($1, $2);
 885   my $decimals          = '1' . substr($post, 0, $places);
 886
 887   my $propagation_limit = $Config{i32size} == 4 ? 7 : 18;
 888   my $add_for_rounding  = substr($post, $places, 1) >= 5 ? 1 : 0;
 889
 890   if ($places > $propagation_limit) {
 891     $decimals = Math::BigInt->new($decimals)->badd($add_for_rounding);
 892     $pre      = Math::BigInt->new($decimals)->badd(1) if substr($decimals, 0, 1) eq '2';
 893
 894   } else {
 895     $decimals += $add_for_rounding;
 896     $pre      += 1 if substr($decimals, 0, 1) eq '2';
 897   }
 898
 899   $amount  = ("${pre}." . substr($decimals, 1)) * ($amount <=> 0);
 900
 901   return $amount;
 902 }
 903
 904 sub parse_template {
 905   $main::lxdebug->enter_sub();
 906
 907   my ($self, $myconfig) = @_;
 908   my ($out, $out_mode);
 909
 910   local (*IN, *OUT);
 911
 912   my $defaults  = SL::DB::Default->get;
 913   my $userspath = $::lx_office_conf{paths}->{userspath};
 914
 915   $self->{"cwd"} = getcwd();
 916   $self->{"tmpdir"} = $self->{cwd} . "/${userspath}";
 917
 918   my $ext_for_format;
 919
 920   my $template_type;
 921   if ($self->{"format"} =~ /(opendocument|oasis)/i) {
 922     $template_type  = 'OpenDocument';
 923     $ext_for_format = $self->{"format"} =~ m/pdf/ ? 'pdf' : 'odt';
 924
 925   } elsif ($self->{"format"} =~ /(postscript|pdf)/i) {
 926     $template_type    = 'LaTeX';
 927     $ext_for_format   = 'pdf';
 928
 929   } elsif (($self->{"format"} =~ /html/i) || (!$self->{"format"} && ($self->{"IN"} =~ /html$/i))) {
 930     $template_type  = 'HTML';
 931     $ext_for_format = 'html';
 932
 933   } elsif (($self->{"format"} =~ /xml/i) || (!$self->{"format"} && ($self->{"IN"} =~ /xml$/i))) {
 934     $template_type  = 'XML';
 935     $ext_for_format = 'xml';
 936
 937   } elsif ( $self->{"format"} =~ /elster(?:winston|taxbird)/i ) {
 938     $template_type = 'XML';
 939
 940   } elsif ( $self->{"format"} =~ /excel/i ) {
 941     $template_type  = 'Excel';
 942     $ext_for_format = 'xls';
 943
 944   } elsif ( defined $self->{'format'}) {
 945     $self->error("Outputformat not defined. This may be a future feature: $self->{'format'}");
 946
 947   } elsif ( $self->{'format'} eq '' ) {
 948     $self->error("No Outputformat given: $self->{'format'}");
 949
 950   } else { #Catch the rest
 951     $self->error("Outputformat not defined: $self->{'format'}");
 952   }
 953
 954   my $template = SL::Template::create(type      => $template_type,
 955                                       file_name => $self->{IN},
 956                                       form      => $self,
 957                                       myconfig  => $myconfig,
 958                                       userspath => $userspath,
 959                                       %{ $self->{TEMPLATE_DRIVER_OPTIONS} || {} });
 960
 961   # Copy the notes from the invoice/sales order etc. back to the variable "notes" because that is where most templates expect it to be.
 962   $self->{"notes"} = $self->{ $self->{"formname"} . "notes" } if exists $self->{ $self->{"formname"} . "notes" };
 963
 964   if (!$self->{employee_id}) {
 965     $self->{"employee_${_}"} = $myconfig->{$_} for qw(email tel fax name signature);
 966     $self->{"employee_${_}"} = $defaults->$_   for qw(address businessnumber co_ustid company duns sepa_creditor_id taxnumber);
 967   }
 968
 969   $self->{"myconfig_${_}"} = $myconfig->{$_} for grep { $_ ne 'dbpasswd' } keys %{ $myconfig };
 970   $self->{$_}              = $defaults->$_   for qw(co_ustid);
 971   $self->{"myconfig_${_}"} = $defaults->$_   for qw(address businessnumber co_ustid company duns sepa_creditor_id taxnumber);
 972   $self->{AUTH}            = $::auth;
 973   $self->{INSTANCE_CONF}   = $::instance_conf;
 974   $self->{LOCALE}          = $::locale;
 975   $self->{LXCONFIG}        = $::lx_office_conf;
 976   $self->{LXDEBUG}         = $::lxdebug;
 977   $self->{MYCONFIG}        = \%::myconfig;
 978
 979   $self->{copies} = 1 if (($self->{copies} *= 1) <= 0);
 980
 981   # OUT is used for the media, screen, printer, email
 982   # for postscript we store a copy in a temporary file
 983   my $keep_temp_files = $::lx_office_conf{debug} && $::lx_office_conf{debug}->{keep_temp_files};
 984
 985   my ($temp_fh, $suffix);
 986   $suffix =  $self->{IN};
 987   $suffix =~ s/.*\.//;
 988   ($temp_fh, $self->{tmpfile}) = File::Temp::tempfile(
 989     strftime('kivitendo-print-%Y%m%d%H%M%S-XXXXXX', localtime()),
 990     SUFFIX => '.' . ($suffix || 'tex'),
 991     DIR    => $userspath,
 992     UNLINK => $keep_temp_files ? 0 : 1,
 993   );
 994   close $temp_fh;
 995   chmod 0644, $self->{tmpfile} if $keep_temp_files;
 996   (undef, undef, $self->{template_meta}{tmpfile}) = File::Spec->splitpath( $self->{tmpfile} );
 997
 998   $out              = $self->{OUT};
 999   $out_mode         = $self->{OUT_MODE} || '>';
1000   $self->{OUT}      = "$self->{tmpfile}";
1001   $self->{OUT_MODE} = '>';
1002
1003   my $result;
1004   my $command_formatter = sub {
1005     my ($out_mode, $out) = @_;
1006     return $out_mode eq '|-' ? SL::Template::create(type => 'ShellCommand', form => $self)->parse($out) : $out;
1007   };
1008
1009   if ($self->{OUT}) {
1010     $self->{OUT} = $command_formatter->($self->{OUT_MODE}, $self->{OUT});
1011     open(OUT, $self->{OUT_MODE}, $self->{OUT}) or $self->error("error on opening $self->{OUT} with mode $self->{OUT_MODE} : $!");
1012   } else {
1013     *OUT = ($::dispatcher->get_standard_filehandles)[1];
1014     $self->header;
1015   }
1016
1017   if (!$template->parse(*OUT)) {
1018     $self->cleanup();
1019     $self->error("$self->{IN} : " . $template->get_error());
1020   }
1021
1022   close OUT if $self->{OUT};
1023   # check only one flag (webdav_documents)
1024   # therefore copy to webdav, even if we do not have the webdav feature enabled (just archive)
1025   my $copy_to_webdav =  $::instance_conf->get_webdav_documents && !$self->{preview} && $self->{tmpdir} && $self->{tmpfile} && $self->{type}
1026                         && $self->{type} ne 'statement';
1027   if ( $ext_for_format eq 'pdf' && $self->doc_storage_enabled ) {
1028     $self->append_general_pdf_attachments(filepath =>  $self->{tmpdir}."/".$self->{tmpfile},
1029                                           type     =>  $self->{type});
1030   }
1031   if ($self->{media} eq 'file') {
1032     copy(join('/', $self->{cwd}, $userspath, $self->{tmpfile}), $out =~ m|^/| ? $out : join('/', $self->{cwd}, $out)) if $template->uses_temp_file;
1033
1034     if ($copy_to_webdav) {
1035       if (my $error = Common::copy_file_to_webdav_folder($self)) {
1036         chdir("$self->{cwd}");
1037         $self->error($error);
1038       }
1039     }
1040
1041     if (!$self->{preview} && $self->doc_storage_enabled)
1042     {
1043       $self->{attachment_filename} ||= $self->generate_attachment_filename;
1044       $self->store_pdf($self);
1045     }
1046     $self->cleanup;
1047     chdir("$self->{cwd}");
1048
1049     $::lxdebug->leave_sub();
1050
1051     return;
1052   }
1053
1054   if ($copy_to_webdav) {
1055     if (my $error = Common::copy_file_to_webdav_folder($self)) {
1056       chdir("$self->{cwd}");
1057       $self->error($error);
1058     }
1059   }
1060
1061   if ( !$self->{preview} && $ext_for_format eq 'pdf' && $self->doc_storage_enabled) {
1062     $self->{attachment_filename} ||= $self->generate_attachment_filename;
1063     my $file_obj = $self->store_pdf($self);
1064     $self->{print_file_id} = $file_obj->id if $file_obj;
1065   }
1066   if ($self->{media} eq 'email') {
1067     if ( getcwd() eq $self->{"tmpdir"} ) {
1068       # in the case of generating pdf we are in the tmpdir, but WHY ???
1069       $self->{tmpfile} = $userspath."/".$self->{tmpfile};
1070       chdir("$self->{cwd}");
1071     }
1072     $self->send_email(\%::myconfig,$ext_for_format);
1073   }
1074   else {
1075     $self->{OUT}      = $out;
1076     $self->{OUT_MODE} = $out_mode;
1077     $self->output_file($template->get_mime_type,$command_formatter);
1078   }
1079   delete $self->{print_file_id};
1080
1081   $self->cleanup;
1082
1083   chdir("$self->{cwd}");
1084   $main::lxdebug->leave_sub();
1085 }
1086
1087 sub get_bcc_defaults {
1088   my ($self, $myconfig, $mybcc) = @_;
1089   if (SL::DB::Default->get->bcc_to_login) {
1090     $mybcc .= ", " if $mybcc;
1091     $mybcc .= $myconfig->{email};
1092   }
1093   my $otherbcc = SL::DB::Default->get->global_bcc;
1094   if ($otherbcc) {
1095     $mybcc .= ", " if $mybcc;
1096     $mybcc .= $otherbcc;
1097   }
1098   return $mybcc;
1099 }
1100
1101 sub send_email {
1102   $main::lxdebug->enter_sub();
1103   my ($self, $myconfig, $ext_for_format) = @_;
1104   my $mail = Mailer->new;
1105
1106   map { $mail->{$_} = $self->{$_} }
1107     qw(cc subject message format);
1108
1109   $mail->{bcc}    = $self->get_bcc_defaults($myconfig, $self->{bcc});
1110   $mail->{to}     = $self->{EMAIL_RECIPIENT} ? $self->{EMAIL_RECIPIENT} : $self->{email};
1111   $mail->{from}   = qq|"$myconfig->{name}" <$myconfig->{email}>|;
1112   $mail->{fileid} = time() . '.' . $$ . '.';
1113   my $full_signature     =  $self->create_email_signature();
1114   $full_signature        =~ s/\r//g;
1115
1116   $mail->{attachments} =  [];
1117   my @attfiles;
1118   # if we send html or plain text inline
1119   if (($self->{format} eq 'html') && ($self->{sendmode} eq 'inline')) {
1120     $mail->{content_type}   =  "text/html";
1121     $mail->{message}        =~ s/\r//g;
1122     $mail->{message}        =~ s/\n/<br>\n/g;
1123     $full_signature         =~ s/\n/<br>\n/g;
1124     $mail->{message}       .=  $full_signature;
1125
1126     open(IN, "<", $self->{tmpfile})
1127       or $self->error($self->cleanup . "$self->{tmpfile} : $!");
1128     $mail->{message} .= $_ while <IN>;
1129     close(IN);
1130
1131   } elsif (($self->{attachment_policy} // '') ne 'no_file') {
1132     my $attachment_name  =  $self->{attachment_filename}  || $self->{tmpfile};
1133     $attachment_name     =~ s/\.(.+?)$/.${ext_for_format}/ if ($ext_for_format);
1134
1135     if (($self->{attachment_policy} // '') eq 'old_file') {
1136       my ( $attfile ) = SL::File->get_all(object_id   => $self->{id},
1137                                           object_type => $self->{formname},
1138                                           file_type   => 'document');
1139
1140       if ($attfile) {
1141         $attfile->{override_file_name} = $attachment_name if $attachment_name;
1142         push @attfiles, $attfile;
1143       }
1144
1145     } else {
1146       push @{ $mail->{attachments} }, { path => $self->{tmpfile},
1147                                         id   => $self->{print_file_id},
1148                                         type => "application/pdf",
1149                                         name => $attachment_name };
1150     }
1151   }
1152
1153   push @attfiles,
1154     grep { $_ }
1155     map  { SL::File->get(id => $_) }
1156     @{ $self->{attach_file_ids} // [] };
1157
1158   foreach my $attfile ( @attfiles ) {
1159     push @{ $mail->{attachments} }, {
1160       path    => $attfile->get_file,
1161       id      => $attfile->id,
1162       type    => $attfile->mime_type,
1163       name    => $attfile->{override_file_name} // $attfile->file_name,
1164       content => $attfile->get_content ? ${ $attfile->get_content } : undef,
1165     };
1166   }
1167
1168   $mail->{message}  =~ s/\r//g;
1169   $mail->{message} .= $full_signature;
1170   $self->{emailerr} = $mail->send();
1171
1172   if ($self->{emailerr}) {
1173     $self->cleanup;
1174     $self->error($::locale->text('The email was not sent due to the following error: #1.', $self->{emailerr}));
1175   }
1176
1177   $self->{email_journal_id} = $mail->{journalentry};
1178   $self->{snumbers}  = "emailjournal" . "_" . $self->{email_journal_id};
1179   $self->{what_done} = $::form->{type};
1180   $self->{addition}  = "MAILED";
1181   $self->save_history;
1182
1183   #write back for message info and mail journal
1184   $self->{cc}  = $mail->{cc};
1185   $self->{bcc} = $mail->{bcc};
1186   $self->{email} = $mail->{to};
1187
1188   $main::lxdebug->leave_sub();
1189 }
1190
1191 sub output_file {
1192   $main::lxdebug->enter_sub();
1193
1194   my ($self,$mimeType,$command_formatter) = @_;
1195   my $numbytes = (-s $self->{tmpfile});
1196   open(IN, "<", $self->{tmpfile})
1197     or $self->error($self->cleanup . "$self->{tmpfile} : $!");
1198   binmode IN;
1199
1200   $self->{copies} = 1 unless $self->{media} eq 'printer';
1201
1202   chdir("$self->{cwd}");
1203   for my $i (1 .. $self->{copies}) {
1204     if ($self->{OUT}) {
1205       $self->{OUT} = $command_formatter->($self->{OUT_MODE}, $self->{OUT});
1206
1207       open  OUT, $self->{OUT_MODE}, $self->{OUT} or $self->error($self->cleanup . "$self->{OUT} : $!");
1208       print OUT $_ while <IN>;
1209       close OUT;
1210       seek  IN, 0, 0;
1211
1212     } else {
1213       my %headers = ('-type'       => $mimeType,
1214                      '-connection' => 'close',
1215                      '-charset'    => 'UTF-8');
1216
1217       $self->{attachment_filename} ||= $self->generate_attachment_filename;
1218
1219       if ($self->{attachment_filename}) {
1220         %headers = (
1221           %headers,
1222           '-attachment'     => $self->{attachment_filename},
1223           '-content-length' => $numbytes,
1224           '-charset'        => '',
1225         );
1226       }
1227
1228       print $::request->cgi->header(%headers);
1229
1230       $::locale->with_raw_io(\*STDOUT, sub { print while <IN> });
1231     }
1232   }
1233   close(IN);
1234   $main::lxdebug->leave_sub();
1235 }
1236
1237 sub get_formname_translation {
1238   $main::lxdebug->enter_sub();
1239   my ($self, $formname) = @_;
1240
1241   $formname ||= $self->{formname};
1242
1243   $self->{recipient_locale} ||=  Locale->lang_to_locale($self->{language});
1244   local $::locale = Locale->new($self->{recipient_locale});
1245
1246   my %formname_translations = (
1247     bin_list                => $main::locale->text('Bin List'),
1248     credit_note             => $main::locale->text('Credit Note'),
1249     invoice                 => $main::locale->text('Invoice'),
1250     pick_list               => $main::locale->text('Pick List'),
1251     proforma                => $main::locale->text('Proforma Invoice'),
1252     purchase_order          => $main::locale->text('Purchase Order'),
1253     request_quotation       => $main::locale->text('RFQ'),
1254     sales_order             => $main::locale->text('Confirmation'),
1255     sales_quotation         => $main::locale->text('Quotation'),
1256     storno_invoice          => $main::locale->text('Storno Invoice'),
1257     sales_delivery_order    => $main::locale->text('Delivery Order'),
1258     purchase_delivery_order => $main::locale->text('Delivery Order'),
1259     dunning                 => $main::locale->text('Dunning'),
1260     dunning1                => $main::locale->text('Payment Reminder'),
1261     dunning2                => $main::locale->text('Dunning'),
1262     dunning3                => $main::locale->text('Last Dunning'),
1263     dunning_invoice         => $main::locale->text('Dunning Invoice'),
1264     letter                  => $main::locale->text('Letter'),
1265     ic_supply               => $main::locale->text('Intra-Community supply'),
1266     statement               => $main::locale->text('Statement'),
1267   );
1268
1269   $main::lxdebug->leave_sub();
1270   return $formname_translations{$formname};
1271 }
1272
1273 sub get_number_prefix_for_type {
1274   $main::lxdebug->enter_sub();
1275   my ($self) = @_;
1276
1277   my $prefix =
1278       (first { $self->{type} eq $_ } qw(invoice credit_note)) ? 'inv'
1279     : ($self->{type} =~ /_quotation$/)                        ? 'quo'
1280     : ($self->{type} =~ /_delivery_order$/)                   ? 'do'
1281     : ($self->{type} =~ /letter/)                             ? 'letter'
1282     :                                                           'ord';
1283
1284   # better default like this?
1285   # : ($self->{type} =~ /(sales|purcharse)_order/           :  'ord';
1286   # :                                                           'prefix_undefined';
1287
1288   $main::lxdebug->leave_sub();
1289   return $prefix;
1290 }
1291
1292 sub get_extension_for_format {
1293   $main::lxdebug->enter_sub();
1294   my ($self)    = @_;
1295
1296   my $extension = $self->{format} =~ /pdf/i          ? ".pdf"
1297                 : $self->{format} =~ /postscript/i   ? ".ps"
1298                 : $self->{format} =~ /opendocument/i ? ".odt"
1299                 : $self->{format} =~ /excel/i        ? ".xls"
1300                 : $self->{format} =~ /html/i         ? ".html"
1301                 :                                      "";
1302
1303   $main::lxdebug->leave_sub();
1304   return $extension;
1305 }
1306
1307 sub generate_attachment_filename {
1308   $main::lxdebug->enter_sub();
1309   my ($self) = @_;
1310
1311   $self->{recipient_locale} ||=  Locale->lang_to_locale($self->{language});
1312   my $recipient_locale = Locale->new($self->{recipient_locale});
1313
1314   my $attachment_filename = $main::locale->unquote_special_chars('HTML', $self->get_formname_translation());
1315   my $prefix              = $self->get_number_prefix_for_type();
1316
1317   if ($self->{preview} && (first { $self->{type} eq $_ } qw(invoice credit_note))) {
1318     $attachment_filename .= ' (' . $recipient_locale->text('Preview') . ')' . $self->get_extension_for_format();
1319
1320   } elsif ($attachment_filename && $self->{"${prefix}number"}) {
1321     $attachment_filename .=  "_" . $self->{"${prefix}number"} . $self->get_extension_for_format();
1322
1323   } elsif ($attachment_filename) {
1324     $attachment_filename .=  $self->get_extension_for_format();
1325
1326   } else {
1327     $attachment_filename = "";
1328   }
1329
1330   $attachment_filename =  $main::locale->quote_special_chars('filenames', $attachment_filename);
1331   $attachment_filename =~ s|[\s/\\]+|_|g;
1332
1333   $main::lxdebug->leave_sub();
1334   return $attachment_filename;
1335 }
1336
1337 sub generate_email_subject {
1338   $main::lxdebug->enter_sub();
1339   my ($self) = @_;
1340
1341   my $subject = $main::locale->unquote_special_chars('HTML', $self->get_formname_translation());
1342   my $prefix  = $self->get_number_prefix_for_type();
1343
1344   if ($subject && $self->{"${prefix}number"}) {
1345     $subject .= " " . $self->{"${prefix}number"}
1346   }
1347
1348   $main::lxdebug->leave_sub();
1349   return $subject;
1350 }
1351
1352 sub generate_email_body {
1353   $main::lxdebug->enter_sub();
1354   my ($self, %params) = @_;
1355   # simple german and english will work grammatically (most european languages as well)
1356   # Dear Mr Alan Greenspan:
1357   # Sehr geehrte Frau Meyer,
1358   # A l’attention de Mme Villeroy,
1359   # Gentile Signora Ferrari,
1360   my $body = '';
1361
1362   if ($self->{cp_id} && !$params{record_email}) {
1363     my $givenname = SL::DB::Contact->load_cached($self->{cp_id})->cp_givenname; # for qw(gender givename name);
1364     my $name      = SL::DB::Contact->load_cached($self->{cp_id})->cp_name; # for qw(gender givename name);
1365     my $gender    = SL::DB::Contact->load_cached($self->{cp_id})->cp_gender; # for qw(gender givename name);
1366     my $mf = $gender eq 'f' ? 'female' : 'male';
1367     $body  = GenericTranslations->get(translation_type => "salutation_$mf", language_id => $self->{language_id});
1368     $body .= ' ' . $givenname . ' ' . $name if $body;
1369   } else {
1370     $body  = GenericTranslations->get(translation_type => "salutation_general", language_id => $self->{language_id});
1371   }
1372
1373   return undef unless $body;
1374
1375   $body   .= GenericTranslations->get(translation_type =>"salutation_punctuation_mark", language_id => $self->{language_id}) . "\n";
1376   $body   .= GenericTranslations->get(translation_type =>"preset_text_$self->{formname}", language_id => $self->{language_id});
1377
1378   $body = $main::locale->unquote_special_chars('HTML', $body);
1379
1380   $main::lxdebug->leave_sub();
1381   return $body;
1382 }
1383
1384 sub cleanup {
1385   $main::lxdebug->enter_sub();
1386
1387   my ($self, $application) = @_;
1388
1389   my $error_code = $?;
1390
1391   chdir("$self->{tmpdir}");
1392
1393   my @err = ();
1394   if ((-1 == $error_code) || (127 == (($error_code) >> 8))) {
1395     push @err, $::locale->text('The application "#1" was not found on the system.', $application || 'pdflatex') . ' ' . $::locale->text('Please contact your administrator.');
1396
1397   } elsif (-f "$self->{tmpfile}.err") {
1398     open(FH, "<:encoding(UTF-8)", "$self->{tmpfile}.err");
1399     @err = <FH>;
1400     close(FH);
1401   }
1402
1403   if ($self->{tmpfile} && !($::lx_office_conf{debug} && $::lx_office_conf{debug}->{keep_temp_files})) {
1404     $self->{tmpfile} =~ s|.*/||g;
1405     # strip extension
1406     $self->{tmpfile} =~ s/\.\w+$//g;
1407     my $tmpfile = $self->{tmpfile};
1408     unlink(<$tmpfile.*>);
1409   }
1410
1411   chdir("$self->{cwd}");
1412
1413   $main::lxdebug->leave_sub();
1414
1415   return "@err";
1416 }
1417
1418 sub datetonum {
1419   $main::lxdebug->enter_sub();
1420
1421   my ($self, $date, $myconfig) = @_;
1422   my ($yy, $mm, $dd);
1423
1424   if ($date && $date =~ /\D/) {
1425
1426     if ($myconfig->{dateformat} =~ /^yy/) {
1427       ($yy, $mm, $dd) = split /\D/, $date;
1428     }
1429     if ($myconfig->{dateformat} =~ /^mm/) {
1430       ($mm, $dd, $yy) = split /\D/, $date;
1431     }
1432     if ($myconfig->{dateformat} =~ /^dd/) {
1433       ($dd, $mm, $yy) = split /\D/, $date;
1434     }
1435
1436     $dd *= 1;
1437     $mm *= 1;
1438     $yy = ($yy < 70) ? $yy + 2000 : $yy;
1439     $yy = ($yy >= 70 && $yy <= 99) ? $yy + 1900 : $yy;
1440
1441     $dd = "0$dd" if ($dd < 10);
1442     $mm = "0$mm" if ($mm < 10);
1443
1444     $date = "$yy$mm$dd";
1445   }
1446
1447   $main::lxdebug->leave_sub();
1448
1449   return $date;
1450 }
1451
1452 # Database routines used throughout
1453 # DB Handling got moved to SL::DB, these are only shims for compatibility
1454
1455 sub dbconnect {
1456   SL::DB->client->dbh;
1457 }
1458
1459 sub get_standard_dbh {
1460   my $dbh = SL::DB->client->dbh;
1461
1462   if ($dbh && !$dbh->{Active}) {
1463     $main::lxdebug->message(LXDebug->INFO(), "get_standard_dbh: \$dbh is defined but not Active anymore");
1464     SL::DB->client->dbh(undef);
1465   }
1466
1467   SL::DB->client->dbh;
1468 }
1469
1470 sub disconnect_standard_dbh {
1471   SL::DB->client->dbh->rollback;
1472 }
1473
1474 # /database
1475
1476 sub date_closed {
1477   $main::lxdebug->enter_sub();
1478
1479   my ($self, $date, $myconfig) = @_;
1480   my $dbh = $self->get_standard_dbh;
1481
1482   my $query = "SELECT 1 FROM defaults WHERE ? < closedto";
1483   my $sth = prepare_execute_query($self, $dbh, $query, conv_date($date));
1484
1485   # Falls $date = '' - Fehlermeldung aus der Datenbank. Ich denke,
1486   # es ist sicher ein conv_date vorher IMMER auszuführen.
1487   # Testfälle ohne definiertes closedto:
1488   #   Leere Datumseingabe i.O.
1489   #     SELECT 1 FROM defaults WHERE '' < closedto
1490   #   normale Zahlungsbuchung über Rechnungsmaske i.O.
1491   #     SELECT 1 FROM defaults WHERE '10.05.2011' < closedto
1492   # Testfälle mit definiertem closedto (30.04.2011):
1493   #  Leere Datumseingabe i.O.
1494   #   SELECT 1 FROM defaults WHERE '' < closedto
1495   # normale Buchung im geschloßenem Zeitraum i.O.
1496   #   SELECT 1 FROM defaults WHERE '21.04.2011' < closedto
1497   #     Fehlermeldung: Es können keine Zahlungen für abgeschlossene Bücher gebucht werden!
1498   # normale Buchung in aktiver Buchungsperiode i.O.
1499   #   SELECT 1 FROM defaults WHERE '01.05.2011' < closedto
1500
1501   my ($closed) = $sth->fetchrow_array;
1502
1503   $main::lxdebug->leave_sub();
1504
1505   return $closed;
1506 }
1507
1508 # prevents bookings to the to far away future
1509 sub date_max_future {
1510   $main::lxdebug->enter_sub();
1511
1512   my ($self, $date, $myconfig) = @_;
1513   my $dbh = $self->get_standard_dbh;
1514
1515   my $query = "SELECT 1 FROM defaults WHERE ? - current_date > max_future_booking_interval";
1516   my $sth = prepare_execute_query($self, $dbh, $query, conv_date($date));
1517
1518   my ($max_future_booking_interval) = $sth->fetchrow_array;
1519
1520   $main::lxdebug->leave_sub();
1521
1522   return $max_future_booking_interval;
1523 }
1524
1525
1526 sub update_balance {
1527   $main::lxdebug->enter_sub();
1528
1529   my ($self, $dbh, $table, $field, $where, $value, @values) = @_;
1530
1531   # if we have a value, go do it
1532   if ($value != 0) {
1533
1534     # retrieve balance from table
1535     my $query = "SELECT $field FROM $table WHERE $where FOR UPDATE";
1536     my $sth = prepare_execute_query($self, $dbh, $query, @values);
1537     my ($balance) = $sth->fetchrow_array;
1538     $sth->finish;
1539
1540     $balance += $value;
1541
1542     # update balance
1543     $query = "UPDATE $table SET $field = $balance WHERE $where";
1544     do_query($self, $dbh, $query, @values);
1545   }
1546   $main::lxdebug->leave_sub();
1547 }
1548
1549 sub update_exchangerate {
1550   $main::lxdebug->enter_sub();
1551
1552   my ($self, $dbh, $curr, $transdate, $buy, $sell) = @_;
1553   my ($query);
1554   # some sanity check for currency
1555   if ($curr eq '') {
1556     $main::lxdebug->leave_sub();
1557     return;
1558   }
1559   $query = qq|SELECT name AS curr FROM currencies WHERE id=(SELECT currency_id FROM defaults)|;
1560
1561   my ($defaultcurrency) = selectrow_query($self, $dbh, $query);
1562
1563   if ($curr eq $defaultcurrency) {
1564     $main::lxdebug->leave_sub();
1565     return;
1566   }
1567
1568   $query = qq|SELECT e.currency_id FROM exchangerate e
1569                  WHERE e.currency_id = (SELECT cu.id FROM currencies cu WHERE cu.name=?) AND e.transdate = ?
1570                  FOR UPDATE|;
1571   my $sth = prepare_execute_query($self, $dbh, $query, $curr, $transdate);
1572
1573   if ($buy == 0) {
1574     $buy = "";
1575   }
1576   if ($sell == 0) {
1577     $sell = "";
1578   }
1579
1580   $buy = conv_i($buy, "NULL");
1581   $sell = conv_i($sell, "NULL");
1582
1583   my $set;
1584   if ($buy != 0 && $sell != 0) {
1585     $set = "buy = $buy, sell = $sell";
1586   } elsif ($buy != 0) {
1587     $set = "buy = $buy";
1588   } elsif ($sell != 0) {
1589     $set = "sell = $sell";
1590   }
1591
1592   if ($sth->fetchrow_array) {
1593     $query = qq|UPDATE exchangerate
1594                 SET $set
1595                 WHERE currency_id = (SELECT id FROM currencies WHERE name = ?)
1596                 AND transdate = ?|;
1597
1598   } else {
1599     $query = qq|INSERT INTO exchangerate (currency_id, buy, sell, transdate)
1600                 VALUES ((SELECT id FROM currencies WHERE name = ?), $buy, $sell, ?)|;
1601   }
1602   $sth->finish;
1603   do_query($self, $dbh, $query, $curr, $transdate);
1604
1605   $main::lxdebug->leave_sub();
1606 }
1607
1608 sub save_exchangerate {
1609   $main::lxdebug->enter_sub();
1610
1611   my ($self, $myconfig, $currency, $transdate, $rate, $fld) = @_;
1612
1613   SL::DB->client->with_transaction(sub {
1614     my $dbh = SL::DB->client->dbh;
1615
1616     my ($buy, $sell);
1617
1618     $buy  = $rate if $fld eq 'buy';
1619     $sell = $rate if $fld eq 'sell';
1620
1621
1622     $self->update_exchangerate($dbh, $currency, $transdate, $buy, $sell);
1623     1;
1624   }) or do { die SL::DB->client->error };
1625
1626   $main::lxdebug->leave_sub();
1627 }
1628
1629 sub get_exchangerate {
1630   $main::lxdebug->enter_sub();
1631
1632   my ($self, $dbh, $curr, $transdate, $fld) = @_;
1633   my ($query);
1634
1635   unless ($transdate && $curr) {
1636     $main::lxdebug->leave_sub();
1637     return 1;
1638   }
1639
1640   $query = qq|SELECT name AS curr FROM currencies WHERE id = (SELECT currency_id FROM defaults)|;
1641
1642   my ($defaultcurrency) = selectrow_query($self, $dbh, $query);
1643
1644   if ($curr eq $defaultcurrency) {
1645     $main::lxdebug->leave_sub();
1646     return 1;
1647   }
1648
1649   $query = qq|SELECT e.$fld FROM exchangerate e
1650                  WHERE e.currency_id = (SELECT id FROM currencies WHERE name = ?) AND e.transdate = ?|;
1651   my ($exchangerate) = selectrow_query($self, $dbh, $query, $curr, $transdate);
1652
1653
1654
1655   $main::lxdebug->leave_sub();
1656
1657   return $exchangerate;
1658 }
1659
1660 sub check_exchangerate {
1661   $main::lxdebug->enter_sub();
1662
1663   my ($self, $myconfig, $currency, $transdate, $fld) = @_;
1664
1665   if ($fld !~/^buy|sell$/) {
1666     $self->error('Fatal: check_exchangerate called with invalid buy/sell argument');
1667   }
1668
1669   unless ($transdate) {
1670     $main::lxdebug->leave_sub();
1671     return "";
1672   }
1673
1674   my ($defaultcurrency) = $self->get_default_currency($myconfig);
1675
1676   if ($currency eq $defaultcurrency) {
1677     $main::lxdebug->leave_sub();
1678     return 1;
1679   }
1680
1681   my $dbh   = $self->get_standard_dbh($myconfig);
1682   my $query = qq|SELECT e.$fld FROM exchangerate e
1683                  WHERE e.currency_id = (SELECT id FROM currencies WHERE name = ?) AND e.transdate = ?|;
1684
1685   my ($exchangerate) = selectrow_query($self, $dbh, $query, $currency, $transdate);
1686
1687   $main::lxdebug->leave_sub();
1688
1689   return $exchangerate;
1690 }
1691
1692 sub get_all_currencies {
1693   $main::lxdebug->enter_sub();
1694
1695   my $self     = shift;
1696   my $myconfig = shift || \%::myconfig;
1697   my $dbh      = $self->get_standard_dbh($myconfig);
1698
1699   my $query = qq|SELECT name FROM currencies|;
1700   my @currencies = map { $_->{name} } selectall_hashref_query($self, $dbh, $query);
1701
1702   $main::lxdebug->leave_sub();
1703
1704   return @currencies;
1705 }
1706
1707 sub get_default_currency {
1708   $main::lxdebug->enter_sub();
1709
1710   my ($self, $myconfig) = @_;
1711   my $dbh      = $self->get_standard_dbh($myconfig);
1712   my $query = qq|SELECT name AS curr FROM currencies WHERE id = (SELECT currency_id FROM defaults)|;
1713
1714   my ($defaultcurrency) = selectrow_query($self, $dbh, $query);
1715
1716   $main::lxdebug->leave_sub();
1717
1718   return $defaultcurrency;
1719 }
1720
1721 sub set_payment_options {
1722   my ($self, $myconfig, $transdate, $type) = @_;
1723
1724   my $terms = $self->{payment_id} ? SL::DB::PaymentTerm->new(id => $self->{payment_id})->load : undef;
1725   return if !$terms;
1726
1727   my $is_invoice                = $type =~ m{invoice}i;
1728
1729   $transdate                  ||= $self->{invdate} || $self->{transdate};
1730   my $due_date                  = $self->{duedate} || $self->{reqdate};
1731
1732   $self->{$_}                   = $terms->$_ for qw(terms_netto terms_skonto percent_skonto);
1733   $self->{payment_description}  = $terms->description;
1734   $self->{netto_date}           = $terms->calc_date(reference_date => $transdate, due_date => $due_date, terms => 'net')->to_kivitendo;
1735   $self->{skonto_date}          = $terms->calc_date(reference_date => $transdate, due_date => $due_date, terms => 'discount')->to_kivitendo;
1736
1737   my ($invtotal, $total);
1738   my (%amounts, %formatted_amounts);
1739
1740   if ($self->{type} =~ /_order$/) {
1741     $amounts{invtotal} = $self->{ordtotal};
1742     $amounts{total}    = $self->{ordtotal};
1743
1744   } elsif ($self->{type} =~ /_quotation$/) {
1745     $amounts{invtotal} = $self->{quototal};
1746     $amounts{total}    = $self->{quototal};
1747
1748   } else {
1749     $amounts{invtotal} = $self->{invtotal};
1750     $amounts{total}    = $self->{total};
1751   }
1752   map { $amounts{$_} = $self->parse_amount($myconfig, $amounts{$_}) } keys %amounts;
1753
1754   $amounts{skonto_in_percent}  = 100.0 * $self->{percent_skonto};
1755   $amounts{skonto_amount}      = $amounts{invtotal} * $self->{percent_skonto};
1756   $amounts{invtotal_wo_skonto} = $amounts{invtotal} * (1 - $self->{percent_skonto});
1757   $amounts{total_wo_skonto}    = $amounts{total}    * (1 - $self->{percent_skonto});
1758
1759   foreach (keys %amounts) {
1760     $amounts{$_}           = $self->round_amount($amounts{$_}, 2);
1761     $formatted_amounts{$_} = $self->format_amount($myconfig, $amounts{$_}, 2);
1762   }
1763
1764   if ($self->{"language_id"}) {
1765     my $language             = SL::DB::Language->new(id => $self->{language_id})->load;
1766
1767     $self->{payment_terms}   = $type =~ m{invoice}i ? $terms->translated_attribute('description_long_invoice', $language->id) : undef;
1768     $self->{payment_terms} ||= $terms->translated_attribute('description_long', $language->id);
1769
1770     if ($language->output_dateformat) {
1771       foreach my $key (qw(netto_date skonto_date)) {
1772         $self->{$key} = $::locale->reformat_date($myconfig, $self->{$key}, $language->output_dateformat, $language->output_longdates);
1773       }
1774     }
1775
1776     if ($language->output_numberformat && ($language->output_numberformat ne $myconfig->{numberformat})) {
1777       local $myconfig->{numberformat};
1778       $myconfig->{"numberformat"} = $language->output_numberformat;
1779       $formatted_amounts{$_} = $self->format_amount($myconfig, $amounts{$_}) for keys %amounts;
1780     }
1781   }
1782
1783   $self->{payment_terms} =  $self->{payment_terms} || ($is_invoice ? $terms->description_long_invoice : undef) || $terms->description_long;
1784
1785   $self->{payment_terms} =~ s/<%netto_date%>/$self->{netto_date}/g;
1786   $self->{payment_terms} =~ s/<%skonto_date%>/$self->{skonto_date}/g;
1787   $self->{payment_terms} =~ s/<%currency%>/$self->{currency}/g;
1788   $self->{payment_terms} =~ s/<%terms_netto%>/$self->{terms_netto}/g;
1789   $self->{payment_terms} =~ s/<%account_number%>/$self->{account_number}/g;
1790   $self->{payment_terms} =~ s/<%bank%>/$self->{bank}/g;
1791   $self->{payment_terms} =~ s/<%bank_code%>/$self->{bank_code}/g;
1792   $self->{payment_terms} =~ s/<\%bic\%>/$self->{bic}/g;
1793   $self->{payment_terms} =~ s/<\%iban\%>/$self->{iban}/g;
1794   $self->{payment_terms} =~ s/<\%mandate_date_of_signature\%>/$self->{mandate_date_of_signature}/g;
1795   $self->{payment_terms} =~ s/<\%mandator_id\%>/$self->{mandator_id}/g;
1796
1797   map { $self->{payment_terms} =~ s/<%${_}%>/$formatted_amounts{$_}/g; } keys %formatted_amounts;
1798
1799   $self->{skonto_in_percent} = $formatted_amounts{skonto_in_percent};
1800
1801 }
1802
1803 sub get_template_language {
1804   $main::lxdebug->enter_sub();
1805
1806   my ($self, $myconfig) = @_;
1807
1808   my $template_code = "";
1809
1810   if ($self->{language_id}) {
1811     my $dbh = $self->get_standard_dbh($myconfig);
1812     my $query = qq|SELECT template_code FROM language WHERE id = ?|;
1813     ($template_code) = selectrow_query($self, $dbh, $query, $self->{language_id});
1814   }
1815
1816   $main::lxdebug->leave_sub();
1817
1818   return $template_code;
1819 }
1820
1821 sub get_printer_code {
1822   $main::lxdebug->enter_sub();
1823
1824   my ($self, $myconfig) = @_;
1825
1826   my $template_code = "";
1827
1828   if ($self->{printer_id}) {
1829     my $dbh = $self->get_standard_dbh($myconfig);
1830     my $query = qq|SELECT template_code, printer_command FROM printers WHERE id = ?|;
1831     ($template_code, $self->{printer_command}) = selectrow_query($self, $dbh, $query, $self->{printer_id});
1832   }
1833
1834   $main::lxdebug->leave_sub();
1835
1836   return $template_code;
1837 }
1838
1839 sub get_shipto {
1840   $main::lxdebug->enter_sub();
1841
1842   my ($self, $myconfig) = @_;
1843
1844   my $template_code = "";
1845
1846   if ($self->{shipto_id}) {
1847     my $dbh = $self->get_standard_dbh($myconfig);
1848     my $query = qq|SELECT * FROM shipto WHERE shipto_id = ?|;
1849     my $ref = selectfirst_hashref_query($self, $dbh, $query, $self->{shipto_id});
1850     map({ $self->{$_} = $ref->{$_} } keys(%$ref));
1851
1852     my $cvars = CVar->get_custom_variables(
1853       dbh      => $dbh,
1854       module   => 'ShipTo',
1855       trans_id => $self->{shipto_id},
1856     );
1857     $self->{"shiptocvar_$_->{name}"} = $_->{value} for @{ $cvars };
1858   }
1859
1860   $main::lxdebug->leave_sub();
1861 }
1862
1863 sub add_shipto {
1864   my ($self, $dbh, $id, $module) = @_;
1865
1866   my $shipto;
1867   my @values;
1868
1869   foreach my $item (qw(name department_1 department_2 street zipcode city country gln
1870                        contact phone fax email)) {
1871     if ($self->{"shipto$item"}) {
1872       $shipto = 1 if ($self->{$item} ne $self->{"shipto$item"});
1873     }
1874     push(@values, $self->{"shipto${item}"});
1875   }
1876
1877   return if !$shipto;
1878
1879   # shiptocp_gender only makes sense, if any other shipto attribute is set.
1880   # Because shiptocp_gender is set to 'm' by default in forms
1881   # it must not be considered above to decide if shiptos has to be added or
1882   # updated, but must be inserted or updated as well in case.
1883   push(@values, $self->{shiptocp_gender});
1884
1885   my $shipto_id = $self->{shipto_id};
1886
1887   if ($self->{shipto_id}) {
1888     my $query = qq|UPDATE shipto set
1889                      shiptoname = ?,
1890                      shiptodepartment_1 = ?,
1891                      shiptodepartment_2 = ?,
1892                      shiptostreet = ?,
1893                      shiptozipcode = ?,
1894                      shiptocity = ?,
1895                      shiptocountry = ?,
1896                      shiptogln = ?,
1897                      shiptocontact = ?,
1898                      shiptocp_gender = ?,
1899                      shiptophone = ?,
1900                      shiptofax = ?,
1901                      shiptoemail = ?
1902                    WHERE shipto_id = ?|;
1903     do_query($self, $dbh, $query, @values, $self->{shipto_id});
1904   } else {
1905     my $query = qq|SELECT * FROM shipto
1906                    WHERE shiptoname = ? AND
1907                      shiptodepartment_1 = ? AND
1908                      shiptodepartment_2 = ? AND
1909                      shiptostreet = ? AND
1910                      shiptozipcode = ? AND
1911                      shiptocity = ? AND
1912                      shiptocountry = ? AND
1913                      shiptogln = ? AND
1914                      shiptocontact = ? AND
1915                      shiptocp_gender = ? AND
1916                      shiptophone = ? AND
1917                      shiptofax = ? AND
1918                      shiptoemail = ? AND
1919                      module = ? AND
1920                      trans_id = ?|;
1921     my $insert_check = selectfirst_hashref_query($self, $dbh, $query, @values, $module, $id);
1922     if(!$insert_check){
1923       my $insert_query =
1924         qq|INSERT INTO shipto (trans_id, shiptoname, shiptodepartment_1, shiptodepartment_2,
1925                                shiptostreet, shiptozipcode, shiptocity, shiptocountry, shiptogln,
1926                                shiptocontact, shiptocp_gender, shiptophone, shiptofax, shiptoemail, module)
1927            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)|;
1928       do_query($self, $dbh, $insert_query, $id, @values, $module);
1929
1930       $insert_check = selectfirst_hashref_query($self, $dbh, $query, @values, $module, $id);
1931     }
1932
1933     $shipto_id = $insert_check->{shipto_id};
1934   }
1935
1936   return unless $shipto_id;
1937
1938   CVar->save_custom_variables(
1939     dbh         => $dbh,
1940     module      => 'ShipTo',
1941     trans_id    => $shipto_id,
1942     variables   => $self,
1943     name_prefix => 'shipto',
1944   );
1945 }
1946
1947 sub get_employee {
1948   $main::lxdebug->enter_sub();
1949
1950   my ($self, $dbh) = @_;
1951
1952   $dbh ||= $self->get_standard_dbh(\%main::myconfig);
1953
1954   my $query = qq|SELECT id, name FROM employee WHERE login = ?|;
1955   ($self->{"employee_id"}, $self->{"employee"}) = selectrow_query($self, $dbh, $query, $self->{login});
1956   $self->{"employee_id"} *= 1;
1957
1958   $main::lxdebug->leave_sub();
1959 }
1960
1961 sub get_employee_data {
1962   $main::lxdebug->enter_sub();
1963
1964   my $self     = shift;
1965   my %params   = @_;
1966   my $defaults = SL::DB::Default->get;
1967
1968   Common::check_params(\%params, qw(prefix));
1969   Common::check_params_x(\%params, qw(id));
1970
1971   if (!$params{id}) {
1972     $main::lxdebug->leave_sub();
1973     return;
1974   }
1975
1976   my $myconfig = \%main::myconfig;
1977   my $dbh      = $params{dbh} || $self->get_standard_dbh($myconfig);
1978
1979   my ($login, $deleted)  = selectrow_query($self, $dbh, qq|SELECT login,deleted FROM employee WHERE id = ?|, conv_i($params{id}));
1980
1981   if ($login) {
1982     # login already fetched and still the same client (mandant) | same for both cases (delete|!delete)
1983     $self->{$params{prefix} . '_login'}   = $login;
1984     $self->{$params{prefix} . "_${_}"}    = $defaults->$_ for qw(address businessnumber co_ustid company duns taxnumber);
1985
1986     if (!$deleted) {
1987       # get employee data from auth.user_config
1988       my $user = User->new(login => $login);
1989       $self->{$params{prefix} . "_${_}"} = $user->{$_} for qw(email fax name signature tel);
1990     } else {
1991       # get saved employee data from employee
1992       my $employee = SL::DB::Manager::Employee->find_by(id => conv_i($params{id}));
1993       $self->{$params{prefix} . "_${_}"} = $employee->{"deleted_$_"} for qw(email fax signature tel);
1994       $self->{$params{prefix} . "_name"} = $employee->name;
1995     }
1996  }
1997   $main::lxdebug->leave_sub();
1998 }
1999
2000 sub _get_contacts {
2001   $main::lxdebug->enter_sub();
2002
2003   my ($self, $dbh, $id, $key) = @_;
2004
2005   $key = "all_contacts" unless ($key);
2006
2007   if (!$id) {
2008     $self->{$key} = [];
2009     $main::lxdebug->leave_sub();
2010     return;
2011   }
2012
2013   my $query =
2014     qq|SELECT cp_id, cp_cv_id, cp_name, cp_givenname, cp_abteilung | .
2015     qq|FROM contacts | .
2016     qq|WHERE cp_cv_id = ? | .
2017     qq|ORDER BY lower(cp_name)|;
2018
2019   $self->{$key} = selectall_hashref_query($self, $dbh, $query, $id);
2020
2021   $main::lxdebug->leave_sub();
2022 }
2023
2024 sub _get_projects {
2025   $main::lxdebug->enter_sub();
2026
2027   my ($self, $dbh, $key) = @_;
2028
2029   my ($all, $old_id, $where, @values);
2030
2031   if (ref($key) eq "HASH") {
2032     my $params = $key;
2033
2034     $key = "ALL_PROJECTS";
2035
2036     foreach my $p (keys(%{$params})) {
2037       if ($p eq "all") {
2038         $all = $params->{$p};
2039       } elsif ($p eq "old_id") {
2040         $old_id = $params->{$p};
2041       } elsif ($p eq "key") {
2042         $key = $params->{$p};
2043       }
2044     }
2045   }
2046
2047   if (!$all) {
2048     $where = "WHERE active ";
2049     if ($old_id) {
2050       if (ref($old_id) eq "ARRAY") {
2051         my @ids = grep({ $_ } @{$old_id});
2052         if (@ids) {
2053           $where .= " OR id IN (" . join(",", map({ "?" } @ids)) . ") ";
2054           push(@values, @ids);
2055         }
2056       } else {
2057         $where .= " OR (id = ?) ";
2058         push(@values, $old_id);
2059       }
2060     }
2061   }
2062
2063   my $query =
2064     qq|SELECT id, projectnumber, description, active | .
2065     qq|FROM project | .
2066     $where .
2067     qq|ORDER BY lower(projectnumber)|;
2068
2069   $self->{$key} = selectall_hashref_query($self, $dbh, $query, @values);
2070
2071   $main::lxdebug->leave_sub();
2072 }
2073
2074 sub _get_shipto {
2075   $main::lxdebug->enter_sub();
2076
2077   my ($self, $dbh, $vc_id, $key) = @_;
2078
2079   $key = "all_shipto" unless ($key);
2080
2081   if ($vc_id) {
2082     # get shipping addresses
2083     my $query = qq|SELECT * FROM shipto WHERE trans_id = ?|;
2084
2085     $self->{$key} = selectall_hashref_query($self, $dbh, $query, $vc_id);
2086
2087   } else {
2088     $self->{$key} = [];
2089   }
2090
2091   $main::lxdebug->leave_sub();
2092 }
2093
2094 sub _get_printers {
2095   $main::lxdebug->enter_sub();
2096
2097   my ($self, $dbh, $key) = @_;
2098
2099   $key = "all_printers" unless ($key);
2100
2101   my $query = qq|SELECT id, printer_description, printer_command, template_code FROM printers|;
2102
2103   $self->{$key} = selectall_hashref_query($self, $dbh, $query);
2104
2105   $main::lxdebug->leave_sub();
2106 }
2107
2108 sub _get_charts {
2109   $main::lxdebug->enter_sub();
2110
2111   my ($self, $dbh, $params) = @_;
2112   my ($key);
2113
2114   $key = $params->{key};
2115   $key = "all_charts" unless ($key);
2116
2117   my $transdate = quote_db_date($params->{transdate});
2118
2119   my $query =
2120     qq|SELECT c.id, c.accno, c.description, c.link, c.charttype, tk.taxkey_id, tk.tax_id | .
2121     qq|FROM chart c | .
2122     qq|LEFT JOIN taxkeys tk ON | .
2123     qq|(tk.id = (SELECT id FROM taxkeys | .
2124     qq|          WHERE taxkeys.chart_id = c.id AND startdate <= $transdate | .
2125     qq|          ORDER BY startdate DESC LIMIT 1)) | .
2126     qq|ORDER BY c.accno|;
2127
2128   $self->{$key} = selectall_hashref_query($self, $dbh, $query);
2129
2130   $main::lxdebug->leave_sub();
2131 }
2132
2133 sub _get_taxcharts {
2134   $main::lxdebug->enter_sub();
2135
2136   my ($self, $dbh, $params) = @_;
2137
2138   my $key = "all_taxcharts";
2139   my @where;
2140
2141   if (ref $params eq 'HASH') {
2142     $key = $params->{key} if ($params->{key});
2143     if ($params->{module} eq 'AR') {
2144       push @where, 'chart_categories ~ \'[ACILQ]\'';
2145
2146     } elsif ($params->{module} eq 'AP') {
2147       push @where, 'chart_categories ~ \'[ACELQ]\'';
2148     }
2149
2150   } elsif ($params) {
2151     $key = $params;
2152   }
2153
2154   my $where = @where ? ' WHERE ' . join(' AND ', map { "($_)" } @where) : '';
2155
2156   my $query = qq|SELECT * FROM tax $where ORDER BY taxkey, rate|;
2157
2158   $self->{$key} = selectall_hashref_query($self, $dbh, $query);
2159
2160   $main::lxdebug->leave_sub();
2161 }
2162
2163 sub _get_taxzones {
2164   $main::lxdebug->enter_sub();
2165
2166   my ($self, $dbh, $key) = @_;
2167
2168   $key = "all_taxzones" unless ($key);
2169   my $tzfilter = "";
2170   $tzfilter = "WHERE obsolete is FALSE" if $key eq 'ALL_ACTIVE_TAXZONES';
2171
2172   my $query = qq|SELECT * FROM tax_zones $tzfilter ORDER BY sortkey|;
2173
2174   $self->{$key} = selectall_hashref_query($self, $dbh, $query);
2175
2176   $main::lxdebug->leave_sub();
2177 }
2178
2179 sub _get_employees {
2180   $main::lxdebug->enter_sub();
2181
2182   my ($self, $dbh, $params) = @_;
2183
2184   my $deleted = 0;
2185
2186   my $key;
2187   if (ref $params eq 'HASH') {
2188     $key     = $params->{key};
2189     $deleted = $params->{deleted};
2190
2191   } else {
2192     $key = $params;
2193   }
2194
2195   $key     ||= "all_employees";
2196   my $filter = $deleted ? '' : 'WHERE NOT COALESCE(deleted, FALSE)';
2197   $self->{$key} = selectall_hashref_query($self, $dbh, qq|SELECT * FROM employee $filter ORDER BY lower(name)|);
2198
2199   $main::lxdebug->leave_sub();
2200 }
2201
2202 sub _get_business_types {
2203   $main::lxdebug->enter_sub();
2204
2205   my ($self, $dbh, $key) = @_;
2206
2207   my $options       = ref $key eq 'HASH' ? $key : { key => $key };
2208   $options->{key} ||= "all_business_types";
2209   my $where         = '';
2210
2211   if (exists $options->{salesman}) {
2212     $where = 'WHERE ' . ($options->{salesman} ? '' : 'NOT ') . 'COALESCE(salesman)';
2213   }
2214
2215   $self->{ $options->{key} } = selectall_hashref_query($self, $dbh, qq|SELECT * FROM business $where ORDER BY lower(description)|);
2216
2217   $main::lxdebug->leave_sub();
2218 }
2219
2220 sub _get_languages {
2221   $main::lxdebug->enter_sub();
2222
2223   my ($self, $dbh, $key) = @_;
2224
2225   $key = "all_languages" unless ($key);
2226
2227   my $query = qq|SELECT * FROM language ORDER BY id|;
2228
2229   $self->{$key} = selectall_hashref_query($self, $dbh, $query);
2230
2231   $main::lxdebug->leave_sub();
2232 }
2233
2234 sub _get_dunning_configs {
2235   $main::lxdebug->enter_sub();
2236
2237   my ($self, $dbh, $key) = @_;
2238
2239   $key = "all_dunning_configs" unless ($key);
2240
2241   my $query = qq|SELECT * FROM dunning_config ORDER BY dunning_level|;
2242
2243   $self->{$key} = selectall_hashref_query($self, $dbh, $query);
2244
2245   $main::lxdebug->leave_sub();
2246 }
2247
2248 sub _get_currencies {
2249 $main::lxdebug->enter_sub();
2250
2251   my ($self, $dbh, $key) = @_;
2252
2253   $key = "all_currencies" unless ($key);
2254
2255   $self->{$key} = [$self->get_all_currencies()];
2256
2257   $main::lxdebug->leave_sub();
2258 }
2259
2260 sub _get_payments {
2261 $main::lxdebug->enter_sub();
2262
2263   my ($self, $dbh, $key) = @_;
2264
2265   $key = "all_payments" unless ($key);
2266
2267   my $query = qq|SELECT * FROM payment_terms ORDER BY sortkey|;
2268
2269   $self->{$key} = selectall_hashref_query($self, $dbh, $query);
2270
2271   $main::lxdebug->leave_sub();
2272 }
2273
2274 sub _get_customers {
2275   $main::lxdebug->enter_sub();
2276
2277   my ($self, $dbh, $key) = @_;
2278
2279   my $options        = ref $key eq 'HASH' ? $key : { key => $key };
2280   $options->{key}  ||= "all_customers";
2281   my $limit_clause   = $options->{limit} ? "LIMIT $options->{limit}" : '';
2282
2283   my @where;
2284   push @where, qq|business_id IN (SELECT id FROM business WHERE salesman)| if  $options->{business_is_salesman};
2285   push @where, qq|NOT obsolete|                                            if !$options->{with_obsolete};
2286   my $where_str = @where ? "WHERE " . join(" AND ", map { "($_)" } @where) : '';
2287
2288   my $query = qq|SELECT * FROM customer $where_str ORDER BY name $limit_clause|;
2289   $self->{ $options->{key} } = selectall_hashref_query($self, $dbh, $query);
2290
2291   $main::lxdebug->leave_sub();
2292 }
2293
2294 sub _get_vendors {
2295   $main::lxdebug->enter_sub();
2296
2297   my ($self, $dbh, $key) = @_;
2298
2299   $key = "all_vendors" unless ($key);
2300
2301   my $query = qq|SELECT * FROM vendor WHERE NOT obsolete ORDER BY name|;
2302
2303   $self->{$key} = selectall_hashref_query($self, $dbh, $query);
2304
2305   $main::lxdebug->leave_sub();
2306 }
2307
2308 sub _get_departments {
2309   $main::lxdebug->enter_sub();
2310
2311   my ($self, $dbh, $key) = @_;
2312
2313   $key = "all_departments" unless ($key);
2314
2315   my $query = qq|SELECT * FROM department ORDER BY description|;
2316
2317   $self->{$key} = selectall_hashref_query($self, $dbh, $query);
2318
2319   $main::lxdebug->leave_sub();
2320 }
2321
2322 sub _get_warehouses {
2323   $main::lxdebug->enter_sub();
2324
2325   my ($self, $dbh, $param) = @_;
2326
2327   my ($key, $bins_key);
2328
2329   if ('' eq ref $param) {
2330     $key = $param;
2331
2332   } else {
2333     $key      = $param->{key};
2334     $bins_key = $param->{bins};
2335   }
2336
2337   my $query = qq|SELECT w.* FROM warehouse w
2338                  WHERE (NOT w.invalid) AND
2339                    ((SELECT COUNT(b.*) FROM bin b WHERE b.warehouse_id = w.id) > 0)
2340                  ORDER BY w.sortkey|;
2341
2342   $self->{$key} = selectall_hashref_query($self, $dbh, $query);
2343
2344   if ($bins_key) {
2345     $query = qq|SELECT id, description FROM bin WHERE warehouse_id = ?
2346                 ORDER BY description|;
2347     my $sth = prepare_query($self, $dbh, $query);
2348
2349     foreach my $warehouse (@{ $self->{$key} }) {
2350       do_statement($self, $sth, $query, $warehouse->{id});
2351       $warehouse->{$bins_key} = [];
2352
2353       while (my $ref = $sth->fetchrow_hashref()) {
2354         push @{ $warehouse->{$bins_key} }, $ref;
2355       }
2356     }
2357     $sth->finish();
2358   }
2359
2360   $main::lxdebug->leave_sub();
2361 }
2362
2363 sub _get_simple {
2364   $main::lxdebug->enter_sub();
2365
2366   my ($self, $dbh, $table, $key, $sortkey) = @_;
2367
2368   my $query  = qq|SELECT * FROM $table|;
2369   $query    .= qq| ORDER BY $sortkey| if ($sortkey);
2370
2371   $self->{$key} = selectall_hashref_query($self, $dbh, $query);
2372
2373   $main::lxdebug->leave_sub();
2374 }
2375
2376 #sub _get_groups {
2377 #  $main::lxdebug->enter_sub();
2378 #
2379 #  my ($self, $dbh, $key) = @_;
2380 #
2381 #  $key ||= "all_groups";
2382 #
2383 #  my $groups = $main::auth->read_groups();
2384 #
2385 #  $self->{$key} = selectall_hashref_query($self, $dbh, $query);
2386 #
2387 #  $main::lxdebug->leave_sub();
2388 #}
2389
2390 sub get_lists {
2391   $main::lxdebug->enter_sub();
2392
2393   my $self = shift;
2394   my %params = @_;
2395
2396   my $dbh = $self->get_standard_dbh(\%main::myconfig);
2397   my ($sth, $query, $ref);
2398
2399   my ($vc, $vc_id);
2400   if ($params{contacts} || $params{shipto}) {
2401     $vc = 'customer' if $self->{"vc"} eq "customer";
2402     $vc = 'vendor'   if $self->{"vc"} eq "vendor";
2403     die "invalid use of get_lists, need 'vc'" unless $vc;
2404     $vc_id = $self->{"${vc}_id"};
2405   }
2406
2407   if ($params{"contacts"}) {
2408     $self->_get_contacts($dbh, $vc_id, $params{"contacts"});
2409   }
2410
2411   if ($params{"shipto"}) {
2412     $self->_get_shipto($dbh, $vc_id, $params{"shipto"});
2413   }
2414
2415   if ($params{"projects"} || $params{"all_projects"}) {
2416     $self->_get_projects($dbh, $params{"all_projects"} ?
2417                          $params{"all_projects"} : $params{"projects"},
2418                          $params{"all_projects"} ? 1 : 0);
2419   }
2420
2421   if ($params{"printers"}) {
2422     $self->_get_printers($dbh, $params{"printers"});
2423   }
2424
2425   if ($params{"languages"}) {
2426     $self->_get_languages($dbh, $params{"languages"});
2427   }
2428
2429   if ($params{"charts"}) {
2430     $self->_get_charts($dbh, $params{"charts"});
2431   }
2432
2433   if ($params{"taxcharts"}) {
2434     $self->_get_taxcharts($dbh, $params{"taxcharts"});
2435   }
2436
2437   if ($params{"taxzones"}) {
2438     $self->_get_taxzones($dbh, $params{"taxzones"});
2439   }
2440
2441   if ($params{"employees"}) {
2442     $self->_get_employees($dbh, $params{"employees"});
2443   }
2444
2445   if ($params{"salesmen"}) {
2446     $self->_get_employees($dbh, $params{"salesmen"});
2447   }
2448
2449   if ($params{"business_types"}) {
2450     $self->_get_business_types($dbh, $params{"business_types"});
2451   }
2452
2453   if ($params{"dunning_configs"}) {
2454     $self->_get_dunning_configs($dbh, $params{"dunning_configs"});
2455   }
2456
2457   if($params{"currencies"}) {
2458     $self->_get_currencies($dbh, $params{"currencies"});
2459   }
2460
2461   if($params{"customers"}) {
2462     $self->_get_customers($dbh, $params{"customers"});
2463   }
2464
2465   if($params{"vendors"}) {
2466     if (ref $params{"vendors"} eq 'HASH') {
2467       $self->_get_vendors($dbh, $params{"vendors"}{key}, $params{"vendors"}{limit});
2468     } else {
2469       $self->_get_vendors($dbh, $params{"vendors"});
2470     }
2471   }
2472
2473   if($params{"payments"}) {
2474     $self->_get_payments($dbh, $params{"payments"});
2475   }
2476
2477   if($params{"departments"}) {
2478     $self->_get_departments($dbh, $params{"departments"});
2479   }
2480
2481   if ($params{price_factors}) {
2482     $self->_get_simple($dbh, 'price_factors', $params{price_factors}, 'sortkey');
2483   }
2484
2485   if ($params{warehouses}) {
2486     $self->_get_warehouses($dbh, $params{warehouses});
2487   }
2488
2489 #  if ($params{groups}) {
2490 #    $self->_get_groups($dbh, $params{groups});
2491 #  }
2492
2493   if ($params{partsgroup}) {
2494     $self->get_partsgroup(\%main::myconfig, { all => 1, target => $params{partsgroup} });
2495   }
2496
2497   $main::lxdebug->leave_sub();
2498 }
2499
2500 # this sub gets the id and name from $table
2501 sub get_name {
2502   $main::lxdebug->enter_sub();
2503
2504   my ($self, $myconfig, $table) = @_;
2505
2506   # connect to database
2507   my $dbh = $self->get_standard_dbh($myconfig);
2508
2509   $table = $table eq "customer" ? "customer" : "vendor";
2510   my $arap = $self->{arap} eq "ar" ? "ar" : "ap";
2511
2512   my ($query, @values);
2513
2514   if (!$self->{openinvoices}) {
2515     my $where;
2516     if ($self->{customernumber} ne "") {
2517       $where = qq|(vc.customernumber ILIKE ?)|;
2518       push(@values, like($self->{customernumber}));
2519     } else {
2520       $where = qq|(vc.name ILIKE ?)|;
2521       push(@values, like($self->{$table}));
2522     }
2523
2524     $query =
2525       qq~SELECT vc.id, vc.name,
2526            vc.street || ' ' || vc.zipcode || ' ' || vc.city || ' ' || vc.country AS address
2527          FROM $table vc
2528          WHERE $where AND (NOT vc.obsolete)
2529          ORDER BY vc.name~;
2530   } else {
2531     $query =
2532       qq~SELECT DISTINCT vc.id, vc.name,
2533            vc.street || ' ' || vc.zipcode || ' ' || vc.city || ' ' || vc.country AS address
2534          FROM $arap a
2535          JOIN $table vc ON (a.${table}_id = vc.id)
2536          WHERE NOT (a.amount = a.paid) AND (vc.name ILIKE ?)
2537          ORDER BY vc.name~;
2538     push(@values, like($self->{$table}));
2539   }
2540
2541   $self->{name_list} = selectall_hashref_query($self, $dbh, $query, @values);
2542
2543   $main::lxdebug->leave_sub();
2544
2545   return scalar(@{ $self->{name_list} });
2546 }
2547
2548 sub new_lastmtime {
2549
2550   my ($self, $table, $provided_dbh) = @_;
2551
2552   my $dbh = $provided_dbh ? $provided_dbh : $self->get_standard_dbh;
2553   return                                       unless $self->{id};
2554   croak ("wrong call, no valid table defined") unless $table =~ /^(oe|ar|ap|delivery_orders|parts)$/;
2555
2556   my $query       = "SELECT mtime, itime FROM " . $table . " WHERE id = ?";
2557   my $ref         = selectfirst_hashref_query($self, $dbh, $query, $self->{id});
2558   $ref->{mtime} ||= $ref->{itime};
2559   $self->{lastmtime} = $ref->{mtime};
2560
2561 }
2562
2563 sub mtime_ischanged {
2564   my ($self, $table, $option) = @_;
2565
2566   return                                       unless $self->{id};
2567   croak ("wrong call, no valid table defined") unless $table =~ /^(oe|ar|ap|delivery_orders|parts)$/;
2568
2569   my $query       = "SELECT mtime, itime FROM " . $table . " WHERE id = ?";
2570   my $ref         = selectfirst_hashref_query($self, $self->get_standard_dbh, $query, $self->{id});
2571   $ref->{mtime} ||= $ref->{itime};
2572
2573   if ($self->{lastmtime} && $self->{lastmtime} ne $ref->{mtime} ) {
2574       $self->error(($option eq 'mail') ?
2575         t8("The document has been changed by another user. No mail was sent. Please reopen it in another window and copy the changes to the new window") :
2576         t8("The document has been changed by another user. Please reopen it in another window and copy the changes to the new window")
2577       );
2578     $::dispatcher->end_request;
2579   }
2580 }
2581
2582 # language_payment duplicates some of the functionality of all_vc (language,
2583 # printer, payment_terms), and at least in the case of sales invoices both
2584 # all_vc and language_payment are called when adding new invoices
2585 sub language_payment {
2586   $main::lxdebug->enter_sub();
2587
2588   my ($self, $myconfig) = @_;
2589
2590   my $dbh = $self->get_standard_dbh($myconfig);
2591   # get languages
2592   my $query = qq|SELECT id, description
2593                  FROM language
2594                  ORDER BY id|;
2595
2596   $self->{languages} = selectall_hashref_query($self, $dbh, $query);
2597
2598   # get printer
2599   $query = qq|SELECT printer_description, id
2600               FROM printers
2601               ORDER BY printer_description|;
2602
2603   $self->{printers} = selectall_hashref_query($self, $dbh, $query);
2604
2605   # get payment terms
2606   $query = qq|SELECT id, description
2607               FROM payment_terms
2608               WHERE ( obsolete IS FALSE OR id = ? )
2609               ORDER BY sortkey |;
2610   $self->{payment_terms} = selectall_hashref_query($self, $dbh, $query, $self->{payment_id} || undef);
2611
2612   # get buchungsgruppen
2613   $query = qq|SELECT id, description
2614               FROM buchungsgruppen|;
2615
2616   $self->{BUCHUNGSGRUPPEN} = selectall_hashref_query($self, $dbh, $query);
2617
2618   $main::lxdebug->leave_sub();
2619 }
2620
2621 # this is only used for reports
2622 sub all_departments {
2623   $main::lxdebug->enter_sub();
2624
2625   my ($self, $myconfig, $table) = @_;
2626
2627   my $dbh = $self->get_standard_dbh($myconfig);
2628
2629   my $query = qq|SELECT id, description
2630                  FROM department
2631                  ORDER BY description|;
2632   $self->{all_departments} = selectall_hashref_query($self, $dbh, $query);
2633
2634   delete($self->{all_departments}) unless (@{ $self->{all_departments} || [] });
2635
2636   $main::lxdebug->leave_sub();
2637 }
2638
2639 sub create_links {
2640   $main::lxdebug->enter_sub();
2641
2642   my ($self, $module, $myconfig, $table, $provided_dbh) = @_;
2643
2644   my ($fld, $arap);
2645   if ($table eq "customer") {
2646     $fld = "buy";
2647     $arap = "ar";
2648   } else {
2649     $table = "vendor";
2650     $fld = "sell";
2651     $arap = "ap";
2652   }
2653
2654   # get last customers or vendors
2655   my ($query, $sth, $ref);
2656
2657   my $dbh = $provided_dbh ? $provided_dbh : $self->get_standard_dbh($myconfig);
2658   my %xkeyref = ();
2659
2660   if (!$self->{id}) {
2661
2662     my $transdate = "current_date";
2663     if ($self->{transdate}) {
2664       $transdate = $dbh->quote($self->{transdate});
2665     }
2666
2667     # now get the account numbers
2668     $query = qq|
2669       SELECT c.accno, c.description, c.link, c.taxkey_id, c.id AS chart_id, tk2.tax_id
2670         FROM chart c
2671         -- find newest entries in taxkeys
2672         INNER JOIN (
2673           SELECT chart_id, MAX(startdate) AS startdate
2674           FROM taxkeys
2675           WHERE (startdate <= $transdate)
2676           GROUP BY chart_id
2677         ) tk ON (c.id = tk.chart_id)
2678         -- and load all of those entries
2679         INNER JOIN taxkeys tk2
2680            ON (tk.chart_id = tk2.chart_id AND tk.startdate = tk2.startdate)
2681        WHERE (c.link LIKE ?)
2682       ORDER BY c.accno|;
2683
2684     $sth = $dbh->prepare($query);
2685
2686     do_statement($self, $sth, $query, like($module));
2687
2688     $self->{accounts} = "";
2689     while ($ref = $sth->fetchrow_hashref("NAME_lc")) {
2690
2691       foreach my $key (split(/:/, $ref->{link})) {
2692         if ($key =~ /\Q$module\E/) {
2693
2694           # cross reference for keys
2695           $xkeyref{ $ref->{accno} } = $key;
2696
2697           push @{ $self->{"${module}_links"}{$key} },
2698             { accno       => $ref->{accno},
2699               chart_id    => $ref->{chart_id},
2700               description => $ref->{description},
2701               taxkey      => $ref->{taxkey_id},
2702               tax_id      => $ref->{tax_id} };
2703
2704           $self->{accounts} .= "$ref->{accno} " unless $key =~ /tax/;
2705         }
2706       }
2707     }
2708   }
2709
2710   # get taxkeys and description
2711   $query = qq|SELECT id, taxkey, taxdescription FROM tax|;
2712   $self->{TAXKEY} = selectall_hashref_query($self, $dbh, $query);
2713
2714   if (($module eq "AP") || ($module eq "AR")) {
2715     # get tax rates and description
2716     $query = qq|SELECT * FROM tax|;
2717     $self->{TAX} = selectall_hashref_query($self, $dbh, $query);
2718   }
2719
2720   my $extra_columns = '';
2721   $extra_columns   .= 'a.direct_debit, ' if ($module eq 'AR') || ($module eq 'AP');
2722
2723   if ($self->{id}) {
2724     $query =
2725       qq|SELECT
2726            a.cp_id, a.invnumber, a.transdate, a.${table}_id, a.datepaid,
2727            a.duedate, a.ordnumber, a.taxincluded, (SELECT cu.name FROM currencies cu WHERE cu.id=a.currency_id) AS currency, a.notes,
2728            a.mtime, a.itime,
2729            a.intnotes, a.department_id, a.amount AS oldinvtotal,
2730            a.paid AS oldtotalpaid, a.employee_id, a.gldate, a.type,
2731            a.globalproject_id, ${extra_columns}
2732            c.name AS $table,
2733            d.description AS department,
2734            e.name AS employee
2735          FROM $arap a
2736          JOIN $table c ON (a.${table}_id = c.id)
2737          LEFT JOIN employee e ON (e.id = a.employee_id)
2738          LEFT JOIN department d ON (d.id = a.department_id)
2739          WHERE a.id = ?|;
2740     $ref = selectfirst_hashref_query($self, $dbh, $query, $self->{id});
2741
2742     foreach my $key (keys %$ref) {
2743       $self->{$key} = $ref->{$key};
2744     }
2745     $self->{mtime}   ||= $self->{itime};
2746     $self->{lastmtime} = $self->{mtime};
2747     my $transdate = "current_date";
2748     if ($self->{transdate}) {
2749       $transdate = $dbh->quote($self->{transdate});
2750     }
2751
2752     # now get the account numbers
2753     $query = qq|SELECT c.accno, c.description, c.link, c.taxkey_id, c.id AS chart_id, tk.tax_id
2754                 FROM chart c
2755                 LEFT JOIN taxkeys tk ON (tk.chart_id = c.id)
2756                 WHERE c.link LIKE ?
2757                   AND (tk.id = (SELECT id FROM taxkeys WHERE taxkeys.chart_id = c.id AND startdate <= $transdate ORDER BY startdate DESC LIMIT 1)
2758                     OR c.link LIKE '%_tax%' OR c.taxkey_id IS NULL)
2759                 ORDER BY c.accno|;
2760
2761     $sth = $dbh->prepare($query);
2762     do_statement($self, $sth, $query, like($module));
2763
2764     $self->{accounts} = "";
2765     while ($ref = $sth->fetchrow_hashref("NAME_lc")) {
2766
2767       foreach my $key (split(/:/, $ref->{link})) {
2768         if ($key =~ /\Q$module\E/) {
2769
2770           # cross reference for keys
2771           $xkeyref{ $ref->{accno} } = $key;
2772
2773           push @{ $self->{"${module}_links"}{$key} },
2774             { accno       => $ref->{accno},
2775               chart_id    => $ref->{chart_id},
2776               description => $ref->{description},
2777               taxkey      => $ref->{taxkey_id},
2778               tax_id      => $ref->{tax_id} };
2779
2780           $self->{accounts} .= "$ref->{accno} " unless $key =~ /tax/;
2781         }
2782       }
2783     }
2784
2785
2786     # get amounts from individual entries
2787     $query =
2788       qq|SELECT
2789            c.accno, c.description,
2790            a.acc_trans_id, a.source, a.amount, a.memo, a.transdate, a.gldate, a.cleared, a.project_id, a.taxkey, a.chart_id,
2791            p.projectnumber,
2792            t.rate, t.id
2793          FROM acc_trans a
2794          LEFT JOIN chart c ON (c.id = a.chart_id)
2795          LEFT JOIN project p ON (p.id = a.project_id)
2796          LEFT JOIN tax t ON (t.id= a.tax_id)
2797          WHERE a.trans_id = ?
2798          AND a.fx_transaction = '0'
2799          ORDER BY a.acc_trans_id, a.transdate|;
2800     $sth = $dbh->prepare($query);
2801     do_statement($self, $sth, $query, $self->{id});
2802
2803     # get exchangerate for currency
2804     $self->{exchangerate} =
2805       $self->get_exchangerate($dbh, $self->{currency}, $self->{transdate}, $fld);
2806     my $index = 0;
2807
2808     # store amounts in {acc_trans}{$key} for multiple accounts
2809     while (my $ref = $sth->fetchrow_hashref("NAME_lc")) {
2810       $ref->{exchangerate} =
2811         $self->get_exchangerate($dbh, $self->{currency}, $ref->{transdate}, $fld);
2812       if (!($xkeyref{ $ref->{accno} } =~ /tax/)) {
2813         $index++;
2814       }
2815       if (($xkeyref{ $ref->{accno} } =~ /paid/) && ($self->{type} eq "credit_note")) {
2816         $ref->{amount} *= -1;
2817       }
2818       $ref->{index} = $index;
2819
2820       push @{ $self->{acc_trans}{ $xkeyref{ $ref->{accno} } } }, $ref;
2821     }
2822
2823     $sth->finish;
2824     #check das:
2825     $query =
2826       qq|SELECT
2827            d.closedto, d.revtrans,
2828            (SELECT cu.name FROM currencies cu WHERE cu.id=d.currency_id) AS defaultcurrency,
2829            (SELECT c.accno FROM chart c WHERE d.fxgain_accno_id = c.id) AS fxgain_accno,
2830            (SELECT c.accno FROM chart c WHERE d.fxloss_accno_id = c.id) AS fxloss_accno,
2831            (SELECT c.accno FROM chart c WHERE d.rndgain_accno_id = c.id) AS rndgain_accno,
2832            (SELECT c.accno FROM chart c WHERE d.rndloss_accno_id = c.id) AS rndloss_accno
2833          FROM defaults d|;
2834     $ref = selectfirst_hashref_query($self, $dbh, $query);
2835     map { $self->{$_} = $ref->{$_} } keys %$ref;
2836
2837   } else {
2838
2839     # get date
2840     $query =
2841        qq|SELECT
2842             current_date AS transdate, d.closedto, d.revtrans,
2843             (SELECT cu.name FROM currencies cu WHERE cu.id=d.currency_id) AS defaultcurrency,
2844             (SELECT c.accno FROM chart c WHERE d.fxgain_accno_id = c.id) AS fxgain_accno,
2845             (SELECT c.accno FROM chart c WHERE d.fxloss_accno_id = c.id) AS fxloss_accno,
2846             (SELECT c.accno FROM chart c WHERE d.rndgain_accno_id = c.id) AS rndgain_accno,
2847             (SELECT c.accno FROM chart c WHERE d.rndloss_accno_id = c.id) AS rndloss_accno
2848           FROM defaults d|;
2849     $ref = selectfirst_hashref_query($self, $dbh, $query);
2850     map { $self->{$_} = $ref->{$_} } keys %$ref;
2851
2852     if ($self->{"$self->{vc}_id"}) {
2853
2854       # only setup currency
2855       ($self->{currency}) = $self->{defaultcurrency} if !$self->{currency};
2856
2857     } else {
2858
2859       $self->lastname_used($dbh, $myconfig, $table, $module);
2860
2861       # get exchangerate for currency
2862       $self->{exchangerate} =
2863         $self->get_exchangerate($dbh, $self->{currency}, $self->{transdate}, $fld);
2864
2865     }
2866
2867   }
2868
2869   $main::lxdebug->leave_sub();
2870 }
2871
2872 sub lastname_used {
2873   $main::lxdebug->enter_sub();
2874
2875   my ($self, $dbh, $myconfig, $table, $module) = @_;
2876
2877   my ($arap, $where);
2878
2879   $table         = $table eq "customer" ? "customer" : "vendor";
2880   my %column_map = ("a.${table}_id"           => "${table}_id",
2881                     "a.department_id"         => "department_id",
2882                     "d.description"           => "department",
2883                     "ct.name"                 => $table,
2884                     "cu.name"                 => "currency",
2885     );
2886
2887   if ($self->{type} =~ /delivery_order/) {
2888     $arap  = 'delivery_orders';
2889     delete $column_map{"cu.currency"};
2890
2891   } elsif ($self->{type} =~ /_order/) {
2892     $arap  = 'oe';
2893     $where = "quotation = '0'";
2894
2895   } elsif ($self->{type} =~ /_quotation/) {
2896     $arap  = 'oe';
2897     $where = "quotation = '1'";
2898
2899   } elsif ($table eq 'customer') {
2900     $arap  = 'ar';
2901
2902   } else {
2903     $arap  = 'ap';
2904
2905   }
2906
2907   $where           = "($where) AND" if ($where);
2908   my $query        = qq|SELECT MAX(id) FROM $arap
2909                         WHERE $where ${table}_id > 0|;
2910   my ($trans_id)   = selectrow_query($self, $dbh, $query);
2911   $trans_id       *= 1;
2912
2913   my $column_spec  = join(', ', map { "${_} AS $column_map{$_}" } keys %column_map);
2914   $query           = qq|SELECT $column_spec
2915                         FROM $arap a
2916                         LEFT JOIN $table     ct ON (a.${table}_id = ct.id)
2917                         LEFT JOIN department d  ON (a.department_id = d.id)
2918                         LEFT JOIN currencies cu ON (cu.id=ct.currency_id)
2919                         WHERE a.id = ?|;
2920   my $ref          = selectfirst_hashref_query($self, $dbh, $query, $trans_id);
2921
2922   map { $self->{$_} = $ref->{$_} } values %column_map;
2923
2924   $main::lxdebug->leave_sub();
2925 }
2926
2927 sub get_variable_content_types {
2928   my %html_variables  = (
2929       longdescription => 'html',
2930       partnotes       => 'html',
2931       notes           => 'html',
2932       orignotes       => 'html',
2933       notes1          => 'html',
2934       notes2          => 'html',
2935       notes3          => 'html',
2936       notes4          => 'html',
2937       header_text     => 'html',
2938       footer_text     => 'html',
2939   );
2940   return \%html_variables;
2941 }
2942
2943 sub current_date {
2944   $main::lxdebug->enter_sub();
2945
2946   my $self     = shift;
2947   my $myconfig = shift || \%::myconfig;
2948   my ($thisdate, $days) = @_;
2949
2950   my $dbh = $self->get_standard_dbh($myconfig);
2951   my $query;
2952
2953   $days *= 1;
2954   if ($thisdate) {
2955     my $dateformat = $myconfig->{dateformat};
2956     $dateformat .= "yy" if $myconfig->{dateformat} !~ /^y/;
2957     $thisdate = $dbh->quote($thisdate);
2958     $query = qq|SELECT to_date($thisdate, '$dateformat') + $days AS thisdate|;
2959   } else {
2960     $query = qq|SELECT current_date AS thisdate|;
2961   }
2962
2963   ($thisdate) = selectrow_query($self, $dbh, $query);
2964
2965   $main::lxdebug->leave_sub();
2966
2967   return $thisdate;
2968 }
2969
2970 sub redo_rows {
2971   $main::lxdebug->enter_sub();
2972
2973   my ($self, $flds, $new, $count, $numrows) = @_;
2974
2975   my @ndx = ();
2976
2977   map { push @ndx, { num => $new->[$_ - 1]->{runningnumber}, ndx => $_ } } 1 .. $count;
2978
2979   my $i = 0;
2980
2981   # fill rows
2982   foreach my $item (sort { $a->{num} <=> $b->{num} } @ndx) {
2983     $i++;
2984     my $j = $item->{ndx} - 1;
2985     map { $self->{"${_}_$i"} = $new->[$j]->{$_} } @{$flds};
2986   }
2987
2988   # delete empty rows
2989   for $i ($count + 1 .. $numrows) {
2990     map { delete $self->{"${_}_$i"} } @{$flds};
2991   }
2992
2993   $main::lxdebug->leave_sub();
2994 }
2995
2996 sub update_status {
2997   $main::lxdebug->enter_sub();
2998
2999   my ($self, $myconfig) = @_;
3000
3001   my ($i, $id);
3002
3003   SL::DB->client->with_transaction(sub {
3004     my $dbh = SL::DB->client->dbh;
3005
3006     my $query = qq|DELETE FROM status
3007                    WHERE (formname = ?) AND (trans_id = ?)|;
3008     my $sth = prepare_query($self, $dbh, $query);
3009
3010     if ($self->{formname} =~ /(check|receipt)/) {
3011       for $i (1 .. $self->{rowcount}) {
3012         do_statement($self, $sth, $query, $self->{formname}, $self->{"id_$i"} * 1);
3013       }
3014     } else {
3015       do_statement($self, $sth, $query, $self->{formname}, $self->{id});
3016     }
3017     $sth->finish();
3018
3019     my $printed = ($self->{printed} =~ /\Q$self->{formname}\E/) ? "1" : "0";
3020     my $emailed = ($self->{emailed} =~ /\Q$self->{formname}\E/) ? "1" : "0";
3021
3022     my %queued = split / /, $self->{queued};
3023     my @values;
3024
3025     if ($self->{formname} =~ /(check|receipt)/) {
3026
3027       # this is a check or receipt, add one entry for each lineitem
3028       my ($accno) = split /--/, $self->{account};
3029       $query = qq|INSERT INTO status (trans_id, printed, spoolfile, formname, chart_id)
3030                   VALUES (?, ?, ?, ?, (SELECT c.id FROM chart c WHERE c.accno = ?))|;
3031       @values = ($printed, $queued{$self->{formname}}, $self->{prinform}, $accno);
3032       $sth = prepare_query($self, $dbh, $query);
3033
3034       for $i (1 .. $self->{rowcount}) {
3035         if ($self->{"checked_$i"}) {
3036           do_statement($self, $sth, $query, $self->{"id_$i"}, @values);
3037         }
3038       }
3039       $sth->finish();
3040
3041     } else {
3042       $query = qq|INSERT INTO status (trans_id, printed, emailed, spoolfile, formname)
3043                   VALUES (?, ?, ?, ?, ?)|;
3044       do_query($self, $dbh, $query, $self->{id}, $printed, $emailed,
3045                $queued{$self->{formname}}, $self->{formname});
3046     }
3047     1;
3048   }) or do { die SL::DB->client->error };
3049
3050   $main::lxdebug->leave_sub();
3051 }
3052
3053 sub save_status {
3054   $main::lxdebug->enter_sub();
3055
3056   my ($self, $dbh) = @_;
3057
3058   my ($query, $printed, $emailed);
3059
3060   my $formnames  = $self->{printed};
3061   my $emailforms = $self->{emailed};
3062
3063   $query = qq|DELETE FROM status
3064                  WHERE (formname = ?) AND (trans_id = ?)|;
3065   do_query($self, $dbh, $query, $self->{formname}, $self->{id});
3066
3067   # this only applies to the forms
3068   # checks and receipts are posted when printed or queued
3069
3070   if ($self->{queued}) {
3071     my %queued = split / /, $self->{queued};
3072
3073     foreach my $formname (keys %queued) {
3074       $printed = ($self->{printed} =~ /\Q$self->{formname}\E/) ? "1" : "0";
3075       $emailed = ($self->{emailed} =~ /\Q$self->{formname}\E/) ? "1" : "0";
3076
3077       $query = qq|INSERT INTO status (trans_id, printed, emailed, spoolfile, formname)
3078                   VALUES (?, ?, ?, ?, ?)|;
3079       do_query($self, $dbh, $query, $self->{id}, $printed, $emailed, $queued{$formname}, $formname);
3080
3081       $formnames  =~ s/\Q$self->{formname}\E//;
3082       $emailforms =~ s/\Q$self->{formname}\E//;
3083
3084     }
3085   }
3086
3087   # save printed, emailed info
3088   $formnames  =~ s/^ +//g;
3089   $emailforms =~ s/^ +//g;
3090
3091   my %status = ();
3092   map { $status{$_}{printed} = 1 } split / +/, $formnames;
3093   map { $status{$_}{emailed} = 1 } split / +/, $emailforms;
3094
3095   foreach my $formname (keys %status) {
3096     $printed = ($formnames  =~ /\Q$self->{formname}\E/) ? "1" : "0";
3097     $emailed = ($emailforms =~ /\Q$self->{formname}\E/) ? "1" : "0";
3098
3099     $query = qq|INSERT INTO status (trans_id, printed, emailed, formname)
3100                 VALUES (?, ?, ?, ?)|;
3101     do_query($self, $dbh, $query, $self->{id}, $printed, $emailed, $formname);
3102   }
3103
3104   $main::lxdebug->leave_sub();
3105 }
3106
3107 #--- 4 locale ---#
3108 # $main::locale->text('SAVED')
3109 # $main::locale->text('SCREENED')
3110 # $main::locale->text('DELETED')
3111 # $main::locale->text('ADDED')
3112 # $main::locale->text('PAYMENT POSTED')
3113 # $main::locale->text('POSTED')
3114 # $main::locale->text('POSTED AS NEW')
3115 # $main::locale->text('ELSE')
3116 # $main::locale->text('SAVED FOR DUNNING')
3117 # $main::locale->text('DUNNING STARTED')
3118 # $main::locale->text('PRINTED')
3119 # $main::locale->text('MAILED')
3120 # $main::locale->text('SCREENED')
3121 # $main::locale->text('CANCELED')
3122 # $main::locale->text('IMPORT')
3123 # $main::locale->text('UNIMPORT')
3124 # $main::locale->text('invoice')
3125 # $main::locale->text('proforma')
3126 # $main::locale->text('sales_order')
3127 # $main::locale->text('pick_list')
3128 # $main::locale->text('purchase_order')
3129 # $main::locale->text('bin_list')
3130 # $main::locale->text('sales_quotation')
3131 # $main::locale->text('request_quotation')
3132
3133 sub save_history {
3134   $main::lxdebug->enter_sub();
3135
3136   my $self = shift;
3137   my $dbh  = shift || SL::DB->client->dbh;
3138   SL::DB->client->with_transaction(sub {
3139
3140     if(!exists $self->{employee_id}) {
3141       &get_employee($self, $dbh);
3142     }
3143
3144     my $query =
3145      qq|INSERT INTO history_erp (trans_id, employee_id, addition, what_done, snumbers) | .
3146      qq|VALUES (?, (SELECT id FROM employee WHERE login = ?), ?, ?, ?)|;
3147     my @values = (conv_i($self->{id}), $self->{login},
3148                   $self->{addition}, $self->{what_done}, "$self->{snumbers}");
3149     do_query($self, $dbh, $query, @values);
3150     1;
3151   }) or do { die SL::DB->client->error };
3152
3153   $main::lxdebug->leave_sub();
3154 }
3155
3156 sub get_history {
3157   $main::lxdebug->enter_sub();
3158
3159   my ($self, $dbh, $trans_id, $restriction, $order) = @_;
3160   my ($orderBy, $desc) = split(/\-\-/, $order);
3161   $order = " ORDER BY " . ($order eq "" ? " h.itime " : ($desc == 1 ? $orderBy . " DESC " : $orderBy . " "));
3162   my @tempArray;
3163   my $i = 0;
3164   if ($trans_id ne "") {
3165     my $query =
3166       qq|SELECT h.employee_id, h.itime::timestamp(0) AS itime, h.addition, h.what_done, emp.name, h.snumbers, h.trans_id AS id | .
3167       qq|FROM history_erp h | .
3168       qq|LEFT JOIN employee emp ON (emp.id = h.employee_id) | .
3169       qq|WHERE (trans_id = | . $trans_id . qq|) $restriction | .
3170       $order;
3171
3172     my $sth = $dbh->prepare($query) || $self->dberror($query);
3173
3174     $sth->execute() || $self->dberror("$query");
3175
3176     while(my $hash_ref = $sth->fetchrow_hashref()) {
3177       $hash_ref->{addition} = $main::locale->text($hash_ref->{addition});
3178       $hash_ref->{what_done} = $main::locale->text($hash_ref->{what_done});
3179       my ( $what, $number ) = split /_/, $hash_ref->{snumbers};
3180       $hash_ref->{snumbers} = $number;
3181       $hash_ref->{haslink}  = 'controller.pl?action=EmailJournal/show&id='.$number if $what eq 'emailjournal';
3182       $hash_ref->{snumbers} = $main::locale->text("E-Mail").' '.$number if $what eq 'emailjournal';
3183       $tempArray[$i++] = $hash_ref;
3184     }
3185     $main::lxdebug->leave_sub() and return \@tempArray
3186       if ($i > 0 && $tempArray[0] ne "");
3187   }
3188   $main::lxdebug->leave_sub();
3189   return 0;
3190 }
3191
3192 sub get_partsgroup {
3193   $main::lxdebug->enter_sub();
3194
3195   my ($self, $myconfig, $p) = @_;
3196   my $target = $p->{target} || 'all_partsgroup';
3197
3198   my $dbh = $self->get_standard_dbh($myconfig);
3199
3200   my $query = qq|SELECT DISTINCT pg.id, pg.partsgroup
3201                  FROM partsgroup pg
3202                  JOIN parts p ON (p.partsgroup_id = pg.id) |;
3203   my @values;
3204
3205   if ($p->{searchitems} eq 'part') {
3206     $query .= qq|WHERE p.part_type = 'part'|;
3207   }
3208   if ($p->{searchitems} eq 'service') {
3209     $query .= qq|WHERE p.part_type = 'service'|;
3210   }
3211   if ($p->{searchitems} eq 'assembly') {
3212     $query .= qq|WHERE p.part_type = 'assembly'|;
3213   }
3214
3215   $query .= qq|ORDER BY partsgroup|;
3216
3217   if ($p->{all}) {
3218     $query = qq|SELECT id, partsgroup FROM partsgroup
3219                 ORDER BY partsgroup|;
3220   }
3221
3222   if ($p->{language_code}) {
3223     $query = qq|SELECT DISTINCT pg.id, pg.partsgroup,
3224                   t.description AS translation
3225                 FROM partsgroup pg
3226                 JOIN parts p ON (p.partsgroup_id = pg.id)
3227                 LEFT JOIN translation t ON ((t.trans_id = pg.id) AND (t.language_code = ?))
3228                 ORDER BY translation|;
3229     @values = ($p->{language_code});
3230   }
3231
3232   $self->{$target} = selectall_hashref_query($self, $dbh, $query, @values);
3233
3234   $main::lxdebug->leave_sub();
3235 }
3236
3237 sub get_pricegroup {
3238   $main::lxdebug->enter_sub();
3239
3240   my ($self, $myconfig, $p) = @_;
3241
3242   my $dbh = $self->get_standard_dbh($myconfig);
3243
3244   my $query = qq|SELECT p.id, p.pricegroup
3245                  FROM pricegroup p|;
3246
3247   $query .= qq| ORDER BY pricegroup|;
3248
3249   if ($p->{all}) {
3250     $query = qq|SELECT id, pricegroup FROM pricegroup
3251                 ORDER BY pricegroup|;
3252   }
3253
3254   $self->{all_pricegroup} = selectall_hashref_query($self, $dbh, $query);
3255
3256   $main::lxdebug->leave_sub();
3257 }
3258
3259 sub all_years {
3260 # usage $form->all_years($myconfig, [$dbh])
3261 # return list of all years where bookings found
3262 # (@all_years)
3263
3264   $main::lxdebug->enter_sub();
3265
3266   my ($self, $myconfig, $dbh) = @_;
3267
3268   $dbh ||= $self->get_standard_dbh($myconfig);
3269
3270   # get years
3271   my $query = qq|SELECT (SELECT MIN(transdate) FROM acc_trans),
3272                    (SELECT MAX(transdate) FROM acc_trans)|;
3273   my ($startdate, $enddate) = selectrow_query($self, $dbh, $query);
3274
3275   if ($myconfig->{dateformat} =~ /^yy/) {
3276     ($startdate) = split /\W/, $startdate;
3277     ($enddate) = split /\W/, $enddate;
3278   } else {
3279     (@_) = split /\W/, $startdate;
3280     $startdate = $_[2];
3281     (@_) = split /\W/, $enddate;
3282     $enddate = $_[2];
3283   }
3284
3285   my @all_years;
3286   $startdate = substr($startdate,0,4);
3287   $enddate = substr($enddate,0,4);
3288
3289   while ($enddate >= $startdate) {
3290     push @all_years, $enddate--;
3291   }
3292
3293   return @all_years;
3294
3295   $main::lxdebug->leave_sub();
3296 }
3297
3298 sub backup_vars {
3299   $main::lxdebug->enter_sub();
3300   my $self = shift;
3301   my @vars = @_;
3302
3303   map { $self->{_VAR_BACKUP}->{$_} = $self->{$_} if exists $self->{$_} } @vars;
3304
3305   $main::lxdebug->leave_sub();
3306 }
3307
3308 sub restore_vars {
3309   $main::lxdebug->enter_sub();
3310
3311   my $self = shift;
3312   my @vars = @_;
3313
3314   map { $self->{$_} = $self->{_VAR_BACKUP}->{$_} if exists $self->{_VAR_BACKUP}->{$_} } @vars;
3315
3316   $main::lxdebug->leave_sub();
3317 }
3318
3319 sub prepare_for_printing {
3320   my ($self) = @_;
3321
3322   my $defaults         = SL::DB::Default->get;
3323
3324   $self->{templates} ||= $defaults->templates;
3325   $self->{formname}  ||= $self->{type};
3326   $self->{media}     ||= 'email';
3327
3328   die "'media' other than 'email', 'file', 'printer' is not supported yet" unless $self->{media} =~ m/^(?:email|file|printer)$/;
3329
3330   # Several fields that used to reside in %::myconfig (stored in
3331   # auth.user_config) are now stored in defaults. Copy them over for
3332   # compatibility.
3333   $self->{$_} = $defaults->$_ for qw(company address taxnumber co_ustid duns sepa_creditor_id);
3334
3335   $self->{"myconfig_${_}"} = $::myconfig{$_} for grep { $_ ne 'dbpasswd' } keys %::myconfig;
3336
3337   if (!$self->{employee_id}) {
3338     $self->{"employee_${_}"} = $::myconfig{$_} for qw(email tel fax name signature);
3339     $self->{"employee_${_}"} = $defaults->$_   for qw(address businessnumber co_ustid company duns sepa_creditor_id taxnumber);
3340   }
3341
3342   # Load shipping address from database. If shipto_id is set then it's
3343   # one from the customer's/vendor's master data. Otherwise look an a
3344   # customized address linking back to the current record.
3345   my $shipto_module = $self->{type} =~ /_delivery_order$/                                             ? 'DO'
3346                     : $self->{type} =~ /sales_order|sales_quotation|request_quotation|purchase_order/ ? 'OE'
3347                     :                                                                                   'AR';
3348   my $shipto        = $self->{shipto_id} ? SL::DB::Shipto->new(shipto_id => $self->{shipto_id})->load
3349                     :                      SL::DB::Manager::Shipto->get_first(where => [ module => $shipto_module, trans_id => $self->{id} ]);
3350   if ($shipto) {
3351     $self->{$_} = $shipto->$_ for grep { m{^shipto} } map { $_->name } @{ $shipto->meta->columns };
3352     $self->{"shiptocvar_" . $_->config->name} = $_->value_as_text for @{ $shipto->cvars_by_config };
3353   }
3354
3355   my $language = $self->{language} ? '_' . $self->{language} : '';
3356
3357   my ($language_tc, $output_numberformat, $output_dateformat, $output_longdates);
3358   if ($self->{language_id}) {
3359     ($language_tc, $output_numberformat, $output_dateformat, $output_longdates) = AM->get_language_details(\%::myconfig, $self, $self->{language_id});
3360   }
3361
3362   $output_dateformat   ||= $::myconfig{dateformat};
3363   $output_numberformat ||= $::myconfig{numberformat};
3364   $output_longdates    //= 1;
3365
3366   $self->{myconfig_output_dateformat}   = $output_dateformat   // $::myconfig{dateformat};
3367   $self->{myconfig_output_longdates}    = $output_longdates    // 1;
3368   $self->{myconfig_output_numberformat} = $output_numberformat // $::myconfig{numberformat};
3369
3370   # Retrieve accounts for tax calculation.
3371   IC->retrieve_accounts(\%::myconfig, $self, map { $_ => $self->{"id_$_"} } 1 .. $self->{rowcount});
3372
3373   if ($self->{type} =~ /_delivery_order$/) {
3374     DO->order_details(\%::myconfig, $self);
3375   } elsif ($self->{type} =~ /sales_order|sales_quotation|request_quotation|purchase_order/) {
3376     OE->order_details(\%::myconfig, $self);
3377   } else {
3378     IS->invoice_details(\%::myconfig, $self, $::locale);
3379   }
3380
3381   # Chose extension & set source file name
3382   my $extension = 'html';
3383   if ($self->{format} eq 'postscript') {
3384     $self->{postscript}   = 1;
3385     $extension            = 'tex';
3386   } elsif ($self->{"format"} =~ /pdf/) {
3387     $self->{pdf}          = 1;
3388     $extension            = $self->{'format'} =~ m/opendocument/i ? 'odt' : 'tex';
3389   } elsif ($self->{"format"} =~ /opendocument/) {
3390     $self->{opendocument} = 1;
3391     $extension            = 'odt';
3392   } elsif ($self->{"format"} =~ /excel/) {
3393     $self->{excel}        = 1;
3394     $extension            = 'xls';
3395   }
3396
3397   my $printer_code    = $self->{printer_code} ? '_' . $self->{printer_code} : '';
3398   my $email_extension = $self->{media} eq 'email' && -f ($defaults->templates . "/$self->{formname}_email${language}.${extension}") ? '_email' : '';
3399   $self->{IN}         = "$self->{formname}${email_extension}${language}${printer_code}.${extension}";
3400
3401   # Format dates.
3402   $self->format_dates($output_dateformat, $output_longdates,
3403                       qw(invdate orddate quodate pldate duedate reqdate transdate shippingdate deliverydate validitydate paymentdate datepaid
3404                          transdate_oe deliverydate_oe employee_startdate employee_enddate),
3405                       grep({ /^(?:datepaid|transdate_oe|reqdate|deliverydate|deliverydate_oe|transdate)_\d+$/ } keys(%{$self})));
3406
3407   $self->reformat_numbers($output_numberformat, 2,
3408                           qw(invtotal ordtotal quototal subtotal linetotal listprice sellprice netprice discount tax taxbase total paid),
3409                           grep({ /^(?:linetotal|listprice|sellprice|netprice|taxbase|discount|paid|subtotal|total|tax)_\d+$/ } keys(%{$self})));
3410
3411   $self->reformat_numbers($output_numberformat, undef, qw(qty price_factor), grep({ /^qty_\d+$/} keys(%{$self})));
3412
3413   my ($cvar_date_fields, $cvar_number_fields) = CVar->get_field_format_list('module' => 'CT', 'prefix' => 'vc_');
3414
3415   if (scalar @{ $cvar_date_fields }) {
3416     $self->format_dates($output_dateformat, $output_longdates, @{ $cvar_date_fields });
3417   }
3418
3419   while (my ($precision, $field_list) = each %{ $cvar_number_fields }) {
3420     $self->reformat_numbers($output_numberformat, $precision, @{ $field_list });
3421   }
3422
3423   # Translate units
3424   if (($self->{language} // '') ne '') {
3425     my $template_arrays = $self->{TEMPLATE_ARRAYS} || $self;
3426     for my $idx (0..scalar(@{ $template_arrays->{unit} }) - 1) {
3427       $template_arrays->{unit}->[$idx] = AM->translate_units($self, $self->{language}, $template_arrays->{unit}->[$idx], $template_arrays->{qty}->[$idx])
3428     }
3429   }
3430
3431   $self->{template_meta} = {
3432     formname  => $self->{formname},
3433     language  => SL::DB::Manager::Language->find_by_or_create(id => $self->{language_id} || undef),
3434     format    => $self->{format},
3435     media     => $self->{media},
3436     extension => $extension,
3437     printer   => SL::DB::Manager::Printer->find_by_or_create(id => $self->{printer_id} || undef),
3438     today     => DateTime->today,
3439   };
3440
3441   return $self;
3442 }
3443
3444 sub calculate_arap {
3445   my ($self,$buysell,$taxincluded,$exchangerate,$roundplaces) = @_;
3446
3447   # this function is used to calculate netamount, total_tax and amount for AP and
3448   # AR transactions (Kreditoren-/Debitorenbuchungen) by going over all lines
3449   # (1..$rowcount)
3450   # Thus it needs a fully prepared $form to work on.
3451   # calculate_arap assumes $form->{amount_$i} entries still need to be parsed
3452
3453   # The calculated total values are all rounded (default is to 2 places) and
3454   # returned as parameters rather than directly modifying form.  The aim is to
3455   # make the calculation of AP and AR behave identically.  There is a test-case
3456   # for this function in t/form/arap.t
3457
3458   # While calculating the totals $form->{amount_$i} and $form->{tax_$i} are
3459   # modified and formatted and receive the correct sign for writing straight to
3460   # acc_trans, depending on whether they are ar or ap.
3461
3462   # check parameters
3463   die "taxincluded needed in Form->calculate_arap" unless defined $taxincluded;
3464   die "exchangerate needed in Form->calculate_arap" unless defined $exchangerate;
3465   die 'illegal buysell parameter, has to be \"buy\" or \"sell\" in Form->calculate_arap\n' unless $buysell =~ /^(buy|sell)$/;
3466   $roundplaces = 2 unless $roundplaces;
3467
3468   my $sign = 1;  # adjust final results for writing amount to acc_trans
3469   $sign = -1 if $buysell eq 'buy';
3470
3471   my ($netamount,$total_tax,$amount);
3472
3473   my $tax;
3474
3475   # parse and round amounts, setting correct sign for writing to acc_trans
3476   for my $i (1 .. $self->{rowcount}) {
3477     $self->{"amount_$i"} = $self->round_amount($self->parse_amount(\%::myconfig, $self->{"amount_$i"}) * $exchangerate * $sign, $roundplaces);
3478
3479     $amount += $self->{"amount_$i"} * $sign;
3480   }
3481
3482   for my $i (1 .. $self->{rowcount}) {
3483     next unless $self->{"amount_$i"};
3484     ($self->{"tax_id_$i"}) = split /--/, $self->{"taxchart_$i"};
3485     my $tax_id = $self->{"tax_id_$i"};
3486
3487     my $selected_tax = SL::DB::Manager::Tax->find_by(id => "$tax_id");
3488
3489     if ( $selected_tax ) {
3490
3491       if ( $buysell eq 'sell' ) {
3492         $self->{AR_amounts}{"tax_$i"} = $selected_tax->chart->accno if defined $selected_tax->chart;
3493       } else {
3494         $self->{AP_amounts}{"tax_$i"} = $selected_tax->chart->accno if defined $selected_tax->chart;
3495       };
3496
3497       $self->{"taxkey_$i"} = $selected_tax->taxkey;
3498       $self->{"taxrate_$i"} = $selected_tax->rate;
3499     };
3500
3501     ($self->{"amount_$i"}, $self->{"tax_$i"}) = $self->calculate_tax($self->{"amount_$i"},$self->{"taxrate_$i"},$taxincluded,$roundplaces);
3502
3503     $netamount  += $self->{"amount_$i"};
3504     $total_tax  += $self->{"tax_$i"};
3505
3506   }
3507   $amount = $netamount + $total_tax;
3508
3509   # due to $sign amount_$i und tax_$i already have the right sign for acc_trans
3510   # but reverse sign of totals for writing amounts to ar
3511   if ( $buysell eq 'buy' ) {
3512     $netamount *= -1;
3513     $amount    *= -1;
3514     $total_tax *= -1;
3515   };
3516
3517   return($netamount,$total_tax,$amount);
3518 }
3519
3520 sub format_dates {
3521   my ($self, $dateformat, $longformat, @indices) = @_;
3522
3523   $dateformat ||= $::myconfig{dateformat};
3524
3525   foreach my $idx (@indices) {
3526     if ($self->{TEMPLATE_ARRAYS} && (ref($self->{TEMPLATE_ARRAYS}->{$idx}) eq "ARRAY")) {
3527       for (my $i = 0; $i < scalar(@{ $self->{TEMPLATE_ARRAYS}->{$idx} }); $i++) {
3528         $self->{TEMPLATE_ARRAYS}->{$idx}->[$i] = $::locale->reformat_date(\%::myconfig, $self->{TEMPLATE_ARRAYS}->{$idx}->[$i], $dateformat, $longformat);
3529       }
3530     }
3531
3532     next unless defined $self->{$idx};
3533
3534     if (!ref($self->{$idx})) {
3535       $self->{$idx} = $::locale->reformat_date(\%::myconfig, $self->{$idx}, $dateformat, $longformat);
3536
3537     } elsif (ref($self->{$idx}) eq "ARRAY") {
3538       for (my $i = 0; $i < scalar(@{ $self->{$idx} }); $i++) {
3539         $self->{$idx}->[$i] = $::locale->reformat_date(\%::myconfig, $self->{$idx}->[$i], $dateformat, $longformat);
3540       }
3541     }
3542   }
3543 }
3544
3545 sub reformat_numbers {
3546   my ($self, $numberformat, $places, @indices) = @_;
3547
3548   return if !$numberformat || ($numberformat eq $::myconfig{numberformat});
3549
3550   foreach my $idx (@indices) {
3551     if ($self->{TEMPLATE_ARRAYS} && (ref($self->{TEMPLATE_ARRAYS}->{$idx}) eq "ARRAY")) {
3552       for (my $i = 0; $i < scalar(@{ $self->{TEMPLATE_ARRAYS}->{$idx} }); $i++) {
3553         $self->{TEMPLATE_ARRAYS}->{$idx}->[$i] = $self->parse_amount(\%::myconfig, $self->{TEMPLATE_ARRAYS}->{$idx}->[$i]);
3554       }
3555     }
3556
3557     next unless defined $self->{$idx};
3558
3559     if (!ref($self->{$idx})) {
3560       $self->{$idx} = $self->parse_amount(\%::myconfig, $self->{$idx});
3561
3562     } elsif (ref($self->{$idx}) eq "ARRAY") {
3563       for (my $i = 0; $i < scalar(@{ $self->{$idx} }); $i++) {
3564         $self->{$idx}->[$i] = $self->parse_amount(\%::myconfig, $self->{$idx}->[$i]);
3565       }
3566     }
3567   }
3568
3569   my $saved_numberformat    = $::myconfig{numberformat};
3570   $::myconfig{numberformat} = $numberformat;
3571
3572   foreach my $idx (@indices) {
3573     if ($self->{TEMPLATE_ARRAYS} && (ref($self->{TEMPLATE_ARRAYS}->{$idx}) eq "ARRAY")) {
3574       for (my $i = 0; $i < scalar(@{ $self->{TEMPLATE_ARRAYS}->{$idx} }); $i++) {
3575         $self->{TEMPLATE_ARRAYS}->{$idx}->[$i] = $self->format_amount(\%::myconfig, $self->{TEMPLATE_ARRAYS}->{$idx}->[$i], $places);
3576       }
3577     }
3578
3579     next unless defined $self->{$idx};
3580
3581     if (!ref($self->{$idx})) {
3582       $self->{$idx} = $self->format_amount(\%::myconfig, $self->{$idx}, $places);
3583
3584     } elsif (ref($self->{$idx}) eq "ARRAY") {
3585       for (my $i = 0; $i < scalar(@{ $self->{$idx} }); $i++) {
3586         $self->{$idx}->[$i] = $self->format_amount(\%::myconfig, $self->{$idx}->[$i], $places);
3587       }
3588     }
3589   }
3590
3591   $::myconfig{numberformat} = $saved_numberformat;
3592 }
3593
3594 sub create_email_signature {
3595
3596   my $client_signature = $::instance_conf->get_signature;
3597   my $user_signature   = $::myconfig{signature};
3598
3599   my $signature = '';
3600   if ( $client_signature or $user_signature ) {
3601     $signature  = "\n\n-- \n";
3602     $signature .= $user_signature   . "\n" if $user_signature;
3603     $signature .= $client_signature . "\n" if $client_signature;
3604   };
3605   return $signature;
3606
3607 };
3608
3609 sub calculate_tax {
3610   # this function calculates the net amount and tax for the lines in ar, ap and
3611   # gl and is used for update as well as post. When used with update the return
3612   # value of amount isn't needed
3613
3614   # calculate_tax should always work with positive values, or rather as the user inputs them
3615   # calculate_tax uses db/perl numberformat, i.e. parsed numbers
3616   # convert to negative numbers (when necessary) only when writing to acc_trans
3617   # the amount from $form for ap/ar/gl is currently always rounded to 2 decimals before it reaches here
3618   # for post_transaction amount already contains exchangerate and correct sign and is rounded
3619   # calculate_tax doesn't (need to) know anything about exchangerate
3620
3621   my ($self,$amount,$taxrate,$taxincluded,$roundplaces) = @_;
3622
3623   $roundplaces //= 2;
3624   $taxincluded //= 0;
3625
3626   my $tax;
3627
3628   if ($taxincluded) {
3629     # calculate tax (unrounded), subtract from amount, round amount and round tax
3630     $tax       = $amount - ($amount / ($taxrate + 1)); # equivalent to: taxrate * amount / (taxrate + 1)
3631     $amount    = $self->round_amount($amount - $tax, $roundplaces);
3632     $tax       = $self->round_amount($tax, $roundplaces);
3633   } else {
3634     $tax       = $amount * $taxrate;
3635     $tax       = $self->round_amount($tax, $roundplaces);
3636   }
3637
3638   $tax = 0 unless $tax;
3639
3640   return ($amount,$tax);
3641 };
3642
3643 1;
3644
3645 __END__
3646
3647 =head1 NAME
3648
3649 SL::Form.pm - main data object.
3650
3651 =head1 SYNOPSIS
3652
3653 This is the main data object of kivitendo.
3654 Unfortunately it also acts as a god object for certain data retrieval procedures used in the entry points.
3655 Points of interest for a beginner are:
3656
3657  - $form->error            - renders a generic error in html. accepts an error message
3658  - $form->get_standard_dbh - returns a database connection for the
3659
3660 =head1 SPECIAL FUNCTIONS
3661
3662 =head2 C<redirect_header> $url
3663
3664 Generates a HTTP redirection header for the new C<$url>. Constructs an
3665 absolute URL including scheme, host name and port. If C<$url> is a
3666 relative URL then it is considered relative to kivitendo base URL.
3667
3668 This function C<die>s if headers have already been created with
3669 C<$::form-E<gt>header>.
3670
3671 Examples:
3672
3673   print $::form->redirect_header('oe.pl?action=edit&id=1234');
3674   print $::form->redirect_header('http://www.lx-office.org/');
3675
3676 =head2 C<header>
3677
3678 Generates a general purpose http/html header and includes most of the scripts
3679 and stylesheets needed. Stylesheets can be added with L<use_stylesheet>.
3680
3681 Only one header will be generated. If the method was already called in this
3682 request it will not output anything and return undef. Also if no
3683 HTTP_USER_AGENT is found, no header is generated.
3684
3685 Although header does not accept parameters itself, it will honor special
3686 hashkeys of its Form instance:
3687
3688 =over 4
3689
3690 =item refresh_time
3691
3692 =item refresh_url
3693
3694 If one of these is set, a http-equiv refresh is generated. Missing parameters
3695 default to 3 seconds and the refering url.
3696
3697 =item stylesheet
3698
3699 Either a scalar or an array ref. Will be inlined into the header. Add
3700 stylesheets with the L<use_stylesheet> function.
3701
3702 =item landscape
3703
3704 If true, a css snippet will be generated that sets the page in landscape mode.
3705
3706 =item favicon
3707
3708 Used to override the default favicon.
3709
3710 =item title
3711
3712 A html page title will be generated from this
3713
3714 =item mtime_ischanged
3715
3716 Tries to avoid concurrent write operations to records by checking the database mtime with a fetched one.
3717
3718 Can be used / called with any table, that has itime and mtime attributes.
3719 Valid C<table> names are: oe, ar, ap, delivery_orders, parts.
3720 Can be called wit C<option> mail to generate a different error message.
3721
3722 Returns undef if no save operation has been done yet ($self->{id} not present).
3723 Returns undef if no concurrent write process is detected otherwise a error message.
3724
3725 =back
3726
3727 =cut