SL/DB/Order.pm

   1 package SL::DB::Order;
   2
   3 use utf8;
   4 use strict;
   5
   6 use Carp;
   7 use DateTime;
   8 use List::Util qw(max);
   9 use List::MoreUtils qw(any);
  10
  11 use SL::DB::MetaSetup::Order;
  12 use SL::DB::Manager::Order;
  13 use SL::DB::Helper::Attr;
  14 use SL::DB::Helper::AttrHTML;
  15 use SL::DB::Helper::AttrSorted;
  16 use SL::DB::Helper::FlattenToForm;
  17 use SL::DB::Helper::LinkedRecords;
  18 use SL::DB::Helper::PriceTaxCalculator;
  19 use SL::DB::Helper::PriceUpdater;
  20 use SL::DB::Helper::TransNumberGenerator;
  21 use SL::Locale::String qw(t8);
  22 use SL::RecordLinks;
  23 use Rose::DB::Object::Helpers qw(as_tree);
  24
  25 __PACKAGE__->meta->add_relationship(
  26   orderitems => {
  27     type         => 'one to many',
  28     class        => 'SL::DB::OrderItem',
  29     column_map   => { id => 'trans_id' },
  30     manager_args => {
  31       with_objects => [ 'part' ]
  32     }
  33   },
  34   periodic_invoices_config => {
  35     type                   => 'one to one',
  36     class                  => 'SL::DB::PeriodicInvoicesConfig',
  37     column_map             => { id => 'oe_id' },
  38   },
  39   custom_shipto            => {
  40     type                   => 'one to one',
  41     class                  => 'SL::DB::Shipto',
  42     column_map             => { id => 'trans_id' },
  43     query_args             => [ module => 'OE' ],
  44   },
  45   exchangerate_obj         => {
  46     type                   => 'one to one',
  47     class                  => 'SL::DB::Exchangerate',
  48     column_map             => { currency_id => 'currency_id', transdate => 'transdate' },
  49   },
  50 );
  51
  52 SL::DB::Helper::Attr::make(__PACKAGE__, daily_exchangerate => 'numeric');
  53
  54 __PACKAGE__->meta->initialize;
  55
  56 __PACKAGE__->attr_html('notes');
  57 __PACKAGE__->attr_sorted('items');
  58
  59 __PACKAGE__->before_save('_before_save_set_ord_quo_number');
  60 __PACKAGE__->before_save('_before_save_create_new_project');
  61 __PACKAGE__->before_save('_before_save_remove_empty_custom_shipto');
  62 __PACKAGE__->before_save('_before_save_set_custom_shipto_module');
  63
  64 # hooks
  65
  66 sub _before_save_set_ord_quo_number {
  67   my ($self) = @_;
  68
  69   # ordnumber is 'NOT NULL'. Therefore make sure it's always set to at
  70   # least an empty string, even if we're saving a quotation.
  71   $self->ordnumber('') if !$self->ordnumber;
  72
  73   my $field = $self->quotation ? 'quonumber' : 'ordnumber';
  74   $self->create_trans_number if !$self->$field;
  75
  76   return 1;
  77 }
  78 sub _before_save_create_new_project {
  79   my ($self) = @_;
  80
  81   # force new project, if not set yet
  82   if ($::instance_conf->get_order_always_project && !$self->globalproject_id && ($self->type eq 'sales_order')) {
  83
  84     die t8("Error while creating project with project number of new order number, project number #1 already exists!", $self->ordnumber)
  85       if SL::DB::Manager::Project->find_by(projectnumber => $self->ordnumber);
  86
  87     eval {
  88       my $new_project = SL::DB::Project->new(
  89           projectnumber     => $self->ordnumber,
  90           description       => $self->customer->name,
  91           customer_id       => $self->customer->id,
  92           active            => 1,
  93           project_type_id   => $::instance_conf->get_project_type_id,
  94           project_status_id => $::instance_conf->get_project_status_id,
  95           );
  96        $new_project->save;
  97        $self->globalproject_id($new_project->id);
  98     } or die t8('Could not create new project #1', $@);
  99   }
 100   return 1;
 101 }
 102
 103
 104 sub _before_save_remove_empty_custom_shipto {
 105   my ($self) = @_;
 106
 107   $self->custom_shipto(undef) if $self->custom_shipto && $self->custom_shipto->is_empty;
 108
 109   return 1;
 110 }
 111
 112 sub _before_save_set_custom_shipto_module {
 113   my ($self) = @_;
 114
 115   $self->custom_shipto->module('OE') if $self->custom_shipto;
 116
 117   return 1;
 118 }
 119
 120 # methods
 121
 122 sub items { goto &orderitems; }
 123 sub add_items { goto &add_orderitems; }
 124 sub record_number { goto &number; }
 125
 126 sub type {
 127   my $self = shift;
 128
 129   return 'sales_order'       if $self->customer_id && ! $self->quotation;
 130   return 'purchase_order'    if $self->vendor_id   && ! $self->quotation;
 131   return 'sales_quotation'   if $self->customer_id &&   $self->quotation;
 132   return 'request_quotation' if $self->vendor_id   &&   $self->quotation;
 133
 134   return;
 135 }
 136
 137 sub is_type {
 138   return shift->type eq shift;
 139 }
 140
 141 sub deliverydate {
 142   # oe doesn't have deliverydate, but PTC checks for deliverydate or transdate to determine tax
 143   # oe can't deal with deviating tax rates, but at least make sure PTC doesn't barf
 144   return shift->transdate;
 145 }
 146
 147 sub displayable_type {
 148   my $type = shift->type;
 149
 150   return $::locale->text('Sales quotation')   if $type eq 'sales_quotation';
 151   return $::locale->text('Request quotation') if $type eq 'request_quotation';
 152   return $::locale->text('Sales Order')       if $type eq 'sales_order';
 153   return $::locale->text('Purchase Order')    if $type eq 'purchase_order';
 154
 155   die 'invalid type';
 156 }
 157
 158 sub displayable_name {
 159   join ' ', grep $_, map $_[0]->$_, qw(displayable_type record_number);
 160 };
 161
 162 sub is_sales {
 163   croak 'not an accessor' if @_ > 1;
 164   return !!shift->customer_id;
 165 }
 166
 167 sub daily_exchangerate {
 168   my ($self, $val) = @_;
 169
 170   return 1 if $self->currency_id == $::instance_conf->get_currency_id;
 171
 172   my $rate = (any { $self->is_type($_) } qw(sales_quotation sales_order))      ? 'buy'
 173            : (any { $self->is_type($_) } qw(request_quotation purchase_order)) ? 'sell'
 174            : undef;
 175   return if !$rate;
 176
 177   if (defined $val) {
 178     croak t8('exchange rate has to be positive') if $val <= 0;
 179     if (!$self->exchangerate_obj) {
 180       $self->exchangerate_obj(SL::DB::Exchangerate->new(
 181         currency_id => $self->currency_id,
 182         transdate   => $self->transdate,
 183         $rate       => $val,
 184       ));
 185     } elsif (!defined $self->exchangerate_obj->$rate) {
 186       $self->exchangerate_obj->$rate($val);
 187     } else {
 188       croak t8('exchange rate already exists, no update allowed');
 189     }
 190   }
 191   return $self->exchangerate_obj->$rate if $self->exchangerate_obj;
 192 }
 193
 194 sub invoices {
 195   my $self   = shift;
 196   my %params = @_;
 197
 198   if ($self->quotation) {
 199     return [];
 200   } else {
 201     require SL::DB::Invoice;
 202     return SL::DB::Manager::Invoice->get_all(
 203       query => [
 204         ordnumber => $self->ordnumber,
 205         @{ $params{query} || [] },
 206       ]
 207     );
 208   }
 209 }
 210
 211 sub displayable_state {
 212   my ($self) = @_;
 213
 214   return $self->closed ? $::locale->text('closed') : $::locale->text('open');
 215 }
 216
 217 sub abschlag_invoices {
 218   return shift()->invoices(query => [ abschlag => 1 ]);
 219 }
 220
 221 sub end_invoice {
 222   return shift()->invoices(query => [ abschlag => 0 ]);
 223 }
 224
 225 sub convert_to_invoice {
 226   my ($self, %params) = @_;
 227
 228   croak("Conversion to invoices is only supported for sales records") unless $self->customer_id;
 229
 230   my $invoice;
 231   if (!$self->db->with_transaction(sub {
 232     require SL::DB::Invoice;
 233     $invoice = SL::DB::Invoice->new_from($self)->post(%params) || die;
 234     $self->link_to_record($invoice);
 235     $self->update_attributes(closed => 1);
 236     1;
 237   })) {
 238     return undef;
 239   }
 240
 241   return $invoice;
 242 }
 243
 244 sub convert_to_delivery_order {
 245   my ($self, @args) = @_;
 246
 247   my $delivery_order;
 248   if (!$self->db->with_transaction(sub {
 249     require SL::DB::DeliveryOrder;
 250     $delivery_order = SL::DB::DeliveryOrder->new_from($self, @args);
 251     $delivery_order->save;
 252     $self->link_to_record($delivery_order);
 253     # TODO extend link_to_record for items, otherwise long-term no d.r.y.
 254     foreach my $item (@{ $delivery_order->items }) {
 255       foreach (qw(orderitems)) {    # expand if needed (delivery_order_items)
 256         if ($item->{"converted_from_${_}_id"}) {
 257           die unless $item->{id};
 258           RecordLinks->create_links('dbh'        => $self->db->dbh,
 259                                     'mode'       => 'ids',
 260                                     'from_table' => $_,
 261                                     'from_ids'   => $item->{"converted_from_${_}_id"},
 262                                     'to_table'   => 'delivery_order_items',
 263                                     'to_id'      => $item->{id},
 264           ) || die;
 265           delete $item->{"converted_from_${_}_id"};
 266         }
 267       }
 268     }
 269
 270     $self->update_attributes(delivered => 1);
 271     1;
 272   })) {
 273     return undef;
 274   }
 275
 276   return $delivery_order;
 277 }
 278
 279 sub _clone_orderitem_cvar {
 280   my ($cvar) = @_;
 281
 282   my $cloned = $_->clone_and_reset;
 283   $cloned->sub_module('orderitems');
 284
 285   return $cloned;
 286 }
 287
 288 sub new_from {
 289   my ($class, $source, %params) = @_;
 290
 291   croak("Unsupported source object type '" . ref($source) . "'") unless ref($source) eq 'SL::DB::Order';
 292   croak("A destination type must be given as parameter")         unless $params{destination_type};
 293
 294   my $destination_type  = delete $params{destination_type};
 295
 296   my @from_tos = (
 297     { from => 'sales_quotation',   to => 'sales_order',       abbr => 'sqso' },
 298     { from => 'request_quotation', to => 'purchase_order',    abbr => 'rqpo' },
 299     { from => 'sales_quotation',   to => 'sales_quotation',   abbr => 'sqsq' },
 300     { from => 'sales_order',       to => 'sales_order',       abbr => 'soso' },
 301     { from => 'request_quotation', to => 'request_quotation', abbr => 'rqrq' },
 302     { from => 'purchase_order',    to => 'purchase_order',    abbr => 'popo' },
 303     { from => 'sales_order',       to => 'purchase_order',    abbr => 'sopo' },
 304     { from => 'purchase_order',    to => 'sales_order',       abbr => 'poso' },
 305   );
 306   my $from_to = (grep { $_->{from} eq $source->type && $_->{to} eq $destination_type} @from_tos)[0];
 307   croak("Cannot convert from '" . $source->type . "' to '" . $destination_type . "'") if !$from_to;
 308
 309   my $is_abbr_any = sub {
 310     # foreach my $abbr (@_) {
 311     #   croak "no such abbreviation: '$abbr'" if !grep { $_->{abbr} eq $abbr } @from_tos;
 312     # }
 313     any { $from_to->{abbr} eq $_ } @_;
 314   };
 315
 316   my ($item_parent_id_column, $item_parent_column);
 317
 318   if (ref($source) eq 'SL::DB::Order') {
 319     $item_parent_id_column = 'trans_id';
 320     $item_parent_column    = 'order';
 321   }
 322
 323   my %args = ( map({ ( $_ => $source->$_ ) } qw(amount cp_id currency_id cusordnumber customer_id delivery_customer_id delivery_term_id delivery_vendor_id
 324                                                 department_id employee_id exchangerate globalproject_id intnotes marge_percent marge_total language_id netamount notes
 325                                                 ordnumber payment_id quonumber reqdate salesman_id shippingpoint shipvia taxincluded taxzone_id
 326                                                 transaction_description vendor_id
 327                                              )),
 328                quotation => !!($destination_type =~ m{quotation$}),
 329                closed    => 0,
 330                delivered => 0,
 331                transdate => DateTime->today_local,
 332             );
 333
 334   if ( $is_abbr_any->(qw(sopo poso)) ) {
 335     $args{ordnumber} = undef;
 336     $args{quonumber} = undef;
 337     $args{reqdate}   = DateTime->today_local->next_workday();
 338     $args{employee}  = SL::DB::Manager::Employee->current;
 339   }
 340   if ( $is_abbr_any->(qw(sopo)) ) {
 341     $args{customer_id}      = undef;
 342     $args{salesman_id}      = undef;
 343     $args{payment_id}       = undef;
 344     $args{delivery_term_id} = undef;
 345   }
 346   if ( $is_abbr_any->(qw(poso)) ) {
 347     $args{vendor_id} = undef;
 348   }
 349   if ( $is_abbr_any->(qw(soso)) ) {
 350     $args{periodic_invoices_config} = $source->periodic_invoices_config->clone_and_reset if $source->periodic_invoices_config;
 351   }
 352
 353   # Custom shipto addresses (the ones specific to the sales/purchase
 354   # record and not to the customer/vendor) are only linked from
 355   # shipto → order. Meaning order.shipto_id
 356   # will not be filled in that case.
 357   if (!$source->shipto_id && $source->id) {
 358     $args{custom_shipto} = $source->custom_shipto->clone($class) if $source->can('custom_shipto') && $source->custom_shipto;
 359
 360   } else {
 361     $args{shipto_id} = $source->shipto_id;
 362   }
 363
 364   my $order = $class->new(%args);
 365   $order->assign_attributes(%{ $params{attributes} }) if $params{attributes};
 366   my $items = delete($params{items}) || $source->items_sorted;
 367
 368   my %item_parents;
 369
 370   my @items = map {
 371     my $source_item      = $_;
 372     my $source_item_id   = $_->$item_parent_id_column;
 373     my @custom_variables = map { _clone_orderitem_cvar($_) } @{ $source_item->custom_variables };
 374
 375     $item_parents{$source_item_id} ||= $source_item->$item_parent_column;
 376     my $item_parent                  = $item_parents{$source_item_id};
 377
 378     my $current_oe_item = SL::DB::OrderItem->new(map({ ( $_ => $source_item->$_ ) }
 379                                                      qw(active_discount_source active_price_source base_qty cusordnumber
 380                                                         description discount lastcost longdescription
 381                                                         marge_percent marge_price_factor marge_total
 382                                                         ordnumber parts_id price_factor price_factor_id pricegroup_id
 383                                                         project_id qty reqdate sellprice serialnumber ship subtotal transdate unit
 384                                                      )),
 385                                                  custom_variables => \@custom_variables,
 386     );
 387     if ( $is_abbr_any->(qw(sopo)) ) {
 388       $current_oe_item->sellprice($source_item->lastcost);
 389       $current_oe_item->discount(0);
 390     }
 391     if ( $is_abbr_any->(qw(poso)) ) {
 392       $current_oe_item->lastcost($source_item->sellprice);
 393     }
 394     $current_oe_item->{"converted_from_orderitems_id"} = $_->{id} if ref($item_parent) eq 'SL::DB::Order';
 395     $current_oe_item;
 396   } @{ $items };
 397
 398   @items = grep { $params{item_filter}->($_) } @items if $params{item_filter};
 399   @items = grep { $_->qty * 1 } @items if $params{skip_items_zero_qty};
 400   @items = grep { $_->qty >=0 } @items if $params{skip_items_negative_qty};
 401
 402   $order->items(\@items);
 403
 404   return $order;
 405 }
 406
 407 sub new_from_multi {
 408   my ($class, $sources, %params) = @_;
 409
 410   croak("Unsupported object type in sources")                             if any { ref($_) !~ m{SL::DB::Order} }                   @$sources;
 411   croak("Cannot create order for purchase records")                       if any { !$_->is_sales }                                 @$sources;
 412   croak("Cannot create order from source records of different customers") if any { $_->customer_id != $sources->[0]->customer_id } @$sources;
 413
 414   # bb: todo: check shipto: is it enough to check the ids or do we have to compare the entries?
 415   if (delete $params{check_same_shipto}) {
 416     die "check same shipto address is not implemented yet";
 417     die "Source records do not have the same shipto"        if 1;
 418   }
 419
 420   # sort sources
 421   if (defined $params{sort_sources_by}) {
 422     my $sort_by = delete $params{sort_sources_by};
 423     if ($sources->[0]->can($sort_by)) {
 424       $sources = [ sort { $a->$sort_by cmp $b->$sort_by } @$sources ];
 425     } else {
 426       die "Cannot sort source records by $sort_by";
 427     }
 428   }
 429
 430   # set this entries to undef that yield different information
 431   my %attributes;
 432   foreach my $attr (qw(ordnumber transdate reqdate taxincluded shippingpoint
 433                        shipvia notes closed delivered reqdate quonumber
 434                        cusordnumber proforma transaction_description
 435                        order_probability expected_billing_date)) {
 436     $attributes{$attr} = undef if any { ($sources->[0]->$attr//'') ne ($_->$attr//'') } @$sources;
 437   }
 438   foreach my $attr (qw(cp_id currency_id employee_id salesman_id department_id
 439                        delivery_customer_id delivery_vendor_id shipto_id
 440                        globalproject_id exchangerate)) {
 441     $attributes{$attr} = undef if any { ($sources->[0]->$attr||0) != ($_->$attr||0) }   @$sources;
 442   }
 443
 444   # set this entries from customer that yield different information
 445   foreach my $attr (qw(language_id taxzone_id payment_id delivery_term_id)) {
 446     $attributes{$attr}  = $sources->[0]->customervendor->$attr if any { ($sources->[0]->$attr||0)     != ($_->$attr||0) }      @$sources;
 447   }
 448   $attributes{intnotes} = $sources->[0]->customervendor->notes if any { ($sources->[0]->intnotes//'') ne ($_->intnotes//'')  } @$sources;
 449
 450   # no periodic invoice config for new order
 451   $attributes{periodic_invoices_config} = undef;
 452
 453   # copy global ordnumber, transdate, cusordnumber into item scope
 454   #   unless already present there
 455   foreach my $attr (qw(ordnumber transdate cusordnumber)) {
 456     foreach my $src (@$sources) {
 457       foreach my $item (@{ $src->items_sorted }) {
 458         $item->$attr($src->$attr) if !$item->$attr;
 459       }
 460     }
 461   }
 462
 463   # collect items
 464   my @items;
 465   push @items, @{$_->items_sorted} for @$sources;
 466   # make order from first source and all items
 467   my $order = $class->new_from($sources->[0],
 468                                destination_type => 'sales_order',
 469                                attributes       => \%attributes,
 470                                items            => \@items,
 471                                %params);
 472
 473   return $order;
 474 }
 475
 476 sub number {
 477   my $self = shift;
 478
 479   return if !$self->type;
 480
 481   my %number_method = (
 482     sales_order       => 'ordnumber',
 483     sales_quotation   => 'quonumber',
 484     purchase_order    => 'ordnumber',
 485     request_quotation => 'quonumber',
 486   );
 487
 488   return $self->${ \ $number_method{$self->type} }(@_);
 489 }
 490
 491 sub customervendor {
 492   $_[0]->is_sales ? $_[0]->customer : $_[0]->vendor;
 493 }
 494
 495 sub date {
 496   goto &transdate;
 497 }
 498
 499 sub digest {
 500   my ($self) = @_;
 501
 502   sprintf "%s %s %s (%s)",
 503     $self->number,
 504     $self->customervendor->name,
 505     $self->amount_as_number,
 506     $self->date->to_kivitendo;
 507 }
 508
 509 1;
 510
 511 __END__
 512
 513 =pod
 514
 515 =encoding utf8
 516
 517 =head1 NAME
 518
 519 SL::DB::Order - Order Datenbank Objekt.
 520
 521 =head1 FUNCTIONS
 522
 523 =head2 C<type>
 524
 525 Returns one of the following string types:
 526
 527 =over 4
 528
 529 =item sales_order
 530
 531 =item purchase_order
 532
 533 =item sales_quotation
 534
 535 =item request_quotation
 536
 537 =back
 538
 539 =head2 C<is_type TYPE>
 540
 541 Returns true if the order is of the given type.
 542
 543 =head2 C<daily_exchangerate $val>
 544
 545 Gets or sets the exchangerate object's value. This is the value from the
 546 table C<exchangerate> depending on the order's currency, the transdate and
 547 if it is a sales or purchase order.
 548
 549 The order object (respectively the table C<oe>) has an own column
 550 C<exchangerate> which can be get or set with the accessor C<exchangerate>.
 551
 552 The idea is to drop the legacy table C<exchangerate> in the future and to
 553 give all relevant tables it's own C<exchangerate> column.
 554
 555 So, this method is here if you need to access the "legacy" exchangerate via
 556 an order object.
 557
 558 =over 4
 559
 560 =item C<$val>
 561
 562 (optional) If given, the exchangerate in the "legacy" table is set to this
 563 value, depending on currency, transdate and sales or purchase.
 564
 565 =back
 566
 567 =head2 C<convert_to_delivery_order %params>
 568
 569 Creates a new delivery order with C<$self> as the basis by calling
 570 L<SL::DB::DeliveryOrder::new_from>. That delivery order is saved, and
 571 C<$self> is linked to the new invoice via
 572 L<SL::DB::RecordLink>. C<$self>'s C<delivered> attribute is set to
 573 C<true>, and C<$self> is saved.
 574
 575 The arguments in C<%params> are passed to
 576 L<SL::DB::DeliveryOrder::new_from>.
 577
 578 Returns C<undef> on failure. Otherwise the new delivery order will be
 579 returned.
 580
 581 =head2 C<convert_to_invoice %params>
 582
 583 Creates a new invoice with C<$self> as the basis by calling
 584 L<SL::DB::Invoice::new_from>. That invoice is posted, and C<$self> is
 585 linked to the new invoice via L<SL::DB::RecordLink>. C<$self>'s
 586 C<closed> attribute is set to C<true>, and C<$self> is saved.
 587
 588 The arguments in C<%params> are passed to L<SL::DB::Invoice::post>.
 589
 590 Returns the new invoice instance on success and C<undef> on
 591 failure. The whole process is run inside a transaction. On failure
 592 nothing is created or changed in the database.
 593
 594 At the moment only sales quotations and sales orders can be converted.
 595
 596 =head2 C<new_from $source, %params>
 597
 598 Creates a new C<SL::DB::Order> instance and copies as much
 599 information from C<$source> as possible. At the moment only records with the
 600 same destination type as the source type and sales orders from
 601 sales quotations and purchase orders from requests for quotations can be
 602 created.
 603
 604 The C<transdate> field will be set to the current date.
 605
 606 The conversion copies the order items as well.
 607
 608 Returns the new order instance. The object returned is not
 609 saved.
 610
 611 C<%params> can include the following options
 612 (C<destination_type> is mandatory):
 613
 614 =over 4
 615
 616 =item C<destination_type>
 617
 618 (mandatory)
 619 The type of the newly created object. Can be C<sales_quotation>,
 620 C<sales_order>, C<purchase_quotation> or C<purchase_order> for now.
 621
 622 =item C<items>
 623
 624 An optional array reference of RDBO instances for the items to use. If
 625 missing then the method C<items_sorted> will be called on
 626 C<$source>. This option can be used to override the sorting, to
 627 exclude certain positions or to add additional ones.
 628
 629 =item C<skip_items_negative_qty>
 630
 631 If trueish then items with a negative quantity are skipped. Items with
 632 a quantity of 0 are not affected by this option.
 633
 634 =item C<skip_items_zero_qty>
 635
 636 If trueish then items with a quantity of 0 are skipped.
 637
 638 =item C<item_filter>
 639
 640 An optional code reference that is called for each item with the item
 641 as its sole parameter. Items for which the code reference returns a
 642 falsish value will be skipped.
 643
 644 =item C<attributes>
 645
 646 An optional hash reference. If it exists then it is passed to C<new>
 647 allowing the caller to set certain attributes for the new delivery
 648 order.
 649
 650 =back
 651
 652 =head2 C<new_from_multi $sources, %params>
 653
 654 Creates a new C<SL::DB::Order> instance from multiple sources and copies as
 655 much information from C<$sources> as possible.
 656 At the moment only sales orders can be combined and they must be of the same
 657 customer.
 658
 659 The new order is created from the first one using C<new_from> and the positions
 660 of all orders are added to the new order. The orders can be sorted with the
 661 parameter C<sort_sources_by>.
 662
 663 The orders attributes are kept if they contain the same information for all
 664 source orders an will be set to empty if they contain different information.
 665
 666 Returns the new order instance. The object returned is not
 667 saved.
 668
 669 C<params> other then C<sort_sources_by> are passed to C<new_from>.
 670
 671 =head1 BUGS
 672
 673 Nothing here yet.
 674
 675 =head1 AUTHOR
 676
 677 Sven Schöling <s.schoeling@linet-services.de>
 678
 679 =cut