SL/DB/Part.pm

   1 package SL::DB::Part;
   2
   3 use strict;
   4
   5 use Carp;
   6 use List::MoreUtils qw(any uniq);
   7 use Rose::DB::Object::Helpers qw(as_tree);
   8
   9 use SL::Locale::String qw(t8);
  10 use SL::DBUtils;
  11 use SL::DB::MetaSetup::Part;
  12 use SL::DB::Manager::Part;
  13 use SL::DB::Chart;
  14 use SL::DB::Helper::AttrHTML;
  15 use SL::DB::Helper::AttrSorted;
  16 use SL::DB::Helper::TransNumberGenerator;
  17 use SL::DB::Helper::CustomVariables (
  18   module      => 'IC',
  19   cvars_alias => 1,
  20 );
  21 use SL::DB::Helper::DisplayableNamePreferences (
  22   title   => t8('Article'),
  23   options => [ {name => 'partnumber',  title => t8('Part Number')     },
  24                {name => 'description', title => t8('Description')    },
  25                {name => 'notes',       title => t8('Notes')},
  26                {name => 'ean',         title => t8('EAN')            }, ],
  27 );
  28
  29 use List::Util qw(sum);
  30
  31 __PACKAGE__->meta->add_relationships(
  32   assemblies                     => {
  33     type         => 'one to many',
  34     class        => 'SL::DB::Assembly',
  35     manager_args => { sort_by => 'position, oid' },
  36     column_map   => { id => 'id' },
  37   },
  38   prices         => {
  39     type         => 'one to many',
  40     class        => 'SL::DB::Price',
  41     column_map   => { id => 'parts_id' },
  42     manager_args => { with_objects => [ 'pricegroup' ] }
  43   },
  44   makemodels     => {
  45     type         => 'one to many',
  46     class        => 'SL::DB::MakeModel',
  47     manager_args => { sort_by => 'sortorder' },
  48     column_map   => { id => 'parts_id' },
  49   },
  50   customerprices => {
  51     type         => 'one to many',
  52     class        => 'SL::DB::PartCustomerPrice',
  53     column_map   => { id => 'parts_id' },
  54   },
  55   translations   => {
  56     type         => 'one to many',
  57     class        => 'SL::DB::Translation',
  58     column_map   => { id => 'parts_id' },
  59   },
  60   assortment_items => {
  61     type         => 'one to many',
  62     class        => 'SL::DB::AssortmentItem',
  63     column_map   => { id => 'assortment_id' },
  64   },
  65   history_entries   => {
  66     type            => 'one to many',
  67     class           => 'SL::DB::History',
  68     column_map      => { id => 'trans_id' },
  69     query_args      => [ what_done => 'part' ],
  70     manager_args    => { sort_by => 'itime' },
  71   },
  72   shop_parts     => {
  73     type         => 'one to many',
  74     class        => 'SL::DB::ShopPart',
  75     column_map   => { id => 'part_id' },
  76     manager_args => { with_objects => [ 'shop' ] },
  77   },
  78 );
  79
  80 __PACKAGE__->meta->initialize;
  81
  82 __PACKAGE__->attr_html('notes');
  83 __PACKAGE__->attr_sorted({ unsorted => 'makemodels',     position => 'sortorder' });
  84 __PACKAGE__->attr_sorted({ unsorted => 'customerprices', position => 'sortorder' });
  85
  86 __PACKAGE__->before_save('_before_save_set_partnumber');
  87
  88 sub _before_save_set_partnumber {
  89   my ($self) = @_;
  90
  91   $self->create_trans_number if !$self->partnumber;
  92   return 1;
  93 }
  94
  95 sub items {
  96   my ($self) = @_;
  97
  98   if ( $self->part_type eq 'assembly' ) {
  99     return $self->assemblies;
 100   } elsif ( $self->part_type eq 'assortment' ) {
 101     return $self->assortment_items;
 102   } else {
 103     return undef;
 104   }
 105 }
 106
 107 sub items_checksum {
 108   my ($self) = @_;
 109
 110   # for detecting if the items of an (orphaned) assembly or assortment have
 111   # changed when saving
 112
 113   return join(' ', sort map { $_->part->id } @{$self->items});
 114 };
 115
 116 sub validate {
 117   my ($self) = @_;
 118
 119   my @errors;
 120   push @errors, $::locale->text('The partnumber is missing.')     if $self->id and !$self->partnumber;
 121   push @errors, $::locale->text('The unit is missing.')           unless $self->unit;
 122   push @errors, $::locale->text('The buchungsgruppe is missing.') unless $self->buchungsgruppen_id or $self->buchungsgruppe;
 123
 124   unless ( $self->id ) {
 125     push @errors, $::locale->text('The partnumber already exists.') if SL::DB::Manager::Part->get_all_count(where => [ partnumber => $self->partnumber ]);
 126   };
 127
 128   if ($self->is_assortment && $self->orphaned && scalar @{$self->assortment_items} == 0) {
 129     # when assortment isn't orphaned form doesn't contain any items
 130     push @errors, $::locale->text('The assortment doesn\'t have any items.');
 131   }
 132
 133   if ($self->is_assembly && scalar @{$self->assemblies} == 0) {
 134     push @errors, $::locale->text('The assembly doesn\'t have any items.');
 135   }
 136
 137   return @errors;
 138 }
 139
 140 sub is_type {
 141   my $self = shift;
 142   my $type  = lc(shift || '');
 143   die 'invalid type' unless $type =~ /^(?:part|service|assembly|assortment)$/;
 144
 145   return $self->type eq $type ? 1 : 0;
 146 }
 147
 148 sub is_part       { $_[0]->part_type eq 'part'       }
 149 sub is_assembly   { $_[0]->part_type eq 'assembly'   }
 150 sub is_service    { $_[0]->part_type eq 'service'    }
 151 sub is_assortment { $_[0]->part_type eq 'assortment' }
 152
 153 sub type {
 154   return $_[0]->part_type;
 155   # my ($self, $type) = @_;
 156   # if (@_ > 1) {
 157   #   die 'invalid type' unless $type =~ /^(?:part|service|assembly)$/;
 158   #   $self->assembly(          $type eq 'assembly' ? 1 : 0);
 159   #   $self->inventory_accno_id($type ne 'service'  ? 1 : undef);
 160   # }
 161
 162   # return 'assembly' if $self->assembly;
 163   # return 'part'     if $self->inventory_accno_id;
 164   # return 'service';
 165 }
 166
 167 sub new_part {
 168   my ($class, %params) = @_;
 169   $class->new(%params, part_type => 'part');
 170 }
 171
 172 sub new_assembly {
 173   my ($class, %params) = @_;
 174   $class->new(%params, part_type => 'assembly');
 175 }
 176
 177 sub new_service {
 178   my ($class, %params) = @_;
 179   $class->new(%params, part_type => 'service');
 180 }
 181
 182 sub new_assortment {
 183   my ($class, %params) = @_;
 184   $class->new(%params, part_type => 'assortment');
 185 }
 186
 187 sub last_modification {
 188   my ($self) = @_;
 189   return $self->mtime // $self->itime;
 190 };
 191
 192 sub used_in_record {
 193   my ($self) = @_;
 194   die 'not an accessor' if @_ > 1;
 195
 196   return 1 unless $self->id;
 197
 198   my @relations = qw(
 199     SL::DB::InvoiceItem
 200     SL::DB::OrderItem
 201     SL::DB::DeliveryOrderItem
 202   );
 203
 204   for my $class (@relations) {
 205     eval "require $class";
 206     return 1 if $class->_get_manager_class->get_all_count(query => [ parts_id => $self->id ]);
 207   }
 208   return 0;
 209 }
 210 sub orphaned {
 211   my ($self) = @_;
 212   die 'not an accessor' if @_ > 1;
 213
 214   return 1 unless $self->id;
 215
 216   my @relations = qw(
 217     SL::DB::InvoiceItem
 218     SL::DB::OrderItem
 219     SL::DB::DeliveryOrderItem
 220     SL::DB::Inventory
 221     SL::DB::AssortmentItem
 222   );
 223
 224   for my $class (@relations) {
 225     eval "require $class";
 226     return 0 if $class->_get_manager_class->get_all_count(query => [ parts_id => $self->id ]);
 227   }
 228   return 1;
 229 }
 230
 231 sub get_sellprice_info {
 232   my $self   = shift;
 233   my %params = @_;
 234
 235   confess "Missing part id" unless $self->id;
 236
 237   my $object = $self->load;
 238
 239   return { sellprice       => $object->sellprice,
 240            price_factor_id => $object->price_factor_id };
 241 }
 242
 243 sub get_ordered_qty {
 244   my $self   = shift;
 245   my %result = SL::DB::Manager::Part->get_ordered_qty($self->id);
 246
 247   return $result{ $self->id };
 248 }
 249
 250 sub available_units {
 251   shift->unit_obj->convertible_units;
 252 }
 253
 254 # autogenerated accessor is slightly off...
 255 sub buchungsgruppe {
 256   shift->buchungsgruppen(@_);
 257 }
 258
 259 sub get_taxkey {
 260   my ($self, %params) = @_;
 261
 262   my $date     = $params{date} || DateTime->today_local;
 263   my $is_sales = !!$params{is_sales};
 264   my $taxzone  = $params{ defined($params{taxzone}) ? 'taxzone' : 'taxzone_id' } * 1;
 265   my $tk_info  = $::request->cache('get_taxkey');
 266
 267   $tk_info->{$self->id}                                      //= {};
 268   $tk_info->{$self->id}->{$taxzone}                          //= { };
 269   my $cache = $tk_info->{$self->id}->{$taxzone}->{$is_sales} //= { };
 270
 271   if (!exists $cache->{$date}) {
 272     $cache->{$date} =
 273       $self->get_chart(type => $is_sales ? 'income' : 'expense', taxzone => $taxzone)
 274       ->get_active_taxkey($date);
 275   }
 276
 277   return $cache->{$date};
 278 }
 279
 280 sub get_chart {
 281   my ($self, %params) = @_;
 282
 283   my $type    = (any { $_ eq $params{type} } qw(income expense inventory)) ? $params{type} : croak("Invalid 'type' parameter '$params{type}'");
 284   my $taxzone = $params{ defined($params{taxzone}) ? 'taxzone' : 'taxzone_id' } * 1;
 285
 286   my $charts     = $::request->cache('get_chart_id/by_part_id_and_taxzone')->{$self->id} //= {};
 287   my $all_charts = $::request->cache('get_chart_id/by_id');
 288
 289   $charts->{$taxzone} ||= { };
 290
 291   if (!exists $charts->{$taxzone}->{$type}) {
 292     require SL::DB::Buchungsgruppe;
 293     my $bugru    = SL::DB::Buchungsgruppe->load_cached($self->buchungsgruppen_id);
 294     my $chart_id = ($type eq 'inventory') ? ($self->is_part ? $bugru->inventory_accno_id : undef)
 295                  :                          $bugru->call_sub("${type}_accno_id", $taxzone);
 296
 297     if ($chart_id) {
 298       my $chart                    = $all_charts->{$chart_id} // SL::DB::Chart->load_cached($chart_id)->load;
 299       $all_charts->{$chart_id}     = $chart;
 300       $charts->{$taxzone}->{$type} = $chart;
 301     }
 302   }
 303
 304   return $charts->{$taxzone}->{$type};
 305 }
 306
 307 sub get_stock {
 308   my ($self, %params) = @_;
 309
 310   return undef unless $self->id;
 311
 312   my $query = 'SELECT SUM(qty) FROM inventory WHERE parts_id = ?';
 313   my @values = ($self->id);
 314
 315   if ( $params{bin_id} ) {
 316     $query .= ' AND bin_id = ?';
 317     push(@values, $params{bin_id});
 318   }
 319
 320   if ( $params{warehouse_id} ) {
 321     $query .= ' AND warehouse_id = ?';
 322     push(@values, $params{warehouse_id});
 323   }
 324
 325   if ( $params{shippingdate} ) {
 326     die unless ref($params{shippingdate}) eq 'DateTime';
 327     $query .= ' AND shippingdate <= ?';
 328     push(@values, $params{shippingdate});
 329   }
 330
 331   my ($stock) = selectrow_query($::form, $self->db->dbh, $query, @values);
 332
 333   return $stock || 0; # never return undef
 334 };
 335
 336
 337 # this is designed to ignore chargenumbers, expiration dates and just give a list of how much <-> where
 338 sub get_simple_stock {
 339   my ($self, %params) = @_;
 340
 341   return [] unless $self->id;
 342
 343   my $query = <<'';
 344     SELECT sum(qty), warehouse_id, bin_id FROM inventory WHERE parts_id = ?
 345     GROUP BY warehouse_id, bin_id
 346
 347   my $stock_info = selectall_hashref_query($::form, $::form->get_standard_dbh, $query, $self->id);
 348   [ map { bless $_, 'SL::DB::Part::SimpleStock'} @$stock_info ];
 349 }
 350 # helper class to have bin/warehouse accessors in stock result
 351 { package SL::DB::Part::SimpleStock;
 352   sub warehouse { require SL::DB::Warehouse; SL::DB::Manager::Warehouse->find_by_or_create(id => $_[0]->{warehouse_id}) }
 353   sub bin       { require SL::DB::Bin;       SL::DB::Manager::Bin      ->find_by_or_create(id => $_[0]->{bin_id}) }
 354 }
 355
 356 sub get_simple_stock_sql {
 357   my ($self, %params) = @_;
 358
 359   return [] unless $self->id;
 360
 361   my $query = <<SQL;
 362      SELECT w.description                         AS warehouse_description,
 363             b.description                         AS bin_description,
 364             SUM(i.qty)                            AS qty,
 365             SUM(i.qty * p.lastcost)               AS stock_value,
 366             p.unit                                AS unit,
 367             LEAD(w.description)           OVER pt AS wh_lead,            -- to detect warehouse changes for subtotals in template
 368             SUM( SUM(i.qty) )             OVER pt AS run_qty,            -- running total of total qty
 369             SUM( SUM(i.qty) )             OVER wh AS wh_run_qty,         -- running total of warehouse qty
 370             SUM( SUM(i.qty * p.lastcost)) OVER pt AS run_stock_value,    -- running total of total stock_value
 371             SUM( SUM(i.qty * p.lastcost)) OVER wh AS wh_run_stock_value  -- running total of warehouse stock_value
 372        FROM inventory i
 373             LEFT JOIN parts p     ON (p.id           = i.parts_id)
 374             LEFT JOIN warehouse w ON (i.warehouse_id = w.id)
 375             LEFT JOIN bin b       ON (i.bin_id       = b.id)
 376       WHERE parts_id = ?
 377    GROUP BY w.description, w.sortkey, b.description, p.unit, i.parts_id
 378      HAVING SUM(qty) != 0
 379      WINDOW pt AS (PARTITION BY i.parts_id    ORDER BY w.sortkey, b.description, p.unit),
 380             wh AS (PARTITION by w.description ORDER BY w.sortkey, b.description, p.unit)
 381    ORDER BY w.sortkey, b.description, p.unit
 382 SQL
 383
 384   my $stock_info = selectall_hashref_query($::form, $self->db->dbh, $query, $self->id);
 385   return $stock_info;
 386 }
 387
 388 sub get_mini_journal {
 389   my ($self) = @_;
 390
 391   # inventory ids of the most recent 10 inventory trans_ids
 392
 393   # duplicate code copied from SL::Controller::Inventory mini_journal, except
 394   # for the added filter on parts_id
 395
 396   my $parts_id = $self->id;
 397   my $query = <<"SQL";
 398 with last_inventories as (
 399    select id,
 400           trans_id,
 401           itime
 402      from inventory
 403     where parts_id = $parts_id
 404  order by itime desc
 405     limit 20
 406 ),
 407 grouped_ids as (
 408    select trans_id,
 409           array_agg(id) as ids
 410      from last_inventories
 411  group by trans_id
 412  order by max(itime)
 413      desc limit 10
 414 )
 415 select unnest(ids)
 416   from grouped_ids
 417  limit 20  -- so the planner knows how many ids to expect, the cte is an optimisation fence
 418 SQL
 419
 420   my $objs  = SL::DB::Manager::Inventory->get_all(
 421     query        => [ id => [ \"$query" ] ],
 422     with_objects => [ 'parts', 'trans_type', 'bin', 'bin.warehouse' ], # prevent lazy loading in template
 423     sort_by      => 'itime DESC',
 424   );
 425   # remember order of trans_ids from query, for ordering hash later
 426   my @sorted_trans_ids = uniq map { $_->trans_id } @$objs;
 427
 428   # at most 2 of them belong to a transaction and the qty determines in or out.
 429   my %transactions;
 430   for (@$objs) {
 431     $transactions{ $_->trans_id }{ $_->qty > 0 ? 'in' : 'out' } = $_;
 432     $transactions{ $_->trans_id }{base} = $_;
 433   }
 434
 435   # because the inventory transactions were built in a hash, we need to sort the
 436   # hash by using the original sort order of the trans_ids
 437   my @sorted = map { $transactions{$_} } @sorted_trans_ids;
 438
 439   return \@sorted;
 440 }
 441
 442 sub clone_and_reset_deep {
 443   my ($self) = @_;
 444
 445   my $clone = $self->clone_and_reset; # resets id and partnumber (primary key and unique constraint)
 446   $clone->makemodels(   map { $_->clone_and_reset } @{$self->makemodels}   ) if @{$self->makemodels};
 447   $clone->translations( map { $_->clone_and_reset } @{$self->translations} ) if @{$self->translations};
 448
 449   if ( $self->is_assortment ) {
 450     # use clone rather than reset_and_clone because the unique constraint would also remove parts_id
 451     $clone->assortment_items( map { $_->clone } @{$self->assortment_items} );
 452     $_->assortment_id(undef) foreach @{ $clone->assortment_items }
 453   };
 454
 455   if ( $self->is_assembly ) {
 456     $clone->assemblies( map { $_->clone_and_reset } @{$self->assemblies});
 457   };
 458
 459   if ( $self->prices ) {
 460     $clone->prices( map { $_->clone } @{$self->prices}); # pricegroup_id gets reset here because it is part of a unique contraint
 461     if ( $clone->prices ) {
 462       foreach my $price ( @{$clone->prices} ) {
 463         $price->id(undef);
 464         $price->parts_id(undef);
 465       };
 466     };
 467   };
 468
 469   return $clone;
 470 }
 471
 472 sub item_diffs {
 473   my ($self, $comparison_part) = @_;
 474
 475   die "item_diffs needs a part object" unless ref($comparison_part) eq 'SL::DB::Part';
 476   die "part and comparison_part need to be of the same part_type" unless
 477         ( $self->part_type eq 'assembly' or $self->part_type eq 'assortment' )
 478     and ( $comparison_part->part_type eq 'assembly' or $comparison_part->part_type eq 'assortment' )
 479     and $self->part_type eq $comparison_part->part_type;
 480
 481   # return [], [] if $self->items_checksum eq $comparison_part->items_checksum;
 482   my @self_part_ids       = map { $_->parts_id } $self->items;
 483   my @comparison_part_ids = map { $_->parts_id } $comparison_part->items;
 484
 485   my %orig       = map{ $_ => 1 } @self_part_ids;
 486   my %comparison = map{ $_ => 1 } @comparison_part_ids;
 487   my (@additions, @removals);
 488   @additions = grep { !exists( $orig{$_}       ) } @comparison_part_ids if @comparison_part_ids;
 489   @removals  = grep { !exists( $comparison{$_} ) } @self_part_ids       if @self_part_ids;
 490
 491   return \@additions, \@removals;
 492 };
 493
 494 sub items_sellprice_sum {
 495   my ($self, %params) = @_;
 496
 497   return unless $self->is_assortment or $self->is_assembly;
 498   return unless $self->items;
 499
 500   if ($self->is_assembly) {
 501     return sum map { $_->linetotal_sellprice          } @{$self->items};
 502   } else {
 503     return sum map { $_->linetotal_sellprice(%params) } grep { $_->charge } @{$self->items};
 504   }
 505 }
 506
 507 sub items_lastcost_sum {
 508   my ($self) = @_;
 509
 510   return unless $self->is_assortment or $self->is_assembly;
 511   return unless $self->items;
 512   sum map { $_->linetotal_lastcost } @{$self->items};
 513 };
 514
 515 1;
 516
 517 __END__
 518
 519 =pod
 520
 521 =encoding utf-8
 522
 523 =head1 NAME
 524
 525 SL::DB::Part: Model for the 'parts' table
 526
 527 =head1 SYNOPSIS
 528
 529 This is a standard Rose::DB::Object based model and can be used as one.
 530
 531 =head1 TYPES
 532
 533 Although the base class is called C<Part> we usually talk about C<Articles> if
 534 we mean instances of this class. This is because articles come in three
 535 flavours called:
 536
 537 =over 4
 538
 539 =item Part     - a single part
 540
 541 =item Service  - a part without onhand, and without inventory accounting
 542
 543 =item Assembly - a collection of both parts and services
 544
 545 =item Assortment - a collection of items (parts or assemblies)
 546
 547 =back
 548
 549 These types are sadly represented by data inside the class and cannot be
 550 migrated into a flag. To work around this, each C<Part> object knows what type
 551 it currently is. Since the type is data driven, there ist no explicit setting
 552 method for it, but you can construct them explicitly with C<new_part>,
 553 C<new_service>, C<new_assembly> and C<new_assortment>. A Buchungsgruppe should be supplied in this
 554 case, but it will use the default Buchungsgruppe if you don't.
 555
 556 Matching these there are assorted helper methods dealing with types,
 557 e.g.  L</new_part>, L</new_service>, L</new_assembly>, L</type>,
 558 L</is_type> and others.
 559
 560 =head1 FUNCTIONS
 561
 562 =over 4
 563
 564 =item C<new_part %PARAMS>
 565
 566 =item C<new_service %PARAMS>
 567
 568 =item C<new_assembly %PARAMS>
 569
 570 Will set the appropriate data fields so that the resulting instance will be of
 571 the requested type. Since accounting targets are part of the distinction,
 572 providing a C<Buchungsgruppe> is recommended. If none is given the constructor
 573 will load a default one and set the accounting targets from it.
 574
 575 =item C<type>
 576
 577 Returns the type as a string. Can be one of C<part>, C<service>, C<assembly>.
 578
 579 =item C<is_type $TYPE>
 580
 581 Tests if the current object is a part, a service or an
 582 assembly. C<$type> must be one of the words 'part', 'service' or
 583 'assembly' (their plurals are ok, too).
 584
 585 Returns 1 if the requested type matches, 0 if it doesn't and
 586 C<confess>es if an unknown C<$type> parameter is encountered.
 587
 588 =item C<is_part>
 589
 590 =item C<is_service>
 591
 592 =item C<is_assembly>
 593
 594 Shorthand for C<is_type('part')> etc.
 595
 596 =item C<get_sellprice_info %params>
 597
 598 Retrieves the C<sellprice> and C<price_factor_id> for a part under
 599 different conditions and returns a hash reference with those two keys.
 600
 601 If C<%params> contains a key C<project_id> then a project price list
 602 will be consulted if one exists for that project. In this case the
 603 parameter C<country_id> is evaluated as well: if a price list entry
 604 has been created for this country then it will be used. Otherwise an
 605 entry without a country set will be used.
 606
 607 If none of the above conditions is met then the information from
 608 C<$self> is used.
 609
 610 =item C<get_ordered_qty %params>
 611
 612 Retrieves the quantity that has been ordered from a vendor but that
 613 has not been delivered yet. Only open purchase orders are considered.
 614
 615 =item C<get_taxkey %params>
 616
 617 Retrieves and returns a taxkey object valid for the given date
 618 C<$params{date}> and tax zone C<$params{taxzone}>
 619 (C<$params{taxzone_id}> is also recognized). The date defaults to the
 620 current date if undefined.
 621
 622 This function looks up the income (for trueish values of
 623 C<$params{is_sales}>) or expense (for falsish values of
 624 C<$params{is_sales}>) account for the current part. It uses the part's
 625 associated buchungsgruppe and uses the fields belonging to the tax
 626 zone given by C<$params{taxzone}>.
 627
 628 The information retrieved by the function is cached.
 629
 630 =item C<get_chart %params>
 631
 632 Retrieves and returns a chart object valid for the given type
 633 C<$params{type}> and tax zone C<$params{taxzone}>
 634 (C<$params{taxzone_id}> is also recognized). The type must be one of
 635 the three key words C<income>, C<expense> and C<inventory>.
 636
 637 This function uses the part's associated buchungsgruppe and uses the
 638 fields belonging to the tax zone given by C<$params{taxzone}>.
 639
 640 The information retrieved by the function is cached.
 641
 642 =item C<used_in_record>
 643
 644 Checks if this article has been used in orders, invoices or delivery orders.
 645
 646 =item C<orphaned>
 647
 648 Checks if this article is used in orders, invoices, delivery orders or
 649 assemblies.
 650
 651 =item C<buchungsgruppe BUCHUNGSGRUPPE>
 652
 653 Used to set the accounting information from a L<SL:DB::Buchungsgruppe> object.
 654 Please note, that this is a write only accessor, the original Buchungsgruppe can
 655 not be retrieved from an article once set.
 656
 657 =item C<get_simple_stock_sql>
 658
 659 Fetches the qty and the stock value for the current part for each bin and
 660 warehouse where the part is in stock (or rather different from 0, might be
 661 negative).
 662
 663 Runs some additional window functions to add the running totals (total running
 664 total and total per warehouse) for qty and stock value to each line.
 665
 666 Using the LEAD(w.description) the template can check if the warehouse
 667 description is about to change, i.e. the next line will contain numbers from a
 668 different warehouse, so that a subtotal line can be added.
 669
 670 The last row will contain the running qty total (run_qty) and the running total
 671 stock value (run_stock_value) over all warehouses/bins and can be used to add a
 672 line for the grand totals.
 673
 674 =item C<items_lastcost_sum>
 675
 676 Non-recursive lastcost sum of all the items in an assembly or assortment.
 677
 678 =item C<get_stock %params>
 679
 680 Fetches stock qty in the default unit for a part.
 681
 682 bin_id and warehouse_id may be passed as params. If only a bin_id is passed,
 683 the stock qty for that bin is returned. If only a warehouse_id is passed, the
 684 stock qty for all bins in that warehouse is returned.  If a shippingdate is
 685 passed the stock qty for that date is returned.
 686
 687 Examples:
 688  my $qty = $part->get_stock(bin_id => 52);
 689
 690  $part->get_stock(shippingdate => DateTime->today->add(days => -5));
 691
 692 =back
 693
 694 =head1 AUTHORS
 695
 696 Moritz Bunkus E<lt>m.bunkus@linet-services.deE<gt>,
 697 Sven Schöling E<lt>s.schoeling@linet-services.deE<gt>
 698
 699 =cut