projekt kivitendo

use SL::DB::Order;

use SL::DB::OrderItem;

use SL::DB::Order::TypeData qw(:types);

use SL::DB::Helper::TypeDataProxy;

use SL::DB::Helper::Record qw(get_object_name_from_type get_class_from_type);

use SL::Model::Record;

use Rose::Object::MakeMethods::Generic

(

 scalar => [ qw(item_ids_to_delete ) ],

 'scalar --get_set_init' => [ qw(poso valid_types type type_data) ],

);

  $self->pre_render();

    %{$self->{template_args}}

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

  unless ($form_attr->{parts_id}) {

    $self->js->flash('error', t8("No part was selected."));

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

  }

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

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

  $self->recalc();

  $self->get_item_cvpartnumber($item);

  my $item_id = join('_', 'new', Time::HiRes::gettimeofday(), int rand 1000000000000);

  my $row_as_html = $self->p->render('pos/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.Order.init_row_handlers')

    ->run('kivi.Order.renumber_positions')

    ->focus('#add_item_parts_id_name');

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

  $self->js_redisplay_amounts_and_taxes;

  $self->js->render();

}

# Create a new order object

#

# And assign changes from the form to this object.

# Create/Update items from form (via make_item) and add them.

sub make_order {

  my ($self) = @_;

  # add_items adds items to an order with no items for saving, but they

  # cannot be retrieved via items until the order is saved. Adding empty

  # items to new order here solves this problem.

  my $order = SL::DB::Order->new(

                     record_type => 'sales_order',

                     orderitems  => [],

                     currency_id => $::instance_conf->get_currency_id(),

                   );

  if (!$::form->{id} && $::form->{customer_id}) {

    $order->customer_id($::form->{customer_id});

    $order = SL::Model::Record->update_after_customer_vendor_change($order);

  }

  my $form_orderitems = delete $::form->{order}->{orderitems};

  $order->assign_attributes(%{$::form->{order}});

  #$self->setup_custom_shipto_from_form($order, $::form);

  # remove deleted items

  $self->item_ids_to_delete([]);

  foreach my $idx (reverse 0..$#{$order->orderitems}) {

    my $item = $order->orderitems->[$idx];

    if (none { $item->id == $_->{id} } @{$form_orderitems}) {

      splice @{$order->orderitems}, $idx, 1;

      push @{$self->item_ids_to_delete}, $item->id;

    }

  }

  my @items;

  my $pos = 1;

  foreach my $form_attr (@{$form_orderitems}) {

    my $item = make_item($order, $form_attr);

    $item->position($pos);

    push @items, $item;

    $pos++;

  }

  $order->add_items(grep {!$_->id} @items);

  return $order;

}

# create a new item

#

# This is used to add one item

sub new_item {

  my ($record, $attr) = @_;

  my $item = SL::DB::OrderItem->new;

  # Remove attributes where the user left or set the inputs empty.

  # So these attributes will be undefined and we can distinguish them

  # from zero later on.

  for (qw(qty_as_number sellprice_as_number discount_as_percent)) {

    delete $attr->{$_} if $attr->{$_} eq '';

  }

  $item->assign_attributes(%$attr);

  $item->qty(1.0)                   if !$item->qty;

  $item->unit($item->part->unit)    if !$item->unit;

  my ($price_src, $discount_src) = get_best_price_and_discount_source($record, $item, 0);

  my %new_attr;

  $new_attr{description}            = $item->part->description     if ! $item->description;

  $new_attr{qty}                    = 1.0                          if ! $item->qty;

  $new_attr{price_factor_id}        = $item->part->price_factor_id if ! $item->price_factor_id;

  $new_attr{sellprice}              = $price_src->price;

  $new_attr{discount}               = $discount_src->discount;

  $new_attr{active_price_source}    = $price_src;

  $new_attr{active_discount_source} = $discount_src;

  $new_attr{longdescription}        = $item->part->notes           if ! defined $attr->{longdescription};

  $new_attr{project_id}             = $record->globalproject_id;

  $new_attr{lastcost}               = $record->is_sales ? $item->part->lastcost : 0;

  # add_custom_variables adds cvars to an orderitem with no cvars for saving, but

  # they cannot be retrieved via custom_variables until the order/orderitem is

  # saved. Adding empty custom_variables to new orderitem here solves this problem.

  $new_attr{custom_variables} = [];

  my $texts = get_part_texts($item->part, $record->language_id, description => $new_attr{description}, longdescription => $new_attr{longdescription});

  $item->assign_attributes(%new_attr, %{ $texts });

  return $item;

}

sub _setup_edit_action_bar {

sub pre_render {

  my ($self) = @_;

  $self->{all_taxzones}               = SL::DB::Manager::TaxZone->get_all_sorted();

  $self->{all_languages}              = SL::DB::Manager::Language->get_all_sorted();

  $self->{all_salesmen}               = SL::DB::Manager::Employee->get_all_sorted();

  $self->{current_employee_id}        = SL::DB::Manager::Employee->current->id;

  $self->{all_delivery_terms}         = SL::DB::Manager::DeliveryTerm->get_all_sorted();

  $self->{all_payment_terms}          = SL::DB::Manager::PaymentTerm->get_all_sorted();

  $::request->{layout}->use_javascript("${_}.js") for

    qw(kivi.SalesPurchase kivi.POS kivi.File

       calculate_qty kivi.Validator follow_up

       show_history

      );

  $self->_setup_edit_action_bar;

}

#inits

sub init_poso {

  $_[0]->make_order;

}

sub init_valid_types {

  $_[0]->type_data->valid_types;

}

sub init_type {

  my ($self) = @_;

  my $type = $self->poso->record_type;

  if (none { $type eq $_ } @{$self->valid_types}) {

    die "Not a valid type for order";

  }

  $self->type($type);

}

sub init_type_data {

  my ($self) = @_;

  SL::DB::Helper::TypeDataProxy->new('SL::DB::Order', $self->poso->record_type);

}