special_chars: ø, Ø und λ ergänzt
[kivitendo-erp.git] / SL / DB / DeliveryOrder.pm
1 package SL::DB::DeliveryOrder;
2
3 use strict;
4
5 use Carp;
6
7 use Rose::DB::Object::Helpers ();
8
9 use SL::DB::MetaSetup::DeliveryOrder;
10 use SL::DB::Manager::DeliveryOrder;
11 use SL::DB::Helper::AttrHTML;
12 use SL::DB::Helper::AttrSorted;
13 use SL::DB::Helper::FlattenToForm;
14 use SL::DB::Helper::LinkedRecords;
15 use SL::DB::Helper::TransNumberGenerator;
16
17 use List::Util qw(first);
18
19 __PACKAGE__->meta->add_relationship(orderitems => { type         => 'one to many',
20                                                     class        => 'SL::DB::DeliveryOrderItem',
21                                                     column_map   => { id => 'delivery_order_id' },
22                                                     manager_args => { with_objects => [ 'part' ] }
23                                                   },
24                                     custom_shipto => {
25                                       type        => 'one to one',
26                                       class       => 'SL::DB::Shipto',
27                                       column_map  => { id => 'trans_id' },
28                                       query_args  => [ module => 'DO' ],
29                                     },
30                                    );
31
32 __PACKAGE__->meta->initialize;
33
34 __PACKAGE__->attr_html('notes');
35 __PACKAGE__->attr_sorted('items');
36
37 __PACKAGE__->before_save('_before_save_set_donumber');
38
39 # hooks
40
41 sub _before_save_set_donumber {
42   my ($self) = @_;
43
44   $self->create_trans_number if !$self->donumber;
45
46   return 1;
47 }
48
49 # methods
50
51 sub items { goto &orderitems; }
52 sub add_items { goto &add_orderitems; }
53 sub payment_terms { goto &payment; }
54 sub record_number { goto &donumber; }
55
56 sub sales_order {
57   my $self   = shift;
58   my %params = @_;
59
60
61   require SL::DB::Order;
62   my $orders = SL::DB::Manager::Order->get_all(
63     query => [
64       ordnumber => $self->ordnumber,
65       @{ $params{query} || [] },
66     ],
67   );
68
69   return first { $_->is_type('sales_order') } @{ $orders };
70 }
71
72 sub type {
73   return shift->customer_id ? 'sales_delivery_order' : 'purchase_delivery_order';
74 }
75
76 sub displayable_type {
77   my $type = shift->type;
78
79   return $::locale->text('Sales Delivery Order')    if $type eq 'sales_delivery_order';
80   return $::locale->text('Purchase Delivery Order') if $type eq 'purchase_delivery_order';
81
82   die 'invalid type';
83 }
84
85 sub displayable_name {
86   join ' ', grep $_, map $_[0]->$_, qw(displayable_type record_number);
87 };
88
89 sub displayable_state {
90   my ($self) = @_;
91
92   return join '; ',
93     ($self->closed    ? $::locale->text('closed')    : $::locale->text('open')),
94     ($self->delivered ? $::locale->text('delivered') : $::locale->text('not delivered'));
95 }
96
97 sub date {
98   goto &transdate;
99 }
100
101 sub _clone_orderitem_cvar {
102   my ($cvar) = @_;
103
104   my $cloned = $_->clone_and_reset;
105   $cloned->sub_module('delivery_order_items');
106
107   return $cloned;
108 }
109
110 sub new_from {
111   my ($class, $source, %params) = @_;
112
113   croak("Unsupported source object type '" . ref($source) . "'") unless ref($source) eq 'SL::DB::Order';
114
115   my ($item_parent_id_column, $item_parent_column);
116
117   if (ref($source) eq 'SL::DB::Order') {
118     $item_parent_id_column = 'trans_id';
119     $item_parent_column    = 'order';
120   }
121
122   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
123                                                 ordnumber payment_id reqdate salesman_id shippingpoint shipvia taxincluded taxzone_id transaction_description vendor_id
124                                              )),
125                closed    => 0,
126                is_sales  => !!$source->customer_id,
127                delivered => 0,
128                transdate => DateTime->today_local,
129             );
130
131   # Custom shipto addresses (the ones specific to the sales/purchase
132   # record and not to the customer/vendor) are only linked from
133   # shipto → delivery_orders. Meaning delivery_orders.shipto_id
134   # will not be filled in that case.
135   if (!$source->shipto_id && $source->id) {
136     $args{custom_shipto} = $source->custom_shipto->clone($class) if $source->can('custom_shipto') && $source->custom_shipto;
137
138   } else {
139     $args{shipto_id} = $source->shipto_id;
140   }
141
142   my $delivery_order = $class->new(%args);
143   $delivery_order->assign_attributes(%{ $params{attributes} }) if $params{attributes};
144   my $items          = delete($params{items}) || $source->items_sorted;
145   my %item_parents;
146
147   my @items = map {
148     my $source_item      = $_;
149     my $source_item_id   = $_->$item_parent_id_column;
150     my @custom_variables = map { _clone_orderitem_cvar($_) } @{ $source_item->custom_variables };
151
152     $item_parents{$source_item_id} ||= $source_item->$item_parent_column;
153     my $item_parent                  = $item_parents{$source_item_id};
154
155     my $current_do_item = SL::DB::DeliveryOrderItem->new(map({ ( $_ => $source_item->$_ ) }
156                                          qw(base_qty cusordnumber description discount lastcost longdescription marge_price_factor parts_id price_factor price_factor_id
157                                             project_id qty reqdate sellprice serialnumber transdate unit active_discount_source active_price_source
158                                          )),
159                                    custom_variables => \@custom_variables,
160                                    ordnumber        => ref($item_parent) eq 'SL::DB::Order' ? $item_parent->ordnumber : $source_item->ordnumber,
161                                  );
162     $current_do_item->{"converted_from_orderitems_id"} = $_->{id} if ref($item_parent) eq 'SL::DB::Order';
163     $current_do_item;
164   } @{ $items };
165
166   @items = grep { $params{item_filter}->($_) } @items if $params{item_filter};
167   @items = grep { $_->qty * 1 } @items if $params{skip_items_zero_qty};
168   @items = grep { $_->qty >=0 } @items if $params{skip_items_negative_qty};
169
170   $delivery_order->items(\@items);
171
172   return $delivery_order;
173 }
174
175 sub customervendor {
176   $_[0]->is_sales ? $_[0]->customer : $_[0]->vendor;
177 }
178
179 sub convert_to_invoice {
180   my ($self, %params) = @_;
181
182   croak("Conversion to invoices is only supported for sales records") unless $self->customer_id;
183
184   my $invoice;
185   if (!$self->db->with_transaction(sub {
186     require SL::DB::Invoice;
187     $invoice = SL::DB::Invoice->new_from($self, %params)->post || die;
188     $self->link_to_record($invoice);
189     # TODO extend link_to_record for items, otherwise long-term no d.r.y.
190     foreach my $item (@{ $invoice->items }) {
191       foreach (qw(delivery_order_items)) {    # expand if needed (orderitems)
192         if ($item->{"converted_from_${_}_id"}) {
193           die unless $item->{id};
194           RecordLinks->create_links('mode'       => 'ids',
195                                     'from_table' => $_,
196                                     'from_ids'   => $item->{"converted_from_${_}_id"},
197                                     'to_table'   => 'invoice',
198                                     'to_id'      => $item->{id},
199           ) || die;
200           delete $item->{"converted_from_${_}_id"};
201         }
202       }
203     }
204     $self->update_attributes(closed => 1);
205     1;
206   })) {
207     return undef;
208   }
209
210   return $invoice;
211 }
212
213 sub digest {
214   my ($self) = @_;
215
216   sprintf "%s %s (%s)",
217     $self->donumber,
218     $self->customervendor->name,
219     $self->date->to_kivitendo;
220 }
221
222 1;
223 __END__
224
225 =pod
226
227 =encoding utf8
228
229 =head1 NAME
230
231 SL::DB::DeliveryOrder - Rose model for delivery orders (table
232 "delivery_orders")
233
234 =head1 FUNCTIONS
235
236 =over 4
237
238 =item C<date>
239
240 An alias for C<transdate> for compatibility with other sales/purchase models.
241
242 =item C<displayable_name>
243
244 Returns a human-readable and translated description of the delivery order, consisting of
245 record type and number, e.g. "Verkaufslieferschein 123".
246
247 =item C<displayable_state>
248
249 Returns a human-readable description of the state regarding being
250 closed and delivered.
251
252 =item C<items>
253
254 An alias for C<delivery_order_items> for compatibility with other
255 sales/purchase models.
256
257 =item C<new_from $source, %params>
258
259 Creates a new C<SL::DB::DeliveryOrder> instance and copies as much
260 information from C<$source> as possible. At the moment only instances
261 of C<SL::DB::Order> (sales quotations, sales orders, requests for
262 quotations and purchase orders) are supported as sources.
263
264 The conversion copies order items into delivery order items. Dates are copied
265 as appropriate, e.g. the C<transdate> field will be set to the current date.
266
267 Returns the new delivery order instance. The object returned is not
268 saved.
269
270 C<%params> can include the following options:
271
272 =over 2
273
274 =item C<items>
275
276 An optional array reference of RDBO instances for the items to use. If
277 missing then the method C<items_sorted> will be called on
278 C<$source>. This option can be used to override the sorting, to
279 exclude certain positions or to add additional ones.
280
281 =item C<skip_items_negative_qty>
282
283 If trueish then items with a negative quantity are skipped. Items with
284 a quantity of 0 are not affected by this option.
285
286 =item C<skip_items_zero_qty>
287
288 If trueish then items with a quantity of 0 are skipped.
289
290 =item C<item_filter>
291
292 An optional code reference that is called for each item with the item
293 as its sole parameter. Items for which the code reference returns a
294 falsish value will be skipped.
295
296 =item C<attributes>
297
298 An optional hash reference. If it exists then it is passed to C<new>
299 allowing the caller to set certain attributes for the new delivery
300 order.
301
302 =back
303
304 =item C<sales_order>
305
306 TODO: Describe sales_order
307
308 =item C<type>
309
310 Returns a string describing this record's type: either
311 C<sales_delivery_order> or C<purchase_delivery_order>.
312
313 =item C<convert_to_invoice %params>
314
315 Creates a new invoice with C<$self> as the basis by calling
316 L<SL::DB::Invoice::new_from>. That invoice is posted, and C<$self> is
317 linked to the new invoice via L<SL::DB::RecordLink>. C<$self>'s
318 C<closed> attribute is set to C<true>, and C<$self> is saved.
319
320 The arguments in C<%params> are passed to L<SL::DB::Invoice::new_from>.
321
322 Returns the new invoice instance on success and C<undef> on
323 failure. The whole process is run inside a transaction. On failure
324 nothing is created or changed in the database.
325
326 At the moment only sales delivery orders can be converted.
327
328 =back
329
330 =head1 BUGS
331
332 Nothing here yet.
333
334 =head1 AUTHOR
335
336 Moritz Bunkus E<lt>m.bunkus@linet-services.deE<gt>
337
338 =cut