|
# This file has been auto-generated only because it didn't exist.
|
|
# Feel free to modify it at will; it will not be overwritten automatically.
|
|
|
|
package SL::DB::Manager::PriceRuleItem;
|
|
|
|
use strict;
|
|
|
|
use SL::DB::Helper::Manager;
|
|
use base qw(SL::DB::Helper::Manager);
|
|
|
|
sub object_class { 'SL::DB::PriceRuleItem' }
|
|
|
|
__PACKAGE__->make_manager_methods;
|
|
|
|
use SL::Locale::String qw(t8);
|
|
use List::Util qw(first);
|
|
|
|
use SL::DB::CustomVariableConfig;
|
|
|
|
my %ops = (
|
|
'num' => { eq => '=', le => '<=', ge => '>=' },
|
|
'date' => { eq => '=', lt => '<', gt => '>' },
|
|
);
|
|
|
|
my @types = (
|
|
{ type => 'customer', description => t8('Customer'), customer => 1, vendor => 0, data_type => 'int', data => sub { $_[0]->customer->id }, },
|
|
{ type => 'vendor', description => t8('Vendor'), customer => 0, vendor => 1, data_type => 'int', data => sub { $_[0]->vendor->id }, },
|
|
{ type => 'business', description => t8('Type of Business'), customer => 1, vendor => 1, data_type => 'int', data => sub { $_[0]->customervendor->business_id }, exclude_nulls => 1 },
|
|
{ type => 'reqdate', description => t8('Reqdate'), customer => 1, vendor => 1, data_type => 'date', data => sub { $_[0]->reqdate }, ops => 'date' },
|
|
{ type => 'transdate', description => t8('Transdate'), customer => 1, vendor => 1, data_type => 'date', data => sub { $_[0]->transdate }, ops => 'date' },
|
|
{ type => 'part', description => t8('Part'), customer => 1, vendor => 1, data_type => 'int', data => sub { $_[1]->part->id }, },
|
|
{ type => 'pricegroup', description => t8('Pricegroup'), customer => 1, vendor => 1, data_type => 'int', data => sub { $_[1]->pricegroup_id }, exclude_nulls => 1 },
|
|
{ type => 'partsgroup', description => t8('Partsgroup'), customer => 1, vendor => 1, data_type => 'int', data => sub { $_[1]->part->partsgroup_id }, exclude_nulls => 1 },
|
|
{ type => 'qty', description => t8('Qty'), customer => 1, vendor => 1, data_type => 'num', data => sub { $_[1]->qty }, ops => 'num' },
|
|
);
|
|
|
|
# text, textfield, htmlfield, bool are not supported
|
|
our %price_rule_type_by_cvar_type = (
|
|
select => 'text',
|
|
customer => 'int',
|
|
vendor => 'int',
|
|
part => 'int',
|
|
number => 'num',
|
|
date => 'date',
|
|
text => undef,
|
|
textfield => undef,
|
|
htmlfield => undef,
|
|
bool => undef,
|
|
);
|
|
|
|
|
|
# ITEM.part.cvar_by_name(var.config.name)
|
|
|
|
sub not_matching_sql_and_values {
|
|
my ($class, %params) = @_;
|
|
|
|
die 'must be called with a customer/vendor type' unless $params{type};
|
|
my @args = @params{'record', 'record_item'};
|
|
|
|
my (@tokens, @values);
|
|
|
|
for my $def (@types, cached_cvar_types()) {
|
|
my $type = $def->{type};
|
|
next unless $def->{$params{type}};
|
|
|
|
my $value = $def->{data}->(@args);
|
|
|
|
my $type_token = $def->{cvar_config} ? "custom_variable_configs_id = '$def->{cvar_config}'" : "type = '$type'";
|
|
|
|
if ($def->{exclude_nulls} && !defined $value) {
|
|
push @tokens, $type_token;
|
|
} else {
|
|
my @sub_tokens;
|
|
if ($def->{ops}) {
|
|
my $ops = $ops{$def->{ops}};
|
|
|
|
for (keys %$ops) {
|
|
push @sub_tokens, "op = '$_' AND NOT ? $ops->{$_} value_$def->{data_type}";
|
|
push @values, $value;
|
|
}
|
|
} else {
|
|
push @sub_tokens, "NOT value_$def->{data_type} = ?";
|
|
push @values, $value;
|
|
}
|
|
|
|
push @tokens, "$type_token AND (@{[ join(' OR ', map qq|($_)|, @sub_tokens) ]})";
|
|
}
|
|
}
|
|
|
|
return join(' OR ', map "($_)", @tokens), @values;
|
|
}
|
|
|
|
sub cached_cvar_types {
|
|
my $cache = $::request->cache("SL::DB::PriceRuleItem::cvar_types", []);
|
|
|
|
@$cache = generate_cvar_types() if !@$cache;
|
|
@$cache
|
|
}
|
|
|
|
# we only generate cvar types for cvar price_rules that are actually used to keep the query smaller
|
|
# these are cached per request
|
|
sub generate_cvar_types {
|
|
my @supported_cvar_modules = qw(CT Contacts IC Projects ShipTo);
|
|
|
|
my $cvar_configs = SL::DB::Manager::CustomVariableConfig->get_all(query => [ module => \@supported_cvar_modules ]);
|
|
|
|
my @types;
|
|
|
|
my %ops_by_cvar_type = (
|
|
number => 'num',
|
|
date => 'date',
|
|
);
|
|
|
|
for my $config (@$cvar_configs) {
|
|
# cvars can be pretty complicated, but most of that luckily doesn't affect price rule filtering:
|
|
# - editable flags are copied to submodule entries - so those need to be preferred
|
|
# - cvars may be invalid - but in that case they just won't get crated so we won't find any
|
|
# - cvars may be restricted to partgroups, but again, in that case we simply won't find any
|
|
# - cvars may have different types of values () just like price_rule_items, but the ->value
|
|
# accessor already handles that, so we only need to set the price_rule type accordingly
|
|
|
|
|
|
my %data_by_module = (
|
|
IC => sub {
|
|
raw_value(
|
|
$config->processed_flags->{editable}
|
|
? $_[1]->cvar_by_name($config->name)->value
|
|
: $_[1]->part->cvar_by_name($config->name)->value
|
|
);
|
|
},
|
|
CT => sub {
|
|
raw_value(
|
|
$_[0]->customervendor->cvar_by_name($config->name)->value
|
|
);
|
|
},
|
|
Projects => sub {
|
|
raw_value(
|
|
$_[1]->project ? $_[1]->project->cvar_by_name($config->name)->value :
|
|
$_[0]->globalproject ? $_[0]->globalproject->cvar_by_name($config->name)->value : undef
|
|
);
|
|
},
|
|
Contacts => sub {
|
|
raw_value(
|
|
$_[0]->contact ? $_[0]->contact->cvar_by_name($config->name)->value : undef
|
|
);
|
|
},
|
|
ShipTo => sub {
|
|
raw_value(
|
|
$_[0]->custom_shipto ? $_[0]->custom_shipto->cvar_by_name($config->name)->value :
|
|
$_[0]->can('shipto') && $_[0]->shipto ? $_[0]->shipto->cvar_by_name($config->name)->value : undef
|
|
|
|
);
|
|
},
|
|
);
|
|
|
|
my $data_type;
|
|
if (exists $price_rule_type_by_cvar_type{$config->type}) {
|
|
# known but undef typedefs are ignored.
|
|
# those cvar configs are not supported and can not be used in price rules
|
|
$data_type = $price_rule_type_by_cvar_type{$config->type} or next;
|
|
} else {
|
|
die "cvar type @{[$config->type]} " . $config->description . " is not supported in price rules";
|
|
}
|
|
|
|
my $ops = $ops_by_cvar_type{$config->type};
|
|
|
|
push @types, {
|
|
type => "cvar_" . $config->id,
|
|
description => $config->description,
|
|
customer => 1,
|
|
vendor => 1,
|
|
data_type => $data_type,
|
|
data => $data_by_module{$config->module},
|
|
exclude_nulls => 1,
|
|
cvar_config => $config->id,
|
|
ops => $ops,
|
|
};
|
|
}
|
|
|
|
@types;
|
|
}
|
|
|
|
sub raw_value {
|
|
my ($value) = @_;
|
|
return if !defined $value;
|
|
return $value->id if (ref $value) =~ /Part|Customer|Contact|Vendor|Project/;
|
|
return $value if (ref $value) =~ /DateTime/;
|
|
die "reference value unsupported for binding to price_rules, got ref " . ref $value if ref $value;
|
|
$value;
|
|
}
|
|
|
|
sub get_all_types {
|
|
my ($class, $vc) = @_;
|
|
|
|
$vc
|
|
? [ map { [ $_->{type}, $_->{description} ] } grep { $_->{$vc} } @types ]
|
|
: [ map { [ $_->{type}, $_->{description} ] } @types ]
|
|
}
|
|
|
|
sub get_type {
|
|
grep { $_->{type} eq $_[1] } @types
|
|
}
|
|
|
|
sub filter_match {
|
|
my ($self, $type, $value) = @_;
|
|
|
|
my $type_def = first { $_->{type} eq $type } @types;
|
|
|
|
if (!$type_def->{ops}) {
|
|
my $evalue = $::form->get_standard_dbh->quote($value);
|
|
return "value_$type_def->{data_type} = $evalue";
|
|
} elsif ($type_def->{ops} eq 'date') {
|
|
my $date_value = $::form->get_standard_dbh->quote(DateTime->from_kivitendo($value));
|
|
return "
|
|
(value_$type_def->{data_type} > $date_value AND op = 'lt') OR
|
|
(value_$type_def->{data_type} < $date_value AND op = 'gt') OR
|
|
(value_$type_def->{data_type} = $date_value AND op = 'eq')
|
|
";
|
|
} elsif ($type_def->{ops} eq 'num') {
|
|
my $num_value = $::form->get_standard_dbh->quote($::form->parse_amount(\%::myconfig, $value));
|
|
return "
|
|
(value_$type_def->{data_type} >= $num_value AND op = 'le') OR
|
|
(value_$type_def->{data_type} <= $num_value AND op = 'ge') OR
|
|
(value_$type_def->{data_type} = $num_value AND op = 'eq')
|
|
";
|
|
}
|
|
}
|
|
|
|
|
|
1;
|