projekt kivitendo

use Carp;

  my $self               = shift;

  my $template           = shift;

  my ($options, %locals) = (@_ && ref($_[0])) ? @_ : ({ }, @_);

  my $source;

  if ($options->{inline}) {

    $source = \$template;

  } else {

    $source = "templates/webpages/${template}.html";

    croak "Template file ${source} not found" unless -f $source;

  }

  if (!$options->{partial} && !$options->{inline}) {

    $::form->{title} = $locals{title} if $locals{title};

  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,

               );

  my $output;

  my $parser = $self->_template_obj;

  $parser->process($source, \%params, \$output) || croak $parser->error;

  print $output unless $options->{inline};

  return $output;

sub _template_obj {

  my ($self) = @_;

  $self->{__basepriv_template_obj} ||=

    Template->new({ INTERPOLATE  => 0,

                    EVAL_PERL    => 0,

                    ABSOLUTE     => 1,

                    CACHE_SIZE   => 0,

                    PLUGIN_BASE  => 'SL::Template::Plugin',

                    INCLUDE_PATH => '.:templates/webpages',

                    COMPILE_EXT  => '.tcc',

                    COMPILE_DIR  => $::userspath . '/templates-cache',

                  }) || croak;

  return $self->{__basepriv_template_obj};

}

=item C<render $template, [ $options, ] %locals>

Renders the template C<$template>. Provides other variables than

C<Form::parse_html_template> does.

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} >>.

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->{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.

If C<< $options->{partial} >> 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.

The template itself has access to the following variables:

=over 2

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

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

=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<LXDEBUG> -- C<$::lxdebug>

=item * C<MYCONFIG> -- C<%::myconfig>

=item * C<SELF> -- the controller instance

=item * All items from C<%locals>

=back

Unless C<< $options->{inline} >> is trueish the function will send the

output to the browser.

The function will always return the output.