SL/DB/Part.pm

   1 package SL::DB::Part;
   2
   3 use strict;
   4
   5 use Carp;
   6 use List::MoreUtils qw(any);
   7 use Rose::DB::Object::Helpers qw(as_tree);
   8
   9 use SL::DBUtils;
  10 use SL::DB::MetaSetup::Part;
  11 use SL::DB::Manager::Part;
  12 use SL::DB::Chart;
  13 use SL::DB::Helper::AttrHTML;
  14 use SL::DB::Helper::TransNumberGenerator;
  15 use SL::DB::Helper::CustomVariables (
  16   module      => 'IC',
  17   cvars_alias => 1,
  18 );
  19 use List::Util qw(sum);
  20
  21 __PACKAGE__->meta->add_relationships(
  22   assemblies                     => {
  23     type         => 'one to many',
  24     class        => 'SL::DB::Assembly',
  25     manager_args => { sort_by => 'position, oid' },
  26     column_map   => { id => 'id' },
  27   },
  28   prices         => {
  29     type         => 'one to many',
  30     class        => 'SL::DB::Price',
  31     column_map   => { id => 'parts_id' },
  32   },
  33   makemodels     => {
  34     type         => 'one to many',
  35     class        => 'SL::DB::MakeModel',
  36     manager_args => { sort_by => 'sortorder' },
  37     column_map   => { id => 'parts_id' },
  38   },
  39   translations   => {
  40     type         => 'one to many',
  41     class        => 'SL::DB::Translation',
  42     column_map   => { id => 'parts_id' },
  43   },
  44   assortment_items => {
  45     type         => 'one to many',
  46     class        => 'SL::DB::AssortmentItem',
  47     column_map   => { id => 'assortment_id' },
  48   },
  49 );
  50
  51 __PACKAGE__->meta->initialize;
  52
  53 __PACKAGE__->attr_html('notes');
  54
  55 __PACKAGE__->before_save('_before_save_set_partnumber');
  56
  57 sub _before_save_set_partnumber {
  58   my ($self) = @_;
  59
  60   $self->create_trans_number if !$self->partnumber;
  61   return 1;
  62 }
  63
  64 sub validate {
  65   my ($self) = @_;
  66
  67   my @errors;
  68   push @errors, $::locale->text('The partnumber is missing.')     unless $self->partnumber;
  69   push @errors, $::locale->text('The unit is missing.')           unless $self->unit;
  70   push @errors, $::locale->text('The buchungsgruppe is missing.') unless $self->buchungsgruppen_id or $self->buchungsgruppe;
  71
  72   unless ( $self->id ) {
  73     push @errors, $::locale->text('The partnumber already exists.') if SL::DB::Manager::Part->get_all_count(where => [ partnumber => $self->partnumber ]);
  74   };
  75
  76   if ($self->is_assortment && scalar @{$self->assortment_items} == 0) {
  77     push @errors, $::locale->text('The assortment doesn\'t have any items.');
  78   }
  79
  80   if ($self->is_assembly && scalar @{$self->assemblies} == 0) {
  81     push @errors, $::locale->text('The assembly doesn\'t have any items.');
  82   }
  83
  84   return @errors;
  85 }
  86
  87 sub is_type {
  88   my $self = shift;
  89   my $type  = lc(shift || '');
  90   die 'invalid type' unless $type =~ /^(?:part|service|assembly|assortment)$/;
  91
  92   return $self->type eq $type ? 1 : 0;
  93 }
  94
  95 sub is_part       { $_[0]->part_type eq 'part'       }
  96 sub is_assembly   { $_[0]->part_type eq 'assembly'   }
  97 sub is_service    { $_[0]->part_type eq 'service'    }
  98 sub is_assortment { $_[0]->part_type eq 'assortment' }
  99
 100 sub type {
 101   return $_[0]->part_type;
 102   # my ($self, $type) = @_;
 103   # if (@_ > 1) {
 104   #   die 'invalid type' unless $type =~ /^(?:part|service|assembly)$/;
 105   #   $self->assembly(          $type eq 'assembly' ? 1 : 0);
 106   #   $self->inventory_accno_id($type ne 'service'  ? 1 : undef);
 107   # }
 108
 109   # return 'assembly' if $self->assembly;
 110   # return 'part'     if $self->inventory_accno_id;
 111   # return 'service';
 112 }
 113
 114 sub new_part {
 115   my ($class, %params) = @_;
 116   $class->new(%params, part_type => 'part');
 117 }
 118
 119 sub new_assembly {
 120   my ($class, %params) = @_;
 121   $class->new(%params, part_type => 'assembly');
 122 }
 123
 124 sub new_service {
 125   my ($class, %params) = @_;
 126   $class->new(%params, part_type => 'service');
 127 }
 128
 129 sub new_assortment {
 130   my ($class, %params) = @_;
 131   $class->new(%params, part_type => 'assortment');
 132 }
 133
 134 sub last_modification {
 135   my ($self) = @_;
 136   return $self->mtime or $self->itime;
 137 };
 138
 139 sub orphaned {
 140   my ($self) = @_;
 141   die 'not an accessor' if @_ > 1;
 142
 143   my @relations = qw(
 144     SL::DB::InvoiceItem
 145     SL::DB::OrderItem
 146     SL::DB::Inventory
 147     SL::DB::Assembly
 148     SL::DB::AssortmentItem
 149   );
 150
 151   for my $class (@relations) {
 152     eval "require $class";
 153     return 0 if $class->_get_manager_class->get_all_count(query => [ parts_id => $self->id ]);
 154   }
 155   return 1;
 156 }
 157
 158 sub get_sellprice_info {
 159   my $self   = shift;
 160   my %params = @_;
 161
 162   confess "Missing part id" unless $self->id;
 163
 164   my $object = $self->load;
 165
 166   return { sellprice       => $object->sellprice,
 167            price_factor_id => $object->price_factor_id };
 168 }
 169
 170 sub get_ordered_qty {
 171   my $self   = shift;
 172   my %result = SL::DB::Manager::Part->get_ordered_qty($self->id);
 173
 174   return $result{ $self->id };
 175 }
 176
 177 sub available_units {
 178   shift->unit_obj->convertible_units;
 179 }
 180
 181 # autogenerated accessor is slightly off...
 182 sub buchungsgruppe {
 183   shift->buchungsgruppen(@_);
 184 }
 185
 186 sub get_taxkey {
 187   my ($self, %params) = @_;
 188
 189   my $date     = $params{date} || DateTime->today_local;
 190   my $is_sales = !!$params{is_sales};
 191   my $taxzone  = $params{ defined($params{taxzone}) ? 'taxzone' : 'taxzone_id' } * 1;
 192   my $tk_info  = $::request->cache('get_taxkey');
 193
 194   $tk_info->{$self->id}                                      //= {};
 195   $tk_info->{$self->id}->{$taxzone}                          //= { };
 196   my $cache = $tk_info->{$self->id}->{$taxzone}->{$is_sales} //= { };
 197
 198   if (!exists $cache->{$date}) {
 199     $cache->{$date} =
 200       $self->get_chart(type => $is_sales ? 'income' : 'expense', taxzone => $taxzone)
 201       ->get_active_taxkey($date);
 202   }
 203
 204   return $cache->{$date};
 205 }
 206
 207 sub get_chart {
 208   my ($self, %params) = @_;
 209
 210   my $type    = (any { $_ eq $params{type} } qw(income expense inventory)) ? $params{type} : croak("Invalid 'type' parameter '$params{type}'");
 211   my $taxzone = $params{ defined($params{taxzone}) ? 'taxzone' : 'taxzone_id' } * 1;
 212
 213   my $charts     = $::request->cache('get_chart_id/by_part_id_and_taxzone')->{$self->id} //= {};
 214   my $all_charts = $::request->cache('get_chart_id/by_id');
 215
 216   $charts->{$taxzone} ||= { };
 217
 218   if (!exists $charts->{$taxzone}->{$type}) {
 219     require SL::DB::Buchungsgruppe;
 220     my $bugru    = SL::DB::Buchungsgruppe->load_cached($self->buchungsgruppen_id);
 221     my $chart_id = ($type eq 'inventory') ? ($self->is_part ? $bugru->inventory_accno_id : undef)
 222                  :                          $bugru->call_sub("${type}_accno_id", $taxzone);
 223
 224     if ($chart_id) {
 225       my $chart                    = $all_charts->{$chart_id} // SL::DB::Chart->load_cached($chart_id)->load;
 226       $all_charts->{$chart_id}     = $chart;
 227       $charts->{$taxzone}->{$type} = $chart;
 228     }
 229   }
 230
 231   return $charts->{$taxzone}->{$type};
 232 }
 233
 234 # this is designed to ignore chargenumbers, expiration dates and just give a list of how much <-> where
 235 sub get_simple_stock {
 236   my ($self, %params) = @_;
 237
 238   return [] unless $self->id;
 239
 240   my $query = <<'';
 241     SELECT sum(qty), warehouse_id, bin_id FROM inventory WHERE parts_id = ?
 242     GROUP BY warehouse_id, bin_id
 243
 244   my $stock_info = selectall_hashref_query($::form, $::form->get_standard_dbh, $query, $self->id);
 245   [ map { bless $_, 'SL::DB::Part::SimpleStock'} @$stock_info ];
 246 }
 247 # helper class to have bin/warehouse accessors in stock result
 248 { package SL::DB::Part::SimpleStock;
 249   sub warehouse { require SL::DB::Warehouse; SL::DB::Manager::Warehouse->find_by_or_create(id => $_[0]->{warehouse_id}) }
 250   sub bin       { require SL::DB::Bin;       SL::DB::Manager::Bin      ->find_by_or_create(id => $_[0]->{bin_id}) }
 251 }
 252
 253 sub displayable_name {
 254   join ' ', grep $_, map $_[0]->$_, qw(partnumber description);
 255 }
 256
 257 sub clone_and_reset_deep {
 258   my ($self) = @_;
 259
 260   my $clone = $self->clone_and_reset; # resets id and partnumber (primary key and unique constraint)
 261   $clone->makemodels(       map { $_->clone_and_reset } @{$self->makemodels});
 262   $clone->translations(     map { $_->clone_and_reset } @{$self->translations});
 263
 264   if ( $self->is_assortment ) {
 265     $clone->assortment_items( map { $_->clone } @{$self->assortment_items} );
 266       foreach my $ai ( @{ $clone->assortment_items } ) {
 267         $ai->assortment_id(undef);
 268       };
 269   };
 270
 271   if ( $self->is_assembly ) {
 272     $clone->assemblies( map { $_->clone_and_reset } @{$self->assemblies});
 273   };
 274
 275   if ( $self->prices ) {
 276     $clone->prices( map { $_->clone } @{$self->prices}); # pricegroup_id gets reset here because it is part of a unique contraint
 277     if ( $clone->prices ) {
 278       foreach my $price ( @{$clone->prices} ) {
 279         $price->id(undef);
 280         $price->parts_id(undef);
 281       };
 282     };
 283   };
 284
 285   return $clone;
 286 }
 287
 288 sub assembly_sellprice_sum {
 289   my ($self) = @_;
 290
 291   return unless $self->is_assembly;
 292   sum map { $_->linetotal } @{$self->part->assemblies};
 293 };
 294
 295 sub assembly_lastcost_sum {
 296   my ($self) = @_;
 297
 298   return unless $self->is_assembly;
 299   sum map { $_->linetotal } @{$self->part->assemblies};
 300 };
 301
 302 sub assortment_sellprice_sum {
 303   my ($self) = @_;
 304
 305   return unless $self->is_assortment;
 306   sum map { $_->linetotal } @{$self->part->assortment_items};
 307 };
 308
 309 sub assortment_lastcost_sum {
 310   my ($self) = @_;
 311
 312   return unless $self->is_assortment;
 313   sum map { $_->linetotal } @{$self->part->assortment_items};
 314 };
 315
 316 1;
 317
 318 __END__
 319
 320 =pod
 321
 322 =encoding utf-8
 323
 324 =head1 NAME
 325
 326 SL::DB::Part: Model for the 'parts' table
 327
 328 =head1 SYNOPSIS
 329
 330 This is a standard Rose::DB::Object based model and can be used as one.
 331
 332 =head1 TYPES
 333
 334 Although the base class is called C<Part> we usually talk about C<Articles> if
 335 we mean instances of this class. This is because articles come in three
 336 flavours called:
 337
 338 =over 4
 339
 340 =item Part     - a single part
 341
 342 =item Service  - a part without onhand, and without inventory accounting
 343
 344 =item Assembly - a collection of both parts and services
 345
 346 =item Assortment - a collection of parts
 347
 348 =back
 349
 350 These types are sadly represented by data inside the class and cannot be
 351 migrated into a flag. To work around this, each C<Part> object knows what type
 352 it currently is. Since the type is data driven, there ist no explicit setting
 353 method for it, but you can construct them explicitly with C<new_part>,
 354 C<new_service>, C<new_assembly> and C<new_assortment>. A Buchungsgruppe should be supplied in this
 355 case, but it will use the default Buchungsgruppe if you don't.
 356
 357 Matching these there are assorted helper methods dealing with types,
 358 e.g.  L</new_part>, L</new_service>, L</new_assembly>, L</type>,
 359 L</is_type> and others.
 360
 361 =head1 FUNCTIONS
 362
 363 =over 4
 364
 365 =item C<new_part %PARAMS>
 366
 367 =item C<new_service %PARAMS>
 368
 369 =item C<new_assembly %PARAMS>
 370
 371 Will set the appropriate data fields so that the resulting instance will be of
 372 the requested type. Since accounting targets are part of the distinction,
 373 providing a C<Buchungsgruppe> is recommended. If none is given the constructor
 374 will load a default one and set the accounting targets from it.
 375
 376 =item C<type>
 377
 378 Returns the type as a string. Can be one of C<part>, C<service>, C<assembly>.
 379
 380 =item C<is_type $TYPE>
 381
 382 Tests if the current object is a part, a service or an
 383 assembly. C<$type> must be one of the words 'part', 'service' or
 384 'assembly' (their plurals are ok, too).
 385
 386 Returns 1 if the requested type matches, 0 if it doesn't and
 387 C<confess>es if an unknown C<$type> parameter is encountered.
 388
 389 =item C<is_part>
 390
 391 =item C<is_service>
 392
 393 =item C<is_assembly>
 394
 395 Shorthand for C<is_type('part')> etc.
 396
 397 =item C<get_sellprice_info %params>
 398
 399 Retrieves the C<sellprice> and C<price_factor_id> for a part under
 400 different conditions and returns a hash reference with those two keys.
 401
 402 If C<%params> contains a key C<project_id> then a project price list
 403 will be consulted if one exists for that project. In this case the
 404 parameter C<country_id> is evaluated as well: if a price list entry
 405 has been created for this country then it will be used. Otherwise an
 406 entry without a country set will be used.
 407
 408 If none of the above conditions is met then the information from
 409 C<$self> is used.
 410
 411 =item C<get_ordered_qty %params>
 412
 413 Retrieves the quantity that has been ordered from a vendor but that
 414 has not been delivered yet. Only open purchase orders are considered.
 415
 416 =item C<get_taxkey %params>
 417
 418 Retrieves and returns a taxkey object valid for the given date
 419 C<$params{date}> and tax zone C<$params{taxzone}>
 420 (C<$params{taxzone_id}> is also recognized). The date defaults to the
 421 current date if undefined.
 422
 423 This function looks up the income (for trueish values of
 424 C<$params{is_sales}>) or expense (for falsish values of
 425 C<$params{is_sales}>) account for the current part. It uses the part's
 426 associated buchungsgruppe and uses the fields belonging to the tax
 427 zone given by C<$params{taxzone}>.
 428
 429 The information retrieved by the function is cached.
 430
 431 =item C<get_chart %params>
 432
 433 Retrieves and returns a chart object valid for the given type
 434 C<$params{type}> and tax zone C<$params{taxzone}>
 435 (C<$params{taxzone_id}> is also recognized). The type must be one of
 436 the three key words C<income>, C<expense> and C<inventory>.
 437
 438 This function uses the part's associated buchungsgruppe and uses the
 439 fields belonging to the tax zone given by C<$params{taxzone}>.
 440
 441 The information retrieved by the function is cached.
 442
 443 =item C<orphaned>
 444
 445 Checks if this article is used in orders, invoices, delivery orders or
 446 assemblies.
 447
 448 =item C<buchungsgruppe BUCHUNGSGRUPPE>
 449
 450 Used to set the accounting information from a L<SL:DB::Buchungsgruppe> object.
 451 Please note, that this is a write only accessor, the original Buchungsgruppe can
 452 not be retrieved from an article once set.
 453
 454 =item C<assembly_sellprice_sum>
 455
 456 Non-recursive sellprice sum of all the assembly item sellprices.
 457
 458 =item C<assortment_sellprice_sum>
 459
 460 Non-recursive sellprice sum of all the assortment item sellprices.
 461
 462 =item C<assembly_lastcost_sum>
 463
 464 Non-recursive lastcost sum of all the assembly item lastcosts.
 465
 466 =item C<assortment_lastcost_sum>
 467
 468 Non-recursive lastcost sum of all the assortment item lastcosts.
 469
 470 =back
 471
 472 =head1 AUTHORS
 473
 474 Moritz Bunkus E<lt>m.bunkus@linet-services.deE<gt>,
 475 Sven Schöling E<lt>s.schoeling@linet-services.deE<gt>
 476
 477 =cut