projekt kivitendo

  # 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 $delivery_order = SL::Model::Record->new_from_workflow_multi(\@multi_orders, $target_type, sort_sources_by => 'transdate');

  $self->order($delivery_order);

use SL::DB::Helper::RecordLink qw(set_record_link_conversions);

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

use SL::Model::Record;

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

use SL::Helper::PrintOptions;

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

  my %params;

  my $order = SL::Model::Record->new_from_workflow($reclamation, $target_type);

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

  my ($self) = @_;

  SL::Model::Record->delete($self->order);

           : '';

  flash_later('info', $text);

  $self->save();

           : '';

  flash_later('info', $text);

  $config  ||= SL::DB::Manager::PeriodicInvoicesConfig->find_by(oe_id => $::form->{id}) if $::form->{id};

  my $has_active_periodic_invoices =

    && $config

    && $config->active

    && (!$config->end_date || ($config->end_date > DateTime->today_local))

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

  $self->save();

  $self->redirect_to(

    controller => 'Reclamation',

    action     => 'add_from_order',

  my $destination_type = $::form->{to_type} ? $::form->{to_type} : '';

  my $from_side        = $self->order->is_sales ? 'sales' : 'purchase';

  # check for direct delivery

  # copy shipto in custom shipto (custom shipto will be copied by new_from() in case)

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

  # no linked records to quotations from the same side (sales -> sales or purchase -> purchase)

       && $from_side eq $to_side) {

    delete $::form->{id};

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

#

sub init_valid_types {

}

sub init_type {

sub init_cv {

  my ($self) = @_;

         : die "Not a valid type for order";

  return $cv;

  my $order;

  $order   = SL::DB::Order->new(id => $::form->{id})->load(with => [ 'orderitems', 'orderitems.part' ]) if $::form->{id};

  $order ||= SL::DB::Order->new(orderitems  => [],

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

  my $cv_id_method = $self->cv . '_id';

    $item->active_discount_source($price_source->discount_from_source($item->active_discount_source));

  }

    # Calculate shipped qtys here to prevent calling calculate for every item via the items method.

    # Do not use write_to_objects to prevent order->delivered to be set, because this should be

    # the value from db, which can be set manually or is set when linked delivery orders are saved.

                                                } } @all_objects;

  }

      && $::instance_conf->get_transport_cost_reminder_article_number_id ) {

    $self->{template_args}->{transport_cost_reminder_article} = SL::DB::Part->new(id => $::instance_conf->get_transport_cost_reminder_article_number_id)->load;

  }

sub setup_edit_action_bar {

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

  my @req_trans_cost_art = qw(kivi.Order.check_transport_cost_article_presence) x!!$::instance_conf->get_transport_cost_reminder_article_number_id;

  my $has_invoice_for_advance_payment;

    my $lr = $self->order->linked_records(direction => 'to', to => ['Invoice']);

    $has_invoice_for_advance_payment = any {'SL::DB::Invoice' eq ref $_ && "invoice_for_advance_payment" eq $_->type} @$lr;

  }

  my $has_final_invoice;

    my $lr = $self->order->linked_records(direction => 'to', to => ['Invoice']);

    $has_final_invoice               = any {'SL::DB::Invoice' eq ref $_ && "final_invoice" eq $_->type} @$lr;

  }

        ],

        action => [

          t8('Save and Quotation'),

          checks   => [ @req_trans_cost_art, @req_cusordnumber ],

          disabled => !$may_edit_create ? t8('You do not have the permissions to access this function.') : undef,

        ],

        action => [

          t8('Save and RFQ'),

          disabled => !$may_edit_create ? t8('You do not have the permissions to access this function.') : undef,

        ],

        action => [

          t8('Save and Sales Order'),

          checks   => [ @req_trans_cost_art ],

          disabled => !$may_edit_create ? t8('You do not have the permissions to access this function.') : undef,

        ],

        action => [

          t8('Save and Purchase Order'),

          checks    => [ @req_trans_cost_art, @req_cusordnumber ],

          disabled  => !$may_edit_create ? t8('You do not have the permissions to access this function.') : undef,

        ],

        action => [

          checks    => [ 'kivi.Order.check_save_active_periodic_invoices',

                         @req_trans_cost_art, @req_cusordnumber,

          ],

          disabled  => !$may_edit_create ? t8('You do not have the permissions to access this function.') : undef,

        ],

        action => [

          checks    => [ 'kivi.Order.check_save_active_periodic_invoices',

                         @req_trans_cost_art, @req_cusordnumber,

          ],

          disabled  => !$may_edit_create ? t8('You do not have the permissions to access this function.') : undef,

        ],

        action => [

          call      => [ 'kivi.Order.save', { action             => 'save_and_reclamation',

                                              warn_on_duplicates => $::instance_conf->get_order_warn_duplicate_parts },

          ],

        ],

        action => [

          t8('Save and Invoice'),

          disabled  => !$may_edit_create  ? t8('You do not have the permissions to access this function.')

                     : $has_final_invoice ? t8('This order has already a final invoice.')

                     :                      undef,

        ],

        action => [

          t8('Save and Final Invoice'),

          disabled  => !$may_edit_create  ? t8('You do not have the permissions to access this function.')

                     : $has_final_invoice ? t8('This order has already a final invoice.')

                     :                      undef,

        ],

        action => [

          t8('Save and AP Transaction'),

          call      => [ 'kivi.Order.save', { action             => 'save_and_ap_transaction',

                                              warn_on_duplicates => $::instance_conf->get_order_warn_duplicate_parts },

          ],

          disabled  => !$may_edit_create  ? t8('You do not have the permissions to access this function.') : undef,

        ],

sub get_periodic_invoices_status {

  my ($self, $config) = @_;

  return t8('not configured') if !$config;

  my $active = ('HASH' eq ref $config)                           ? $config->{active}

  # $::locale->text("Edit Request for Quotation");

  $action = ucfirst(lc($action));

       : '';

}

  return ($price_src, $discount_src);

}

sub nr_key {

       : '';

}

  $self->save();

           : '';

  flash_later('info', $text);

use SL::DB::DeliveryOrder;

use SL::DB::Invoice;

use SL::Model::Record;

use List::Util qw(first sum0);

use List::UtilsBy qw(sort_by uniq_by);

  }

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

  my $reclamation = SL::Model::Record->new_from_workflow($order, $target_type);

  $self->reclamation($reclamation);

  }

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

  my $reclamation = SL::Model::Record->new_from_workflow($delivery_order, $target_type);

  $self->reclamation($reclamation);

  }

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

  my $reclamation = SL::Model::Record->new_from_workflow($invoice, $target_type);

  $self->reclamation($reclamation);

  require SL::DB::PurchaseInvoice;

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

  $invoice->{type} = $invoice->invoice_type; #can't add type → invoice_type in SL/DB/PurchaseInvoice

  my $reclamation = SL::Model::Record->new_from_workflow($invoice, $target_type);

  $self->reclamation($reclamation);

sub action_save_and_order {

  my ($self) = @_;

  $self->save_with_render_error();

  flash_later('info', t8('The reclamation has been saved'));

    controller => 'Reclamation',

    action     => 'add_from_reclamation',

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

  );

}

    controller => 'Reclamation',

    action     => 'add_from_reclamation',

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

  );

}

#

sub init_valid_types {

}

sub init_type {

sub init_cv {

  my ($self) = @_;

         : die "Not a valid type for reclamation";

  return $cv;

      language_id             => t8('Language'),

      department_id           => t8('Department'),

      globalproject_id        => t8('Project Number'),

      transaction_description => t8('Description'),

      notes                   => t8('Notes'),

      intnotes                => t8('Internal Notes'),

sub init_part_picker_classification_ids {

  my ($self)    = @_;

  return [ map { $_->id } @{ SL::DB::Manager::PartClassification->get_all(where => [ $attribute => 1 ]) } ];

}

  # check for direct delivery

  # copy shipto in custom shipto (custom shipto will be copied by new_from() in case)

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

      my $custom_shipto = $source_reclamation->shipto->clone('SL::DB::Reclamation');

      $self->reclamation->custom_shipto($custom_shipto) if $custom_shipto;

      sub      => sub { $_[0]->closed ? t8('Yes') : t8('No') },

    },

  );

    $column_defs{customer_id} = ({

      raw_data => sub { $_[0]->customervendor->presenter->customer(display => 'table-cell', callback => $callback) },

      sub      => sub { $_[0]->customervendor->name },

      },

      sub      => sub { $_[0]->contact ? $_[0]->contact->cp_name : '' },

    });

    $column_defs{vendor_id} = ({

      raw_data => sub { $_[0]->customervendor->presenter->vendor(display => 'table-cell', callback => $callback) },

      sub      => sub { $_[0]->customervendor->name },

     { output => 0 },

     models => $self->models

    ),

    allow_pdf_export      => 1,

    allow_csv_export      => 1,

  );

sub _setup_edit_action_bar {

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

                          && $::instance_conf->get_sales_reclamation_show_delete)

                          && $::instance_conf->get_purchase_reclamation_show_delete);

  for my $bar ($::request->layout->get('actionbar')) {

            $::instance_conf->get_reclamation_warn_duplicate_parts,

            $::instance_conf->get_reclamation_warn_no_reqdate,

          ],

        ],

        action => [

          t8('Save and Purchase Reclamation'),

          call      => [ 'kivi.Reclamation.purchase_reclamation_check_for_direct_delivery' ],

        ],

        action => [

          t8('Save and Order'),

            $::instance_conf->get_reclamation_warn_duplicate_parts,

            $::instance_conf->get_reclamation_warn_no_reqdate,

          ],

        ],

        action => [

          t8('Save and Supplier Delivery Order'),

            $::instance_conf->get_reclamation_warn_duplicate_parts,

            $::instance_conf->get_reclamation_warn_no_reqdate,

          ],

        ],

        action => [

          t8('Save and Credit Note'),

            $::instance_conf->get_reclamation_warn_duplicate_parts,

            $::instance_conf->get_reclamation_warn_no_reqdate,

          ],

        ],

      ], # end of combobox "Workflow"

  # t8("Edit Purchase Reclamation");

  $action = ucfirst(lc($action));

       : '';

}

  return $texts;

}

sub save_history {

  my ($self, $addition) = @_;

}

sub init_type_data {

}

1;

use SL::DB::Unit;

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

use SL::Helper::Number qw(_format_total _round_total);

    ],

  );

}

sub type {

sub displayable_type {

  my $type = shift->type;

  die 'invalid type';

}

sub convert_to_reclamation {

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

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

  }

  # infer type from legacy fields if not given

                      : croak "need some way to set delivery order type from source";

  my $delivery_order = $class->new(%record_args);

  $delivery_order->assign_attributes(%{ $params{attributes} }) if $params{attributes};

  my $items = delete($params{items}) || $source->items_sorted;

                ()

              : map { SL::DB::DeliveryOrderItem->new_from($_, %params) } @{ $items };

use SL::RecordLinks;

use Rose::DB::Object::Helpers qw(as_tree strip);

__PACKAGE__->meta->add_relationship(

  orderitems => {

    type         => 'one to many',

  my ($self) = @_;

  # force new project, if not set yet

    die t8("Error while creating project with project number of new order number, project number #1 already exists!", $self->ordnumber)

      if SL::DB::Manager::Project->find_by(projectnumber => $self->ordnumber);

sub type {

  my $self = shift;

  return;

}

  # But this has a different meaning for sales quotations.

  # deliverydate can be used to determine tax if tax_point isn't set.

}

sub effective_tax_point {

sub displayable_type {

  my $type = shift->type;

  die 'invalid type';

}

  return 1 if $self->currency_id == $::instance_conf->get_currency_id;

           : undef;

  return if !$rate;

sub convert_to_reclamation {

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

  require SL::DB::Reclamation;

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

  my $destination_type  = delete $params{destination_type};

  my @from_tos = (

  );

  my $from_to = (grep { $_->{from} eq $source->type && $_->{to} eq $destination_type} @from_tos)[0];

  croak("Cannot convert from '" . $source->type . "' to '" . $destination_type . "'") if !$from_to;

  push @items, @{$_->items_sorted} for @$sources;

  # make order from first source and all items

  my $order = $class->new_from($sources->[0],

                               attributes       => \%attributes,

                               items            => \@items,

                               %params);

  return if !$self->type;

  my %number_method = (

  );

  return $self->${ \ $number_method{$self->type} }(@_);

use List::Util qw(max sum0);

use List::MoreUtils qw(any);

use SL::DB::MetaSetup::Reclamation;

use SL::DB::Manager::Reclamation;

use SL::DB::Helper::Attr;

sub type {

  my ($self) = @_;

  return;

}

sub displayable_type {

  my $type = shift->type;

  die 'invalid type';

}

  return 1 if $self->currency_id == $::instance_conf->get_currency_id;

           : undef;

  return if !$rate;

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

  my $order;

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

    require SL::DB::Order;

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

  my @from_tos = (

    #Reclamation

    #Order

    #Delivery Order

    #Invoice

  );

  my $from_to = (grep { $_->{from} eq $source->type && $_->{to} eq $destination_type} @from_tos)[0];

  if (!$from_to) {

use SL::DB::Status;

use SL::DB::ValidityToken;

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

use SL::Util qw(trim);

use SL::Locale::String qw(t8);

  my %subtype_to_type = (

    # Order

    # DeliveryOrder

    # Reclamation

  );

  my $target_type = $subtype_to_type{$target_subtype};

  unless ($target_type) {

  my %subtype_to_type = (

    # Order

  );

  my $target_type = $subtype_to_type{$target_subtype};

  unless ($target_type) {