use List::MoreUtils qw(uniq);
use Rose::Object::MakeMethods::Generic (
- scalar => [ qw(filter_args filter_params orig_filter) ],
- 'scalar --get_set_init' => [ qw(form_params launder_to) ],
+ scalar => [ qw(filter_args filter_params orig_filter filter no_launder) ],
+ 'scalar --get_set_init' => [ qw(form_params laundered) ],
);
sub init {
return %{ $self->filter_params } if $self->filter_params;
my $source = $self->get_models->source;
- my $filter = $params{filter} // $source->{ $self->form_params } // {};
+ my $filter = $self->filter // $source->{ $self->form_params } // {};
$self->orig_filter($filter);
my %filter_args = $self->_get_filter_args;
class => $self->get_models->manager,
with_objects => $params{with_objects},
);
- my $laundered;
- if ($self->launder_to eq '__INPLACE__') {
- # nothing to do
- } elsif ($self->launder_to) {
- $laundered = {};
- $parse_filter_args{launder_to} = $laundered;
+
+ # Store laundered result in $self->laundered.
+
+ if (!$self->no_launder) {
+ $self->laundered({});
+ $parse_filter_args{launder_to} = $self->laundered;
} else {
+ $self->laundered(undef);
$parse_filter_args{no_launder} = 1;
}
my %calculated_params = SL::Controller::Helper::ParseFilter::parse_filter($filter, %parse_filter_args);
%calculated_params = $self->merge_args(\%calculated_params, \%filter_args, \%params);
- if ($laundered) {
- if ($self->get_models->controller->can($self->launder_to)) {
- $self->get_models->controller->${\ $self->launder_to }($laundered);
- } else {
- $self->get_models->controller->{$self->launder_to} = $laundered;
- }
- }
-
# $::lxdebug->dump(0, "get_current_filter_params: ", \%calculated_params);
$self->filter_params(\%calculated_params);
'filter'
}
-sub init_launder_to {
- 'filter'
-}
+sub init_laundered {
+ my ($self) = @_;
+ $self->get_models->finalize;
+ return $self->{laundered};
+}
1;
...
filtered => {
filter => HASHREF,
- launder_to => HASHREF | SUBNAME | '__INPLACE__',
+ no_launder => 0 | 1,
}
OR
filtered => 0,
);
-
=head1 OVERVIEW
This C<GetModels> plugin enables use of the
Defaults to the value C<filter> if missing.
-=item * C<launder_to>
+=item * C<no_launder>
-Optional. Indicates a target for laundered filter arguments in the controller.
-Can be set to C<undef> to disable laundering, and can be set to method named or
-hash keys of the controller. In the latter case the laundered structure will be
-put there.
-
-Defaults to the controller. Laundered values will end up in C<SELF.filter> for
-template purposes.
-
-Setting this to the special value C<__INPLACE__> will cause inplace laundering.
+Optional. If given and trueish then laundering is disabled.
=back
=head1 CUSTOM FILTERS
C<Filtered> will honor custom filters defined in RDBO managers. See
-L<SL::DB::Helper::Filtered> for an explanation fo those.
+L<SL::DB::Helper::Filtered> for an explanation of those.
+
+=head1 FUNCTIONS
+
+=over 4
+
+=item C<laundered>
+
+Finalizes the object (which causes laundering of the filter structure)
+and returns a hashref of the laundered filter. If the plugin is
+configured not to launder then C<undef> will be returned.
+
+=back
=head1 BUGS