torrus/perllib/Torrus/Renderer/HTML.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 # $Id: HTML.pm,v 1.14 2011-03-01 00:09:39 ivan Exp $
  18 # Stanislav Sinyagin <ssinyagin@yahoo.com>
  19
  20 package Torrus::Renderer::HTML;
  21
  22 use strict;
  23
  24 use Torrus::ConfigTree;
  25 use Torrus::Search;
  26 use Torrus::Log;
  27
  28 use URI::Escape;
  29 use Template;
  30 use POSIX qw(abs log floor pow);
  31 use Date::Parse;
  32 use Date::Format;
  33
  34 Torrus::SiteConfig::loadStyling();
  35
  36 # All our methods are imported by Torrus::Renderer;
  37
  38 sub render_html
  39 {
  40     my $self = shift;
  41     my $config_tree = shift;
  42     my $token = shift;
  43     my $view = shift;
  44     my $outfile = shift;
  45
  46     my $tmplfile = $config_tree->getParam($view, 'html-template');
  47
  48     my $expires = $config_tree->getParam($view, 'expires');
  49
  50     # Create the Template Toolkit processor once, and reuse
  51     # it in subsequent render() calls
  52
  53     if( not defined( $self->{'tt'} ) )
  54     {
  55         $self->{'tt'} =
  56             new Template(INCLUDE_PATH => $Torrus::Global::templateDirs,
  57                          TRIM => 1);
  58     }
  59     my $ttvars =
  60     {
  61         'treeName'   => $config_tree->treeName(),
  62         'token'      => $token,
  63         'view'       => $view,
  64         'expires'    => $expires,
  65         'path'       => sub { return $config_tree->path($_[0]); },
  66         'pathToken'  => sub { return $config_tree->token($_[0]); },
  67         'nodeExists' => sub { return $config_tree->nodeExists($_[0]); },
  68         'children'   => sub { return $config_tree->getChildren($_[0]); },
  69         'isLeaf'     => sub { return $config_tree->isLeaf($_[0]); },
  70         'isAlias'    => sub { return $config_tree->isAlias($_[0]); },
  71         'sortTokens' => sub { return $self->sortTokens($config_tree,
  72                                                        $_[0]); },
  73         'nodeName'   => sub { return $self->nodeName($config_tree, $_[0]); },
  74         'parent'     => sub { return $config_tree->getParent($_[0]); },
  75         'nodeParam'  => sub { return $config_tree->getNodeParam(@_); },
  76         'param'      => sub { return $config_tree->getParam(@_); },
  77         'url'        => sub { return $self->makeURL($config_tree, 0, @_); },
  78         'persistentUrl' => sub { return $self->makeURL($config_tree, 1, @_); },
  79         'clearVar'   => sub { delete $self->{'options'}{'variables'}{$_[0]};
  80                               return undef;},
  81         'plainURL'   => $Torrus::Renderer::plainURL,
  82         'splitUrls'  => sub { return $self->makeSplitURLs($config_tree,
  83                                                           $_[0], $_[1]); },
  84         'topURL'     => ($Torrus::Renderer::rendererURL ne '' ?
  85                          $Torrus::Renderer::rendererURL : '/'),
  86         'rrprint'    => sub { return $self->rrPrint($config_tree,
  87                                                     $_[0], $_[1]); },
  88         'scale'      => sub { return $self->scale($_[0], $_[1]); },
  89         'tsetMembers' => sub { $config_tree->tsetMembers($_[0]); },
  90         'tsetList'   => sub { $config_tree->getTsets(); },
  91         'style'      => sub { return $self->style($_[0]); },
  92         'companyName'=> $Torrus::Renderer::companyName,
  93         'companyLogo'=> $Torrus::Renderer::companyLogo,
  94         'companyURL' => $Torrus::Renderer::companyURL,
  95         'siteInfo'   => $Torrus::Renderer::siteInfo,
  96         'treeInfo'   => sub { return $Torrus::Global::treeConfig{
  97             $config_tree->treeName()}{'info'}; },
  98         'version'    => $Torrus::Global::version,
  99         'xmlnorm'    => \&Torrus::Renderer::xmlnormalize,
 100         'userAuth'   => $Torrus::CGI::authorizeUsers,
 101         'uid'        => $self->{'options'}->{'uid'},
 102         'userAttr'   => sub { return $self->userAttribute( $_[0] ) },
 103         'mayDisplayAdmInfo' => sub {
 104             return $self->may_display_adminfo( $config_tree, $_[0] ) },
 105         'adminfo' => $self->{'adminfo'},
 106         'mayDisplayReports' => sub {
 107             return $self->may_display_reports($config_tree) },
 108         'reportsUrl' => sub {
 109             return $self->reportsUrl($config_tree); },
 110         'timestamp'  => sub { return time2str($Torrus::Renderer::timeFormat,
 111                                               time()); },
 112         'verifyDate'  => sub { return verifyDate($_[0]); },
 113         'markup'     => sub{ return $self->translateMarkup( @_ ); },
 114         'searchEnabled' => $Torrus::Renderer::searchEnabled,
 115         'searchResults' => sub { return $self->doSearch($config_tree, $_[0]); },
 116
 117         #Freeside
 118         'freesideHeader' => sub { return $self->freesideHeader(@_); },
 119         'freesideFooter' => sub { return $self->freesideFooter(); },
 120         'freesideComponent' => sub { return $self->freesideComponent(@_); },
 121         'uri_escape'        => sub { return uri_escape(@_); },
 122         'matches'        => sub { return $_[0] =~ $_[1]; },
 123         'iface_underscore' => sub { $_[0] =~ s/[\/\.]/_/g; return $_[0]; },
 124         'load_nms'       => sub { return $self->load_nms; },
 125         'get_serviceids'    => sub { my $nms = shift;
 126                                   my $router = shift;
 127                                   return $nms->get_router_serviceids($router);
 128                                 },
 129         'popup_link'     => sub {
 130           my $type = shift;
 131
 132           if($type eq 'nms-add_iface.html') {
 133               my $host = shift;
 134               my $iface = shift;
 135               my $nms = shift;
 136               my $serviceids = shift;
 137
 138               if ( $serviceids && $serviceids->{$iface} ) {
 139
 140                 my $svc_port = $nms->find_svc($serviceids->{$iface});
 141
 142                 if ($svc_port) {
 143                    my $url = $Torrus::Freeside::FSURL.
 144                              "/view/svc_port.cgi?". $svc_port->svcnum;
 145                    return "<A HREF='$url'>View Service</A>";
 146                 } else {
 147                   my $component =
 148                    $nms->find_torrus_srvderive_component($serviceids->{$iface});
 149
 150                   if ($component) {
 151                      return $serviceids->{$iface}. ' combined into '.
 152                             $component->torrus_srvderive->serviceid;
 153                   } else {
 154                      return 'Monitored as '. $serviceids->{$iface}.
 155                             '; not yet provisioned or combined';
 156                   }
 157                 }
 158
 159               } else {
 160
 161                return
 162                    $self->freesideComponent('/elements/popup_link.html',
 163                        'action' => "/freeside/misc/".
 164                                $type."?host=$host;iface=$iface",
 165                         'label' => 'Monitor for billing',
 166                         'actionlabel' => 'Monitor interface',
 167                    );
 168
 169               }
 170
 171           } elsif ($type eq 'nms-add_router.html') {
 172                return
 173                    $self->freesideComponent('/elements/popup_link.html',
 174                        'action' => "/freeside/misc/$type",
 175                         'label' => 'Add Router',
 176                         'actionlabel' => 'Add Router',
 177                    );
 178           }
 179
 180           '';
 181        },
 182
 183     };
 184
 185
 186     # Pass the options from Torrus::Renderer::render() to Template
 187     while( my( $opt, $val ) = each( %{$self->{'options'}} ) )
 188     {
 189         $ttvars->{$opt} = $val;
 190     }
 191
 192     my $result = $self->{'tt'}->process( $tmplfile, $ttvars, $outfile );
 193
 194     undef $ttvars;
 195
 196     if( not $result )
 197     {
 198         if( $config_tree->isTset( $token ) )
 199         {
 200             Error("Error while rendering tokenset $token: " .
 201                   $self->{'tt'}->error());
 202         }
 203         else
 204         {
 205             my $path = $config_tree->path($token);
 206             Error("Error while rendering $path: " .
 207                   $self->{'tt'}->error());
 208         }
 209         return undef;
 210     }
 211
 212     return ($expires+time(), 'text/html; charset=UTF-8');
 213 }
 214
 215
 216 sub nodeName
 217 {
 218     my $self = shift;
 219     my $config_tree = shift;
 220     my $token = shift;
 221
 222     my $n = $config_tree->getNodeParam($token, 'node-display-name', 1);
 223     if( defined( $n ) and length( $n ) > 0 )
 224     {
 225         return $n;
 226     }
 227
 228     return $config_tree->nodeName($config_tree->path($token));
 229 }
 230
 231
 232 sub sortTokens
 233 {
 234     my $self = shift;
 235     my $config_tree = shift;
 236     my $tokenlist = shift;
 237
 238     my @sorted = ();
 239     if( ref($tokenlist) and scalar(@{$tokenlist}) > 0 )
 240     {
 241         @sorted = sort
 242         {
 243             my $p_a = $config_tree->getNodeParam($a, 'precedence', 1);
 244             $p_a = 0 unless defined $p_a;
 245             my $p_b = $config_tree->getNodeParam($b, 'precedence', 1);
 246             $p_b = 0 unless defined $p_b;
 247             if( $p_a == $p_b )
 248             {
 249                 my $n_a = $config_tree->path($a);
 250                 my $n_b = $config_tree->path($b);
 251                 return $n_a cmp $n_b;
 252             }
 253             else
 254             {
 255                 return $p_b <=> $p_a;
 256             }
 257         } @{$tokenlist};
 258     }
 259     else
 260     {
 261         push(@sorted, $tokenlist);
 262     }
 263     return @sorted;
 264 }
 265
 266
 267 # compose an URL for a node.
 268 # $persistent defines if the link should be persistent
 269 # Persistent link is done with nodeid if available, or with path
 270
 271 sub makeURL
 272 {
 273     my $self = shift;
 274     my $config_tree = shift;
 275     my $persistent = shift;
 276     my $token = shift;
 277     my $view = shift;
 278     my @add_vars = @_;
 279
 280     my $ret = $Torrus::Renderer::rendererURL . '/' . $config_tree->treeName();
 281
 282     if( $persistent )
 283     {
 284         my $nodeid = $config_tree->getNodeParam($token, 'nodeid', 1);
 285         if( defined( $nodeid ) )
 286         {
 287             $ret .= '?nodeid=' .
 288                 uri_escape($nodeid, $Torrus::Renderer::uriEscapeExceptions);
 289         }
 290         else
 291         {
 292             $ret .= '?path=' .
 293                 uri_escape($config_tree->path($token),
 294                            $Torrus::Renderer::uriEscapeExceptions);
 295         }
 296     }
 297     else
 298     {
 299         $ret .= '?token=' . uri_escape($token);
 300     }
 301
 302     if( $view )
 303     {
 304         $ret .= '&amp;view=' . uri_escape($view);
 305     }
 306
 307     my %vars = ();
 308     # This could be array or a reference to array
 309     my $add_vars_size = scalar( @add_vars );
 310     if( $add_vars_size == 1 and ref( $add_vars[0] ) )
 311     {
 312         %vars = @{$add_vars[0]};
 313     }
 314     elsif( $add_vars_size > 0 and ($add_vars_size % 2 == 0) )
 315     {
 316         %vars = @add_vars;
 317     }
 318
 319     if( ref( $self->{'options'}->{'variables'} ) )
 320     {
 321         foreach my $name ( sort keys %{$self->{'options'}->{'variables'}} )
 322         {
 323             my $val = $self->{'options'}->{'variables'}->{$name};
 324             if( not defined( $vars{$name} ) )
 325             {
 326                 $vars{$name} = $val;
 327             }
 328         }
 329     }
 330
 331     foreach my $name ( sort keys %vars )
 332     {
 333         if( $vars{$name} ne '' )
 334         {
 335             $ret .= '&amp;' . $name . '=' .
 336                 uri_escape( $vars{$name},
 337                             $Torrus::Renderer::uriEscapeExceptions );
 338         }
 339     }
 340
 341     return $ret;
 342 }
 343
 344 sub makeSplitURLs
 345 {
 346     my $self = shift;
 347     my $config_tree = shift;
 348     my $token = shift;
 349     my $view = shift;
 350
 351     my $ret = '';
 352     while( defined( $token ) )
 353     {
 354         my $path = $config_tree->path($token);
 355
 356         my $str = '<SPAN CLASS="PathElement">';
 357         $str .=
 358             sprintf('<A HREF="%s">%s%s</A>',
 359                     $self->makeURL($config_tree, 0, $token, $view),
 360                     $config_tree->nodeName($path),
 361                     ( $config_tree->isSubtree($token) and
 362                       $path ne '/') ? '/':'' );
 363         $str .= "</SPAN>\n";
 364
 365         $ret = $str . $ret;
 366
 367         $token = $config_tree->getParent( $token );
 368     }
 369
 370     return $ret;
 371 }
 372
 373
 374 sub rrPrint
 375 {
 376     my $self = shift;
 377     my $config_tree = shift;
 378     my $token = shift;
 379     my $view = shift;
 380
 381     my @ret = ();
 382     my($fname, $mimetype) = $self->render( $config_tree, $token, $view );
 383
 384     if( $mimetype ne 'text/plain' )
 385     {
 386         Error("View $view does not produce text/plain for token $token");
 387     }
 388     else
 389     {
 390         if( not open(IN, $fname) )
 391         {
 392             Error("Cannot open $fname for reading: $!");
 393         }
 394         else
 395         {
 396             chomp(my $values = <IN>);
 397             @ret = split(':', $values);
 398             close IN;
 399         }
 400     }
 401     return @ret;
 402 }
 403
 404 # This subroutine is taken from Dave Plonka's Flowscan
 405
 406 sub scale
 407 {
 408     my $self = shift;
 409     # This is based somewhat on Tobi Oetiker's code in rrd_graph.c:
 410     my $fmt = shift;
 411     my $value = shift;
 412     my @symbols = ("a", # 10e-18 Ato
 413                    "f", # 10e-15 Femto
 414                    "p", # 10e-12 Pico
 415                    "n", # 10e-9  Nano
 416                    "u", # 10e-6  Micro
 417                    "m", # 10e-3  Milli
 418                    " ", # Base
 419                    "k", # 10e3   Kilo
 420                    "M", # 10e6   Mega
 421                    "G", # 10e9   Giga
 422                    "T", # 10e12  Terra
 423                    "P", # 10e15  Peta
 424                    "E"); # 10e18  Exa
 425
 426     my $symbcenter = 6;
 427     my $digits = (0 == $value)? 0 : floor(log(abs($value))/log(1000));
 428     return sprintf( $fmt . " %s", $value/pow(1000, $digits),
 429                     $symbols[ $symbcenter+$digits ] );
 430 }
 431
 432 sub style
 433 {
 434     my $self = shift;
 435     my $object = shift;
 436
 437     my $media;
 438     if( not defined( $media = $self->{'options'}->{'variables'}->{'MEDIA'} ) )
 439     {
 440         $media = 'default';
 441     }
 442     return  $Torrus::Renderer::styling{$media}{$object};
 443 }
 444
 445
 446
 447 sub userAttribute
 448 {
 449     my $self = shift;
 450     my $attr = shift;
 451
 452     if( $self->{'options'}->{'uid'} and $self->{'options'}->{'acl'} )
 453     {
 454         $self->{'options'}->{'acl'}->
 455             userAttribute( $self->{'options'}->{'uid'}, $attr );
 456     }
 457     else
 458     {
 459         return '';
 460     }
 461 }
 462
 463 sub hasPrivilege
 464 {
 465     my $self = shift;
 466     my $object = shift;
 467     my $privilege = shift;
 468
 469     if( $self->{'options'}->{'uid'} and $self->{'options'}->{'acl'} )
 470     {
 471         $self->{'options'}->{'acl'}->
 472             hasPrivilege( $self->{'options'}->{'uid'}, $object, $privilege );
 473     }
 474     else
 475     {
 476         return undef;
 477     }
 478 }
 479
 480
 481 sub translateMarkup
 482 {
 483     my $self = shift;
 484     my @strings = @_;
 485
 486     my $tt = new Template( TRIM => 1 );
 487
 488     my $ttvars =
 489     {
 490         'em'      =>  sub { return '<em>' . $_[0] . '</em>'; },
 491         'strong'  =>  sub { return '<strong>' . $_[0] . '</strong>'; }
 492     };
 493
 494     my $ret = '';
 495
 496     foreach my $str ( @strings )
 497     {
 498         my $output = '';
 499         my $result = $tt->process( \$str, $ttvars, \$output );
 500
 501         if( not $result )
 502         {
 503             Error('Error translating markup: ' . $tt->error());
 504         }
 505         else
 506         {
 507             $ret .= $output;
 508         }
 509     }
 510
 511     undef $tt;
 512
 513     return $ret;
 514 }
 515
 516
 517 sub verifyDate
 518 {
 519     my $input = shift;
 520
 521     my $time = str2time( $input );
 522     # rrdtool does not understand dates prior to 1980 (315529200)
 523     if( defined( $time ) and $time > 315529200 )
 524     {
 525         # Present the time in format understood by rrdtool
 526         return time2str('%H:%M %Y%m%d', $time);
 527     }
 528     else
 529     {
 530         return '';
 531     }
 532 }
 533
 534
 535 sub may_display_reports
 536 {
 537     my $self = shift;
 538     my $config_tree = shift;
 539
 540     if( $Torrus::Renderer::displayReports )
 541     {
 542         if( not $Torrus::CGI::authorizeUsers )
 543         {
 544             return 1;
 545         }
 546
 547         my $tree = $config_tree->treeName();
 548         if( $self->hasPrivilege( $tree, 'DisplayReports' ) and
 549             -r $Torrus::Global::reportsDir . '/' . $tree .
 550             '/html/index.html' )
 551         {
 552             return 1;
 553         }
 554     }
 555     return 0;
 556 }
 557
 558
 559 sub reportsUrl
 560 {
 561     my $self = shift;
 562     my $config_tree = shift;
 563
 564     return $Torrus::Renderer::rendererURL . '/' .
 565         $config_tree->treeName() . '?htmlreport=index.html';
 566 }
 567
 568
 569 sub doSearch
 570 {
 571     my $self = shift;
 572     my $config_tree = shift;
 573     my $string = shift;
 574
 575
 576     my $tree = $config_tree->treeName();
 577
 578     my $sr = new Torrus::Search;
 579     $sr->openTree( $tree );
 580     my $result = $sr->searchPrefix( $string, $tree );
 581     $sr->closeTree( $tree );
 582
 583     my $ret = [];
 584     push( @{$ret}, sort {$a->[0] cmp $b->[0]} @{$result} );
 585
 586     return $ret;
 587 }
 588
 589
 590 1;
 591
 592
 593 # Local Variables:
 594 # mode: perl
 595 # indent-tabs-mode: nil
 596 # perl-indent-level: 4
 597 # End: