Part Controller -part link in Verbrauchsbericht (?) aktualisiert

[mfinanz.git] / SL / Presenter.pm

diff --git a/SL/Presenter.pm b/SL/Presenter.pm
index eeeb43fabbcaaaf893154f19417d48c10ea22993..5067b77179df2a61f3eabfeebc9a7d2484396061 100644 (file)
--- a/SL/Presenter.pm
+++ b/SL/Presenter.pm
@@ -7,17 +7,31 @@ use parent qw(Rose::Object);
 use Carp;
 use Template;
 
 use Carp;
 use Template;
 

+use SL::Presenter::Chart;

 use SL::Presenter::CustomerVendor;
 use SL::Presenter::DeliveryOrder;
 use SL::Presenter::EscapedText;
 use SL::Presenter::Invoice;
 use SL::Presenter::CustomerVendor;
 use SL::Presenter::DeliveryOrder;
 use SL::Presenter::EscapedText;
 use SL::Presenter::Invoice;

+use SL::Presenter::GL;
+use SL::Presenter::Letter;

 use SL::Presenter::Order;
 use SL::Presenter::Order;

+use SL::Presenter::Part;

 use SL::Presenter::Project;
 use SL::Presenter::Record;
 use SL::Presenter::Project;
 use SL::Presenter::Record;

+use SL::Presenter::RequirementSpec;
+use SL::Presenter::RequirementSpecItem;
+use SL::Presenter::RequirementSpecTextBlock;
+use SL::Presenter::SepaExport;
+use SL::Presenter::Text;
+use SL::Presenter::Tag;
+use SL::Presenter::BankAccount;
+
+use Rose::Object::MakeMethods::Generic (
+  scalar => [ qw(need_reinit_widgets) ],
+);

 
 sub get {
 
 sub get {

-  $::request->{presenter} ||= SL::Presenter->new;
-  return $::request->{presenter};
+  return $::request->presenter;

 }
 
 sub render {
 }
 
 sub render {


@@ -25,17 +39,58 @@ sub render {
   my $template           = shift;
   my ($options, %locals) = (@_ && ref($_[0])) ? @_ : ({ }, @_);
 
   my $template           = shift;
   my ($options, %locals) = (@_ && ref($_[0])) ? @_ : ({ }, @_);
 

-  $options->{type}       = lc($options->{type} || 'html');
+  # Set defaults for all available options.
+  my %defaults = (
+    type       => 'html',
+    process    => 1,
+  );
+  $options->{$_} //= $defaults{$_} for keys %defaults;
+  $options->{type} = lc $options->{type};
+
+  # Check supplied options for validity.
+  foreach (keys %{ $options }) {
+    croak "Unsupported option: $_" unless $defaults{$_};
+  }

 
 

+  # Only certain types are supported.
+  croak "Unsupported type: " . $options->{type} unless $options->{type} =~ m/^(?:html|js|json|text)$/;
+
+  # The "template" argument must be a string or a reference to one.
+  $template = ${ $template }                                       if ((ref($template) || '') eq 'REF') && (ref(${ $template }) eq 'SL::Presenter::EscapedText');
+  croak "Unsupported 'template' reference type: " . ref($template) if ref($template) && (ref($template) !~ m/^(?:SCALAR|SL::Presenter::EscapedText)$/);
+
+  # Look for the file given by $template if $template is not a reference.

   my $source;
   my $source;

-  if ($options->{inline}) {
-    $source = \$template;
+  if (!ref $template) {
+    my $ext = $options->{type} eq 'text' ? 'txt' : $options->{type};
+    $source = "templates/webpages/${template}.${ext}";
+    croak "Template file ${source} not found" unless -f $source;
+
+  } elsif (ref($template) eq 'SCALAR') {
+    # Normal scalar reference: hand over to Template
+    $source = $template;

 
   } else {
 
   } else {

-    $source = "templates/webpages/${template}." . $options->{type};
-    croak "Template file ${source} not found" unless -f $source;
+    # Instance of SL::Presenter::EscapedText. Get reference to its content.
+    $source = \$template->{text};

   }
 
   }
 

+  # If no processing is requested then return the content.
+  if (!$options->{process}) {
+    # If $template is a reference then don't try to read a file.
+    my $ref = ref $template;
+    return $template                                                                if $ref eq 'SL::Presenter::EscapedText';
+    return SL::Presenter::EscapedText->new(text => ${ $template }, is_escaped => 1) if $ref eq 'SCALAR';
+
+    # Otherwise return the file's content.
+    my $file    = IO::File->new($source, "r") || croak("Template file ${source} could not be read");
+    my $content = do { local $/ = ''; <$file> };
+    $file->close;
+
+    return SL::Presenter::EscapedText->new(text => $content, is_escaped => 1);
+  }
+
+  # Processing was requested. Set up all variables.

   my %params = ( %locals,
                  AUTH          => $::auth,
                  FLASH         => $::form->{FLASH},
   my %params = ( %locals,
                  AUTH          => $::auth,
                  FLASH         => $::form->{FLASH},


@@ -68,6 +123,7 @@ sub get_template {
                     COMPILE_EXT  => '.tcc',
                     COMPILE_DIR  => $::lx_office_conf{paths}->{userspath} . '/templates-cache',
                     ERROR        => 'templates/webpages/generic/exception.html',
                     COMPILE_EXT  => '.tcc',
                     COMPILE_DIR  => $::lx_office_conf{paths}->{userspath} . '/templates-cache',
                     ERROR        => 'templates/webpages/generic/exception.html',

+                    ENCODING     => 'utf8',

                   }) || croak;
 
   return $self->{template};
                   }) || croak;
 
   return $self->{template};


@@ -85,6 +141,16 @@ sub escaped_text {
   return SL::Presenter::EscapedText->new(text => $text, is_escaped => 1);
 }
 
   return SL::Presenter::EscapedText->new(text => $text, is_escaped => 1);
 }
 

+sub escape_js {
+  my ($self, $text) = @_;
+
+  $text =~ s|\\|\\\\|g;
+  $text =~ s|\"|\\\"|g;
+  $text =~ s|\n|\\n|g;
+
+  return SL::Presenter::EscapedText->new(text => $text, is_escaped => 1);
+}
+

 1;
 
 __END__
 1;
 
 __END__


@@ -147,32 +213,62 @@ controller. Therefore the presenter's L<render> function does not use
 all of the parameters for controlling the output that the controller's
 function does.
 
 all of the parameters for controlling the output that the controller's
 function does.
 

-What is rendered and how C<$template> is interpreted is determined by
-the options I<type> and I<inline>.
+What is rendered and how C<$template> is interpreted is determined
+both by C<$template>'s reference type and by the supplied options.
+
+If C<$template> is a normal scalar (not a reference) then it is meant
+to be a template file name relative to the C<templates/webpages>
+directory. The file name to use is determined by the C<type> option.

 
 

-If C<< $options->{inline} >> is trueish then C<$template> is a string
-containing the template code to interprete.
+If C<$template> is a reference to a scalar then the referenced
+scalar's content is used as the content to process. The C<type> option
+is not considered in this case.

 
 

-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 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.
+C<$template> can also be an instance of L<SL::Presenter::EscapedText>
+or a reference to such an instance. Both of these cases are handled
+the same way as if C<$template> were a reference to a scalar: its
+content is processed, and C<type> is not considered.

 
 

-The template itself has access to the following variables:
+Other reference types, unknown options and unknown arguments to the
+C<type> option cause the function to L<croak>.
+
+The following options are available:
+
+=over 2
+
+=item C<type>
+
+The template type. Can be C<html> (the default), C<js> for JavaScript,
+C<json> for JSON and C<text> for plain text content. Affects only the
+extension that's added to the file name given with a non-reference
+C<$template> argument.
+
+=item C<process>
+
+If trueish (which is also the default) it causes the template/content
+to be processed by the Template toolkit. Otherwise the
+template/content is returned as-is.
+
+=back
+
+If template processing is requested then the template has access to
+the following variables:

 
 =over 2
 
 =item * C<AUTH> -- C<$::auth>
 
 
 =over 2
 
 =item * C<AUTH> -- C<$::auth>
 

+=item * C<FLASH> -- the flash instance (C<$::form-E<gt>{FLASH}>)
+

 =item * C<FORM> -- C<$::form>
 
 =item * C<FORM> -- C<$::form>
 

+=item * C<INSTANCE_CONF> -- C<$::instance_conf>
+

 =item * C<LOCALE> -- C<$::locale>
 
 =item * C<LXCONFIG> -- all parameters from C<config/kivitendo.conf>
 with the same name they appear in the file (first level is the
 =item * C<LOCALE> -- C<$::locale>
 
 =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>,
+section, second the actual variable, e.g. C<system.language>,

 C<features.webdav> etc)
 
 =item * C<LXDEBUG> -- C<$::lxdebug>
 C<features.webdav> etc)
 
 =item * C<LXDEBUG> -- C<$::lxdebug>


@@ -181,6 +277,9 @@ C<features.webdav> etc)
 
 =item * C<SELF> -- the controller instance
 
 
 =item * C<SELF> -- the controller instance
 

+=item * C<PRESENTER> -- the presenter instance the template is
+rendered with
+

 =item * All items from C<%locals>
 
 =back
 =item * All items from C<%locals>
 
 =back


@@ -197,9 +296,14 @@ Example: Render a HTML template with a certain title and a few locals
 Example: Render a string and return its content for further processing
 by the calling function.
 
 Example: Render a string and return its content for further processing
 by the calling function.
 

-  my $content = $presenter->render(
-    '[% USE JavaScript %][% JavaScript.replace_with("#someid", "js/something") %]',
-    { type => 'js' }
+  my $content = $presenter->render(\'[% USE JavaScript %][% JavaScript.replace_with("#someid", "js/something") %]');
+
+Example: Return the content of a JSON template file without processing
+it at all:
+
+  my $template_content = $presenter->render(
+    'customer/contact',
+    { type => 'json', process => 0 }

   );
 
 =item C<escape $text>
   );
 
 =item C<escape $text>


@@ -221,6 +325,16 @@ It is safe to call C<escaped_text> on an instance of
 L<SL::Presenter::EscapedText>. This is a no-op (the same instance will
 be returned).
 
 L<SL::Presenter::EscapedText>. This is a no-op (the same instance will
 be returned).
 

+=item C<escape_js $text>
+
+Returns a JavaScript-escaped version of C<$text>. Instead of a string
+an instance of the thin proxy-object L<SL::Presenter::EscapedText> is
+returned.
+
+It is safe to call C<escape> on an instance of
+L<SL::Presenter::EscapedText>. This is a no-op (the same instance will
+be returned).
+

 =item C<get_template>
 
 Returns the global instance of L<Template> and creates it if it
 =item C<get_template>
 
 Returns the global instance of L<Template> and creates it if it