X-Git-Url: http://wagnertech.de/git?a=blobdiff_plain;f=SL%2FController%2FBase.pm;h=ac09057af1c279bfcf000604bc46d102c3d06728;hb=e74dac176e01090f7e3b6bd9e99596a36e614284;hp=8e7e721dde70dedd2e062e3dd4b10ae69004850e;hpb=f1c874c3725f159f1b00295bf825b2a270cf57bc;p=kivitendo-erp.git

diff --git a/SL/Controller/Base.pm b/SL/Controller/Base.pm
index 8e7e721dd..ac09057af 100644
--- a/SL/Controller/Base.pm
+++ b/SL/Controller/Base.pm
@@ -5,7 +5,10 @@ use strict;
 use parent qw(Rose::Object);
 
 use Carp;
+use IO::File;
 use List::Util qw(first);
+use SL::Request qw(flatten);
+use SL::MoreCommon qw(uri_encode);
 
 #
 # public/helper functions
@@ -20,7 +23,7 @@ sub url_for {
   my $controller  = delete($params{controller}) || $self->_controller_name;
   my $action      = delete($params{action})     || 'dispatch';
   $params{action} = "${controller}/${action}";
-  my $query       = join('&', map { $::form->escape($_) . '=' . $::form->escape($params{$_}) } keys %params);
+  my $query       = join '&', map { uri_encode($_->[0]) . '=' . uri_encode($_->[1]) } @{ flatten(\%params) };
 
   return "controller.pl?${query}";
 }
@@ -29,7 +32,12 @@ sub redirect_to {
   my $self = shift;
   my $url  = $self->url_for(@_);
 
-  print $::cgi->redirect($url);
+  if ($self->delay_flash_on_redirect) {
+    require SL::Helper::Flash;
+    SL::Helper::Flash::delay_flash();
+  }
+
+  print $::request->{cgi}->redirect($url);
 }
 
 sub render {
@@ -37,46 +45,76 @@ sub render {
   my $template           = shift;
   my ($options, %locals) = (@_ && ref($_[0])) ? @_ : ({ }, @_);
 
+  $options->{type}       = lc($options->{type} || 'html');
+  $options->{no_layout}  = 1 if $options->{type} eq 'js';
+
   my $source;
   if ($options->{inline}) {
     $source = \$template;
 
+  } elsif($options->{raw}) {
+    $source =  $template;
+
   } else {
-    $source = "templates/webpages/${template}.html";
+    $source = "templates/webpages/${template}." . $options->{type};
     croak "Template file ${source} not found" unless -f $source;
   }
 
-  if (!$options->{partial} && !$options->{inline}) {
-    $::form->{title} = $locals{title} if $locals{title};
-    $::form->header;
+  if (!$options->{partial} && !$options->{inline} && !$::form->{header}) {
+    if ($options->{no_layout}) {
+      $::form->{header} = 1;
+      my $content_type  = $options->{type} eq 'js' ? 'text/javascript' : 'text/html';
+
+      print $::form->create_http_response(content_type => $content_type,
+                                          charset      => $::lx_office_conf{system}->{dbcharset} || Common::DEFAULT_CHARSET());
+
+    } else {
+      $::form->{title} = $locals{title} if $locals{title};
+      $::form->header;
+    }
   }
 
   my %params = ( %locals,
-                 AUTH     => $::auth,
-                 FORM     => $::form,
-                 LOCALE   => $::locale,
-                 LXCONFIG => { dbcharset              => $::dbcharset,
-                               webdav                 => $::webdav,
-                               lizenzen               => $::lizenzen,
-                               latex_templates        => $::latex,
-                               opendocument_templates => $::opendocument_templates,
-                               vertreter              => $::vertreter,
-                               show_best_before       => $::show_best_before,
-                             },
-                 LXDEBUG  => $::lxdebug,
-                 MYCONFIG => \%::myconfig,
-                 SELF     => $self,
+                 AUTH          => $::auth,
+                 FLASH         => $::form->{FLASH},
+                 FORM          => $::form,
+                 INSTANCE_CONF => $::instance_conf,
+                 LOCALE        => $::locale,
+                 LXCONFIG      => \%::lx_office_conf,
+                 LXDEBUG       => $::lxdebug,
+                 MYCONFIG      => \%::myconfig,
+                 SELF          => $self,
                );
 
   my $output;
-  my $parser = $self->_template_obj;
-  $parser->process($source, \%params, \$output) || croak $parser->error;
+  if (!$options->{raw}) {
+    my $parser = $self->_template_obj;
+    $parser->process($source, \%params, \$output) || croak $parser->error;
+  } else {
+    $output = $$source;
+  }
 
-  print $output unless $options->{inline};
+  print $output unless $options->{inline} || $options->{no_output};
 
   return $output;
 }
 
+sub send_file {
+  my ($self, $file_name, %params) = @_;
+
+  my $file            = IO::File->new($file_name, 'r') || croak("Cannot open file '${file_name}'");
+  my $content_type    =  $params{type} || 'application/octet_stream';
+  my $attachment_name =  $params{name} || $file_name;
+  $attachment_name    =~ s:.*//::g;
+
+  print $::form->create_http_response(content_type        => $content_type,
+                                      content_disposition => 'attachment; filename="' . $attachment_name . '"',
+                                      content_length      => -s $file);
+
+  $::locale->with_raw_io(\*STDOUT, sub { print while <$file> });
+  $file->close;
+}
+
 #
 # Before/after run hooks
 #
@@ -121,6 +159,14 @@ sub _run_hooks {
   }
 }
 
+#
+#  behaviour. override these
+#
+
+sub delay_flash_on_redirect {
+  0;
+}
+
 #
 # private functions -- for use in Base only
 #
@@ -151,9 +197,13 @@ sub _dispatch {
   my $action  = first { $::form->{"action_${_}"} } @actions;
   my $sub     = "action_${action}";
 
-  $self->_run_hooks('before', $action);
-  $self->$sub(@_);
-  $self->_run_hooks('after', $action);
+  if ($self->can($sub)) {
+    $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.'));
+  }
 }
 
 sub _template_obj {
@@ -167,7 +217,7 @@ sub _template_obj {
                     PLUGIN_BASE  => 'SL::Template::Plugin',
                     INCLUDE_PATH => '.:templates/webpages',
                     COMPILE_EXT  => '.tcc',
-                    COMPILE_DIR  => $::userspath . '/templates-cache',
+                    COMPILE_DIR  => $::lx_office_conf{paths}->{userspath} . '/templates-cache',
                   }) || croak;
 
   return $self->{__basepriv_template_obj};
@@ -287,23 +337,36 @@ C<$options>, if present, must be a hash reference. All remaining
 parameters are slurped into C<%locals>.
 
 What is rendered and how C<$template> is interpreted is determined by
-C<< $options->{inline} >> and C<< $options->{partial} >>.
+the options I<type>, I<inline>, I<partial> and I<no_layout>.
 
 If C<< $options->{inline} >> is trueish then C<$template> is a string
 containing the template code to interprete. Additionally the output
 will not be sent to the browser. Instead it is only returned to the
 caller.
 
+If C<< $options->{raw} >> is trueish, the function will treat the input as
+already parsed, and will not filter the input through Template. Unlike
+C<inline>, the input is taked as a reference.
+
 If C<< $options->{inline} >> is falsish then C<$template> is
 interpreted as the name of a template file. It is prefixed with
-"templates/webpages/" and postfixed with ".html". An exception will be
-thrown if that file does not exist.
+"templates/webpages/" and postfixed with a file extension based on
+C<< $options->{type} >>. C<< $options->{type} >> can be either C<html>
+or C<js> and defaults to C<html>. An exception will be thrown if that
+file does not exist.
+
+If C<< $options->{partial} >> or C<< $options->{inline} >> is trueish
+then neither the HTTP response header nor the standard HTML header is
+generated.
+
+Otherwise at least the HTTP response header will be generated based on
+the template type (C<< $options->{type} >>).
 
-If C<< $options->{partial} >> or C<< $options->{inline} }} is trueish
-then C<< $::form->header >> will not be called. Otherwise
-C<< $::form->{header} >> will be set to C<$locals{header}> (only if
-$locals{header} is trueish) and C<< $::form->header >> will be called
-before the template itself is processed.
+If the template type is C<html> then the standard HTML header will be
+output via C<< $::form->header >> with C<< $::form->{title} >> set to
+C<$locals{title}> (the latter only if C<$locals{title}> is
+trueish). Setting C<< $options->{no_layout} >> to trueish will prevent
+this.
 
 The template itself has access to the following variables:
 
@@ -315,9 +378,10 @@ The template itself has access to the following variables:
 
 =item * C<LOCALE> -- C<$::locale>
 
-=item * C<LXCONFIG> -- all parameters from C<config/lx-erp.conf> with
-the same name they appear in the file (e.g. C<dbcharset>, C<webdav>
-etc)
+=item * C<LXCONFIG> -- all parameters from C<config/lx_office.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)
 
 =item * C<LXDEBUG> -- C<$::lxdebug>
 
@@ -334,6 +398,39 @@ output to the browser.
 
 The function will always return the output.
 
+Example: Render a HTML template with a certain title and a few locals
+
+  $self->render('todo/list',
+                title      => 'List TODO items',
+                TODO_ITEMS => SL::DB::Manager::Todo->get_all_sorted);
+
+Example: Render a string and return its content for further processing
+by the calling function. No header is generated due to C<inline>.
+
+  my $content = $self->render('[% USE JavaScript %][% JavaScript.replace_with("#someid", "js/something") %]',
+                              { type => 'js', inline => 1 });
+
+Example: Render a JavaScript template and send it to the
+browser. Typical use for actions called via AJAX:
+
+  $self->render('todo/single_item', { type => 'js' },
+                item => $employee->most_important_todo_item);
+
+=item C<send_file $file_name, [%params]>
+
+Sends the file C<$file_name> to the browser including appropriate HTTP
+headers for a download. C<%params> can include the following:
+
+=over 2
+
+=item * C<type> -- the file's content type; defaults to
+'application/octet_stream'
+
+=item * C<name> -- the name presented to the browser; defaults to
+C<$file_name>
+
+=back
+
 =item C<url_for $url>
 
 =item C<url_for $params>
@@ -361,7 +458,7 @@ Usage from a template might look like this:
 
   <a href="[% SELF.url_for(controller => 'Message', action => 'new', recipient_id => 42) %]">create new message</a>
 
-=item redirect_to %url_params
+=item C<redirect_to %url_params>
 
 Redirects the browser to a new URL by outputting a HTTP redirect
 header. The URL is generated by calling L</url_for> with
@@ -400,6 +497,12 @@ action.
 
 The hook's return values are discarded.
 
+=item 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
+compatibility reasons.
+
 =back
 
 =head2 PRIVATE FUNCTIONS