Projekt

Allgemein

Profil

Herunterladen (84 KB) Statistiken
| Zweig: | Markierung: | Revision:

kivitendo/SL/Controller/DeliveryOrder.pm @ 8eaf5ab5

"DeliveryOrder.pm.html#L1305" data-txt="1305">
package SL::Controller::DeliveryOrder;

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

use SL::Helper::Flash qw(flash_later);
use SL::Helper::Number qw(_format_number _parse_number);
use SL::Presenter::Tag qw(select_tag hidden_tag div_tag);
use SL::Presenter::DeliveryOrder qw(delivery_order_status_line);
use SL::Locale::String qw(t8);
use SL::SessionFile::Random;
use SL::PriceSource;
use SL::Webdav;
use SL::File;
use SL::MIME;
use SL::YAML;
use SL::DB::History;
use SL::DB::Order;
use SL::DB::Default;
use SL::DB::Unit;
use SL::DB::Order;
use SL::DB::Part;
use SL::DB::PartClassification;
use SL::DB::PartsGroup;
use SL::DB::Printer;
use SL::DB::Language;
use SL::DB::Reclamation;
use SL::DB::RecordLink;
use SL::DB::Shipto;
use SL::DB::Translation;
use SL::DB::TransferType;
use SL::DB::ValidityToken;
use SL::DB::Warehouse;
use SL::DB::Helper::RecordLink qw(set_record_link_conversions);
use SL::Model::Record;

use SL::Helper::CreatePDF qw(:all);
use SL::Helper::PrintOptions;
use SL::Helper::ShippedQty;
use SL::Helper::UserPreferences::DisplayPreferences;
use SL::Helper::UserPreferences::PositionsScrollbar;
use SL::Helper::UserPreferences::UpdatePositions;

use SL::Controller::Helper::GetModels;
use SL::Controller::DeliveryOrder::TypeData qw(:types);

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) ],
'scalar --get_set_init' => [ qw(order valid_types type cv p all_price_factors search_cvpartnumber show_update_button part_picker_classification_ids type_data) ],
);


# safety
__PACKAGE__->run_before('check_auth',
except => [ qw(update_stock_information) ]);

__PACKAGE__->run_before('check_auth_for_edit',
except => [ qw(update_stock_information edit show_customer_vendor_details_dialog price_popup stock_in_out_dialog load_second_rows) ]);

__PACKAGE__->run_before('get_unalterable_data',
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(SL::Model::Record->update_after_new($self->order, $self->type));

$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->render(
'delivery_order/form',
title => $self->get_title_for('add'),
%{$self->{template_args}}
);
}

sub action_add_from_order {
my ($self) = @_;
# this interfers with init_order
$self->{converted_from_oe_id} = delete $::form->{id};

$self->type_data->validate($::form->{type});

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

my $target_type = $::form->{type};
my $delivery_order = SL::Model::Record->new_from_workflow($order, $target_type);
$self->order($delivery_order);

$self->action_add;
}

sub action_add_from_reclamation {
my ($self) = @_;

my $reclamation = SL::DB::Reclamation->new(id => $::form->{from_id})->load;
my $target_type = $reclamation->is_sales ? 'rma_delivery_order'
: 'supplier_delivery_order';
my $delivery_order = SL::Model::Record->new_from_workflow($reclamation, $target_type);
$self->{converted_from_reclamation_id} = $::form->{from_id};
$self->order($delivery_order);

$self->action_add;
}

# edit an existing order
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(
'delivery_order/form',
title => $self->get_title_for('edit'),
%{$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) {
$self->order(SL::DB::DeliveryOrder->new(id => $multi_ids[0])->load);
$self->action_save_as_new();
return;
}

# make new order from given orders
my @multi_orders = map { SL::DB::DeliveryOrder->new(id => $_)->load } @multi_ids;
$self->{converted_from_oe_id} = join ' ', map { $_->id } @multi_orders;
my $target_type = "sales_delivery_order";
my $delivery_order = SL::Model::Record->new_from_workflow_multi(\@multi_orders, $target_type, sort_sources_by => 'transdate');
$self->order($delivery_order);

$self->action_edit();
}

# delete the order
sub action_delete {
my ($self) = @_;

my $number_type = $self->type_data;
my %history = (snumbers => $self->type . '_' . $self->order->number);
my %params = (history => \%history);
SL::Model::Record->delete($self->order,%params);
flash_later('info', $self->type_data->text("delete"));

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();
}

flash_later('info', $self->type_data->text("saved"));

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();
}

my $saved_order = SL::DB::DeliveryOrder->new(id => $order->id)->load;

# Create new record from current one
my $updated_order = SL::Model::Record->update_for_save_as_new($saved_order, $order);

$self->order($updated_order);

# no linked records on save as new
delete $::form->{$_} for qw(converted_from_oe_id converted_from_orderitems_ids);

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

# save
$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) = @_;

if ( !$self->order->delivered ) {
my $errors = $self->save();

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

$self->js_reset_order_and_item_ids_after_save;
}

my $format = $::form->{print_options}->{format};
my $media = $::form->{print_options}->{media};
my $formname = $::form->{print_options}->{formname};
my $copies = $::form->{print_options}->{copies};
$details{discount_as_percent} = $cv->discount_as_percent;
$details{creditlimt} = $cv->creditlimit_as_number;
$details{business} = $cv->business->description if $cv->business;
$details{language} = $cv->language_obj->description if $cv->language_obj;
$details{delivery_terms} = $cv->delivery_term->description if $cv->delivery_term;
$details{payment_terms} = $cv->payment->description if $cv->payment;
$details{pricegroup} = $cv->pricegroup->pricegroup if $is_customer && $cv->pricegroup;

foreach my $entry (@{ $cv->shipto }) {
push @{ $details{SHIPTO} }, { map { $_ => $entry->$_ } @{$entry->meta->columns} };
}
foreach my $entry (@{ $cv->contacts }) {
push @{ $details{CONTACTS} }, { map { $_ => $entry->$_ } @{$entry->meta->columns} };
}

$_[0]->render('common/show_vc_details', { layout => 0 },
is_customer => $is_customer,
%details);

}

# called if a unit in an existing item row is changed
sub action_unit_changed {
my ($self) = @_;

my $idx = first_index { $_ eq $::form->{item_id} } @{ $::form->{orderitem_ids} };
my $item = $self->order->items_sorted->[$idx];

my $old_unit_obj = SL::DB::Unit->new(name => $::form->{old_unit})->load;
$item->sellprice($item->unit_obj->convert_to($item->sellprice, $old_unit_obj));

$self->js
->run('kivi.DeliveryOrder.update_sellprice', $::form->{item_id}, $item->sellprice_as_number);
$self->js_redisplay_line_values;
$self->js->render();
}

# add an item row for a new item entered in the input row
sub action_add_item {
my ($self) = @_;

delete $::form->{add_item}->{create_part_type};

my $form_attr = $::form->{add_item};

return unless $form_attr->{parts_id};

my $item = new_item($self->order, $form_attr);

$self->order->add_items($item);

$self->get_item_cvpartnumber($item);

my $item_id = join('_', 'new', Time::HiRes::gettimeofday(), int rand 1000000000000);
my $row_as_html = $self->p->render('delivery_order/tabs/_row',
ITEM => $item,
ID => $item_id,
SELF => $self,
in_out => $self->type_data->transfer,
);

if ($::form->{insert_before_item_id}) {
$self->js
->before ('.row_entry:has(#item_' . $::form->{insert_before_item_id} . ')', $row_as_html);
} else {
$self->js
->append('#row_table_id', $row_as_html);
}

if ( $item->part->is_assortment ) {
$form_attr->{qty_as_number} = 1 unless $form_attr->{qty_as_number};
foreach my $assortment_item ( @{$item->part->assortment_items} ) {
my $attr = { parts_id => $assortment_item->parts_id,
qty => $assortment_item->qty * $::form->parse_amount(\%::myconfig, $form_attr->{qty_as_number}), # TODO $form_attr->{unit}
unit => $assortment_item->unit,
description => $assortment_item->part->description,
};
my $item = new_item($self->order, $attr);

# set discount to 100% if item isn't supposed to be charged, overwriting any customer discount
$item->discount(1) unless $assortment_item->charge;

$self->order->add_items( $item );
$self->get_item_cvpartnumber($item);
my $item_id = join('_', 'new', Time::HiRes::gettimeofday(), int rand 1000000000000);
my $row_as_html = $self->p->render('delivery_order/tabs/_row',
ITEM => $item,
ID => $item_id,
SELF => $self,
);
if ($::form->{insert_before_item_id}) {
$self->js
->before ('.row_entry:has(#item_' . $::form->{insert_before_item_id} . ')', $row_as_html);
} else {
$self->js
->append('#row_table_id', $row_as_html);
}
};
};

$self->js
->val('.add_item_input', '')
->run('kivi.DeliveryOrder.init_row_handlers')
->run('kivi.DeliveryOrder.renumber_positions')
->focus('#add_item_parts_id_name');

$self->js->run('kivi.DeliveryOrder.row_table_scroll_down') if !$::form->{insert_before_item_id};

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

# add item rows for multiple items at once
sub action_add_multi_items {
my ($self) = @_;

my @form_attr = grep { $_->{qty_as_number} } @{ $::form->{add_items} };
return $self->js->render() unless scalar @form_attr;

my @items;
foreach my $attr (@form_attr) {
my $item = new_item($self->order, $attr);
push @items, $item;
if ( $item->part->is_assortment ) {
foreach my $assortment_item ( @{$item->part->assortment_items} ) {
my $attr = { parts_id => $assortment_item->parts_id,
qty => $assortment_item->qty * $item->qty, # TODO $form_attr->{unit}
unit => $assortment_item->unit,
description => $assortment_item->part->description,
};
my $item = new_item($self->order, $attr);

# set discount to 100% if item isn't supposed to be charged, overwriting any customer discount
$item->discount(1) unless $assortment_item->charge;
push @items, $item;
}
}
}
$self->order->add_items(@items);

foreach my $item (@items) {
$self->get_item_cvpartnumber($item);
my $item_id = join('_', 'new', Time::HiRes::gettimeofday(), int rand 1000000000000);
my $row_as_html = $self->p->render('delivery_order/tabs/_row',
ITEM => $item,
ID => $item_id,
SELF => $self,
in_out => $self->type_data->transfer,
);

if ($::form->{insert_before_item_id}) {
$self->js
->before ('.row_entry:has(#item_' . $::form->{insert_before_item_id} . ')', $row_as_html);
} else {
$self->js
->append('#row_table_id', $row_as_html);
}
}

$self->js
->run('kivi.Part.close_picker_dialogs')
->run('kivi.DeliveryOrder.init_row_handlers')
->run('kivi.DeliveryOrder.renumber_positions')
->focus('#add_item_parts_id_name');

$self->js->run('kivi.DeliveryOrder.row_table_scroll_down') if !$::form->{insert_before_item_id};

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

sub action_update_exchangerate {
my ($self) = @_;

my $data = {
is_standard => $self->order->currency_id == $::instance_conf->get_currency_id,
currency_name => $self->order->currency->name,
};

$self->render(\SL::JSON::to_json($data), { type => 'json', process => 0 });
}

# redisplay item rows if they are sorted by an attribute
sub action_reorder_items {
my ($self) = @_;

my %sort_keys = (
partnumber => sub { $_[0]->part->partnumber },
description => sub { $_[0]->description },
qty => sub { $_[0]->qty },
sellprice => sub { $_[0]->sellprice },
discount => sub { $_[0]->discount },
cvpartnumber => sub { $_[0]->{cvpartnumber} },
);

$self->get_item_cvpartnumber($_) for @{$self->order->items_sorted};

my $method = $sort_keys{$::form->{order_by}};
my @to_sort = map { { old_pos => $_->position, order_by => $method->($_) } } @{ $self->order->items_sorted };
if ($::form->{sort_dir}) {
if ( $::form->{order_by} =~ m/qty|sellprice|discount/ ){
@to_sort = sort { $a->{order_by} <=> $b->{order_by} } @to_sort;
} else {
@to_sort = sort { $a->{order_by} cmp $b->{order_by} } @to_sort;
}
} else {
if ( $::form->{order_by} =~ m/qty|sellprice|discount/ ){
@to_sort = sort { $b->{order_by} <=> $a->{order_by} } @to_sort;
} else {
@to_sort = sort { $b->{order_by} cmp $a->{order_by} } @to_sort;
}
}
$self->js
->run('kivi.DeliveryOrder.redisplay_items', \@to_sort)
->render;
}

# show the popup to choose a price/discount source
sub action_price_popup {
my ($self) = @_;

my $idx = first_index { $_ eq $::form->{item_id} } @{ $::form->{orderitem_ids} };
my $item = $self->order->items_sorted->[$idx];

$self->render_price_dialog($item);
}

# save the order in a session variable and redirect to the part controller
sub action_create_part {
my ($self) = @_;

my $previousform = $::auth->save_form_in_session(non_scalars => 1);

my $callback = $self->url_for(
action => 'return_from_create_part',
type => $self->type, # type is needed for check_auth on return
previousform => $previousform,
);

flash_later('info', t8('You are adding a new part while you are editing another document. You will be redirected to your document when saving the new part or aborting this form.'));

my @redirect_params = (
controller => 'Part',
action => 'add',
part_type => $::form->{add_item}->{create_part_type},
callback => $callback,
inline_create => 1,
);

$self->redirect_to(@redirect_params);
}

sub action_return_from_create_part {
my ($self) = @_;

$self->{created_part} = SL::DB::Part->new(id => delete $::form->{new_parts_id})->load if $::form->{new_parts_id};

$::auth->restore_form_from_session(delete $::form->{previousform});

# 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);
}

$self->get_unalterable_data();
$self->pre_render();

# trigger rendering values for second row/longdescription 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 };
$_->{render_longdescription} = 1 for @{ $self->order->items_sorted };

$self->render(
'delivery_order/form',
title => $self->get_title_for('edit'),
%{$self->{template_args}}
);

}

sub action_stock_in_out_dialog {
my ($self) = @_;

my $part = SL::DB::Part->load_cached($::form->{parts_id}) or die "need parts_id";
my $unit = SL::DB::Unit->load_cached($::form->{unit}) or die "need unit";
my $stock = $::form->{stock};
my $row = $::form->{row};
my $item_id = $::form->{item_id};
my $qty = _parse_number($::form->{qty_as_number});

my $inout = $self->type_data->transfer;

my @contents = DO->get_item_availability(parts_id => $part->id);
my $stock_info = DO->unpack_stock_information(packed => $stock);

$self->merge_stock_data($stock_info, \@contents, $part, $unit);

$self->render("delivery_order/stock_dialog", { layout => 0 },
WHCONTENTS => \@contents,
STOCK_INFO => $stock_info,
WAREHOUSES => SL::DB::Manager::Warehouse->get_all(with_objects=> ["bins",]),
part => $part,
do_qty => $qty,
do_unit => $unit->unit,
delivered => $self->order->delivered,
row => $row,
item_id => $item_id,
in_out => $inout,
);
}

sub action_add_stock_in_line_to_dialog {
my ($self) = @_;

my $do_qty = _parse_number($::form->{do_qty});
my $qty_sum = $::form->{qty_sum};
my $row_count = $::form->{row_count};
my $part = SL::DB::Part->load_cached($::form->{parts_id}) or die "need parts_id";

my $row_as_html = $self->p->render('delivery_order/stock_dialog/_stock_in_new_row',
WAREHOUSES => SL::DB::Manager::Warehouse->get_all(with_objects=> ["bins",]),
PART => $part,
pos => $row_count + 1,
remaining_qty => $do_qty - $qty_sum,
);

$self->js->append('#stock-in-out-table', $row_as_html)->render();
}

sub action_update_stock_information {
my ($self) = @_;

my $stock_info = $::form->{stock_info};
my $unit = $::form->{unit};
my $yaml = SL::YAML::Dump($stock_info);
my $stock_qty = $self->calculate_stock_in_out_from_stock_info($unit, $stock_info);

my $response = {
stock_info => $yaml,
stock_qty => $stock_qty,
};
$self->render(\ SL::JSON::to_json($response), { layout => 0, type => 'json', process => 0 });
}

$::auth->assert($self->type_data->access('view') || 'DOES_NOT_EXIST');
}

sub check_auth_for_edit {
my ($self) = @_;

$::auth->assert($self->type_data->access('edit') || 'DOES_NOT_EXIST');
}

# build the selection box for contacts
#
# Needed, if customer/vendor changed.
sub build_contact_select {
my (