use SL::Request qw(flatten);
use SL::MoreCommon qw(uri_encode);
+use Rose::Object::MakeMethods::Generic
+(
+ scalar => [ qw(action_name) ],
+);
+
#
# public/helper functions
#
return $_[0] if (scalar(@_) == 1) && !ref($_[0]);
my %params = ref($_[0]) eq 'HASH' ? %{ $_[0] } : @_;
- my $controller = delete($params{controller}) || $self->_controller_name;
- my $action = delete($params{action}) || 'dispatch';
- $params{action} = "${controller}/${action}";
+ my $controller = delete($params{controller}) || $self->controller_name;
+ my $action = $params{action} || 'dispatch';
+
+ my $script;
+ if ($controller =~ m/\.pl$/) {
+ # Old-style controller
+ $script = $controller;
+ } else {
+ $params{action} = "${controller}/${action}";
+ $script = "controller.pl";
+ }
+
my $query = join '&', map { uri_encode($_->[0]) . '=' . uri_encode($_->[1]) } @{ flatten(\%params) };
- return "controller.pl?${query}";
+ return "${script}?${query}";
}
sub redirect_to {
} else {
$::form->{title} = $locals{title} if $locals{title};
- $::form->header;
+ $::form->header(no_menu => $options->{no_menu});
}
}
$file->close;
}
+sub controller_name {
+ my $class = ref($_[0]) || $_[0];
+ $class =~ s/^SL::Controller:://;
+ return $class;
+}
+
#
# Before/after run hooks
#
|| ($hook->{except} && $hook->{except}->{$action});
if (ref($hook->{code}) eq 'CODE') {
- $hook->{code}->($self);
+ $hook->{code}->($self, $action);
} else {
my $sub = $hook->{code};
- $self->$sub;
+ $self->$sub($action);
}
}
}
return 'user';
}
+sub keep_auth_vars_in_form {
+ return 0;
+}
+
#
# private functions -- for use in Base only
#
$::form->error("Invalid action '${action}' for controller " . ref($self)) if !$self->can($sub);
+ $self->action_name($action);
$self->_run_hooks('before', $action);
$self->$sub(@_);
$self->_run_hooks('after', $action);
}
-sub _controller_name {
- return (split(/::/, ref($_[0])))[-1];
-}
-
sub _dispatch {
my $self = shift;
my $sub = "action_${action}";
if ($self->can($sub)) {
+ $self->action_name($action);
$self->_run_hooks('before', $action);
$self->$sub(@_);
$self->_run_hooks('after', $action);
} else {
- $::form->error($::locale->text('Oops. No valid action found to dispatch. Please report this case to the Lx-Office team.'));
+ $::form->error($::locale->text('Oops. No valid action found to dispatch. Please report this case to the kivitendo team.'));
}
}
INCLUDE_PATH => '.:templates/webpages',
COMPILE_EXT => '.tcc',
COMPILE_DIR => $::lx_office_conf{paths}->{userspath} . '/templates-cache',
+ ERROR => 'templates/webpages/generic/exception.html',
}) || croak;
return $self->{__basepriv_template_obj};
Hooks are run in the order they're added.
+The hooks receive a single parameter: the name of the action that is
+about to be called (for C<before> hooks) / was called (for C<after>
+hooks).
+
The return value of the hooks is discarded.
Hooks can be defined to run for all actions, for only specific actions
=item * C<LOCALE> -- C<$::locale>
-=item * C<LXCONFIG> -- all parameters from C<config/lx_office.conf>
+=item * C<LXCONFIG> -- all parameters from C<config/kivitendo.conf>
with the same name they appear in the file (first level is the
section, second the actual variable, e.g. C<system.dbcharset>,
C<features.webdav> etc)
The controller to call is given by C<$params{controller}>. It defaults
to the current controller as returned by
-L</_controller_name>.
+L</controller_name>.
The action to call is given by C<$params{action}>. It defaults to
C<dispatch>.
The hook's return values are discarded.
-=item delay_flash_on_redirect
+=item C<delay_flash_on_redirect>
May be overridden by a controller. If this method returns true, redirect_to
will delay all flash messages for the current request. Defaults to false for
future value C<none> (which would require no authentication but is not
yet implemented).
+=item C<keep_auth_vars_in_form>
+
+May be overridden by a controller. If falsish (the default) all form
+variables whose name starts with C<{AUTH}> are removed before the
+request is routed. Only controllers that handle login requests
+themselves should return trueish for this function.
+
+=item C<controller_name>
+
+Returns the name of the curernt controller package without the
+C<SL::Controller::> prefix. This method can be called both as a class
+method and an instance method.
+
+=item C<action_name>
+
+Returns the name of the currently executing action. If the dispatcher
+mechanism was used then this is not C<dispatch> but the actual method
+name the dispatching resolved to.
+
=back
=head2 PRIVATE FUNCTIONS
=over 4
-=item C<_controller_name>
-
-Returns the name of the curernt controller package without the
-C<SL::Controller::> prefix.
-
=item C<_dispatch>
Implements the method lookup for indirect dispatching mentioned in the