X-Git-Url: http://wagnertech.de/git?a=blobdiff_plain;ds=sidebyside;f=SL%2FDB%2FPart.pm;h=46a06513c06336c7c6775ec38c318e6b5008d566;hb=f27794056c50783ab7af7fb4af5c48097001cc3b;hp=6ea2be9b1f05ff664554cb4164a8fce443d319c1;hpb=82515b2d93dc5632f24d6e0b6f8f05f3fd19fbb0;p=kivitendo-erp.git diff --git a/SL/DB/Part.pm b/SL/DB/Part.pm index 6ea2be9b1..46a06513c 100644 --- a/SL/DB/Part.pm +++ b/SL/DB/Part.pm @@ -3,45 +3,163 @@ package SL::DB::Part; use strict; use Carp; +use List::MoreUtils qw(any); +use Rose::DB::Object::Helpers qw(as_tree); + use SL::DBUtils; use SL::DB::MetaSetup::Part; use SL::DB::Manager::Part; - -__PACKAGE__->attr_number('lastcost', places => -2); -__PACKAGE__->attr_number('listprice', places => -2); -__PACKAGE__->attr_number('sellprice', places => -2); +use SL::DB::Chart; +use SL::DB::Helper::AttrHTML; +use SL::DB::Helper::TransNumberGenerator; +use SL::DB::Helper::CustomVariables ( + module => 'IC', + cvars_alias => 1, +); +use List::Util qw(sum); __PACKAGE__->meta->add_relationships( - unit_obj => { - type => 'one to one', - class => 'SL::DB::Unit', - column_map => { unit => 'name' }, - }, assemblies => { type => 'one to many', class => 'SL::DB::Assembly', + manager_args => { sort_by => 'position, oid' }, column_map => { id => 'id' }, }, + prices => { + type => 'one to many', + class => 'SL::DB::Price', + column_map => { id => 'parts_id' }, + }, + makemodels => { + type => 'one to many', + class => 'SL::DB::MakeModel', + manager_args => { sort_by => 'sortorder' }, + column_map => { id => 'parts_id' }, + }, + translations => { + type => 'one to many', + class => 'SL::DB::Translation', + column_map => { id => 'parts_id' }, + }, + assortment_items => { + type => 'one to many', + class => 'SL::DB::AssortmentItem', + column_map => { id => 'assortment_id' }, + }, + history_entries => { + type => 'one to many', + class => 'SL::DB::History', + column_map => { id => 'trans_id' }, + query_args => [ what_done => 'part' ], + manager_args => { sort_by => 'itime' }, + }, ); __PACKAGE__->meta->initialize; +__PACKAGE__->attr_html('notes'); + +__PACKAGE__->before_save('_before_save_set_partnumber'); + +sub _before_save_set_partnumber { + my ($self) = @_; + + $self->create_trans_number if !$self->partnumber; + return 1; +} + +sub validate { + my ($self) = @_; + + my @errors; + push @errors, $::locale->text('The partnumber is missing.') if $self->id and !$self->partnumber; + push @errors, $::locale->text('The unit is missing.') unless $self->unit; + push @errors, $::locale->text('The buchungsgruppe is missing.') unless $self->buchungsgruppen_id or $self->buchungsgruppe; + + unless ( $self->id ) { + push @errors, $::locale->text('The partnumber already exists.') if SL::DB::Manager::Part->get_all_count(where => [ partnumber => $self->partnumber ]); + }; + + if ($self->is_assortment && scalar @{$self->assortment_items} == 0) { + push @errors, $::locale->text('The assortment doesn\'t have any items.'); + } + + if ($self->is_assembly && scalar @{$self->assemblies} == 0) { + push @errors, $::locale->text('The assembly doesn\'t have any items.'); + } + + return @errors; +} + sub is_type { my $self = shift; my $type = lc(shift || ''); + die 'invalid type' unless $type =~ /^(?:part|service|assembly|assortment)$/; - if ($type =~ m/^part/) { - return !$self->assembly && $self->inventory_accno_id ? 1 : 0; + return $self->type eq $type ? 1 : 0; +} - } elsif ($type =~ m/^service/) { - return !$self->inventory_accno_id && !$self->assembly ? 1 : 0; +sub is_part { $_[0]->part_type eq 'part' } +sub is_assembly { $_[0]->part_type eq 'assembly' } +sub is_service { $_[0]->part_type eq 'service' } +sub is_assortment { $_[0]->part_type eq 'assortment' } + +sub type { + return $_[0]->part_type; + # my ($self, $type) = @_; + # if (@_ > 1) { + # die 'invalid type' unless $type =~ /^(?:part|service|assembly)$/; + # $self->assembly( $type eq 'assembly' ? 1 : 0); + # $self->inventory_accno_id($type ne 'service' ? 1 : undef); + # } + + # return 'assembly' if $self->assembly; + # return 'part' if $self->inventory_accno_id; + # return 'service'; +} - } elsif ($type =~ m/^assembl/) { - return $self->assembly ? 1 : 0; +sub new_part { + my ($class, %params) = @_; + $class->new(%params, part_type => 'part'); +} - } +sub new_assembly { + my ($class, %params) = @_; + $class->new(%params, part_type => 'assembly'); +} + +sub new_service { + my ($class, %params) = @_; + $class->new(%params, part_type => 'service'); +} - confess "Unknown type parameter '$type'"; +sub new_assortment { + my ($class, %params) = @_; + $class->new(%params, part_type => 'assortment'); +} + +sub last_modification { + my ($self) = @_; + return $self->mtime or $self->itime; +}; + +sub orphaned { + my ($self) = @_; + die 'not an accessor' if @_ > 1; + + my @relations = qw( + SL::DB::InvoiceItem + SL::DB::OrderItem + SL::DB::Inventory + SL::DB::Assembly + SL::DB::AssortmentItem + ); + + for my $class (@relations) { + eval "require $class"; + return 0 if $class->_get_manager_class->get_all_count(query => [ parts_id => $self->id ]); + } + return 1; } sub get_sellprice_info { @@ -63,47 +181,153 @@ sub get_ordered_qty { return $result{ $self->id }; } -sub get_uncommissioned_qty { - my $self = shift; - my %params = @_; +sub available_units { + shift->unit_obj->convertible_units; +} - confess "Missing part id" unless $self->id; +# autogenerated accessor is slightly off... +sub buchungsgruppe { + shift->buchungsgruppen(@_); +} + +sub get_taxkey { + my ($self, %params) = @_; - my $query = < 0)), - 0) - - - COALESCE((SELECT SUM(i.qty) AS qty - FROM inventory i - LEFT JOIN warehouse wh ON (i.warehouse_id = wh.id) - WHERE (i.parts_id = ?) - AND COALESCE(wh.commission)), - 0) - AS qty -SQL - - my $result = selectfirst_hashref_query($::form, $self->dbh, $query, $self->id, $self->id); - return $result ? $result->{qty} : 0; + my $date = $params{date} || DateTime->today_local; + my $is_sales = !!$params{is_sales}; + my $taxzone = $params{ defined($params{taxzone}) ? 'taxzone' : 'taxzone_id' } * 1; + my $tk_info = $::request->cache('get_taxkey'); + + $tk_info->{$self->id} //= {}; + $tk_info->{$self->id}->{$taxzone} //= { }; + my $cache = $tk_info->{$self->id}->{$taxzone}->{$is_sales} //= { }; + + if (!exists $cache->{$date}) { + $cache->{$date} = + $self->get_chart(type => $is_sales ? 'income' : 'expense', taxzone => $taxzone) + ->get_active_taxkey($date); + } + + return $cache->{$date}; } -sub available_units { - shift->unit_obj->convertible_units; +sub get_chart { + my ($self, %params) = @_; + + my $type = (any { $_ eq $params{type} } qw(income expense inventory)) ? $params{type} : croak("Invalid 'type' parameter '$params{type}'"); + my $taxzone = $params{ defined($params{taxzone}) ? 'taxzone' : 'taxzone_id' } * 1; + + my $charts = $::request->cache('get_chart_id/by_part_id_and_taxzone')->{$self->id} //= {}; + my $all_charts = $::request->cache('get_chart_id/by_id'); + + $charts->{$taxzone} ||= { }; + + if (!exists $charts->{$taxzone}->{$type}) { + require SL::DB::Buchungsgruppe; + my $bugru = SL::DB::Buchungsgruppe->load_cached($self->buchungsgruppen_id); + my $chart_id = ($type eq 'inventory') ? ($self->is_part ? $bugru->inventory_accno_id : undef) + : $bugru->call_sub("${type}_accno_id", $taxzone); + + if ($chart_id) { + my $chart = $all_charts->{$chart_id} // SL::DB::Chart->load_cached($chart_id)->load; + $all_charts->{$chart_id} = $chart; + $charts->{$taxzone}->{$type} = $chart; + } + } + + return $charts->{$taxzone}->{$type}; } +# this is designed to ignore chargenumbers, expiration dates and just give a list of how much <-> where +sub get_simple_stock { + my ($self, %params) = @_; + + return [] unless $self->id; + + my $query = <<''; + SELECT sum(qty), warehouse_id, bin_id FROM inventory WHERE parts_id = ? + GROUP BY warehouse_id, bin_id + + my $stock_info = selectall_hashref_query($::form, $::form->get_standard_dbh, $query, $self->id); + [ map { bless $_, 'SL::DB::Part::SimpleStock'} @$stock_info ]; +} +# helper class to have bin/warehouse accessors in stock result +{ package SL::DB::Part::SimpleStock; + sub warehouse { require SL::DB::Warehouse; SL::DB::Manager::Warehouse->find_by_or_create(id => $_[0]->{warehouse_id}) } + sub bin { require SL::DB::Bin; SL::DB::Manager::Bin ->find_by_or_create(id => $_[0]->{bin_id}) } +} + +sub displayable_name { + join ' ', grep $_, map $_[0]->$_, qw(partnumber description); +} + +sub clone_and_reset_deep { + my ($self) = @_; + + my $clone = $self->clone_and_reset; # resets id and partnumber (primary key and unique constraint) + $clone->makemodels( map { $_->clone_and_reset } @{$self->makemodels}); + $clone->translations( map { $_->clone_and_reset } @{$self->translations}); + + if ( $self->is_assortment ) { + $clone->assortment_items( map { $_->clone } @{$self->assortment_items} ); + foreach my $ai ( @{ $clone->assortment_items } ) { + $ai->assortment_id(undef); + }; + }; + + if ( $self->is_assembly ) { + $clone->assemblies( map { $_->clone_and_reset } @{$self->assemblies}); + }; + + if ( $self->prices ) { + $clone->prices( map { $_->clone } @{$self->prices}); # pricegroup_id gets reset here because it is part of a unique contraint + if ( $clone->prices ) { + foreach my $price ( @{$clone->prices} ) { + $price->id(undef); + $price->parts_id(undef); + }; + }; + }; + + return $clone; +} + +sub assembly_sellprice_sum { + my ($self) = @_; + + return unless $self->is_assembly; + sum map { $_->linetotal_sellprice } @{$self->assemblies}; +}; + +sub assembly_lastcost_sum { + my ($self) = @_; + + return unless $self->is_assembly; + sum map { $_->linetotal_lastcost } @{$self->assemblies}; +}; + +sub assortment_sellprice_sum { + my ($self) = @_; + + return unless $self->is_assortment; + sum map { $_->linetotal_sellprice } @{$self->assortment_items}; +}; + +sub assortment_lastcost_sum { + my ($self) = @_; + + return unless $self->is_assortment; + sum map { $_->linetotal_lastcost } @{$self->assortment_items}; +}; + 1; __END__ =pod +=encoding utf-8 + =head1 NAME SL::DB::Part: Model for the 'parts' table @@ -112,11 +336,55 @@ SL::DB::Part: Model for the 'parts' table This is a standard Rose::DB::Object based model and can be used as one. +=head1 TYPES + +Although the base class is called C we usually talk about C if +we mean instances of this class. This is because articles come in three +flavours called: + +=over 4 + +=item Part - a single part + +=item Service - a part without onhand, and without inventory accounting + +=item Assembly - a collection of both parts and services + +=item Assortment - a collection of parts + +=back + +These types are sadly represented by data inside the class and cannot be +migrated into a flag. To work around this, each C object knows what type +it currently is. Since the type is data driven, there ist no explicit setting +method for it, but you can construct them explicitly with C, +C, C and C. A Buchungsgruppe should be supplied in this +case, but it will use the default Buchungsgruppe if you don't. + +Matching these there are assorted helper methods dealing with types, +e.g. L, L, L, L, +L and others. + =head1 FUNCTIONS =over 4 -=item is_type $type +=item C + +=item C + +=item C + +Will set the appropriate data fields so that the resulting instance will be of +the requested type. Since accounting targets are part of the distinction, +providing a C is recommended. If none is given the constructor +will load a default one and set the accounting targets from it. + +=item C + +Returns the type as a string. Can be one of C, C, C. + +=item C Tests if the current object is a part, a service or an assembly. C<$type> must be one of the words 'part', 'service' or @@ -125,7 +393,15 @@ assembly. C<$type> must be one of the words 'part', 'service' or Returns 1 if the requested type matches, 0 if it doesn't and Ces if an unknown C<$type> parameter is encountered. -=item get_sellprice_info %params +=item C + +=item C + +=item C + +Shorthand for C etc. + +=item C Retrieves the C and C for a part under different conditions and returns a hash reference with those two keys. @@ -139,20 +415,70 @@ entry without a country set will be used. If none of the above conditions is met then the information from C<$self> is used. -=item get_ordered_qty %params +=item C Retrieves the quantity that has been ordered from a vendor but that has not been delivered yet. Only open purchase orders are considered. -=item get_uncommissioned_qty %params +=item C + +Retrieves and returns a taxkey object valid for the given date +C<$params{date}> and tax zone C<$params{taxzone}> +(C<$params{taxzone_id}> is also recognized). The date defaults to the +current date if undefined. + +This function looks up the income (for trueish values of +C<$params{is_sales}>) or expense (for falsish values of +C<$params{is_sales}>) account for the current part. It uses the part's +associated buchungsgruppe and uses the fields belonging to the tax +zone given by C<$params{taxzone}>. + +The information retrieved by the function is cached. + +=item C + +Retrieves and returns a chart object valid for the given type +C<$params{type}> and tax zone C<$params{taxzone}> +(C<$params{taxzone_id}> is also recognized). The type must be one of +the three key words C, C and C. + +This function uses the part's associated buchungsgruppe and uses the +fields belonging to the tax zone given by C<$params{taxzone}>. + +The information retrieved by the function is cached. + +=item C + +Checks if this article is used in orders, invoices, delivery orders or +assemblies. + +=item C + +Used to set the accounting information from a L object. +Please note, that this is a write only accessor, the original Buchungsgruppe can +not be retrieved from an article once set. + +=item C + +Non-recursive sellprice sum of all the assembly item sellprices. + +=item C + +Non-recursive sellprice sum of all the assortment item sellprices. + +=item C + +Non-recursive lastcost sum of all the assembly item lastcosts. + +=item C -Retrieves the quantity that has been ordered by a customer but that -has not been commissioned yet. Only open sales orders are considered. +Non-recursive lastcost sum of all the assortment item lastcosts. =back -=head1 AUTHOR +=head1 AUTHORS -Moritz Bunkus Em.bunkus@linet-services.deE +Moritz Bunkus Em.bunkus@linet-services.deE, +Sven Schöling Es.schoeling@linet-services.deE =cut