/SL/Controller/Helper/GetModels.pm - Annotieren - projekt kivitendo - wissen

| Zweig: | Markierung: | Revision:

kivitendo/SL/Controller/Helper/GetModels.pm @ 706d20f4

-deadd1d
+package SL::Controller::Helper::GetModels;
 use strict;
 use Exporter qw(import);
 our @EXPORT = qw(get_callback get_models);
-f51d62
+use constant PRIV => '__getmodelshelperpriv';
-deadd1d
+my %registered_handlers = ( callback => [], get_models => [] );
 sub register_get_models_handlers {
   my ($class, %additional_handlers) = @_;
   my $only        = delete($additional_handlers{ONLY}) || [];
   $only           = [ $only ] if !ref $only;
   my %hook_params = @{ $only } ? ( only => $only ) : ();
-f51d62
+  $class->run_before(sub { $_[0]->{PRIV()} = { current_action => $_[1] }; }, %hook_params);
-deadd1d
+            Moritz Bunkus
   map { push @{ $registered_handlers{$_} }, $additional_handlers{$_} if $additional_handlers{$_} } keys %registered_handlers;
+}
 sub get_callback {
   my ($self, %override_params) = @_;
-f51d62
+  my %default_params = _run_handlers($self, 'callback', action => ($self->{PRIV()} || {})->{current_action});
-deadd1d
+            Moritz Bunkus
   return $self->url_for(%default_params, %override_params);
+}
 sub get_models {
   my ($self, %override_params) = @_;
   my %default_params           = _run_handlers($self, 'get_models');
   my %params                   = (%default_params, %override_params);
   my $model                    = delete($params{model}) || die "No 'model' to work on";
   return "SL::DB::Manager::${model}"->get_all(%params);
+}
+#
 # private/internal functions
+#
 sub _run_handlers {
   my ($self, $handler_type, %params) = @_;
   foreach my $sub (@{ $registered_handlers{$handler_type} }) {
     if (ref $sub eq 'CODE') {
       %params = $sub->($self, %params);
     } elsif ($self->can($sub)) {
       %params = $self->$sub(%params);
     } else {
       die "SL::Controller::Helper::GetModels::get_callback: Cannot call $sub on " . ref($self) . ")";
+    }
+  }
   return %params;
+}
 ;
 __END__
 =pod
 =encoding utf8
 =head1 NAME
 SL::Controller::Helper::GetModels - Base mixin for controller helpers
 dealing with semi-automatic handling of sorting and paginating lists
 =head1 SYNOPSIS
 For a proper synopsis see L<SL::Controller::Helper::Sorted>.
 =head1 OVERVIEW
 For a generic overview see L<SL::Controller::Helper::Sorted>.
 This base module is the interface between a controller and specialized
 helper modules that handle things like sorting and paginating. The
 specialized helpers register themselves with this module via a call to
 L<register_get_models_handlers> during compilation time (e.g. in the
 case of C<Sorted> this happens when the controller calls
 L<SL::Controller::Helper::Sorted::make_sorted>).
 A controller will later usually call the L<get_models>
 function. Templates will call the L<get_callback> function. Both
 functions run the registered handlers handing over control to the
 specialized helpers so that they may inject their parameters into the
 call chain.
 The C<GetModels> helper hooks into the controller call to the action
 via a C<run_before> hook. This is done so that it can remember the
 action called by the user. This is used for constructing the callback
 in L<get_callback>.
 =head1 PACKAGE FUNCTIONS
 =over 4
 =item C<register_get_models_handlers $class, %handlers>
 This function should only be called from other controller helpers like
 C<Sorted> or C<Paginated>. It is not exported and must therefore be
 called its full name. The first parameter C<$class> must be the actual
 controller's class name.
 If C<%handlers> contains a key C<ONLY> then it is passed to the hook
 registration in L<SL::Controller::Base::run_before>.
 The C<%handlers> register callback functions in the specialized
 controller helpers that are called during invocation of
 L<get_callback> or L<get_models>. Possible keys are C<callback> and
 C<models>.
 Each handler (the value in the hash) can be either a code reference
 (in which case it is called directly) or the name of an instance
 function callable on a controller instance. In both cases the handler
 receives a hash of parameters built during this very call to
 L<get_callback> or L<get_models> respectively. The handler's return
 value must be the new hash to be used in calls to further handlers and
 to the actual database model functions later on.
 =back
 =head1 INSTANCE FUNCTIONS
 =over 4
 =item C<get_callback [%params]>
 Return an URL suitable for use as a callback parameter. It maps to the
 current controller and action. All registered handlers of type
 'callback' (e.g. the ones by C<Sorted> and C<Paginated>) can inject
 the parameters they need so that the same list view as is currently
 visible can be re-rendered.
 Optional C<%params> passed to this function may override any parameter
 set by the registered handlers.
 =item C<get_models [%params]>
 Query the model manager via C<get_all> and return its result. The
 parameters to C<get_all> are constructed by calling all registered
 handlers of type 'models' (e.g. the ones by C<Sorted> and
 C<Paginated>).
 Optional C<%params> passed to this function may override any parameter
 set by the registered handlers.
 The return value is the an array reference of C<Rose> models.
 =back
 =head1 BUGS
 Nothing here yet.
 =head1 AUTHOR
 Moritz Bunkus E<lt>m.bunkus@linet-services.deE<gt>
 =cut

Projekt

Allgemein

Profil

projekt kivitendo