|
package SL::DB::Part;
|
|
|
|
use strict;
|
|
|
|
use Carp;
|
|
use List::MoreUtils qw(any uniq);
|
|
use List::Util qw(sum);
|
|
use Rose::DB::Object::Helpers qw(as_tree);
|
|
|
|
use SL::Locale::String qw(t8);
|
|
use SL::Helper::Inventory;
|
|
use SL::DBUtils;
|
|
use SL::DB::MetaSetup::Part;
|
|
use SL::DB::Manager::Part;
|
|
use SL::DB::Helper::AttrHTML;
|
|
use SL::DB::Helper::AttrSorted;
|
|
use SL::DB::Helper::TransNumberGenerator;
|
|
use SL::DB::Helper::CustomVariables (
|
|
module => 'IC',
|
|
cvars_alias => 1,
|
|
);
|
|
use SL::DB::Helper::DisplayableNamePreferences (
|
|
title => t8('Article'),
|
|
options => [ {name => 'partnumber', title => t8('Part Number') },
|
|
{name => 'description', title => t8('Description') },
|
|
{name => 'notes', title => t8('Notes')},
|
|
{name => 'ean', title => t8('EAN') }, ],
|
|
);
|
|
|
|
|
|
__PACKAGE__->meta->add_relationships(
|
|
assemblies => {
|
|
type => 'one to many',
|
|
class => 'SL::DB::Assembly',
|
|
manager_args => { sort_by => 'position' },
|
|
column_map => { id => 'id' },
|
|
},
|
|
prices => {
|
|
type => 'one to many',
|
|
class => 'SL::DB::Price',
|
|
column_map => { id => 'parts_id' },
|
|
manager_args => { with_objects => [ 'pricegroup' ] }
|
|
},
|
|
makemodels => {
|
|
type => 'one to many',
|
|
class => 'SL::DB::MakeModel',
|
|
manager_args => { sort_by => 'sortorder' },
|
|
column_map => { id => 'parts_id' },
|
|
},
|
|
businessmodels => {
|
|
type => 'one to many',
|
|
class => 'SL::DB::BusinessModel',
|
|
column_map => { id => 'parts_id' },
|
|
},
|
|
customerprices => {
|
|
type => 'one to many',
|
|
class => 'SL::DB::PartCustomerPrice',
|
|
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' },
|
|
manager_args => { sort_by => 'position' },
|
|
},
|
|
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' },
|
|
},
|
|
shop_parts => {
|
|
type => 'one to many',
|
|
class => 'SL::DB::ShopPart',
|
|
column_map => { id => 'part_id' },
|
|
manager_args => { with_objects => [ 'shop' ] },
|
|
},
|
|
last_price_update => {
|
|
type => 'one to one',
|
|
class => 'SL::DB::PartsPriceHistory',
|
|
column_map => { id => 'part_id' },
|
|
manager_args => { sort_by => 'valid_from DESC, id DESC', limit => 1 },
|
|
},
|
|
purchase_basket_item => {
|
|
type => 'one to one',
|
|
class => 'SL::DB::PurchaseBasketItem',
|
|
column_map => { id => 'part_id' },
|
|
},
|
|
);
|
|
|
|
__PACKAGE__->meta->initialize;
|
|
|
|
use Rose::Object::MakeMethods::Generic (
|
|
'scalar --get_set_init' => [ qw(onhandqty stockqty get_open_ordered_qty) ],
|
|
);
|
|
__PACKAGE__->attr_html('notes');
|
|
__PACKAGE__->attr_sorted({ unsorted => 'makemodels', position => 'sortorder' });
|
|
__PACKAGE__->attr_sorted({ unsorted => 'customerprices', position => 'sortorder' });
|
|
__PACKAGE__->attr_sorted('businessmodels');
|
|
|
|
__PACKAGE__->before_save('_before_save_set_partnumber');
|
|
__PACKAGE__->before_save('_before_save_set_assembly_weight');
|
|
|
|
sub _before_save_set_partnumber {
|
|
my ($self) = @_;
|
|
|
|
$self->create_trans_number if !$self->partnumber;
|
|
return 1;
|
|
}
|
|
|
|
sub _before_save_set_assembly_weight {
|
|
my ($self) = @_;
|
|
|
|
if ( $self->part_type eq 'assembly' ) {
|
|
my $weight_sum = $self->items_weight_sum;
|
|
$self->weight($self->items_weight_sum) if $weight_sum;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
sub items {
|
|
my ($self) = @_;
|
|
|
|
if ( $self->part_type eq 'assembly' ) {
|
|
return $self->assemblies;
|
|
} elsif ( $self->part_type eq 'assortment' ) {
|
|
return $self->assortment_items;
|
|
} else {
|
|
return undef;
|
|
}
|
|
}
|
|
|
|
sub items_checksum {
|
|
my ($self) = @_;
|
|
|
|
# for detecting if the items of an (orphaned) assembly or assortment have
|
|
# changed when saving
|
|
|
|
return join(' ', sort map { $_->part->id } @{$self->items});
|
|
}
|
|
|
|
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;
|
|
|
|
if ( $::instance_conf->get_partsgroup_required
|
|
&& ( !$self->partsgroup_id or ( $self->id && !$self->partsgroup_id && $self->partsgroup ) ) ) {
|
|
# when unsetting an existing partsgroup in the interface, $self->partsgroup_id will be undef but $self->partsgroup will still have a value
|
|
# this needs to be checked, as partsgroup dropdown has an empty value
|
|
push @errors, $::locale->text('The partsgroup is missing.');
|
|
}
|
|
|
|
push @errors, $::locale->text('The partnumber already exists.') if SL::DB::Manager::Part->get_all_count(where => [ partnumber => $self->partnumber, '!id' => $self->id ]);
|
|
|
|
if ($self->is_assortment && $self->orphaned && scalar @{$self->assortment_items} == 0) {
|
|
# when assortment isn't orphaned form doesn't contain any items
|
|
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)$/;
|
|
|
|
return $self->type eq $type ? 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';
|
|
}
|
|
|
|
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');
|
|
}
|
|
|
|
sub new_assortment {
|
|
my ($class, %params) = @_;
|
|
$class->new(%params, part_type => 'assortment');
|
|
}
|
|
|
|
sub last_modification {
|
|
my ($self) = @_;
|
|
return $self->mtime // $self->itime;
|
|
}
|
|
|
|
sub used_in_record {
|
|
my ($self) = @_;
|
|
die 'not an accessor' if @_ > 1;
|
|
|
|
return 1 unless $self->id;
|
|
|
|
my @relations = qw(
|
|
SL::DB::InvoiceItem
|
|
SL::DB::OrderItem
|
|
SL::DB::DeliveryOrderItem
|
|
);
|
|
|
|
for my $class (@relations) {
|
|
eval "require $class";
|
|
return 1 if $class->_get_manager_class->get_all_count(query => [ parts_id => $self->id ]);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
sub orphaned {
|
|
my ($self) = @_;
|
|
die 'not an accessor' if @_ > 1;
|
|
|
|
return 1 unless $self->id;
|
|
|
|
my @relations = qw(
|
|
SL::DB::InvoiceItem
|
|
SL::DB::OrderItem
|
|
SL::DB::DeliveryOrderItem
|
|
SL::DB::Inventory
|
|
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 {
|
|
my $self = shift;
|
|
my %params = @_;
|
|
|
|
confess "Missing part id" unless $self->id;
|
|
|
|
my $object = $self->load;
|
|
|
|
return { sellprice => $object->sellprice,
|
|
price_factor_id => $object->price_factor_id };
|
|
}
|
|
|
|
sub get_ordered_qty {
|
|
my $self = shift;
|
|
my %result = SL::DB::Manager::Part->get_ordered_qty($self->id);
|
|
|
|
return $result{ $self->id };
|
|
}
|
|
|
|
sub available_units {
|
|
shift->unit_obj->convertible_units;
|
|
}
|
|
|
|
# autogenerated accessor is slightly off...
|
|
sub buchungsgruppe {
|
|
shift->buchungsgruppen(@_);
|
|
}
|
|
|
|
sub get_taxkey {
|
|
my ($self, %params) = @_;
|
|
|
|
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 get_chart {
|
|
my ($self, %params) = @_;
|
|
require SL::DB::Chart;
|
|
|
|
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};
|
|
}
|
|
|
|
sub get_stock {
|
|
my ($self, %params) = @_;
|
|
|
|
return undef unless $self->id;
|
|
|
|
my $query = 'SELECT SUM(qty) FROM inventory WHERE parts_id = ?';
|
|
my @values = ($self->id);
|
|
|
|
if ( $params{bin_id} ) {
|
|
$query .= ' AND bin_id = ?';
|
|
push(@values, $params{bin_id});
|
|
}
|
|
|
|
if ( $params{warehouse_id} ) {
|
|
$query .= ' AND warehouse_id = ?';
|
|
push(@values, $params{warehouse_id});
|
|
}
|
|
|
|
if ( $params{shippingdate} ) {
|
|
die unless ref($params{shippingdate}) eq 'DateTime';
|
|
$query .= ' AND shippingdate <= ?';
|
|
push(@values, $params{shippingdate});
|
|
}
|
|
|
|
my ($stock) = selectrow_query($::form, $self->db->dbh, $query, @values);
|
|
|
|
return $stock || 0; # never return undef
|
|
}
|
|
|
|
|
|
# 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 get_simple_stock_sql {
|
|
my ($self, %params) = @_;
|
|
|
|
return [] unless $self->id;
|
|
|
|
my $query = <<SQL;
|
|
SELECT w.description AS warehouse_description,
|
|
b.description AS bin_description,
|
|
SUM(i.qty) AS qty,
|
|
SUM(i.qty * p.lastcost) AS stock_value,
|
|
p.unit AS unit,
|
|
LEAD(w.description) OVER pt AS wh_lead, -- to detect warehouse changes for subtotals in template
|
|
SUM( SUM(i.qty) ) OVER pt AS run_qty, -- running total of total qty
|
|
SUM( SUM(i.qty) ) OVER wh AS wh_run_qty, -- running total of warehouse qty
|
|
SUM( SUM(i.qty * p.lastcost)) OVER pt AS run_stock_value, -- running total of total stock_value
|
|
SUM( SUM(i.qty * p.lastcost)) OVER wh AS wh_run_stock_value -- running total of warehouse stock_value
|
|
FROM inventory i
|
|
LEFT JOIN parts p ON (p.id = i.parts_id)
|
|
LEFT JOIN warehouse w ON (i.warehouse_id = w.id)
|
|
LEFT JOIN bin b ON (i.bin_id = b.id)
|
|
WHERE parts_id = ?
|
|
GROUP BY w.description, w.sortkey, b.description, p.unit, i.parts_id
|
|
HAVING SUM(qty) != 0
|
|
WINDOW pt AS (PARTITION BY i.parts_id ORDER BY w.sortkey, b.description, p.unit),
|
|
wh AS (PARTITION by w.description ORDER BY w.sortkey, b.description, p.unit)
|
|
ORDER BY w.sortkey, b.description, p.unit
|
|
SQL
|
|
|
|
my $stock_info = selectall_hashref_query($::form, $self->db->dbh, $query, $self->id);
|
|
return $stock_info;
|
|
}
|
|
|
|
sub get_mini_journal {
|
|
my ($self) = @_;
|
|
|
|
# inventory ids of the most recent 10 inventory trans_ids
|
|
|
|
# duplicate code copied from SL::Controller::Inventory mini_journal, except
|
|
# for the added filter on parts_id
|
|
|
|
my $parts_id = $self->id;
|
|
my $query = <<"SQL";
|
|
with last_inventories as (
|
|
select id,
|
|
trans_id,
|
|
itime
|
|
from inventory
|
|
where parts_id = $parts_id
|
|
order by itime desc
|
|
limit 20
|
|
),
|
|
grouped_ids as (
|
|
select trans_id,
|
|
array_agg(id) as ids
|
|
from last_inventories
|
|
group by trans_id
|
|
order by max(itime)
|
|
desc limit 10
|
|
)
|
|
select unnest(ids)
|
|
from grouped_ids
|
|
limit 20 -- so the planner knows how many ids to expect, the cte is an optimisation fence
|
|
SQL
|
|
|
|
my $objs = SL::DB::Manager::Inventory->get_all(
|
|
query => [ id => [ \"$query" ] ], # make emacs happy "]]
|
|
with_objects => [ 'parts', 'trans_type', 'bin', 'bin.warehouse' ], # prevent lazy loading in template
|
|
sort_by => 'itime DESC',
|
|
);
|
|
# remember order of trans_ids from query, for ordering hash later
|
|
my @sorted_trans_ids = uniq map { $_->trans_id } @$objs;
|
|
|
|
# at most 2 of them belong to a transaction and the qty determines in or out.
|
|
my %transactions;
|
|
for (@$objs) {
|
|
$transactions{ $_->trans_id }{ $_->qty > 0 ? 'in' : 'out' } = $_;
|
|
$transactions{ $_->trans_id }{base} = $_;
|
|
}
|
|
|
|
# because the inventory transactions were built in a hash, we need to sort the
|
|
# hash by usi |