src/lib/Torrus/Renderer/Frontpage.pm

   1 #  Copyright (C) 2002  Stanislav Sinyagin
   2 #
   3 #  This program is free software; you can redistribute it and/or modify
   4 #  it under the terms of the GNU General Public License as published by
   5 #  the Free Software Foundation; either version 2 of the License, or
   6 #  (at your option) any later version.
   7 #
   8 #  This program is distributed in the hope that it will be useful,
   9 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11 #  GNU General Public License for more details.
  12 #
  13 #  You should have received a copy of the GNU General Public License
  14 #  along with this program; if not, write to the Free Software
  15 #  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
  16
  17 # Stanislav Sinyagin <ssinyagin@yahoo.com>
  18
  19 package Torrus::Renderer::Frontpage;
  20 use strict;
  21 use warnings;
  22
  23 use Torrus::ConfigTree;
  24 use Torrus::Search;
  25 use Torrus::Log;
  26
  27 use URI::Escape qw( uri_escape );
  28 use File::Spec;
  29
  30 our $VERSION = 1.0;
  31
  32 # All our methods are imported by Torrus::Renderer;
  33
  34 sub renderUserLogin
  35 {
  36     my $self = shift;
  37     my %new_options = @_;
  38     my $cache = $self->{cache};
  39
  40     $self->{'options'} = \%new_options
  41         if( %new_options );
  42
  43     my($t_render, $t_expires, $filename, $mime_type);
  44
  45     my $cachekey = $cache->cacheKey( 'LOGINSCREEN', $self->{options} );
  46
  47     ($t_render, $t_expires, $filename, $mime_type) =
  48         $cache->getCache( $cachekey );
  49
  50     # We don't check the expiration time for login screen
  51     if( not defined( $filename ) )
  52     {
  53         $filename = $cache->newCacheFileName($cachekey,
  54                                             $self->{options} );
  55     }
  56
  57     my $outfile = File::Spec->catfile($Torrus::Global::cacheDir,$filename);
  58
  59     $t_expires = time();
  60     $mime_type = $Torrus::Renderer::LoginScreen::mimeType;
  61     my $tmplfile = $Torrus::Renderer::LoginScreen::template;
  62
  63     my $url = $Torrus::Renderer::rendererURL;
  64     if( length( $self->{'options'}->{'urlPassTree'} ) > 0 )
  65     {
  66         $url .= '/' . $self->{'options'}->{'urlPassTree'};
  67     }
  68
  69     my $ttvars =
  70     {
  71         'url'        => $url,
  72         'plainURL'   => $Torrus::Renderer::plainURL,
  73         'style'      => sub { return $self->style($_[0]); },
  74         'companyName'=> $Torrus::Renderer::companyName,
  75         'companyLogo'=> $Torrus::Renderer::companyLogo,
  76         'companyURL' => $Torrus::Renderer::companyURL,
  77         'lostPasswordURL' => $Torrus::Renderer::lostPasswordURL,
  78         'siteInfo'   => $Torrus::Renderer::siteInfo,
  79         'version'    => $Torrus::Global::version,
  80         'xmlnorm'    => \&Torrus::Renderer::xmlnormalize
  81         };
  82
  83
  84     # Pass the options from Torrus::Renderer::render() to Template
  85     while( my( $opt, $val ) = each %{$self->{'options'}} )
  86     {
  87         $ttvars->{$opt} = $val;
  88     }
  89
  90     my $result = $self->{'tt'}->process( $tmplfile, $ttvars, $outfile );
  91
  92     undef $ttvars;
  93
  94     my @ret;
  95     if( not $result )
  96     {
  97         Error('Error while rendering login screen: ' .
  98               $self->{'tt'}->error());
  99     }
 100     else
 101     {
 102         $cache->setCache($cachekey, time(), $t_expires, $filename, $mime_type);
 103         @ret = ($outfile, $mime_type, $t_expires - time());
 104     }
 105
 106     $self->{'options'} = undef;
 107
 108     return @ret;
 109 }
 110
 111
 112 sub renderTreeChooser
 113 {
 114     my $self = shift;
 115     my %new_options = @_;
 116     my $cache = $self->{cache};
 117
 118     $self->{'options'} = \%new_options
 119         if( %new_options );
 120
 121     my($t_render, $t_expires, $filename, $mime_type);
 122
 123     my $uid = $self->{'options'}->{'uid'} || '';
 124
 125     my $cachekey = $cache->cacheKey( $uid . ':' . 'TREECHOOSER',
 126                                     $self->{options} );
 127
 128     ($t_render, $t_expires, $filename, $mime_type) =
 129         $cache->getCache( $cachekey );
 130
 131     if( defined( $filename ) )
 132     {
 133         if( $t_expires >= time() )
 134         {
 135             return (File::Spec->catfile($Torrus::Global::cacheDir,$filename),
 136                     $mime_type, $t_expires - time());
 137         }
 138         # Else reuse the old filename
 139     }
 140     else
 141     {
 142         $filename = $cache->newCacheFileName( $cachekey );
 143     }
 144
 145     my $outfile = File::Spec->catfile($Torrus::Global::cacheDir,$filename);
 146
 147     $t_expires = time() + $Torrus::Renderer::Chooser::expires;
 148     $mime_type = $Torrus::Renderer::Chooser::mimeType;
 149
 150     my $tmplfile;
 151     if( defined( $self->{'options'}{'variables'}{'SEARCH'} ) and
 152         $self->mayGlobalSearch() )
 153     {
 154         $tmplfile = $Torrus::Renderer::Chooser::searchTemplate;
 155     }
 156     else
 157     {
 158         $tmplfile = $Torrus::Renderer::Chooser::template;
 159     }
 160
 161     my $ttvars =
 162     {
 163         'treeNames'  => sub{ return Torrus::SiteConfig::listTreeNames() },
 164         'treeDescr'  => sub{ return
 165                                 Torrus::SiteConfig::treeDescription($_[0]) }
 166         ,
 167         'url'        => sub { return $Torrus::Renderer::rendererURL . '/' . $_[0] },
 168         'pathUrl'    => sub { return $Torrus::Renderer::rendererURL . '/' .
 169                                 $_[0] . '?path=' . $_[1] },
 170         'plainURL'   => $Torrus::Renderer::plainURL,
 171         'clearVar'   => sub { delete $self->{'options'}{'variables'}{$_[0]};
 172                               return},
 173         'style'      => sub { return $self->style($_[0]); },
 174         'companyName'=> $Torrus::Renderer::companyName,
 175         'companyLogo'=> $Torrus::Renderer::companyLogo,
 176         'companyURL' => $Torrus::Renderer::companyURL,
 177         'siteInfo'   => $Torrus::Renderer::siteInfo,
 178         'version'    => $Torrus::Global::version,
 179         'xmlnorm'    => \&Torrus::Renderer::xmlnormalize,
 180         'userAuth'   => $Torrus::CGI::authorizeUsers,
 181         'uid'        => $self->{'options'}->{'uid'},
 182         'userAttr'   => sub { return $self->userAttribute( $_[0] ) },
 183         'mayDisplayTree' => sub { return $self->
 184                                       hasPrivilege( $_[0], 'DisplayTree' ) }
 185         ,
 186         'mayGlobalSearch' => sub { return $self->mayGlobalSearch(); },
 187         'searchResults'   => sub { return $self->doGlobalSearch($_[0]); }
 188     };
 189
 190
 191     # Pass the options from Torrus::Renderer::render() to Template
 192     while( my( $opt, $val ) = each( %{$self->{'options'}} ) )
 193     {
 194         $ttvars->{$opt} = $val;
 195     }
 196
 197     my $result = $self->{'tt'}->process( $tmplfile, $ttvars, $outfile );
 198
 199     undef $ttvars;
 200
 201     my @ret;
 202     if( not $result )
 203     {
 204         Error('Error while rendering tree chooser: ' .
 205               $self->{'tt'}->error());
 206     }
 207     else
 208     {
 209         $cache->setCache($cachekey, time(), $t_expires, $filename, $mime_type);
 210         @ret = ($outfile, $mime_type, $t_expires - time());
 211     }
 212
 213     $self->{'options'} = undef;
 214
 215     return @ret;
 216 }
 217
 218
 219 sub mayGlobalSearch
 220 {
 221     my $self = shift;
 222
 223     return ( $Torrus::Renderer::globalSearchEnabled and
 224              ( not $Torrus::CGI::authorizeUsers or
 225                ( $self->hasPrivilege( '*', 'GlobalSearch' ) ) ) );
 226 }
 227
 228 =head2 doGlobalSearch
 229
 230 Takes two arguments: I<$self> and I<$string>, the later being the search
 231 string. This $string is then searched for and returns an array reference
 232 of results.
 233
 234 =cut
 235
 236 sub doGlobalSearch
 237 {
 238     my $self = shift;
 239     my $string = shift;
 240
 241     my $sr = Torrus::Search->new();
 242     $sr->openGlobal();
 243     my $result = $sr->searchPrefix( $string );
 244
 245     my $sorted = [];
 246     push( @{$sorted}, sort {$a->[0] cmp $b->[0]} @{$result} );
 247
 248     # remove duplicating entries
 249     my %seen;
 250     my $ret = [];
 251
 252     for my $element ( @{$sorted} )
 253     {
 254         my $str = join( ':', $element->[0], $element->[1] );
 255         if( not $seen{$str} )
 256         {
 257             $seen{$str} = 1;
 258             push( @{$ret}, $element );
 259         }
 260     }
 261
 262     return $ret;
 263 }
 264
 265
 266
 267
 268 1;
 269
 270
 271 # Local Variables:
 272 # mode: perl
 273 # indent-tabs-mode: nil
 274 # perl-indent-level: 4
 275 # End: