projekt kivitendo

package SL::Controller::DeliveryOrder;

use strict;

use parent qw(SL::Controller::Base);

use SL::Helper::Flash qw(flash_later);

use SL::SessionFile::Random;

use SL::PriceSource;

use SL::Webdav;

use SL::File;

use SL::MIME;

use SL::Util qw(trim);

use SL::YAML;

use SL::DB::History;

use SL::DB::Order;

use SL::DB::Default;

use SL::DB::Unit;

use SL::DB::PartClassification;

use SL::DB::PartsGroup;

use SL::DB::Printer;

use SL::DB::Language;

use SL::DB::Shipto;

use SL::DB::Translation;

use SL::Helper::CreatePDF qw(:all);

use SL::Helper::PrintOptions;

use SL::Helper::ShippedQty;

use SL::Helper::UserPreferences::UpdatePositions;

use SL::Controller::Helper::GetModels;

use List::Util qw(first sum0);

use List::UtilsBy qw(sort_by uniq_by);

use List::MoreUtils qw(any none pairwise first_index);

use English qw(-no_match_vars);

use File::Spec;

use Cwd;

use Sort::Naturally;

use Rose::Object::MakeMethods::Generic

(

scalar => [ qw(item_ids_to_delete is_custom_shipto_to_delete) ],

# safety

except => [ qw(update_stock_information edit show_customer_vendor_details_dialog price_popup stock_in_out_dialog load_second_rows) ]);

only => [ qw(save save_as_new save_and_delivery_order save_and_invoice save_and_ap_transaction

print send_email) ]);

#

# actions

#

# add a new order

sub action_add {

my ($self) = @_;

$self->order->transdate(DateTime->now_local());

$self->pre_render();

if (!$::form->{form_validity_token}) {

$::form->{form_validity_token} = SL::DB::ValidityToken->create(scope => SL::DB::ValidityToken::SCOPE_DELIVERY_ORDER_SAVE())->token;

}

%{$self->{template_args}}

);

}

my ($self) = @_;

# this interfers with init_order

$self->{converted_from_oe_id} = delete $::form->{id};

my $order = SL::DB::Order->new(id => $self->{converted_from_oe_id})->load;

$self->order(SL::DB::DeliveryOrder->new_from($order, type => $::form->{type}));

$self->action_add;

}

my ($self) = @_;

my $reclamation = SL::DB::Reclamation->new(id => $::form->{from_id})->load;

$self->{converted_from_reclamation_id} = $::form->{from_id};

$self->action_add;

}

sub action_edit {

my ($self) = @_;

if ($::form->{id}) {

$self->load_order;

} else {

# this is to edit an order from an unsaved order object

# set item ids to new fake id, to identify them as new items

foreach my $item (@{$self->order->items_sorted}) {

$item->{new_fake_id} = join('_', 'new', Time::HiRes::gettimeofday(), int rand 1000000000000);

}

# trigger rendering values for second row as hidden, because they

# are loaded only on demand. So we need to keep the values from

# the source.

$_->{render_second_row} = 1 for @{ $self->order->items_sorted };

if (!$::form->{form_validity_token}) {

$::form->{form_validity_token} = SL::DB::ValidityToken->create(scope => SL::DB::ValidityToken::SCOPE_DELIVERY_ORDER_SAVE())->token;

}

$self->pre_render();

$self->render(

%{$self->{template_args}}

);

}

# edit a collective order (consisting of one or more existing orders)

sub action_edit_collective {

my ($self) = @_;

# collect order ids

my @multi_ids = map {

$_ =~ m{^multi_id_(\d+)$} && $::form->{'multi_id_' . $1} && $::form->{'trans_id_' . $1} && $::form->{'trans_id_' . $1}

} grep { $_ =~ m{^multi_id_\d+$} } keys %$::form;

# fall back to add if no ids are given

if (scalar @multi_ids == 0) {

$self->action_add();

return;

}

# fall back to save as new if only one id is given

if (scalar @multi_ids == 1) {

return;

}

# make new order from given orders

$self->action_edit();

}

# delete the order

sub action_delete {

my ($self) = @_;

my $errors = $self->delete();

if (scalar @{ $errors }) {

$self->js->flash('error', $_) foreach @{ $errors };

return $self->js->render();

}

my @redirect_params = (

action => 'add',

type => $self->type,

);

$self->redirect_to(@redirect_params);

}

# save the order

sub action_save {

my ($self) = @_;

my $errors = $self->save();

if (scalar @{ $errors }) {

$self->js->flash('error', $_) foreach @{ $errors };

return $self->js->render();

}

my @redirect_params = (

action => 'edit',

type => $self->type,

id => $self->order->id,

);

$self->redirect_to(@redirect_params);

}

# save the order as new document an open it for edit

sub action_save_as_new {

my ($self) = @_;

my $order = $self->order;

if (!$order->id) {

$self->js->flash('error', t8('This object has not been saved yet.'));

return $self->js->render();

}

# load order from db to check if values changed

my %new_attrs;

# Lets assign a new number if the user hasn't changed the previous one.

# If it has been changed manually then use it as-is.

$new_attrs{number} = (trim($order->number) eq $saved_order->number)

? ''

: trim($order->number);

# Clear transdate unless changed

$new_attrs{transdate} = ($order->transdate == $saved_order->transdate)

? DateTime->today_local

: $order->transdate;

# Set new reqdate unless changed if it is enabled in client config

# Update employee

$new_attrs{employee} = SL::DB::Manager::Employee->current;

# Create new record from current one

# no linked records on save as new

delete $::form->{$_} for qw(converted_from_oe_id converted_from_orderitems_ids);

$::form->{form_validity_token} = SL::DB::ValidityToken->create(scope => SL::DB::ValidityToken::SCOPE_DELIVERY_ORDER_SAVE())->token;

}

$self->action_save();

}

# print the order

#

# This is called if "print" is pressed in the print dialog.

# If PDF creation was requested and succeeded, the pdf is offered for download

# via send_file (which uses ajax in this case).

sub action_print {

my ($self) = @_;

my $errors = $self->save();

$self->js->flash('error', $_) foreach @{ $errors };

return $self->js->render();

}

}

my $format = $::form->{print_options}->{format};

my $media = $::form->{print_options}->{media};

my $formname = $::form->{print_options}->{formname};

my $copies = $::form->{print_options}->{copies};

my $groupitems = $::form->{print_options}->{groupitems};

my $printer_id = $::form->{print_options}->{printer_id};

# only pdf and opendocument by now

if (none { $format eq $_ } qw(pdf opendocument opendocument_pdf)) {

return $self->js->flash('error', t8('Format \'#1\' is not supported yet/anymore.', $format))->render;

}

# only screen or printer by now

if (none { $media eq $_ } qw(screen printer)) {

return $self->js->flash('error', t8('Media \'#1\' is not supported yet/anymore.', $media))->render;

}

# create a form for generate_attachment_filename

my $form = Form->new;

$form->{$self->nr_key()} = $self->order->number;

$form->{type} = $self->type;

$form->{format} = $format;

$form->{formname} = $formname;

$form->{language} = '_' . $self->order->language->template_code if $self->order->language;

my $pdf_filename = $form->generate_attachment_filename();

$main::lxdebug->dump(0, 'WH: PDF ', $pdf_filename);

my @errors = generate_pdf($self->order, \$pdf, { format => $format,

formname => $formname,

language => $self->order->language,

printer_id => $printer_id,

groupitems => $groupitems });

if (scalar @errors) {

return $self->js->flash('error', t8('Conversion to PDF failed: #1', $errors[0]))->render;

}

if ($media eq 'screen') {

# screen/download

$self->js->flash('info', t8('The PDF has been created'));

$self->send_file(

\$pdf,

type => SL::MIME->mime_type_from_ext($pdf_filename),

name => $pdf_filename,

js_no_render => 1,

);

} elsif ($media eq 'printer') {

# printer

my $printer_id = $::form->{print_options}->{printer_id};

SL::DB::Printer->new(id => $printer_id)->load->print_document(

copies => $copies,

content => $pdf,

);

$self->js->flash('info', t8('The PDF has been printed'));

}

my @warnings = store_pdf_to_webdav_and_filemanagement($self->order, $pdf, $pdf_filename);

if (scalar @warnings) {

$self->js->flash('warning', $_) for @warnings;

}

$self->save_history('PRINTED');

$self->js

->run('kivi.ActionBar.setEnabled', '#save_and_email_action')

->render;

}

sub action_preview_pdf {

my ($self) = @_;

my $errors = $self->save();

if (scalar @{ $errors }) {

$self->js->flash('error', $_) foreach @{ $errors };

return $self->js->render();

}

}

my $format = 'pdf';

my $media = 'screen';

my $formname = $self->type;

# only pdf

# create a form for generate_attachment_filename

my $form = Form->new;

$form->{$self->nr_key()} = $self->order->number;

$form->{type} = $self->type;

$form->{format} = $format;

$form->{formname} = $formname;

$form->{language} = '_' . $self->order->language->template_code if $self->order->language;

my $pdf_filename = $form->generate_attachment_filename();

my $pdf;

my @errors = generate_pdf($self->order, \$pdf, { format => $format,

formname => $formname,

language => $self->order->language,

});

if (scalar @errors) {

return $self->js->flash('error', t8('Conversion to PDF failed: #1', $errors[0]))->render;

}

$self->save_history('PREVIEWED');

$self->js->flash('info', t8('The PDF has been previewed'));

# screen/download

$self->send_file(

\$pdf,

type => SL::MIME->mime_type_from_ext($pdf_filename),

name => $pdf_filename,

js_no_render => 0,

);

}

# open the email dialog

sub action_save_and_show_email_dialog {

my ($self) = @_;

my $errors = $self->save();

$self->js->flash('error', $_) foreach @{ $errors };

return $self->js->render();

}

my $cv_method = $self->cv;

if (!$self->order->$cv_method) {

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'))

->render($self);

}

my $email_form;

$email_form->{to} = $self->order->contact->cp_email if $self->order->contact;

$email_form->{to} ||= $self->order->$cv_method->email;

$email_form->{cc} = $self->order->$cv_method->cc;

my $form = Form->new;

$form->{$self->nr_key()} = $self->order->number;

$form->{cusordnumber} = $self->order->cusordnumber;

$form->{formname} = $self->type;

$form->{type} = $self->type;

$form->{language} = '_' . $self->order->language->template_code if $self->order->language;

$form->{language_id} = $self->order->language->id if $self->order->language;

$form->{format} = 'pdf';

$form->{cp_id} = $self->order->contact->cp_id if $self->order->contact;

$email_form->{subject} = $form->generate_email_subject();

$email_form->{attachment_filename} = $form->generate_attachment_filename();

$email_form->{message} = $form->generate_email_body();

my %files = $self->get_files_for_email_dialog();

$self->{all_employees} = SL::DB::Manager::Employee->get_all(query => [ deleted => 0 ]);

my $dialog_html = $self->render('common/_send_email_dialog', { output => 0 },

email_form => $email_form,

show_bcc => $::auth->assert('email_bcc', 'may fail'),

FILES => \%files,

);

$self->js

->render($self);

}

# send email

#

# Todo: handling error messages: flash is not displayed in dialog, but in the main form

sub action_send_email {

my ($self) = @_;

my $errors = $self->save();

$self->js->run('kivi.DeliveryOrder.close_email_dialog');

$self->js->flash('error', $_) foreach @{ $errors };

return $self->js->render();

}

$self->js_reset_order_and_item_ids_after_save;

my $email_form = delete $::form->{email_form};

my %field_names = (to => 'email');

$::form->{ $field_names{$_} // $_ } = $email_form->{$_} for keys %{ $email_form };

# for Form::cleanup which may be called in Form::send_email

$::form->{cwd} = getcwd();

$::form->{tmpdir} = $::lx_office_conf{paths}->{userspath};

$::form->{$_} = $::form->{print_options}->{$_} for keys %{ $::form->{print_options} };

$::form->{media} = 'email';

if (($::form->{attachment_policy} // '') !~ m{^(?:old_file|no_file)$}) {

my $pdf;

my @errors = generate_pdf($self->order, \$pdf, {media => $::form->{media},

format => $::form->{print_options}->{format},

formname => $::form->{print_options}->{formname},

language => $self->order->language,

printer_id => $::form->{print_options}->{printer_id},

groupitems => $::form->{print_options}->{groupitems}});

if (scalar @errors) {

return $self->js->flash('error', t8('Conversion to PDF failed: #1', $errors[0]))->render($self);

}

my @warnings = store_pdf_to_webdav_and_filemanagement($self->order, $pdf, $::form->{attachment_filename});

if (scalar @warnings) {

flash_later('warning', $_) for @warnings;

}

my $sfile = SL::SessionFile::Random->new(mode => "w");

$sfile->fh->print($pdf);

$sfile->fh->close;

$::form->{tmpfile} = $sfile->file_name;

$::form->{tmpdir} = $sfile->get_path; # for Form::cleanup which may be called in Form::send_email

}

$::form->{id} = $self->order->id; # this is used in SL::Mailer to create a linked record to the mail

$::form->send_email(\%::myconfig, 'pdf');

unless ($::instance_conf->get_email_journal) {

my $intnotes = $self->order->intnotes;

$intnotes .= "\n\n" if $self->order->intnotes;

$intnotes .= t8('[email]') . "\n";

$intnotes .= t8('Date') . ": " . $::locale->format_date_object(DateTime->now_local, precision => 'seconds') . "\n";

$intnotes .= t8('To (email)') . ": " . $::form->{email} . "\n";

$intnotes .= t8('Cc') . ": " . $::form->{cc} . "\n" if $::form->{cc};

$intnotes .= t8('Bcc') . ": " . $::form->{bcc} . "\n" if $::form->{bcc};