SL/Controller/Order.pm

   1 package SL::Controller::Order;
   2
   3 use strict;
   4 use parent qw(SL::Controller::Base);
   5
   6 use SL::Helper::Flash qw(flash_later);
   7 use SL::Presenter::Tag qw(select_tag hidden_tag);
   8 use SL::Locale::String qw(t8);
   9 use SL::SessionFile::Random;
  10 use SL::PriceSource;
  11 use SL::Webdav;
  12 use SL::File;
  13 use SL::Util qw(trim);
  14 use SL::DB::Order;
  15 use SL::DB::Default;
  16 use SL::DB::Unit;
  17 use SL::DB::Part;
  18 use SL::DB::Printer;
  19 use SL::DB::Language;
  20 use SL::DB::RecordLink;
  21
  22 use SL::Helper::CreatePDF qw(:all);
  23 use SL::Helper::PrintOptions;
  24
  25 use SL::Controller::Helper::GetModels;
  26
  27 use List::Util qw(first);
  28 use List::UtilsBy qw(sort_by uniq_by);
  29 use List::MoreUtils qw(any none pairwise first_index);
  30 use English qw(-no_match_vars);
  31 use File::Spec;
  32 use Cwd;
  33
  34 use Rose::Object::MakeMethods::Generic
  35 (
  36  scalar => [ qw(item_ids_to_delete) ],
  37  'scalar --get_set_init' => [ qw(order valid_types type cv p multi_items_models all_price_factors) ],
  38 );
  39
  40
  41 # safety
  42 __PACKAGE__->run_before('check_auth');
  43
  44 __PACKAGE__->run_before('recalc',
  45                         only => [ qw(save save_as_new save_and_delivery_order save_and_invoice print create_pdf send_email) ]);
  46
  47 __PACKAGE__->run_before('get_unalterable_data',
  48                         only => [ qw(save save_as_new save_and_delivery_order save_and_invoice print create_pdf send_email) ]);
  49
  50 #
  51 # actions
  52 #
  53
  54 # add a new order
  55 sub action_add {
  56   my ($self) = @_;
  57
  58   $self->order->transdate(DateTime->now_local());
  59   my $extra_days = $self->type eq sales_quotation_type() ? $::instance_conf->get_reqdate_interval : 1;
  60   $self->order->reqdate(DateTime->today_local->next_workday(extra_days => $extra_days)) if !$self->order->reqdate;
  61
  62   $self->pre_render();
  63   $self->render(
  64     'order/form',
  65     title => $self->get_title_for('add'),
  66     %{$self->{template_args}}
  67   );
  68 }
  69
  70 # edit an existing order
  71 sub action_edit {
  72   my ($self) = @_;
  73
  74   $self->load_order;
  75   $self->recalc();
  76   $self->pre_render();
  77   $self->render(
  78     'order/form',
  79     title => $self->get_title_for('edit'),
  80     %{$self->{template_args}}
  81   );
  82 }
  83
  84 # delete the order
  85 sub action_delete {
  86   my ($self) = @_;
  87
  88   my $errors = $self->delete();
  89
  90   if (scalar @{ $errors }) {
  91     $self->js->flash('error', $_) foreach @{ $errors };
  92     return $self->js->render();
  93   }
  94
  95   my $text = $self->type eq sales_order_type()       ? $::locale->text('The order has been deleted')
  96            : $self->type eq purchase_order_type()    ? $::locale->text('The order has been deleted')
  97            : $self->type eq sales_quotation_type()   ? $::locale->text('The quotation has been deleted')
  98            : $self->type eq request_quotation_type() ? $::locale->text('The rfq has been deleted')
  99            : '';
 100   flash_later('info', $text);
 101
 102   my @redirect_params = (
 103     action => 'add',
 104     type   => $self->type,
 105   );
 106
 107   $self->redirect_to(@redirect_params);
 108 }
 109
 110 # save the order
 111 sub action_save {
 112   my ($self) = @_;
 113
 114   my $errors = $self->save();
 115
 116   if (scalar @{ $errors }) {
 117     $self->js->flash('error', $_) foreach @{ $errors };
 118     return $self->js->render();
 119   }
 120
 121   my $text = $self->type eq sales_order_type()       ? $::locale->text('The order has been saved')
 122            : $self->type eq purchase_order_type()    ? $::locale->text('The order has been saved')
 123            : $self->type eq sales_quotation_type()   ? $::locale->text('The quotation has been saved')
 124            : $self->type eq request_quotation_type() ? $::locale->text('The rfq has been saved')
 125            : '';
 126   flash_later('info', $text);
 127
 128   my @redirect_params = (
 129     action => 'edit',
 130     type   => $self->type,
 131     id     => $self->order->id,
 132   );
 133
 134   $self->redirect_to(@redirect_params);
 135 }
 136
 137 # save the order as new document an open it for edit
 138 sub action_save_as_new {
 139   my ($self) = @_;
 140
 141   my $order = $self->order;
 142
 143   if (!$order->id) {
 144     $self->js->flash('error', t8('This object has not been saved yet.'));
 145     return $self->js->render();
 146   }
 147
 148   # load order from db to check if values changed
 149   my $saved_order = SL::DB::Order->new(id => $order->id)->load;
 150
 151   my %new_attrs;
 152   # Lets assign a new number if the user hasn't changed the previous one.
 153   # If it has been changed manually then use it as-is.
 154   $new_attrs{number}    = (trim($order->number) eq $saved_order->number)
 155                         ? ''
 156                         : trim($order->number);
 157
 158   # Clear transdate unless changed
 159   $new_attrs{transdate} = ($order->transdate == $saved_order->transdate)
 160                         ? DateTime->today_local
 161                         : $order->transdate;
 162
 163   # Set new reqdate unless changed
 164   if ($order->reqdate == $saved_order->reqdate) {
 165     my $extra_days = $self->type eq sales_quotation_type() ? $::instance_conf->get_reqdate_interval : 1;
 166     $new_attrs{reqdate} = DateTime->today_local->next_workday(extra_days => $extra_days);
 167   } else {
 168     $new_attrs{reqdate} = $order->reqdate;
 169   }
 170
 171   # Update employee
 172   $new_attrs{employee}  = SL::DB::Manager::Employee->current;
 173
 174   # Create new record from current one
 175   $self->order(SL::DB::Order->new_from($order, destination_type => $order->type, attributes => \%new_attrs));
 176
 177   # no linked records on save as new
 178   delete $::form->{$_} for qw(converted_from_oe_id converted_from_orderitems_ids);
 179
 180   # save
 181   $self->action_save();
 182 }
 183
 184 # print the order
 185 #
 186 # This is called if "print" is pressed in the print dialog.
 187 # If PDF creation was requested and succeeded, the pdf is stored in a session
 188 # file and the filename is stored as session value with an unique key. A
 189 # javascript function with this key is then called. This function calls the
 190 # download action below (action_download_pdf), which offers the file for
 191 # download.
 192 sub action_print {
 193   my ($self) = @_;
 194
 195   my $format      = $::form->{print_options}->{format};
 196   my $media       = $::form->{print_options}->{media};
 197   my $formname    = $::form->{print_options}->{formname};
 198   my $copies      = $::form->{print_options}->{copies};
 199   my $groupitems  = $::form->{print_options}->{groupitems};
 200
 201   # only pdf by now
 202   if (none { $format eq $_ } qw(pdf)) {
 203     return $self->js->flash('error', t8('Format \'#1\' is not supported yet/anymore.', $format))->render;
 204   }
 205
 206   # only screen or printer by now
 207   if (none { $media eq $_ } qw(screen printer)) {
 208     return $self->js->flash('error', t8('Media \'#1\' is not supported yet/anymore.', $media))->render;
 209   }
 210
 211   my $language;
 212   $language = SL::DB::Language->new(id => $::form->{print_options}->{language_id})->load if $::form->{print_options}->{language_id};
 213
 214   # create a form for generate_attachment_filename
 215   my $form   = Form->new;
 216   $form->{$self->nr_key()}  = $self->order->number;
 217   $form->{type}             = $self->type;
 218   $form->{format}           = $format;
 219   $form->{formname}         = $formname;
 220   $form->{language}         = '_' . $language->template_code if $language;
 221   my $pdf_filename          = $form->generate_attachment_filename();
 222
 223   my $pdf;
 224   my @errors = generate_pdf($self->order, \$pdf, { format     => $format,
 225                                                    formname   => $formname,
 226                                                    language   => $language,
 227                                                    groupitems => $groupitems });
 228   if (scalar @errors) {
 229     return $self->js->flash('error', t8('Conversion to PDF failed: #1', $errors[0]))->render;
 230   }
 231
 232   if ($media eq 'screen') {
 233     # screen/download
 234     my $sfile = SL::SessionFile::Random->new(mode => "w");
 235     $sfile->fh->print($pdf);
 236     $sfile->fh->close;
 237
 238     my $key = join('_', Time::HiRes::gettimeofday(), int rand 1000000000000);
 239     $::auth->set_session_value("Order::create_pdf-${key}" => $sfile->file_name);
 240
 241     $self->js
 242     ->run('kivi.Order.download_pdf', $pdf_filename, $key)
 243     ->flash('info', t8('The PDF has been created'));
 244
 245   } elsif ($media eq 'printer') {
 246     # printer
 247     my $printer_id = $::form->{print_options}->{printer_id};
 248     SL::DB::Printer->new(id => $printer_id)->load->print_document(
 249       copies  => $copies,
 250       content => $pdf,
 251     );
 252
 253     $self->js->flash('info', t8('The PDF has been printed'));
 254   }
 255
 256   # copy file to webdav folder
 257   if ($self->order->number && $::instance_conf->get_webdav_documents) {
 258     my $webdav = SL::Webdav->new(
 259       type     => $self->type,
 260       number   => $self->order->number,
 261     );
 262     my $webdav_file = SL::Webdav::File->new(
 263       webdav   => $webdav,
 264       filename => $pdf_filename,
 265     );
 266     eval {
 267       $webdav_file->store(data => \$pdf);
 268       1;
 269     } or do {
 270       $self->js->flash('error', t8('Storing PDF to webdav folder failed: #1', $@));
 271     }
 272   }
 273   if ($self->order->number && $::instance_conf->get_doc_storage) {
 274     eval {
 275       SL::File->save(object_id     => $self->order->id,
 276                      object_type   => $self->type,
 277                      mime_type     => 'application/pdf',
 278                      source        => 'created',
 279                      file_type     => 'document',
 280                      file_name     => $pdf_filename,
 281                      file_contents => $pdf);
 282       1;
 283     } or do {
 284       $self->js->flash('error', t8('Storing PDF in storage backend failed: #1', $@));
 285     }
 286   }
 287   $self->js->render;
 288 }
 289
 290 # offer pdf for download
 291 #
 292 # It needs to get the key for the session value to get the pdf file.
 293 sub action_download_pdf {
 294   my ($self) = @_;
 295
 296   my $key = $::form->{key};
 297   my $tmp_filename = $::auth->get_session_value("Order::create_pdf-${key}");
 298   return $self->send_file(
 299     $tmp_filename,
 300     type => 'application/pdf',
 301     name => $::form->{pdf_filename},
 302   );
 303 }
 304
 305 # open the email dialog
 306 sub action_show_email_dialog {
 307   my ($self) = @_;
 308
 309   my $cv_method = $self->cv;
 310
 311   if (!$self->order->$cv_method) {
 312     return $self->js->flash('error', $self->cv eq 'customer' ? t8('Cannot send E-mail without customer given') : t8('Cannot send E-mail without vendor given'))
 313                     ->render($self);
 314   }
 315
 316   my $email_form;
 317   $email_form->{to}   = $self->order->contact->cp_email if $self->order->contact;
 318   $email_form->{to} ||= $self->order->$cv_method->email;
 319   $email_form->{cc}   = $self->order->$cv_method->cc;
 320   $email_form->{bcc}  = join ', ', grep $_, $self->order->$cv_method->bcc, SL::DB::Default->get->global_bcc;
 321   # Todo: get addresses from shipto, if any
 322
 323   my $form = Form->new;
 324   $form->{$self->nr_key()}  = $self->order->number;
 325   $form->{formname}         = $self->type;
 326   $form->{type}             = $self->type;
 327   $form->{language}         = 'de';
 328   $form->{format}           = 'pdf';
 329
 330   $email_form->{subject}             = $form->generate_email_subject();
 331   $email_form->{attachment_filename} = $form->generate_attachment_filename();
 332   $email_form->{message}             = $form->generate_email_body();
 333   $email_form->{js_send_function}    = 'kivi.Order.send_email()';
 334
 335   my %files = $self->get_files_for_email_dialog();
 336   my $dialog_html = $self->render('common/_send_email_dialog', { output => 0 },
 337                                   email_form  => $email_form,
 338                                   show_bcc    => $::auth->assert('email_bcc', 'may fail'),
 339                                   FILES       => \%files,
 340                                   is_customer => $self->cv eq 'customer',
 341   );
 342
 343   $self->js
 344       ->run('kivi.Order.show_email_dialog', $dialog_html)
 345       ->reinit_widgets
 346       ->render($self);
 347 }
 348
 349 # send email
 350 #
 351 # Todo: handling error messages: flash is not displayed in dialog, but in the main form
 352 sub action_send_email {
 353   my ($self) = @_;
 354
 355   my $email_form  = delete $::form->{email_form};
 356   my %field_names = (to => 'email');
 357
 358   $::form->{ $field_names{$_} // $_ } = $email_form->{$_} for keys %{ $email_form };
 359
 360   # for Form::cleanup which may be called in Form::send_email
 361   $::form->{cwd}    = getcwd();
 362   $::form->{tmpdir} = $::lx_office_conf{paths}->{userspath};
 363
 364   $::form->{$_}     = $::form->{print_options}->{$_} for keys %{ $::form->{print_options} };
 365   $::form->{media}  = 'email';
 366
 367   if (($::form->{attachment_policy} // '') !~ m{^(?:old_file|no_file)$}) {
 368     my $language;
 369     $language = SL::DB::Language->new(id => $::form->{print_options}->{language_id})->load if $::form->{print_options}->{language_id};
 370
 371     my $pdf;
 372     my @errors = genereate_pdf($self->order, \$pdf, {media      => $::form->{media},
 373                                                      format     => $::form->{print_options}->{format},
 374                                                      formname   => $::form->{print_options}->{formname},
 375                                                      language   => $language,
 376                                                      groupitems => $::form->{print_options}->{groupitems}});
 377     if (scalar @errors) {
 378       return $self->js->flash('error', t8('Conversion to PDF failed: #1', $errors[0]))->render($self);
 379     }
 380
 381     my $sfile = SL::SessionFile::Random->new(mode => "w");
 382     $sfile->fh->print($pdf);
 383     $sfile->fh->close;
 384
 385     $::form->{tmpfile} = $sfile->file_name;
 386     $::form->{tmpdir}  = $sfile->get_path; # for Form::cleanup which may be called in Form::send_email
 387   }
 388
 389   $::form->send_email(\%::myconfig, 'pdf');
 390
 391   # internal notes
 392   my $intnotes = $self->order->intnotes;
 393   $intnotes   .= "\n\n" if $self->order->intnotes;
 394   $intnotes   .= t8('[email]')                                                                                        . "\n";
 395   $intnotes   .= t8('Date')       . ": " . $::locale->format_date_object(DateTime->now_local, precision => 'seconds') . "\n";
 396   $intnotes   .= t8('To (email)') . ": " . $::form->{email}                                                           . "\n";
 397   $intnotes   .= t8('Cc')         . ": " . $::form->{cc}                                                              . "\n"    if $::form->{cc};
 398   $intnotes   .= t8('Bcc')        . ": " . $::form->{bcc}                                                             . "\n"    if $::form->{bcc};
 399   $intnotes   .= t8('Subject')    . ": " . $::form->{subject}                                                         . "\n\n";
 400   $intnotes   .= t8('Message')    . ": " . $::form->{message};
 401
 402   $self->js
 403       ->val('#order_intnotes', $intnotes)
 404       ->run('kivi.Order.close_email_dialog')
 405       ->flash('info', t8('The email has been sent.'))
 406       ->render($self);
 407 }
 408
 409 # open the periodic invoices config dialog
 410 #
 411 # If there are values in the form (i.e. dialog was opened before),
 412 # then use this values. Create new ones, else.
 413 sub action_show_periodic_invoices_config_dialog {
 414   my ($self) = @_;
 415
 416   my $config = make_periodic_invoices_config_from_yaml(delete $::form->{config});
 417   $config  ||= SL::DB::Manager::PeriodicInvoicesConfig->find_by(oe_id => $::form->{id}) if $::form->{id};
 418   $config  ||= SL::DB::PeriodicInvoicesConfig->new(periodicity             => 'm',
 419                                                    order_value_periodicity => 'p', # = same as periodicity
 420                                                    start_date_as_date      => $::form->{transdate} || $::form->current_date,
 421                                                    extend_automatically_by => 12,
 422                                                    active                  => 1,
 423                                                    email_subject           => GenericTranslations->get(
 424                                                                                 language_id      => $::form->{language_id},
 425                                                                                 translation_type =>"preset_text_periodic_invoices_email_subject"),
 426                                                    email_body              => GenericTranslations->get(
 427                                                                                 language_id      => $::form->{language_id},
 428                                                                                 translation_type =>"preset_text_periodic_invoices_email_body"),
 429   );
 430   $config->periodicity('m')             if none { $_ eq $config->periodicity             }       @SL::DB::PeriodicInvoicesConfig::PERIODICITIES;
 431   $config->order_value_periodicity('p') if none { $_ eq $config->order_value_periodicity } ('p', @SL::DB::PeriodicInvoicesConfig::ORDER_VALUE_PERIODICITIES);
 432
 433   $::form->get_lists(printers => "ALL_PRINTERS",
 434                      charts   => { key       => 'ALL_CHARTS',
 435                                    transdate => 'current_date' });
 436
 437   $::form->{AR} = [ grep { $_->{link} =~ m/(?:^|:)AR(?::|$)/ } @{ $::form->{ALL_CHARTS} } ];
 438
 439   if ($::form->{customer_id}) {
 440     $::form->{ALL_CONTACTS} = SL::DB::Manager::Contact->get_all_sorted(where => [ cp_cv_id => $::form->{customer_id} ]);
 441   }
 442
 443   $self->render('oe/edit_periodic_invoices_config', { layout => 0 },
 444                 popup_dialog             => 1,
 445                 popup_js_close_function  => 'kivi.Order.close_periodic_invoices_config_dialog()',
 446                 popup_js_assign_function => 'kivi.Order.assign_periodic_invoices_config()',
 447                 config                   => $config,
 448                 %$::form);
 449 }
 450
 451 # assign the values of the periodic invoices config dialog
 452 # as yaml in the hidden tag and set the status.
 453 sub action_assign_periodic_invoices_config {
 454   my ($self) = @_;
 455
 456   $::form->isblank('start_date_as_date', $::locale->text('The start date is missing.'));
 457
 458   my $config = { active                     => $::form->{active}       ? 1 : 0,
 459                  terminated                 => $::form->{terminated}   ? 1 : 0,
 460                  direct_debit               => $::form->{direct_debit} ? 1 : 0,
 461                  periodicity                => (any { $_ eq $::form->{periodicity}             }       @SL::DB::PeriodicInvoicesConfig::PERIODICITIES)              ? $::form->{periodicity}             : 'm',
 462                  order_value_periodicity    => (any { $_ eq $::form->{order_value_periodicity} } ('p', @SL::DB::PeriodicInvoicesConfig::ORDER_VALUE_PERIODICITIES)) ? $::form->{order_value_periodicity} : 'p',
 463                  start_date_as_date         => $::form->{start_date_as_date},
 464                  end_date_as_date           => $::form->{end_date_as_date},
 465                  first_billing_date_as_date => $::form->{first_billing_date_as_date},
 466                  print                      => $::form->{print}      ? 1                         : 0,
 467                  printer_id                 => $::form->{print}      ? $::form->{printer_id} * 1 : undef,
 468                  copies                     => $::form->{copies} * 1 ? $::form->{copies}         : 1,
 469                  extend_automatically_by    => $::form->{extend_automatically_by}    * 1 || undef,
 470                  ar_chart_id                => $::form->{ar_chart_id} * 1,
 471                  send_email                 => $::form->{send_email} ? 1 : 0,
 472                  email_recipient_contact_id => $::form->{email_recipient_contact_id} * 1 || undef,
 473                  email_recipient_address    => $::form->{email_recipient_address},
 474                  email_sender               => $::form->{email_sender},
 475                  email_subject              => $::form->{email_subject},
 476                  email_body                 => $::form->{email_body},
 477                };
 478
 479   my $periodic_invoices_config = YAML::Dump($config);
 480
 481   my $status = $self->get_periodic_invoices_status($config);
 482
 483   $self->js
 484     ->remove('#order_periodic_invoices_config')
 485     ->insertAfter(hidden_tag('order.periodic_invoices_config', $periodic_invoices_config), '#periodic_invoices_status')
 486     ->run('kivi.Order.close_periodic_invoices_config_dialog')
 487     ->html('#periodic_invoices_status', $status)
 488     ->flash('info', t8('The periodic invoices config has been assigned.'))
 489     ->render($self);
 490 }
 491
 492 sub action_get_has_active_periodic_invoices {
 493   my ($self) = @_;
 494
 495   my $config = make_periodic_invoices_config_from_yaml(delete $::form->{config});
 496   $config  ||= SL::DB::Manager::PeriodicInvoicesConfig->find_by(oe_id => $::form->{id}) if $::form->{id};
 497
 498   my $has_active_periodic_invoices =
 499        $self->type eq sales_order_type()
 500     && $config
 501     && $config->active
 502     && (!$config->end_date || ($config->end_date > DateTime->today_local))
 503     && $config->get_previous_billed_period_start_date;
 504
 505   $_[0]->render(\ !!$has_active_periodic_invoices, { type => 'text' });
 506 }
 507
 508 # save the order and redirect to the frontend subroutine for a new
 509 # delivery order
 510 sub action_save_and_delivery_order {
 511   my ($self) = @_;
 512
 513   my $errors = $self->save();
 514
 515   if (scalar @{ $errors }) {
 516     $self->js->flash('error', $_) foreach @{ $errors };
 517     return $self->js->render();
 518   }
 519
 520   my $text = $self->type eq sales_order_type()       ? $::locale->text('The order has been saved')
 521            : $self->type eq purchase_order_type()    ? $::locale->text('The order has been saved')
 522            : $self->type eq sales_quotation_type()   ? $::locale->text('The quotation has been saved')
 523            : $self->type eq request_quotation_type() ? $::locale->text('The rfq has been saved')
 524            : '';
 525   flash_later('info', $text);
 526
 527   my @redirect_params = (
 528     controller => 'oe.pl',
 529     action     => 'oe_delivery_order_from_order',
 530     id         => $self->order->id,
 531   );
 532
 533   $self->redirect_to(@redirect_params);
 534 }
 535
 536 # save the order and redirect to the frontend subroutine for a new
 537 # invoice
 538 sub action_save_and_invoice {
 539   my ($self) = @_;
 540
 541   my $errors = $self->save();
 542
 543   if (scalar @{ $errors }) {
 544     $self->js->flash('error', $_) foreach @{ $errors };
 545     return $self->js->render();
 546   }
 547
 548   my $text = $self->type eq sales_order_type()       ? $::locale->text('The order has been saved')
 549            : $self->type eq purchase_order_type()    ? $::locale->text('The order has been saved')
 550            : $self->type eq sales_quotation_type()   ? $::locale->text('The quotation has been saved')
 551            : $self->type eq request_quotation_type() ? $::locale->text('The rfq has been saved')
 552            : '';
 553   flash_later('info', $text);
 554
 555   my @redirect_params = (
 556     controller => 'oe.pl',
 557     action     => 'oe_invoice_from_order',
 558     id         => $self->order->id,
 559   );
 560
 561   $self->redirect_to(@redirect_params);
 562 }
 563
 564 # workflow from sales quotation to sales order
 565 sub action_sales_order {
 566   $_[0]->workflow_sales_or_purchase_order();
 567 }
 568
 569 # workflow from rfq to purchase order
 570 sub action_purchase_order {
 571   $_[0]->workflow_sales_or_purchase_order();
 572 }
 573
 574 # set form elements in respect to a changed customer or vendor
 575 #
 576 # This action is called on an change of the customer/vendor picker.
 577 sub action_customer_vendor_changed {
 578   my ($self) = @_;
 579
 580   setup_order_from_cv($self->order);
 581   $self->recalc();
 582
 583   my $cv_method = $self->cv;
 584
 585   if ($self->order->$cv_method->contacts && scalar @{ $self->order->$cv_method->contacts } > 0) {
 586     $self->js->show('#cp_row');
 587   } else {
 588     $self->js->hide('#cp_row');
 589   }
 590
 591   if ($self->order->$cv_method->shipto && scalar @{ $self->order->$cv_method->shipto } > 0) {
 592     $self->js->show('#shipto_row');
 593   } else {
 594     $self->js->hide('#shipto_row');
 595   }
 596
 597   $self->js->val( '#order_salesman_id',      $self->order->salesman_id)        if $self->order->is_sales;
 598
 599   $self->js
 600     ->replaceWith('#order_cp_id',            $self->build_contact_select)
 601     ->replaceWith('#order_shipto_id',        $self->build_shipto_select)
 602     ->replaceWith('#business_info_row',      $self->build_business_info_row)
 603     ->val(        '#order_taxzone_id',       $self->order->taxzone_id)
 604     ->val(        '#order_taxincluded',      $self->order->taxincluded)
 605     ->val(        '#order_payment_id',       $self->order->payment_id)
 606     ->val(        '#order_delivery_term_id', $self->order->delivery_term_id)
 607     ->val(        '#order_intnotes',         $self->order->intnotes)
 608     ->focus(      '#order_' . $self->cv . '_id');
 609
 610   $self->js_redisplay_amounts_and_taxes;
 611   $self->js->render();
 612 }
 613
 614 # open the dialog for customer/vendor details
 615 sub action_show_customer_vendor_details_dialog {
 616   my ($self) = @_;
 617
 618   my $is_customer = 'customer' eq $::form->{vc};
 619   my $cv;
 620   if ($is_customer) {
 621     $cv = SL::DB::Customer->new(id => $::form->{vc_id})->load;
 622   } else {
 623     $cv = SL::DB::Vendor->new(id => $::form->{vc_id})->load;
 624   }
 625
 626   my %details = map { $_ => $cv->$_ } @{$cv->meta->columns};
 627   $details{discount_as_percent} = $cv->discount_as_percent;
 628   $details{creditlimt}          = $cv->creditlimit_as_number;
 629   $details{business}            = $cv->business->description      if $cv->business;
 630   $details{language}            = $cv->language_obj->description  if $cv->language_obj;
 631   $details{delivery_terms}      = $cv->delivery_term->description if $cv->delivery_term;
 632   $details{payment_terms}       = $cv->payment->description       if $cv->payment;
 633   $details{pricegroup}          = $cv->pricegroup->pricegroup     if $is_customer && $cv->pricegroup;
 634
 635   foreach my $entry (@{ $cv->shipto }) {
 636     push @{ $details{SHIPTO} },   { map { $_ => $entry->$_ } @{$entry->meta->columns} };
 637   }
 638   foreach my $entry (@{ $cv->contacts }) {
 639     push @{ $details{CONTACTS} }, { map { $_ => $entry->$_ } @{$entry->meta->columns} };
 640   }
 641
 642   $_[0]->render('common/show_vc_details', { layout => 0 },
 643                 is_customer => $is_customer,
 644                 %details);
 645
 646 }
 647
 648 # called if a unit in an existing item row is changed
 649 sub action_unit_changed {
 650   my ($self) = @_;
 651
 652   my $idx  = first_index { $_ eq $::form->{item_id} } @{ $::form->{orderitem_ids} };
 653   my $item = $self->order->items_sorted->[$idx];
 654
 655   my $old_unit_obj = SL::DB::Unit->new(name => $::form->{old_unit})->load;
 656   $item->sellprice($item->unit_obj->convert_to($item->sellprice, $old_unit_obj));
 657
 658   $self->recalc();
 659
 660   $self->js
 661     ->run('kivi.Order.update_sellprice', $::form->{item_id}, $item->sellprice_as_number);
 662   $self->js_redisplay_line_values;
 663   $self->js_redisplay_amounts_and_taxes;
 664   $self->js->render();
 665 }
 666
 667 # add an item row for a new item entered in the input row
 668 sub action_add_item {
 669   my ($self) = @_;
 670
 671   my $form_attr = $::form->{add_item};
 672
 673   return unless $form_attr->{parts_id};
 674
 675   my $item = new_item($self->order, $form_attr);
 676
 677   $self->order->add_items($item);
 678
 679   $self->recalc();
 680
 681   my $item_id = join('_', 'new', Time::HiRes::gettimeofday(), int rand 1000000000000);
 682   my $row_as_html = $self->p->render('order/tabs/_row',
 683                                      ITEM              => $item,
 684                                      ID                => $item_id,
 685                                      TYPE              => $self->type,
 686                                      ALL_PRICE_FACTORS => $self->all_price_factors
 687   );
 688
 689   $self->js
 690     ->append('#row_table_id', $row_as_html);
 691
 692   if ( $item->part->is_assortment ) {
 693     $form_attr->{qty_as_number} = 1 unless $form_attr->{qty_as_number};
 694     foreach my $assortment_item ( @{$item->part->assortment_items} ) {
 695       my $attr = { parts_id => $assortment_item->parts_id,
 696                    qty      => $assortment_item->qty * $::form->parse_amount(\%::myconfig, $form_attr->{qty_as_number}), # TODO $form_attr->{unit}
 697                    unit     => $assortment_item->unit,
 698                    description => $assortment_item->part->description,
 699                  };
 700       my $item = new_item($self->order, $attr);
 701
 702       # set discount to 100% if item isn't supposed to be charged, overwriting any customer discount
 703       $item->discount(1) unless $assortment_item->charge;
 704
 705       $self->order->add_items( $item );
 706       $self->recalc();
 707       my $item_id = join('_', 'new', Time::HiRes::gettimeofday(), int rand 1000000000000);
 708       my $row_as_html = $self->p->render('order/tabs/_row',
 709                                          ITEM              => $item,
 710                                          ID                => $item_id,
 711                                          TYPE              => $self->type,
 712                                          ALL_PRICE_FACTORS => $self->all_price_factors
 713       );
 714       $self->js
 715         ->append('#row_table_id', $row_as_html);
 716     };
 717   };
 718
 719   $self->js
 720     ->val('.add_item_input', '')
 721     ->run('kivi.Order.init_row_handlers')
 722     ->run('kivi.Order.row_table_scroll_down')
 723     ->run('kivi.Order.renumber_positions')
 724     ->focus('#add_item_parts_id_name');
 725
 726   $self->js_redisplay_amounts_and_taxes;
 727   $self->js->render();
 728 }
 729
 730 # open the dialog for entering multiple items at once
 731 sub action_show_multi_items_dialog {
 732   require SL::DB::PartsGroup;
 733   $_[0]->render('order/tabs/_multi_items_dialog', { layout => 0 },
 734                 all_partsgroups => SL::DB::Manager::PartsGroup->get_all);
 735 }
 736
 737 # update the filter results in the multi item dialog
 738 sub action_multi_items_update_result {
 739   my $max_count = 100;
 740
 741   $::form->{multi_items}->{filter}->{obsolete} = 0;
 742
 743   my $count = $_[0]->multi_items_models->count;
 744
 745   if ($count == 0) {
 746     my $text = SL::Presenter::EscapedText->new(text => $::locale->text('No results.'));
 747     $_[0]->render($text, { layout => 0 });
 748   } elsif ($count > $max_count) {
 749     my $text = SL::Presenter::EscapedText->new(text => $::locale->text('Too many results (#1 from #2).', $count, $max_count));
 750     $_[0]->render($text, { layout => 0 });
 751   } else {
 752     my $multi_items = $_[0]->multi_items_models->get;
 753     $_[0]->render('order/tabs/_multi_items_result', { layout => 0 },
 754                   multi_items => $multi_items);
 755   }
 756 }
 757
 758 # add item rows for multiple items at once
 759 sub action_add_multi_items {
 760   my ($self) = @_;
 761
 762   my @form_attr = grep { $_->{qty_as_number} } @{ $::form->{add_multi_items} };
 763   return $self->js->render() unless scalar @form_attr;
 764
 765   my @items;
 766   foreach my $attr (@form_attr) {
 767     my $item = new_item($self->order, $attr);
 768     push @items, $item;
 769     if ( $item->part->is_assortment ) {
 770       foreach my $assortment_item ( @{$item->part->assortment_items} ) {
 771         my $attr = { parts_id => $assortment_item->parts_id,
 772                      qty      => $assortment_item->qty * $item->qty, # TODO $form_attr->{unit}
 773                      unit     => $assortment_item->unit,
 774                      description => $assortment_item->part->description,
 775                    };
 776         my $item = new_item($self->order, $attr);
 777
 778         # set discount to 100% if item isn't supposed to be charged, overwriting any customer discount
 779         $item->discount(1) unless $assortment_item->charge;
 780         push @items, $item;
 781       }
 782     }
 783   }
 784   $self->order->add_items(@items);
 785
 786   $self->recalc();
 787
 788   foreach my $item (@items) {
 789     my $item_id = join('_', 'new', Time::HiRes::gettimeofday(), int rand 1000000000000);
 790     my $row_as_html = $self->p->render('order/tabs/_row',
 791                                        ITEM              => $item,
 792                                        ID                => $item_id,
 793                                        TYPE              => $self->type,
 794                                        ALL_PRICE_FACTORS => $self->all_price_factors
 795     );
 796
 797     $self->js->append('#row_table_id', $row_as_html);
 798   }
 799
 800   $self->js
 801     ->run('kivi.Order.close_multi_items_dialog')
 802     ->run('kivi.Order.init_row_handlers')
 803     ->run('kivi.Order.row_table_scroll_down')
 804     ->run('kivi.Order.renumber_positions')
 805     ->focus('#add_item_parts_id_name');
 806
 807   $self->js_redisplay_amounts_and_taxes;
 808   $self->js->render();
 809 }
 810
 811 # recalculate all linetotals, amounts and taxes and redisplay them
 812 sub action_recalc_amounts_and_taxes {
 813   my ($self) = @_;
 814
 815   $self->recalc();
 816
 817   $self->js_redisplay_line_values;
 818   $self->js_redisplay_amounts_and_taxes;
 819   $self->js->render();
 820 }
 821
 822 # redisplay item rows if they are sorted by an attribute
 823 sub action_reorder_items {
 824   my ($self) = @_;
 825
 826   my %sort_keys = (
 827     partnumber  => sub { $_[0]->part->partnumber },
 828     description => sub { $_[0]->description },
 829     qty         => sub { $_[0]->qty },
 830     sellprice   => sub { $_[0]->sellprice },
 831     discount    => sub { $_[0]->discount },
 832   );
 833
 834   my $method = $sort_keys{$::form->{order_by}};
 835   my @to_sort = map { { old_pos => $_->position, order_by => $method->($_) } } @{ $self->order->items_sorted };
 836   if ($::form->{sort_dir}) {
 837     @to_sort = sort { $a->{order_by} cmp $b->{order_by} } @to_sort;
 838   } else {
 839     @to_sort = sort { $b->{order_by} cmp $a->{order_by} } @to_sort;
 840   }
 841   $self->js
 842     ->run('kivi.Order.redisplay_items', \@to_sort)
 843     ->render;
 844 }
 845
 846 # show the popup to choose a price/discount source
 847 sub action_price_popup {
 848   my ($self) = @_;
 849
 850   my $idx  = first_index { $_ eq $::form->{item_id} } @{ $::form->{orderitem_ids} };
 851   my $item = $self->order->items_sorted->[$idx];
 852
 853   $self->render_price_dialog($item);
 854 }
 855
 856 # get the longdescription for an item if the dialog to enter/change the
 857 # longdescription was opened and the longdescription is empty
 858 #
 859 # If this item is new, get the longdescription from Part.
 860 # Otherwise get it from OrderItem.
 861 sub action_get_item_longdescription {
 862   my $longdescription;
 863
 864   if ($::form->{item_id}) {
 865     $longdescription = SL::DB::OrderItem->new(id => $::form->{item_id})->load->longdescription;
 866   } elsif ($::form->{parts_id}) {
 867     $longdescription = SL::DB::Part->new(id => $::form->{parts_id})->load->notes;
 868   }
 869   $_[0]->render(\ $longdescription, { type => 'text' });
 870 }
 871
 872 # load the second row for one or more items
 873 #
 874 # This action gets the html code for all items second rows by rendering a template for
 875 # the second row and sets the html code via client js.
 876 sub action_load_second_rows {
 877   my ($self) = @_;
 878
 879   $self->recalc() if $self->order->is_sales; # for margin calculation
 880
 881   foreach my $item_id (@{ $::form->{item_ids} }) {
 882     my $idx  = first_index { $_ eq $item_id } @{ $::form->{orderitem_ids} };
 883     my $item = $self->order->items_sorted->[$idx];
 884
 885     $self->js_load_second_row($item, $item_id, 0);
 886   }
 887
 888   $self->js->run('kivi.Order.init_row_handlers') if $self->order->is_sales; # for lastcosts change-callback
 889
 890   $self->js->render();
 891 }
 892
 893 sub js_load_second_row {
 894   my ($self, $item, $item_id, $do_parse) = @_;
 895
 896   if ($do_parse) {
 897     # Parse values from form (they are formated while rendering (template)).
 898     # Workaround to pre-parse number-cvars (parse_custom_variable_values does not parse number values).
 899     # This parsing is not necessary at all, if we assure that the second row/cvars are only loaded once.
 900     foreach my $var (@{ $item->cvars_by_config }) {
 901       $var->unparsed_value($::form->parse_amount(\%::myconfig, $var->{__unparsed_value})) if ($var->config->type eq 'number' && exists($var->{__unparsed_value}));
 902     }
 903     $item->parse_custom_variable_values;
 904   }
 905
 906   my $row_as_html = $self->p->render('order/tabs/_second_row', ITEM => $item, TYPE => $self->type);
 907
 908   $self->js
 909     ->html('.row_entry:has(#item_' . $item_id . ') [name = "second_row"]', $row_as_html)
 910     ->data('.row_entry:has(#item_' . $item_id . ') [name = "second_row"]', 'loaded', 1);
 911 }
 912
 913 sub js_redisplay_line_values {
 914   my ($self) = @_;
 915
 916   my $is_sales = $self->order->is_sales;
 917
 918   # sales orders with margins
 919   my @data;
 920   if ($is_sales) {
 921     @data = map {
 922       [
 923        $::form->format_amount(\%::myconfig, $_->{linetotal},     2, 0),
 924        $::form->format_amount(\%::myconfig, $_->{marge_total},   2, 0),
 925        $::form->format_amount(\%::myconfig, $_->{marge_percent}, 2, 0),
 926       ]} @{ $self->order->items_sorted };
 927   } else {
 928     @data = map {
 929       [
 930        $::form->format_amount(\%::myconfig, $_->{linetotal},     2, 0),
 931       ]} @{ $self->order->items_sorted };
 932   }
 933
 934   $self->js
 935     ->run('kivi.Order.redisplay_line_values', $is_sales, \@data);
 936 }
 937
 938 sub js_redisplay_amounts_and_taxes {
 939   my ($self) = @_;
 940
 941   if (scalar @{ $self->{taxes} }) {
 942     $self->js->show('#taxincluded_row_id');
 943   } else {
 944     $self->js->hide('#taxincluded_row_id');
 945   }
 946
 947   if ($self->order->taxincluded) {
 948     $self->js->hide('#subtotal_row_id');
 949   } else {
 950     $self->js->show('#subtotal_row_id');
 951   }
 952
 953   $self->js
 954     ->html('#netamount_id', $::form->format_amount(\%::myconfig, $self->order->netamount, -2))
 955     ->html('#amount_id',    $::form->format_amount(\%::myconfig, $self->order->amount,    -2))
 956     ->remove('.tax_row')
 957     ->insertBefore($self->build_tax_rows, '#amount_row_id');
 958 }
 959
 960 #
 961 # helpers
 962 #
 963
 964 sub init_valid_types {
 965   [ sales_order_type(), purchase_order_type(), sales_quotation_type(), request_quotation_type() ];
 966 }
 967
 968 sub init_type {
 969   my ($self) = @_;
 970
 971   if (none { $::form->{type} eq $_ } @{$self->valid_types}) {
 972     die "Not a valid type for order";
 973   }
 974
 975   $self->type($::form->{type});
 976 }
 977
 978 sub init_cv {
 979   my ($self) = @_;
 980
 981   my $cv = (any { $self->type eq $_ } (sales_order_type(),    sales_quotation_type()))   ? 'customer'
 982          : (any { $self->type eq $_ } (purchase_order_type(), request_quotation_type())) ? 'vendor'
 983          : die "Not a valid type for order";
 984
 985   return $cv;
 986 }
 987
 988 sub init_p {
 989   SL::Presenter->get;
 990 }
 991
 992 sub init_order {
 993   $_[0]->make_order;
 994 }
 995
 996 # model used to filter/display the parts in the multi-items dialog
 997 sub init_multi_items_models {
 998   SL::Controller::Helper::GetModels->new(
 999     controller     => $_[0],
1000     model          => 'Part',
1001     with_objects   => [ qw(unit_obj) ],
1002     disable_plugin => 'paginated',
1003     source         => $::form->{multi_items},
1004     sorted         => {
1005       _default    => {
1006         by  => 'partnumber',
1007         dir => 1,
1008       },
1009       partnumber  => t8('Partnumber'),
1010       description => t8('Description')}
1011   );
1012 }
1013
1014 sub init_all_price_factors {
1015   SL::DB::Manager::PriceFactor->get_all;
1016 }
1017
1018 sub check_auth {
1019   my ($self) = @_;
1020
1021   my $right_for = { map { $_ => $_.'_edit' } @{$self->valid_types} };
1022
1023   my $right   = $right_for->{ $self->type };
1024   $right    ||= 'DOES_NOT_EXIST';
1025
1026   $::auth->assert($right);
1027 }
1028
1029 # build the selection box for contacts
1030 #
1031 # Needed, if customer/vendor changed.
1032 sub build_contact_select {
1033   my ($self) = @_;
1034
1035   select_tag('order.cp_id', [ $self->order->{$self->cv}->contacts ],
1036     value_key  => 'cp_id',
1037     title_key  => 'full_name_dep',
1038     default    => $self->order->cp_id,
1039     with_empty => 1,
1040     style      => 'width: 300px',
1041   );
1042 }
1043
1044 # build the selection box for shiptos
1045 #
1046 # Needed, if customer/vendor changed.
1047 sub build_shipto_select {
1048   my ($self) = @_;
1049
1050   select_tag('order.shipto_id', [ $self->order->{$self->cv}->shipto ],
1051     value_key  => 'shipto_id',
1052     title_key  => 'displayable_id',
1053     default    => $self->order->shipto_id,
1054     with_empty => 1,
1055     style      => 'width: 300px',
1056   );
1057 }
1058
1059 # render the info line for business
1060 #
1061 # Needed, if customer/vendor changed.
1062 sub build_business_info_row
1063 {
1064   $_[0]->p->render('order/tabs/_business_info_row', SELF => $_[0]);
1065 }
1066
1067 # build the rows for displaying taxes
1068 #
1069 # Called if amounts where recalculated and redisplayed.
1070 sub build_tax_rows {
1071   my ($self) = @_;
1072
1073   my $rows_as_html;
1074   foreach my $tax (sort { $a->{tax}->rate cmp $b->{tax}->rate } @{ $self->{taxes} }) {
1075     $rows_as_html .= $self->p->render('order/tabs/_tax_row', TAX => $tax, TAXINCLUDED => $self->order->taxincluded);
1076   }
1077   return $rows_as_html;
1078 }
1079
1080
1081 sub render_price_dialog {
1082   my ($self, $record_item) = @_;
1083
1084   my $price_source = SL::PriceSource->new(record_item => $record_item, record => $self->order);
1085
1086   $self->js
1087     ->run(
1088       'kivi.io.price_chooser_dialog',
1089       t8('Available Prices'),
1090       $self->render('order/tabs/_price_sources_dialog', { output => 0 }, price_source => $price_source)
1091     )
1092     ->reinit_widgets;
1093
1094 #   if (@errors) {
1095 #     $self->js->text('#dialog_flash_error_content', join ' ', @errors);
1096 #     $self->js->show('#dialog_flash_error');
1097 #   }
1098
1099   $self->js->render;
1100 }
1101
1102 sub load_order {
1103   my ($self) = @_;
1104
1105   return if !$::form->{id};
1106
1107   $self->order(SL::DB::Order->new(id => $::form->{id})->load);
1108 }
1109
1110 # load or create a new order object
1111 #
1112 # And assign changes from the form to this object.
1113 # If the order is loaded from db, check if items are deleted in the form,
1114 # remove them form the object and collect them for removing from db on saving.
1115 # Then create/update items from form (via make_item) and add them.
1116 sub make_order {
1117   my ($self) = @_;
1118
1119   # add_items adds items to an order with no items for saving, but they cannot
1120   # be retrieved via items until the order is saved. Adding empty items to new
1121   # order here solves this problem.
1122   my $order;
1123   $order   = SL::DB::Manager::Order->find_by(id => $::form->{id}) if $::form->{id};
1124   $order ||= SL::DB::Order->new(orderitems => [],
1125                                 quotation  => (any { $self->type eq $_ } (sales_quotation_type(), request_quotation_type())));
1126
1127   my $cv_id_method = $self->cv . '_id';
1128   if (!$::form->{id} && $::form->{$cv_id_method}) {
1129     $order->$cv_id_method($::form->{$cv_id_method});
1130     setup_order_from_cv($order);
1131   }
1132
1133   my $form_orderitems               = delete $::form->{order}->{orderitems};
1134   my $form_periodic_invoices_config = delete $::form->{order}->{periodic_invoices_config};
1135
1136   $order->assign_attributes(%{$::form->{order}});
1137
1138   my $periodic_invoices_config = make_periodic_invoices_config_from_yaml($form_periodic_invoices_config);
1139   $order->periodic_invoices_config($periodic_invoices_config) if $periodic_invoices_config;
1140
1141   # remove deleted items
1142   $self->item_ids_to_delete([]);
1143   foreach my $idx (reverse 0..$#{$order->orderitems}) {
1144     my $item = $order->orderitems->[$idx];
1145     if (none { $item->id == $_->{id} } @{$form_orderitems}) {
1146       splice @{$order->orderitems}, $idx, 1;
1147       push @{$self->item_ids_to_delete}, $item->id;
1148     }
1149   }
1150
1151   my @items;
1152   my $pos = 1;
1153   foreach my $form_attr (@{$form_orderitems}) {
1154     my $item = make_item($order, $form_attr);
1155     $item->position($pos);
1156     push @items, $item;
1157     $pos++;
1158   }
1159   $order->add_items(grep {!$_->id} @items);
1160
1161   return $order;
1162 }
1163
1164 # create or update items from form
1165 #
1166 # Make item objects from form values. For items already existing read from db.
1167 # Create a new item else. And assign attributes.
1168 sub make_item {
1169   my ($record, $attr) = @_;
1170
1171   my $item;
1172   $item = first { $_->id == $attr->{id} } @{$record->items} if $attr->{id};
1173
1174   my $is_new = !$item;
1175
1176   # add_custom_variables adds cvars to an orderitem with no cvars for saving, but
1177   # they cannot be retrieved via custom_variables until the order/orderitem is
1178   # saved. Adding empty custom_variables to new orderitem here solves this problem.
1179   $item ||= SL::DB::OrderItem->new(custom_variables => []);
1180
1181   $item->assign_attributes(%$attr);
1182   $item->longdescription($item->part->notes)                     if $is_new && !defined $attr->{longdescription};
1183   $item->project_id($record->globalproject_id)                   if $is_new && !defined $attr->{project_id};
1184   $item->lastcost($record->is_sales ? $item->part->lastcost : 0) if $is_new && !defined $attr->{lastcost_as_number};
1185
1186   return $item;
1187 }
1188
1189 # create a new item
1190 #
1191 # This is used to add one item
1192 sub new_item {
1193   my ($record, $attr) = @_;
1194
1195   my $item = SL::DB::OrderItem->new;
1196
1197   # Remove attributes where the user left or set the inputs empty.
1198   # So these attributes will be undefined and we can distinguish them
1199   # from zero later on.
1200   for (qw(qty_as_number sellprice_as_number discount_as_percent)) {
1201     delete $attr->{$_} if $attr->{$_} eq '';
1202   }
1203
1204   $item->assign_attributes(%$attr);
1205
1206   my $part         = SL::DB::Part->new(id => $attr->{parts_id})->load;
1207   my $price_source = SL::PriceSource->new(record_item => $item, record => $record);
1208
1209   $item->unit($part->unit) if !$item->unit;
1210
1211   my $price_src;
1212   if ( $part->is_assortment ) {
1213     # add assortment items with price 0, as the components carry the price
1214     $price_src = $price_source->price_from_source("");
1215     $price_src->price(0);
1216   } elsif (defined $item->sellprice) {
1217     $price_src = $price_source->price_from_source("");
1218     $price_src->price($item->sellprice);
1219   } else {
1220     $price_src = $price_source->best_price
1221            ? $price_source->best_price
1222            : $price_source->price_from_source("");
1223     $price_src->price(0) if !$price_source->best_price;
1224   }
1225
1226   my $discount_src;
1227   if (defined $item->discount) {
1228     $discount_src = $price_source->discount_from_source("");
1229     $discount_src->discount($item->discount);
1230   } else {
1231     $discount_src = $price_source->best_discount
1232                   ? $price_source->best_discount
1233                   : $price_source->discount_from_source("");
1234     $discount_src->discount(0) if !$price_source->best_discount;
1235   }
1236
1237   my %new_attr;
1238   $new_attr{part}                   = $part;
1239   $new_attr{description}            = $part->description     if ! $item->description;
1240   $new_attr{qty}                    = 1.0                    if ! $item->qty;
1241   $new_attr{price_factor_id}        = $part->price_factor_id if ! $item->price_factor_id;
1242   $new_attr{sellprice}              = $price_src->price;
1243   $new_attr{discount}               = $discount_src->discount;
1244   $new_attr{active_price_source}    = $price_src;
1245   $new_attr{active_discount_source} = $discount_src;
1246   $new_attr{longdescription}        = $part->notes           if ! defined $attr->{longdescription};
1247   $new_attr{project_id}             = $record->globalproject_id;
1248   $new_attr{lastcost}               = $record->is_sales ? $part->lastcost : 0;
1249
1250   # add_custom_variables adds cvars to an orderitem with no cvars for saving, but
1251   # they cannot be retrieved via custom_variables until the order/orderitem is
1252   # saved. Adding empty custom_variables to new orderitem here solves this problem.
1253   $new_attr{custom_variables} = [];
1254
1255   $item->assign_attributes(%new_attr);
1256
1257   return $item;
1258 }
1259
1260 sub setup_order_from_cv {
1261   my ($order) = @_;
1262
1263   $order->$_($order->customervendor->$_) for (qw(taxzone_id payment_id delivery_term_id));
1264
1265   $order->intnotes($order->customervendor->notes);
1266
1267   if ($order->is_sales) {
1268     $order->salesman_id($order->customer->salesman_id);
1269     $order->taxincluded(defined($order->customer->taxincluded_checked)
1270                         ? $order->customer->taxincluded_checked
1271                         : $::myconfig{taxincluded_checked});
1272   }
1273
1274 }
1275
1276 # recalculate prices and taxes
1277 #
1278 # Using the PriceTaxCalculator. Store linetotals in the item objects.
1279 sub recalc {
1280   my ($self) = @_;
1281
1282   # bb: todo: currency later
1283   $self->order->currency_id($::instance_conf->get_currency_id());
1284
1285   my %pat = $self->order->calculate_prices_and_taxes();
1286   $self->{taxes} = [];
1287   foreach my $tax_chart_id (keys %{ $pat{taxes} }) {
1288     my $tax = SL::DB::Manager::Tax->find_by(chart_id => $tax_chart_id);
1289
1290     my @amount_keys = grep { $pat{amounts}->{$_}->{tax_id} == $tax->id } keys %{ $pat{amounts} };
1291     push(@{ $self->{taxes} }, { amount    => $pat{taxes}->{$tax_chart_id},
1292                                 netamount => $pat{amounts}->{$amount_keys[0]}->{amount},
1293                                 tax       => $tax });
1294   }
1295
1296   pairwise { $a->{linetotal} = $b->{linetotal} } @{$self->order->items}, @{$pat{items}};
1297 }
1298
1299 # get data for saving, printing, ..., that is not changed in the form
1300 #
1301 # Only cvars for now.
1302 sub get_unalterable_data {
1303   my ($self) = @_;
1304
1305   foreach my $item (@{ $self->order->items }) {
1306     # autovivify all cvars that are not in the form (cvars_by_config can do it).
1307     # workaround to pre-parse number-cvars (parse_custom_variable_values does not parse number values).
1308     foreach my $var (@{ $item->cvars_by_config }) {
1309       $var->unparsed_value($::form->parse_amount(\%::myconfig, $var->{__unparsed_value})) if ($var->config->type eq 'number' && exists($var->{__unparsed_value}));
1310     }
1311     $item->parse_custom_variable_values;
1312   }
1313 }
1314
1315 # delete the order
1316 #
1317 # And remove related files in the spool directory
1318 sub delete {
1319   my ($self) = @_;
1320
1321   my $errors = [];
1322   my $db     = $self->order->db;
1323
1324   $db->with_transaction(
1325     sub {
1326       my @spoolfiles = grep { $_ } map { $_->spoolfile } @{ SL::DB::Manager::Status->get_all(where => [ trans_id => $self->order->id ]) };
1327       $self->order->delete;
1328       my $spool = $::lx_office_conf{paths}->{spool};
1329       unlink map { "$spool/$_" } @spoolfiles if $spool;
1330
1331       1;
1332   }) || push(@{$errors}, $db->error);
1333
1334   return $errors;
1335 }
1336
1337 # save the order
1338 #
1339 # And delete items that are deleted in the form.
1340 sub save {
1341   my ($self) = @_;
1342
1343   my $errors = [];
1344   my $db     = $self->order->db;
1345
1346   $db->with_transaction(sub {
1347     SL::DB::OrderItem->new(id => $_)->delete for @{$self->item_ids_to_delete};
1348     $self->order->save(cascade => 1);
1349
1350     # link records
1351     if ($::form->{converted_from_oe_id}) {
1352       SL::DB::Order->new(id => $::form->{converted_from_oe_id})->load->link_to_record($self->order);
1353
1354       if (scalar @{ $::form->{converted_from_orderitems_ids} || [] }) {
1355         my $idx = 0;
1356         foreach (@{ $self->order->items_sorted }) {
1357           my $from_id = $::form->{converted_from_orderitems_ids}->[$idx];
1358           next if !$from_id;
1359           SL::DB::RecordLink->new(from_table => 'orderitems',
1360                                   from_id    => $from_id,
1361                                   to_table   => 'orderitems',
1362                                   to_id      => $_->id
1363           )->save;
1364           $idx++;
1365         }
1366       }
1367     }
1368     1;
1369   }) || push(@{$errors}, $db->error);
1370
1371   return $errors;
1372 }
1373
1374 sub workflow_sales_or_purchase_order {
1375   my ($self) = @_;
1376
1377   my $destination_type = $::form->{type} eq sales_quotation_type()   ? sales_order_type()
1378                        : $::form->{type} eq request_quotation_type() ? purchase_order_type()
1379                        : $::form->{type} eq purchase_order_type()    ? sales_order_type()
1380                        : $::form->{type} eq sales_order_type()       ? purchase_order_type()
1381                        : '';
1382
1383   $self->order(SL::DB::Order->new_from($self->order, destination_type => $destination_type));
1384   $self->{converted_from_oe_id} = delete $::form->{id};
1385
1386   # set item ids to new fake id, to identify them as new items
1387   foreach my $item (@{$self->order->items_sorted}) {
1388     $item->{new_fake_id} = join('_', 'new', Time::HiRes::gettimeofday(), int rand 1000000000000);
1389   }
1390
1391   # change form type
1392   $::form->{type} = $destination_type;
1393   $self->type($self->init_type);
1394   $self->cv  ($self->init_cv);
1395   $self->check_auth;
1396
1397   $self->recalc();
1398   $self->get_unalterable_data();
1399   $self->pre_render();
1400
1401   # trigger rendering values for second row/longdescription as hidden,
1402   # because they are loaded only on demand. So we need to keep the values
1403   # from the source.
1404   $_->{render_second_row}      = 1 for @{ $self->order->items_sorted };
1405   $_->{render_longdescription} = 1 for @{ $self->order->items_sorted };
1406
1407   $self->render(
1408     'order/form',
1409     title => $self->get_title_for('edit'),
1410     %{$self->{template_args}}
1411   );
1412 }
1413
1414
1415 sub pre_render {
1416   my ($self) = @_;
1417
1418   $self->{all_taxzones}             = SL::DB::Manager::TaxZone->get_all_sorted();
1419   $self->{all_departments}          = SL::DB::Manager::Department->get_all_sorted();
1420   $self->{all_employees}            = SL::DB::Manager::Employee->get_all(where => [ or => [ id => $self->order->employee_id,
1421                                                                                             deleted => 0 ] ],
1422                                                                          sort_by => 'name');
1423   $self->{all_salesmen}             = SL::DB::Manager::Employee->get_all(where => [ or => [ id => $self->order->salesman_id,
1424                                                                                             deleted => 0 ] ],
1425                                                                          sort_by => 'name');
1426   $self->{all_payment_terms}        = SL::DB::Manager::PaymentTerm->get_all_sorted(where => [ or => [ id => $self->order->payment_id,
1427                                                                                                       obsolete => 0 ] ]);
1428   $self->{all_delivery_terms}       = SL::DB::Manager::DeliveryTerm->get_all_sorted();
1429   $self->{current_employee_id}      = SL::DB::Manager::Employee->current->id;
1430   $self->{periodic_invoices_status} = $self->get_periodic_invoices_status($self->order->periodic_invoices_config);
1431   $self->{order_probabilities}      = [ map { { title => ($_ * 10) . '%', id => $_ * 10 } } (0..10) ];
1432
1433   my $print_form = Form->new('');
1434   $print_form->{type}      = $self->type;
1435   $print_form->{printers}  = SL::DB::Manager::Printer->get_all_sorted;
1436   $print_form->{languages} = SL::DB::Manager::Language->get_all_sorted;
1437   $self->{print_options}   = SL::Helper::PrintOptions->get_print_options(
1438     form => $print_form,
1439     options => {dialog_name_prefix => 'print_options.',
1440                 show_headers       => 1,
1441                 no_queue           => 1,
1442                 no_postscript      => 1,
1443                 no_opendocument    => 1,
1444                 no_html            => 1},
1445   );
1446
1447   foreach my $item (@{$self->order->orderitems}) {
1448     my $price_source = SL::PriceSource->new(record_item => $item, record => $self->order);
1449     $item->active_price_source(   $price_source->price_from_source(   $item->active_price_source   ));
1450     $item->active_discount_source($price_source->discount_from_source($item->active_discount_source));
1451   }
1452
1453   if ($self->order->number && $::instance_conf->get_webdav) {
1454     my $webdav = SL::Webdav->new(
1455       type     => $self->type,
1456       number   => $self->order->number,
1457     );
1458     my @all_objects = $webdav->get_all_objects;
1459     @{ $self->{template_args}->{WEBDAV} } = map { { name => $_->filename,
1460                                                     type => t8('File'),
1461                                                     link => File::Spec->catfile($_->full_filedescriptor),
1462                                                 } } @all_objects;
1463   }
1464
1465   $::request->{layout}->use_javascript("${_}.js") for qw(kivi.SalesPurchase kivi.Order kivi.File ckeditor/ckeditor ckeditor/adapters/jquery edit_periodic_invoices_config calculate_qty);
1466   $self->setup_edit_action_bar;
1467 }
1468
1469 sub setup_edit_action_bar {
1470   my ($self, %params) = @_;
1471
1472   my $deletion_allowed = (any { $self->type eq $_ } (sales_quotation_type(), request_quotation_type()))
1473                       || (($self->type eq sales_order_type())    && $::instance_conf->get_sales_order_show_delete)
1474                       || (($self->type eq purchase_order_type()) && $::instance_conf->get_purchase_order_show_delete);
1475
1476   for my $bar ($::request->layout->get('actionbar')) {
1477     $bar->add(
1478       combobox => [
1479         action => [
1480           t8('Save'),
1481           call      => [ 'kivi.Order.save', 'save', $::instance_conf->get_order_warn_duplicate_parts,
1482                                                     $::instance_conf->get_order_warn_no_deliverydate,
1483                                                                                                       ],
1484           checks    => [ 'kivi.Order.check_save_active_periodic_invoices' ],
1485         ],
1486         action => [
1487           t8('Save as new'),
1488           call      => [ 'kivi.Order.save', 'save_as_new', $::instance_conf->get_order_warn_duplicate_parts ],
1489           checks    => [ 'kivi.Order.check_save_active_periodic_invoices' ],
1490           disabled  => !$self->order->id ? t8('This object has not been saved yet.') : undef,
1491         ],
1492         action => [
1493           t8('Save and Delivery Order'),
1494           call      => [ 'kivi.Order.save', 'save_and_delivery_order', $::instance_conf->get_order_warn_duplicate_parts,
1495                                                                        $::instance_conf->get_order_warn_no_deliverydate,
1496                                                                                                                         ],
1497           checks    => [ 'kivi.Order.check_save_active_periodic_invoices' ],
1498           only_if   => (any { $self->type eq $_ } (sales_order_type(), purchase_order_type()))
1499         ],
1500         action => [
1501           t8('Save and Invoice'),
1502           call      => [ 'kivi.Order.save', 'save_and_invoice', $::instance_conf->get_order_warn_duplicate_parts ],
1503           checks    => [ 'kivi.Order.check_save_active_periodic_invoices' ],
1504         ],
1505       ], # end of combobox "Save"
1506
1507       combobox => [
1508         action => [
1509           t8('Workflow'),
1510         ],
1511         action => [
1512           t8('Sales Order'),
1513           submit   => [ '#order_form', { action => "Order/sales_order" } ],
1514           only_if  => (any { $self->type eq $_ } (sales_quotation_type(), purchase_order_type())),
1515           disabled => !$self->order->id ? t8('This object has not been saved yet.') : undef,
1516         ],
1517         action => [
1518           t8('Purchase Order'),
1519           submit   => [ '#order_form', { action => "Order/purchase_order" } ],
1520           only_if  => (any { $self->type eq $_ } (sales_order_type(), request_quotation_type())),
1521           disabled => !$self->order->id ? t8('This object has not been saved yet.') : undef,
1522         ],
1523       ], # end of combobox "Workflow"
1524
1525       combobox => [
1526         action => [
1527           t8('Export'),
1528         ],
1529         action => [
1530           t8('Print'),
1531           call => [ 'kivi.Order.show_print_options' ],
1532         ],
1533         action => [
1534           t8('E-mail'),
1535           call => [ 'kivi.Order.email' ],
1536         ],
1537         action => [
1538           t8('Download attachments of all parts'),
1539           call     => [ 'kivi.File.downloadOrderitemsFiles', $::form->{type}, $::form->{id} ],
1540           disabled => !$self->order->id ? t8('This object has not been saved yet.') : undef,
1541           only_if  => $::instance_conf->get_doc_storage,
1542         ],
1543       ], # end of combobox "Export"
1544
1545       action => [
1546         t8('Delete'),
1547         call     => [ 'kivi.Order.delete_order' ],
1548         confirm  => $::locale->text('Do you really want to delete this object?'),
1549         disabled => !$self->order->id ? t8('This object has not been saved yet.') : undef,
1550         only_if  => $deletion_allowed,
1551       ],
1552     );
1553   }
1554 }
1555
1556 sub generate_pdf {
1557   my ($order, $pdf_ref, $params) = @_;
1558
1559   my @errors = ();
1560
1561   my $print_form = Form->new('');
1562   $print_form->{type}        = $order->type;
1563   $print_form->{formname}    = $params->{formname} || $order->type;
1564   $print_form->{format}      = $params->{format}   || 'pdf';
1565   $print_form->{media}       = $params->{media}    || 'file';
1566   $print_form->{groupitems}  = $params->{groupitems};
1567   $print_form->{media}       = 'file'                             if $print_form->{media} eq 'screen';
1568
1569   $order->language($params->{language});
1570   $order->flatten_to_form($print_form, format_amounts => 1);
1571
1572   # search for the template
1573   my ($template_file, @template_files) = SL::Helper::CreatePDF->find_template(
1574     name        => $print_form->{formname},
1575     email       => $print_form->{media} eq 'email',
1576     language    => $params->{language},
1577     printer_id  => $print_form->{printer_id},  # todo
1578   );
1579
1580   if (!defined $template_file) {
1581     push @errors, $::locale->text('Cannot find matching template for this print request. Please contact your template maintainer. I tried these: #1.', join ', ', map { "'$_'"} @template_files);
1582   }
1583
1584   return @errors if scalar @errors;
1585
1586   $print_form->throw_on_error(sub {
1587     eval {
1588       $print_form->prepare_for_printing;
1589
1590       $$pdf_ref = SL::Helper::CreatePDF->create_pdf(
1591         template  => $template_file,
1592         variables => $print_form,
1593         variable_content_types => {
1594           longdescription => 'html',
1595           partnotes       => 'html',
1596           notes           => 'html',
1597         },
1598       );
1599       1;
1600     } || push @errors, ref($EVAL_ERROR) eq 'SL::X::FormError' ? $EVAL_ERROR->getMessage : $EVAL_ERROR;
1601   });
1602
1603   return @errors;
1604 }
1605
1606 sub get_files_for_email_dialog {
1607   my ($self) = @_;
1608
1609   my %files = map { ($_ => []) } qw(versions files vc_files part_files);
1610
1611   return %files if !$::instance_conf->get_doc_storage;
1612
1613   if ($self->order->id) {
1614     $files{versions} = [ SL::File->get_all_versions(object_id => $self->order->id,              object_type => $self->order->type, file_type => 'document') ];
1615     $files{files}    = [ SL::File->get_all(         object_id => $self->order->id,              object_type => $self->order->type, file_type => 'attachment') ];
1616     $files{vc_files} = [ SL::File->get_all(         object_id => $self->order->{$self->cv}->id, object_type => $self->cv,          file_type => 'attachment') ];
1617   }
1618
1619   my @parts =
1620     uniq_by { $_->{id} }
1621     map {
1622       +{ id         => $_->part->id,
1623          partnumber => $_->part->partnumber }
1624     } @{$self->order->items_sorted};
1625
1626   foreach my $part (@parts) {
1627     my @pfiles = SL::File->get_all(object_id => $part->{id}, object_type => 'part');
1628     push @{ $files{part_files} }, map { +{ %{ $_ }, partnumber => $part->{partnumber} } } @pfiles;
1629   }
1630
1631   foreach my $key (keys %files) {
1632     $files{$key} = [ sort_by { lc $_->{db_file}->{file_name} } @{ $files{$key} } ];
1633   }
1634
1635   return %files;
1636 }
1637
1638 sub make_periodic_invoices_config_from_yaml {
1639   my ($yaml_config) = @_;
1640
1641   return if !$yaml_config;
1642   my $attr = YAML::Load($yaml_config);
1643   return if 'HASH' ne ref $attr;
1644   return SL::DB::PeriodicInvoicesConfig->new(%$attr);
1645 }
1646
1647
1648 sub get_periodic_invoices_status {
1649   my ($self, $config) = @_;
1650
1651   return                      if $self->type ne sales_order_type();
1652   return t8('not configured') if !$config;
1653
1654   my $active = ('HASH' eq ref $config)                           ? $config->{active}
1655              : ('SL::DB::PeriodicInvoicesConfig' eq ref $config) ? $config->active
1656              :                                                     die "Cannot get status of periodic invoices config";
1657
1658   return $active ? t8('active') : t8('inactive');
1659 }
1660
1661 sub get_title_for {
1662   my ($self, $action) = @_;
1663
1664   return '' if none { lc($action)} qw(add edit);
1665
1666   # for locales:
1667   # $::locale->text("Add Sales Order");
1668   # $::locale->text("Add Purchase Order");
1669   # $::locale->text("Add Quotation");
1670   # $::locale->text("Add Request for Quotation");
1671   # $::locale->text("Edit Sales Order");
1672   # $::locale->text("Edit Purchase Order");
1673   # $::locale->text("Edit Quotation");
1674   # $::locale->text("Edit Request for Quotation");
1675
1676   $action = ucfirst(lc($action));
1677   return $self->type eq sales_order_type()       ? $::locale->text("$action Sales Order")
1678        : $self->type eq purchase_order_type()    ? $::locale->text("$action Purchase Order")
1679        : $self->type eq sales_quotation_type()   ? $::locale->text("$action Quotation")
1680        : $self->type eq request_quotation_type() ? $::locale->text("$action Request for Quotation")
1681        : '';
1682 }
1683
1684 sub sales_order_type {
1685   'sales_order';
1686 }
1687
1688 sub purchase_order_type {
1689   'purchase_order';
1690 }
1691
1692 sub sales_quotation_type {
1693   'sales_quotation';
1694 }
1695
1696 sub request_quotation_type {
1697   'request_quotation';
1698 }
1699
1700 sub nr_key {
1701   return $_[0]->type eq sales_order_type()       ? 'ordnumber'
1702        : $_[0]->type eq purchase_order_type()    ? 'ordnumber'
1703        : $_[0]->type eq sales_quotation_type()   ? 'quonumber'
1704        : $_[0]->type eq request_quotation_type() ? 'quonumber'
1705        : '';
1706 }
1707
1708 1;
1709
1710 __END__
1711
1712 =encoding utf-8
1713
1714 =head1 NAME
1715
1716 SL::Controller::Order - controller for orders
1717
1718 =head1 SYNOPSIS
1719
1720 This is a new form to enter orders, completely rewritten with the use
1721 of controller and java script techniques.
1722
1723 The aim is to provide the user a better expirience and a faster flow
1724 of work. Also the code should be more readable, more reliable and
1725 better to maintain.
1726
1727 =head2 Key Features
1728
1729 =over 4
1730
1731 =item *
1732
1733 One input row, so that input happens every time at the same place.
1734
1735 =item *
1736
1737 Use of pickers where possible.
1738
1739 =item *
1740
1741 Possibility to enter more than one item at once.
1742
1743 =item *
1744
1745 Save order only on "save" (and "save and delivery order"-workflow). No
1746 hidden save on "print" or "email".
1747
1748 =item *
1749
1750 Item list in a scrollable area, so that the workflow buttons stay at
1751 the bottom.
1752
1753 =item *
1754
1755 Reordering item rows with drag and drop is possible. Sorting item rows is
1756 possible (by partnumber, description, qty, sellprice and discount for now).
1757
1758 =item *
1759
1760 No C<update> is necessary. All entries and calculations are managed
1761 with ajax-calls and the page does only reload on C<save>.
1762
1763 =item *
1764
1765 User can see changes immediately, because of the use of java script
1766 and ajax.
1767
1768 =back
1769
1770 =head1 CODE
1771
1772 =head2 Layout
1773
1774 =over 4
1775
1776 =item * C<SL/Controller/Order.pm>
1777
1778 the controller
1779
1780 =item * C<template/webpages/order/form.html>
1781
1782 main form
1783
1784 =item * C<template/webpages/order/tabs/basic_data.html>
1785
1786 Main tab for basic_data.
1787
1788 This is the only tab here for now. "linked records" and "webdav" tabs are
1789 reused from generic code.
1790
1791 =over 4
1792
1793 =item * C<template/webpages/order/tabs/_business_info_row.html>
1794
1795 For displaying information on business type
1796
1797 =item * C<template/webpages/order/tabs/_item_input.html>
1798
1799 The input line for items
1800
1801 =item * C<template/webpages/order/tabs/_row.html>
1802
1803 One row for already entered items
1804
1805 =item * C<template/webpages/order/tabs/_tax_row.html>
1806
1807 Displaying tax information
1808
1809 =item * C<template/webpages/order/tabs/_multi_items_dialog.html>
1810
1811 Dialog for entering more than one item at once
1812
1813 =item * C<template/webpages/order/tabs/_multi_items_result.html>
1814
1815 Results for the filter in the multi items dialog
1816
1817 =item * C<template/webpages/order/tabs/_price_sources_dialog.html>
1818
1819 Dialog for selecting price and discount sources
1820
1821 =back
1822
1823 =item * C<js/kivi.Order.js>
1824
1825 java script functions
1826
1827 =back
1828
1829 =head1 TODO
1830
1831 =over 4
1832
1833 =item * testing
1834
1835 =item * currency
1836
1837 =item * credit limit
1838
1839 =item * more workflows (save as new, quotation, purchase order)
1840
1841 =item * price sources: little symbols showing better price / better discount
1842
1843 =item * select units in input row?
1844
1845 =item * custom shipto address
1846
1847 =item * check for direct delivery (workflow sales order -> purchase order)
1848
1849 =item * language / part translations
1850
1851 =item * access rights
1852
1853 =item * display weights
1854
1855 =item * history
1856
1857 =item * mtime check
1858
1859 =item * optional client/user behaviour
1860
1861 (transactions has to be set - department has to be set -
1862  force project if enabled in client config - transport cost reminder)
1863
1864 =back
1865
1866 =head1 KNOWN BUGS AND CAVEATS
1867
1868 =over 4
1869
1870 =item *
1871
1872 Customer discount is not displayed as a valid discount in price source popup
1873 (this might be a bug in price sources)
1874
1875 (I cannot reproduce this (Bernd))
1876
1877 =item *
1878
1879 No indication that <shift>-up/down expands/collapses second row.
1880
1881 =item *
1882
1883 Inline creation of parts is not currently supported
1884
1885 =item *
1886
1887 Table header is not sticky in the scrolling area.
1888
1889 =item *
1890
1891 Sorting does not include C<position>, neither does reordering.
1892
1893 This behavior was implemented intentionally. But we can discuss, which behavior
1894 should be implemented.
1895
1896 =item *
1897
1898 C<show_multi_items_dialog> does not use the currently inserted string for
1899 filtering.
1900
1901 =item *
1902
1903 The language selected in print or email dialog is not saved when the order is saved.
1904
1905 =back
1906
1907 =head1 To discuss / Nice to have
1908
1909 =over 4
1910
1911 =item *
1912
1913 How to expand/collapse second row. Now it can be done clicking the icon or
1914 <shift>-up/down.
1915
1916 =item *
1917
1918 Possibility to change longdescription in input row?
1919
1920 =item *
1921
1922 Possibility to select PriceSources in input row?
1923
1924 =item *
1925
1926 This controller uses a (changed) copy of the template for the PriceSource
1927 dialog. Maybe there could be used one code source.
1928
1929 =item *
1930
1931 Rounding-differences between this controller (PriceTaxCalculator) and the old
1932 form. This is not only a problem here, but also in all parts using the PTC.
1933 There exists a ticket and a patch. This patch should be testet.
1934
1935 =item *
1936
1937 An indicator, if the actual inputs are saved (like in an
1938 editor or on text processing application).
1939
1940 =item *
1941
1942 A warning when leaving the page without saveing unchanged inputs.
1943
1944 =item *
1945
1946 Workflows for delivery order and invoice are in the menu "Save", because the
1947 order is saved before opening the new document form. Nevertheless perhaps these
1948 workflow buttons should be put under "Workflows".
1949
1950
1951 =back
1952
1953 =head1 AUTHOR
1954
1955 Bernd Bleßmann E<lt>bernd@kivitendo-premium.deE<gt>
1956
1957 =cut