projekt kivitendo

sub action_add_from_reclamation {

  my ($self) = @_;

  require SL::DB::Reclamation;

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

  my $order = $reclamation->convert_to_order();

  $self->order($order);

  $self->recalc();

  $self->pre_render();

  $self->render(

    'order/form',

    title => $self->get_title_for('edit'),

    %{$self->{template_args}}

  );

}

# save the order and redirect to the frontend subroutine for a new reclamation

sub action_save_and_reclamation {

  my ($self) = @_;

  # cann't use save_and_redirect_to, because id is set!

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

  if (scalar @{ $errors }) {

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

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

  }

  my $to_type = $self->order->is_sales ? 'sales_reclamation'

                                       : 'purchase_reclamation';

  $self->redirect_to(

    controller => 'Reclamation',

    action     => 'add_from_order',

    type       => $to_type,

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

  );

}

        action => [

          t8('Save and Reclamation'),

          call      => [ 'kivi.Order.save', 'save_and_reclamation', $::instance_conf->get_order_warn_duplicate_parts ],

          only_if   => (any { $self->type eq $_ } (sales_order_type(), purchase_order_type()))

        ],

                          save_and_order

                          save_and_order

sub action_add_from_order {

  my ($self) = @_;

  unless ($::form->{from_id}) {

    $self->js->flash('error', t8("Can't create new reclamation. No 'from_id' was given."));

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

  }

  require SL::DB::Order;

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

  my $reclamation = $order->convert_to_reclamation();

  $self->reclamation($reclamation);

  $self->reinit_after_new_reclamation();

  $self->render(

    'reclamation/form',

    title => $self->get_title_for('add'),

    %{$self->{template_args}},

  );

}

sub action_save_and_order {

  my ($self) = @_;

  my $to_type = $self->reclamation->is_sales ? 'sales_order'

                                             : 'purchase_order';

  $self->save_and_redirect_to(

    controller => 'Order',

    action     => 'add_from_reclamation',

    type       => $to_type,

    from_id    => $self->reclamation->id,

  );

}

    SL::DB::Order

    SL::DB::OrderItem

        action => [

          t8('Save and Order'),

          call      => [

            'kivi.Reclamation.save', 'save_and_order',

            $::instance_conf->get_reclamation_warn_duplicate_parts,

            $::instance_conf->get_reclamation_warn_no_reqdate,

          ],

        ],

sub convert_to_reclamation {

  my ($self, %params) = @_;

  $params{destination_type} = $self->is_sales ? 'sales_reclamation'

                                              : 'purchase_reclamation';

  require SL::DB::Reclamation;

  my $reclamation = SL::DB::Reclamation->new_from($self, %params);

  return $reclamation;

}

  unless (any {ref($source) eq $_} qw(

    SL::DB::Order

    SL::DB::Reclamation

  )) {

    croak("Unsupported source object type '" . ref($source) . "'");

  }

    { from => 'sales_reclamation', to => 'sales_order',       abbr => 'srso' },

    { from => 'purchase_reclamation', to => 'purchase_order', abbr => 'prpo' },

  } elsif ( ref($source) eq 'SL::DB::Reclamation') {

    $item_parent_id_column = 'reclamation_id';

    $item_parent_column    = 'reclamation';

  my %args;

  if (ref($source) eq 'SL::DB::Order') {

    %args = ( map({ ( $_ => $source->$_ ) } qw(amount cp_id currency_id cusordnumber customer_id delivery_customer_id delivery_term_id delivery_vendor_id

                                               department_id exchangerate globalproject_id intnotes marge_percent marge_total language_id netamount notes

                                               ordnumber payment_id quonumber reqdate salesman_id shippingpoint shipvia taxincluded tax_point taxzone_id

                                               transaction_description vendor_id billing_address_id

                                            )),

                 quotation => !!($destination_type =~ m{quotation$}),

                 closed    => 0,

                 delivered => 0,

                 transdate => DateTime->today_local,

                 employee  => SL::DB::Manager::Employee->current,

              );

    # reqdate in quotation is 'offer is valid    until reqdate'

    # reqdate in order     is 'will be delivered until reqdate'

    # both dates are setable (on|off)

    # and may have a additional interval in days (+ n days)

    # dies if this convention will change

    $args{reqdate} = $from_to->{to} =~ m/_quotation$/

                   ? $::instance_conf->get_reqdate_on

                   ? DateTime->today_local->next_workday(extra_days => $::instance_conf->get_reqdate_interval)->to_kivitendo

                   : undef

                   : $from_to->{to} =~ m/_order$/

                   ? $::instance_conf->get_deliverydate_on

                   ? DateTime->today_local->next_workday(extra_days => $::instance_conf->get_delivery_date_interval)->to_kivitendo

                   : undef

                   : die "Wrong state for reqdate";

  } elsif ( ref($source) eq 'SL::DB::Reclamation') {

    #TODO(Tamino): add billing_address_id to reclamation

    %args = ( map({ ( $_ => $source->$_ ) } qw(

        amount currency_id customer_id delivery_term_id department_id

        exchangerate globalproject_id intnotes language_id netamount

        notes payment_id  reqdate salesman_id shippingpoint shipvia taxincluded

        tax_point taxzone_id transaction_description vendor_id

      )),

      cp_id     => $source->{contact_id},

      closed    => 0,

      delivered => 0,

      transdate => DateTime->today_local,

      employee  => SL::DB::Manager::Employee->current,

   );

  }

    my $current_oe_item;

    if (ref($source) eq 'SL::DB::Order') {

      $current_oe_item = SL::DB::OrderItem->new(map({ ( $_ => $source_item->$_ ) }

                                                       qw(active_discount_source active_price_source base_qty cusordnumber

                                                          description discount lastcost longdescription

                                                          marge_percent marge_price_factor marge_total

                                                          ordnumber parts_id price_factor price_factor_id pricegroup_id

                                                          project_id qty reqdate sellprice serialnumber ship subtotal transdate unit

                                                          optional

                                                       )),

                                                   custom_variables => \@custom_variables,

      );

    } elsif (ref($source) eq 'SL::DB::Reclamation') {

      $current_oe_item = SL::DB::OrderItem->new(

        map({ ( $_ => $source_item->$_ ) } qw(

          active_discount_source active_price_source base_qty description

          discount lastcost longdescription parts_id price_factor

          price_factor_id pricegroup_id project_id qty reqdate sellprice

          serialnumber unit

        )),

        custom_variables => \@custom_variables,

      );

    }

    $current_oe_item->{"converted_from_reclamation_item_id"} = $_->{id} if ref($item_parent) eq 'SL::DB::Reclamation';

sub convert_to_order {

  my ($self, %params) = @_;

  my $order;

  $params{destination_type} = $self->is_sales ? 'sales_order'

                                              : 'purchase_order';

  if (!$self->db->with_transaction(sub {

    require SL::DB::Order;

    $order = SL::DB::Order->new_from($self, %params);

    $order->save;

    $self->link_to_record($order);

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

      foreach (qw(reclamation_item)) {

        if ($item->{"converted_from_${_}_id"}) {

          die unless $item->{id};

          RecordLinks->create_links('dbh'        => $self->db->dbh,

                                    'mode'       => 'ids',

                                    'from_table' => 'reclamation_items',

                                    'from_ids'   => $item->{"converted_from_${_}_id"},

                                    'to_table'   => 'orderitems',

                                    'to_id'      => $item->{id},

          ) || die;

          delete $item->{"converted_from_${_}_id"};

        }

      }

    }

    1;

  })) {

    return undef;

  }

  return $order;

}

    SL::DB::Order

    #Order

    { from => 'sales_order',             to => 'sales_reclamation',    abbr => 'sosr', },

    { from => 'purchase_order',          to => 'purchase_reclamation', abbr => 'popr', },

  } elsif ( $is_abbr_any->(qw(sosr popr)) ) { #Order

    map { $record_args{$_} = $source->$_ } # {{{ for vim folds

    qw(

      amount

      currency_id

      customer_id

      delivery_term_id

      department_id

      exchangerate

      globalproject_id

      intnotes

      language_id

      netamount

      notes

      payment_id

      salesman_id

      shippingpoint

      shipvia

      tax_point

      taxincluded

      taxzone_id

      transaction_description

      vendor_id

    );

    $record_args{contact_id} = $source->cp_id;

    $record_args{cv_record_number} = $source->cusordnumber;

    # }}} for vim folds

      SL::DB::OrderItem

  } elsif (ref($source) eq 'SL::DB::OrderItem') {

    map { $item_args{$_} = $source->$_ } qw(

      active_discount_source active_price_source base_qty description discount

      lastcost longdescription parts_id position price_factor price_factor_id

      pricegroup_id project_id qty reqdate sellprice serialnumber unit

    );

    $item_args{custom_variables} = \@custom_variables;