X-Git-Url: http://wagnertech.de/git?a=blobdiff_plain;f=SL%2FDB%2FDeliveryOrder.pm;h=45d658876023f2efbe8890d5008e3cf09682b6e2;hb=b775c378552e6b5bf59f98046cdf4e577cd351df;hp=d844854767e2b93a68fba570d185e4e1307c62f8;hpb=7664f50fac4a789932317d0e0d35e15bc2d7d1c4;p=kivitendo-erp.git diff --git a/SL/DB/DeliveryOrder.pm b/SL/DB/DeliveryOrder.pm index d84485476..45d658876 100644 --- a/SL/DB/DeliveryOrder.pm +++ b/SL/DB/DeliveryOrder.pm @@ -4,22 +4,45 @@ use strict; use Carp; +use Rose::DB::Object::Helpers (); + use SL::DB::MetaSetup::DeliveryOrder; use SL::DB::Manager::DeliveryOrder; +use SL::DB::Helper::AttrHTML; +use SL::DB::Helper::AttrSorted; +use SL::DB::Helper::FlattenToForm; use SL::DB::Helper::LinkedRecords; use SL::DB::Helper::TransNumberGenerator; +use SL::DB::Part; +use SL::DB::Unit; + +use SL::DB::DeliveryOrder::TypeData qw(:types); + +use SL::Helper::Number qw(_format_total _round_total); + use List::Util qw(first); +use List::MoreUtils qw(any pairwise); +use Math::Round qw(nhimult); __PACKAGE__->meta->add_relationship(orderitems => { type => 'one to many', class => 'SL::DB::DeliveryOrderItem', column_map => { id => 'delivery_order_id' }, manager_args => { with_objects => [ 'part' ] } }, + custom_shipto => { + type => 'one to one', + class => 'SL::DB::Shipto', + column_map => { id => 'trans_id' }, + query_args => [ module => 'DO' ], + }, ); __PACKAGE__->meta->initialize; +__PACKAGE__->attr_html('notes'); +__PACKAGE__->attr_sorted('items'); + __PACKAGE__->before_save('_before_save_set_donumber'); # hooks @@ -35,12 +58,9 @@ sub _before_save_set_donumber { # methods sub items { goto &orderitems; } - -sub items_sorted { - my ($self) = @_; - - return [ sort {$a->id <=> $b->id } @{ $self->items } ]; -} +sub add_items { goto &add_orderitems; } +sub payment_terms { goto &payment; } +sub record_number { goto &donumber; } sub sales_order { my $self = shift; @@ -59,9 +79,26 @@ sub sales_order { } sub type { - return shift->customer_id ? 'sales_delivery_order' : 'purchase_delivery_order'; + goto &order_type; +} + +sub is_type { + return shift->type eq shift; } +sub displayable_type { + my $type = shift->type; + + return $::locale->text('Sales Delivery Order') if $type eq 'sales_delivery_order'; + return $::locale->text('Purchase Delivery Order') if $type eq 'purchase_delivery_order'; + + die 'invalid type'; +} + +sub displayable_name { + join ' ', grep $_, map $_[0]->$_, qw(displayable_type record_number); +}; + sub displayable_state { my ($self) = @_; @@ -74,60 +111,269 @@ sub date { goto &transdate; } +sub number { + goto &donumber; +} + +sub _clone_orderitem_cvar { + my ($cvar) = @_; + + my $cloned = $_->clone_and_reset; + $cloned->sub_module('delivery_order_items'); + + return $cloned; +} + sub new_from { my ($class, $source, %params) = @_; croak("Unsupported source object type '" . ref($source) . "'") unless ref($source) eq 'SL::DB::Order'; - my $terms = $source->can('payment_id') && $source->payment_id ? $source->payment_terms->terms_netto : 0; + my ($item_parent_id_column, $item_parent_column); + + if (ref($source) eq 'SL::DB::Order') { + $item_parent_id_column = 'trans_id'; + $item_parent_column = 'order'; + } - my %args = ( map({ ( $_ => $source->$_ ) } qw(cp_id currency_id customer_id cusordnumber department_id employee_id globalproject_id intnotes language_id notes - ordnumber reqdate salesman_id shippingpoint shipvia taxincluded taxzone_id transaction_description vendor_id + my %args = ( map({ ( $_ => $source->$_ ) } qw(cp_id currency_id customer_id cusordnumber delivery_term_id department_id employee_id globalproject_id intnotes language_id notes + ordnumber payment_id reqdate salesman_id shippingpoint shipvia taxincluded taxzone_id transaction_description vendor_id billing_address_id )), closed => 0, - is_sales => !!$source->customer_id, delivered => 0, - terms => $terms, + order_type => $params{type}, transdate => DateTime->today_local, ); # Custom shipto addresses (the ones specific to the sales/purchase # record and not to the customer/vendor) are only linked from - # shipto -> delivery_orders. Meaning delivery_orders.shipto_id - # will not be filled in that case. Therefore we have to return the - # new shipto object as a separate object so that the caller can - # save it, too. - my $custom_shipto; + # shipto → delivery_orders. Meaning delivery_orders.shipto_id + # will not be filled in that case. if (!$source->shipto_id && $source->id) { - require SL::DB::Shipto; - - my $old = SL::DB::Manager::Shipto->find_by(trans_id => $source->id); - if ($old) { - $custom_shipto = SL::DB::Shipto->new( - map { +($_ => $old->$_) } - grep { !m{^ (?: itime | mtime | shipto_id | trans_id ) $}x } - map { $_->name } - @{ $old->meta->columns } - ); - } + $args{custom_shipto} = $source->custom_shipto->clone($class) if $source->can('custom_shipto') && $source->custom_shipto; } else { $args{shipto_id} = $source->shipto_id; } - my $delivery_order = $class->new(%args, %params); - - my @items = map { - my $source_item = $_; - SL::DB::DeliveryOrderItem->new(map({ ( $_ => $source_item->$_ ) } - qw(base_qty cusordnumber description discount lastcost longdescription marge_price_factor ordnumber parts_id price_factor price_factor_id - project_id qty reqdate sellprice serialnumber transdate unit - ))); - } @{ $source->items_sorted }; + # infer type from legacy fields if not given + $args{order_type} //= $source->customer_id ? 'sales_delivery_order' + : $source->vendor_id ? 'purchase_delivery_order' + : $source->is_sales ? 'sales_delivery_order' + : croak "need some way to set delivery order type from source"; + + my $delivery_order = $class->new(%args); + $delivery_order->assign_attributes(%{ $params{attributes} }) if $params{attributes}; + my $items = delete($params{items}) || $source->items_sorted; + my %item_parents; + + # do not copy items when converting to supplier delivery order + my @items = $delivery_order->is_type(SUPPLIER_DELIVERY_ORDER_TYPE) ? () : map { + my $source_item = $_; + my $source_item_id = $_->$item_parent_id_column; + my @custom_variables = map { _clone_orderitem_cvar($_) } @{ $source_item->custom_variables }; + + $item_parents{$source_item_id} ||= $source_item->$item_parent_column; + my $item_parent = $item_parents{$source_item_id}; + + my $current_do_item = SL::DB::DeliveryOrderItem->new(map({ ( $_ => $source_item->$_ ) } + qw(base_qty cusordnumber description discount lastcost longdescription marge_price_factor parts_id price_factor price_factor_id + project_id qty reqdate sellprice serialnumber transdate unit active_discount_source active_price_source + )), + custom_variables => \@custom_variables, + ordnumber => ref($item_parent) eq 'SL::DB::Order' ? $item_parent->ordnumber : $source_item->ordnumber, + ); + $current_do_item->{"converted_from_orderitems_id"} = $_->{id} if ref($item_parent) eq 'SL::DB::Order'; + $current_do_item; + } @{ $items }; + + @items = grep { $params{item_filter}->($_) } @items if $params{item_filter}; + @items = grep { $_->qty * 1 } @items if $params{skip_items_zero_qty}; + @items = grep { $_->qty >=0 } @items if $params{skip_items_negative_qty}; $delivery_order->items(\@items); - return ($delivery_order, $custom_shipto); + return $delivery_order; +} + +sub new_from_time_recordings { + my ($class, $sources, %params) = @_; + + croak("Unsupported object type in sources") if any { ref($_) ne 'SL::DB::TimeRecording' } @$sources; + croak("Cannot create delivery order from source records of different customers") if any { $_->customer_id != $sources->[0]->customer_id } @$sources; + + # - one item per part (article) + # - qty is sum of duration + # - description goes to item longdescription + # - ordered and summed by date + # - each description goes to an ordered list + # - (as time recording descriptions are formatted text by now, use stripped text) + # - merge same descriptions + # + + my $default_part_id = $params{default_part_id} ? $params{default_part_id} + : $params{default_partnumber} ? SL::DB::Manager::Part->find_by(partnumber => $params{default_partnumber})->id + : undef; + my $override_part_id = $params{override_part_id} ? $params{override_part_id} + : $params{override_partnumber} ? SL::DB::Manager::Part->find_by(partnumber => $params{override_partnumber})->id + : undef; + + # check parts and collect entries + my %part_by_part_id; + my $entries; + foreach my $source (@$sources) { + next if !$source->duration; + + my $part_id = $override_part_id; + $part_id ||= $source->part_id; + $part_id ||= $default_part_id; + + die 'article not found for entry "' . $source->displayable_times . '"' if !$part_id; + + if (!$part_by_part_id{$part_id}) { + $part_by_part_id{$part_id} = SL::DB::Part->new(id => $part_id)->load; + die 'article unit must be time based for entry "' . $source->displayable_times . '"' if !$part_by_part_id{$part_id}->unit_obj->is_time_based; + } + + my $date = $source->date->to_kivitendo; + $entries->{$part_id}->{$date}->{duration} += $params{rounding} + ? nhimult(0.25, ($source->duration_in_hours)) + : _round_total($source->duration_in_hours); + # add content if not already in description + my $new_description = '' . $source->description_as_stripped_html; + $entries->{$part_id}->{$date}->{content} ||= ''; + $entries->{$part_id}->{$date}->{content} .= '
  • ' . $new_description . '
    • ' + unless $entries->{$part_id}->{$date}->{content} =~ m/\Q$new_description/; + + $entries->{$part_id}->{$date}->{date_obj} = $source->start_time || $source->date; # for sorting + } + + my @items; + + my $h_unit = SL::DB::Manager::Unit->find_h_unit; + + my @keys = sort { $part_by_part_id{$a}->partnumber cmp $part_by_part_id{$b}->partnumber } keys %$entries; + foreach my $key (@keys) { + my $qty = 0; + my $longdescription = ''; + + my @dates = sort { $entries->{$key}->{$a}->{date_obj} <=> $entries->{$key}->{$b}->{date_obj} } keys %{$entries->{$key}}; + foreach my $date (@dates) { + my $entry = $entries->{$key}->{$date}; + + $qty += $entry->{duration}; + $longdescription .= $date . ' ' . _format_total($entry->{duration}) . ' h'; + $longdescription .= ''; + } + + my $item = SL::DB::DeliveryOrderItem->new( + parts_id => $part_by_part_id{$key}->id, + description => $part_by_part_id{$key}->description, + qty => $qty, + base_qty => $h_unit->convert_to($qty, $part_by_part_id{$key}->unit_obj), + unit_obj => $h_unit, + sellprice => $part_by_part_id{$key}->sellprice, # Todo: use price rules to get sellprice + longdescription => $longdescription, + ); + + push @items, $item; + } + + my $delivery_order; + + if ($params{related_order}) { + # collect suitable items in related order + my @items_to_use; + my @new_attributes; + foreach my $item (@items) { + my $item_to_use = first {$item->parts_id == $_->parts_id} @{ $params{related_order}->items_sorted }; + + die "no suitable item found in related order" if !$item_to_use; + + my %new_attributes; + $new_attributes{$_} = $item->$_ for qw(qty base_qty unit_obj longdescription); + push @items_to_use, $item_to_use; + push @new_attributes, \%new_attributes; + } + + $delivery_order = $class->new_from($params{related_order}, items => \@items_to_use, %params); + pairwise { $a->assign_attributes( %$b) } @{$delivery_order->items}, @new_attributes; + + } else { + my %args = ( + is_sales => 1, + order_type => 'sales_delivery_order', + delivered => 0, + customer_id => $sources->[0]->customer_id, + taxzone_id => $sources->[0]->customer->taxzone_id, + currency_id => $sources->[0]->customer->currency_id, + employee_id => SL::DB::Manager::Employee->current->id, + salesman_id => SL::DB::Manager::Employee->current->id, + items => \@items, + ); + $delivery_order = $class->new(%args); + $delivery_order->assign_attributes(%{ $params{attributes} }) if $params{attributes}; + } + + return $delivery_order; +} + +# legacy for compatibility +# use type_data cusomtervendor and transfer direction instead +sub is_sales { + if ($_[0]->order_type) { + return SL::DB::DeliveryOrder::TypeData::get3($_[0]->order_type, "properties", "is_customer"); + } + return $_[0]{is_sales}; +} + +sub customervendor { + SL::DB::DeliveryOrder::TypeData::get3($_[0]->order_type, "properties", "is_customer") ? $_[0]->customer : $_[0]->vendor; +} + +sub convert_to_invoice { + my ($self, %params) = @_; + + croak("Conversion to invoices is only supported for sales records") unless $self->customer_id; + + my $invoice; + if (!$self->db->with_transaction(sub { + require SL::DB::Invoice; + $invoice = SL::DB::Invoice->new_from($self, %params)->post || die; + $self->link_to_record($invoice); + # TODO extend link_to_record for items, otherwise long-term no d.r.y. + foreach my $item (@{ $invoice->items }) { + foreach (qw(delivery_order_items)) { # expand if needed (orderitems) + if ($item->{"converted_from_${_}_id"}) { + die unless $item->{id}; + RecordLinks->create_links('mode' => 'ids', + 'from_table' => $_, + 'from_ids' => $item->{"converted_from_${_}_id"}, + 'to_table' => 'invoice', + 'to_id' => $item->{id}, + ) || die; + delete $item->{"converted_from_${_}_id"}; + } + } + } + $self->update_attributes(closed => 1); + 1; + })) { + return undef; + } + + return $invoice; +} + +sub digest { + my ($self) = @_; + + sprintf "%s %s (%s)", + $self->donumber, + $self->customervendor->name, + $self->date->to_kivitendo; } 1; @@ -148,7 +394,12 @@ SL::DB::DeliveryOrder - Rose model for delivery orders (table =item C -An alias for L for compatibility with other sales/purchase models. +An alias for C for compatibility with other sales/purchase models. + +=item C + +Returns a human-readable and translated description of the delivery order, consisting of +record type and number, e.g. "Verkaufslieferschein 123". =item C @@ -157,15 +408,10 @@ closed and delivered. =item C -An alias for L for compatibility with other +An alias for C for compatibility with other sales/purchase models. -=item C - -Returns the delivery order items sorted by their ID (same order they -appear in the frontend delivery order masks). - -=item C +=item C Creates a new C instance and copies as much information from C<$source> as possible. At the moment only instances @@ -175,18 +421,98 @@ quotations and purchase orders) are supported as sources. The conversion copies order items into delivery order items. Dates are copied as appropriate, e.g. the C field will be set to the current date. -Returns one or two objects depending on the context. In list context -the new delivery order instance and a shipto instance will be -returned. In scalar instance only the delivery order instance is -returned. +Returns the new delivery order instance. The object returned is not +saved. + +C<%params> can include the following options: -Custom shipto addresses (the ones specific to the sales/purchase -record and not to the customer/vendor) are only linked from C -to C. Meaning C will not -be filled in that case. That's why a separate shipto object is created -and returned. +=over 2 + +=item C + +An optional array reference of RDBO instances for the items to use. If +missing then the method C will be called on +C<$source>. This option can be used to override the sorting, to +exclude certain positions or to add additional ones. + +=item C + +If trueish then items with a negative quantity are skipped. Items with +a quantity of 0 are not affected by this option. + +=item C + +If trueish then items with a quantity of 0 are skipped. + +=item C + +An optional code reference that is called for each item with the item +as its sole parameter. Items for which the code reference returns a +falsish value will be skipped. + +=item C + +An optional hash reference. If it exists then it is passed to C +allowing the caller to set certain attributes for the new delivery +order. + +=back -The objects returned are not saved. +=item C + +Creates a new C instance from the time recordings +given as C<$sources>. All time recording entries must belong to the same +customer. Time recordings are sorted by article and date. For each article +a new delivery order item is created. If no article is associated with an +entry, a default article will be used. The article given in the time +recording entry can be overriden. +Entries of the same date (for each article) are summed together and form a +list entry in the long description of the item. + +The created delivery order object will be returnd but not saved. + +C<$sources> must be an array reference of C instances. + +C<%params> can include the following options: + +=over 2 + +=item C + +An optional hash reference. If it exists then it is used to set +attributes of the newly created delivery order object. + +=item C + +An optional part id which is used as default value if no part is set +in the time recording entry. + +=item C + +Like C but given as partnumber, not as id. + +=item C + +An optional part id which is used instead of a value set in the time +recording entry. + +=item C + +Like C but given as partnumber, not as id. + +=item C + +An optional C object. If it exists then it is used to +generate the delivery order from that via C. +The generated items are created from a suitable item of the related +order. If no suitable item is found, an exception is thrown. + +=item C + +An optional boolean value. If truish, then the durations of the time entries +are rounded up to the full quarters of an hour. + +=back =item C @@ -194,9 +520,24 @@ TODO: Describe sales_order =item C -Returns a stringdescribing this record's type: either +Returns a string describing this record's type: either C or C. +=item C + +Creates a new invoice with C<$self> as the basis by calling +L. That invoice is posted, and C<$self> is +linked to the new invoice via L. C<$self>'s +C attribute is set to C, and C<$self> is saved. + +The arguments in C<%params> are passed to L. + +Returns the new invoice instance on success and C on +failure. The whole process is run inside a transaction. On failure +nothing is created or changed in the database. + +At the moment only sales delivery orders can be converted. + =back =head1 BUGS