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