Changeset 363


Ignore:
Timestamp:
Jun 10, 2004, 4:49:54 PM (18 years ago)
Author:
kake
Message:

A start at moving code from wiki.cgi into OpenGuides.pm

Location:
trunk
Files:
1 added
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/lib/OpenGuides.pm

    r362 r363  
    22use strict;
    33
     4use CGI;
     5use OpenGuides::Template;
     6use OpenGuides::Utils;
     7
    48use vars qw( $VERSION );
    59
    6 $VERSION = '0.33_01';
     10$VERSION = '0.33_02';
    711
    812=head1 NAME
     
    1923Every page includes a link to a machine-readable (RDF) version of the page.
    2024
     25=head1 METHODS
     26
     27=over
     28
     29=item B<new>
     30
     31  my $guide = OpenGuides->new( config => $config );
     32
     33=cut
     34
     35sub new {
     36    my ($class, %args) = @_;
     37    my $self = {};
     38    bless $self, $class;
     39    my $wiki = OpenGuides::Utils->make_wiki_object( config => $args{config} );
     40    $self->{wiki} = $wiki;
     41    $self->{config} = $args{config};
     42    return $self;
     43}
     44
     45=item B<wiki>
     46
     47An accessor, returns the underlying L<CGI::Wiki> object.
     48
     49=cut
     50
     51sub wiki {
     52    my $self = shift;
     53    return $self->{wiki};
     54}
     55
     56=item B<config>
     57
     58An accessor, returns the underlying L<Config::Tiny> object.
     59
     60=cut
     61
     62sub config {
     63    my $self = shift;
     64    return $self->{config};
     65}
     66
     67=item B<display_node>
     68
     69  $guide->display_node(
     70                        id      => "Calthorpe Arms",
     71                        version => 2,
     72                      );
     73
     74Prints to STDOUT.  If C<version> is omitted then the latest version
     75will be displayed.
     76
     77=cut
     78
     79sub display_node {
     80    my ($self, %args) = @_;
     81    my $return_output = $args{return_output} || 0;
     82    my $version = $args{version};
     83    my $id = $args{id} || "Home";
     84    my $wiki = $self->wiki;
     85    my $config = $self->config;
     86
     87    my %tt_vars;
     88
     89    if ( $id =~ /^(Category|Locale) (.*)$/ ) {
     90        my $type = $1;
     91        $tt_vars{is_indexable_node} = 1;
     92        $tt_vars{index_type} = lc($type);
     93        $tt_vars{index_value} = $2;
     94    }
     95
     96    my %current_data = $wiki->retrieve_node( $id );
     97    my $current_version = $current_data{version};
     98    undef $version if ($version && $version == $current_version);
     99    my %criteria = ( name => $id );
     100    $criteria{version} = $version if $version;#retrieve_node default is current
     101
     102    my %node_data = $wiki->retrieve_node( %criteria );
     103    my $raw = $node_data{content};
     104    if ( $raw =~ /^#REDIRECT\s+(.+?)\s*$/ ) {
     105        my $redirect = $1;
     106        # Strip off enclosing [[ ]] in case this is an extended link.
     107        $redirect =~ s/^\[\[//;
     108        $redirect =~ s/\]\]\s*$//;
     109        # See if this is a valid node, if not then just show the page as-is.
     110        if ( $wiki->node_exists($redirect) ) {
     111            redirect_to_node($redirect);
     112        }
     113    }
     114    my $content    = $wiki->format($raw);
     115    my $modified   = $node_data{last_modified};
     116    my %metadata   = %{$node_data{metadata}};
     117
     118    my %metadata_vars = OpenGuides::Template->extract_metadata_vars(
     119                            wiki     => $wiki,
     120                            config   => $config,
     121                            metadata => $node_data{metadata} );
     122
     123    %tt_vars = (
     124                 %tt_vars,
     125                 %metadata_vars,
     126                 content       => $content,
     127                 geocache_link => $self->make_geocache_link($id),
     128                 last_modified => $modified,
     129                 version       => $node_data{version},
     130                 node_name     => CGI->escapeHTML($id),
     131                 node_param    => CGI->escape($id),
     132                 language      => $config->{_}->{default_language},
     133               );
     134
     135
     136    # We've undef'ed $version above if this is the current version.
     137    $tt_vars{current} = 1 unless $version;
     138
     139    if ($id eq "RecentChanges") {
     140        my $minor_edits = $self->get_cookie( "show_minor_edits_in_rc" );
     141        my %criteria = ( days => 7 );
     142        $criteria{metadata_was} = { edit_type => "Normal edit" }
     143          unless $minor_edits;
     144        my @recent = $wiki->list_recent_changes( %criteria );
     145        @recent = map { {name          => CGI->escapeHTML($_->{name}),
     146                         last_modified => CGI->escapeHTML($_->{last_modified}),
     147                         comment       => CGI->escapeHTML($_->{metadata}{comment}[0]),
     148                         username      => CGI->escapeHTML($_->{metadata}{username}[0]),
     149                         host          => CGI->escapeHTML($_->{metadata}{host}[0]),
     150                         username_param => CGI->escape($_->{metadata}{username}[0]),
     151                         edit_type     => CGI->escapeHTML($_->{metadata}{edit_type}[0]),
     152                         url           => "$config->{_}->{script_name}?"
     153          . CGI->escape($wiki->formatter->node_name_to_node_param($_->{name})) }
     154                       } @recent;
     155        $tt_vars{recent_changes} = \@recent;
     156        $tt_vars{days} = 7;
     157        my $output = $self->process_template(
     158                                          id            => $id,
     159                                          template      => "recent_changes.tt",
     160                                          tt_vars       => \%tt_vars,
     161                                            );
     162        return $output if $return_output;
     163        print $output;
     164    } elsif ($id eq "Home") {
     165        my @recent = $wiki->list_recent_changes(
     166            last_n_changes => 10,
     167            metadata_was   => { edit_type => "Normal edit" },
     168        );
     169        @recent = map { {name          => CGI->escapeHTML($_->{name}),
     170                         last_modified => CGI->escapeHTML($_->{last_modified}),
     171                         comment       => CGI->escapeHTML($_->{metadata}{comment}[0]),
     172                         username      => CGI->escapeHTML($_->{metadata}{username}[0]),
     173                         url           => "$config->{_}->{script_name}?"
     174          . CGI->escape($wiki->formatter->node_name_to_node_param($_->{name})) }
     175                       } @recent;
     176        $tt_vars{recent_changes} = \@recent;
     177        my $output = $self->process_template(
     178                                              id            => $id,
     179                                              template      => "home_node.tt",
     180                                              tt_vars       => \%tt_vars,
     181                                            );
     182        return $output if $return_output;
     183        print $output;
     184    } else {
     185        my $output = $self->process_template(
     186                                              id            => $id,
     187                                              template      => "node.tt",
     188                                              tt_vars       => \%tt_vars,
     189                                            );
     190        return $output if $return_output;
     191        print $output;
     192    }
     193}
     194
     195sub process_template {
     196    my ($self, %args) = @_;
     197    my %output_conf = ( wiki     => $self->wiki,
     198                        config   => $self->config,
     199                        node     => $args{id},
     200                        template => $args{template},
     201                        vars     => $args{tt_vars},
     202    );
     203    return OpenGuides::Template->output( %output_conf );
     204}
     205
     206sub get_cookie {
     207    my $self = shift;
     208    my $config = $self->config;
     209    my $pref_name = shift or return "";
     210    my %cookie_data = OpenGuides::CGI->get_prefs_from_cookie(config=>$config);
     211    return $cookie_data{$pref_name};
     212}
     213
     214sub make_geocache_link {
     215    my $self = shift;
     216    my $wiki = $self->wiki;
     217    my $config = $self->config;
     218    return "" unless $self->get_cookie( "include_geocache_link" );
     219    my $node = shift || $config->{_}->{home_name};
     220    my %current_data = $wiki->retrieve_node( $node );
     221    my %criteria     = ( name => $node );
     222    my %node_data    = $wiki->retrieve_node( %criteria );
     223    my %metadata     = %{$node_data{metadata}};
     224    my $latitude     = $metadata{latitude}[0];
     225    my $longitude    = $metadata{longitude}[0];
     226    my $geocache     = CGI::Wiki::Plugin::GeoCache->new();
     227    my $link_text    = "Look for nearby geocaches";
     228
     229    if ($latitude && $longitude) {
     230        my $cache_url    = $geocache->make_link(
     231                                        latitude  => $latitude,
     232                                        longitude => $longitude,
     233                                        link_text => $link_text
     234                                );
     235        return $cache_url;
     236    }
     237    else {
     238        return "";
     239    }
     240}
     241
     242=back
     243
    21244=head1 BUGS AND CAVEATS
    22245
  • trunk/wiki.cgi

    r362 r363  
    1212use CGI::Wiki::Search::SII;
    1313use CGI::Wiki::Formatter::UseMod;
    14 use CGI::Wiki::Plugin::GeoCache;
    1514use CGI::Wiki::Plugin::Locator::UK;
    1615use CGI::Wiki::Plugin::Diff;
     
    1817use Geography::NationalGrid;
    1918use Geography::NationalGrid::GB;
     19use OpenGuides;
    2020use OpenGuides::CGI;
    2121use OpenGuides::RDF;
     
    3131my $script_name = $config->{_}->{script_name};
    3232my $script_url  = $config->{_}->{script_url};
    33 my $language    = $config->{_}->{default_language};
    3433
    3534# Ensure that script_url ends in a '/' - this is done in Build.PL but
     
    3736$script_url .= "/" unless $script_url =~ /\/$/;
    3837
    39 my ($wiki, $formatter, $locator, $q, $differ);
     38my ($guide, $wiki, $formatter, $locator, $q, $differ);
    4039eval {
    41     $wiki = OpenGuides::Utils->make_wiki_object( config => $config );
     40    $guide = OpenGuides->new( config => $config );
     41    $wiki = $guide->wiki;
    4242    $formatter = $wiki->formatter;
    4343    $locator = CGI::Wiki::Plugin::Locator::UK->new;
     
    150150                );
    151151            } else {
    152                 display_node($node, $version);
     152                $guide->display_node( id => $node, version => $version);
    153153            }
    154154        }
     
    178178    print $q->redirect("$script_url$script_name?" . $q->escape($formatter->node_name_to_node_param($node)));
    179179    exit 0;
    180 }
    181 
    182 sub display_node {
    183     my ($node, $version) = @_;
    184     $node ||= "Home";
    185 
    186     my %tt_vars;
    187 
    188     if ( $node =~ /^(Category|Locale) (.*)$/ ) {
    189         my $type = $1;
    190         $tt_vars{is_indexable_node} = 1;
    191         $tt_vars{index_type} = lc($type);
    192         $tt_vars{index_value} = $2;
    193     }
    194 
    195     my %current_data = $wiki->retrieve_node( $node );
    196     my $current_version = $current_data{version};
    197     undef $version if ($version && $version == $current_version);
    198     my %criteria = ( name => $node );
    199     $criteria{version} = $version if $version;#retrieve_node default is current
    200 
    201     my %node_data = $wiki->retrieve_node( %criteria );
    202     my $raw = $node_data{content};
    203     if ( $raw =~ /^#REDIRECT\s+(.+?)\s*$/ ) {
    204         my $redirect = $1;
    205         # Strip off enclosing [[ ]] in case this is an extended link.
    206         $redirect =~ s/^\[\[//;
    207         $redirect =~ s/\]\]\s*$//;
    208         # See if this is a valid node, if not then just show the page as-is.
    209         if ( $wiki->node_exists($redirect) ) {
    210             redirect_to_node($redirect);
    211         }
    212     }
    213     my $content    = $wiki->format($raw);
    214     my $modified   = $node_data{last_modified};
    215     my %metadata   = %{$node_data{metadata}};
    216 
    217     my %metadata_vars = OpenGuides::Template->extract_metadata_vars(
    218                             wiki     => $wiki,
    219                             config   => $config,
    220                             metadata => $node_data{metadata} );
    221 
    222     %tt_vars = (
    223                  %tt_vars,
    224                  %metadata_vars,
    225                  content       => $content,
    226                  geocache_link => make_geocache_link($node),
    227                  last_modified => $modified,
    228                  version       => $node_data{version},
    229                  node_name     => $q->escapeHTML($node),
    230                  node_param    => $q->escape($node),
    231                  language      => $language, );
    232 
    233 
    234     # We've undef'ed $version above if this is the current version.
    235     $tt_vars{current} = 1 unless $version;
    236 
    237     if ($node eq "RecentChanges") {
    238         my $minor_edits = get_cookie( "show_minor_edits_in_rc" );
    239         my %criteria = ( days => 7 );
    240         $criteria{metadata_was} = { edit_type => "Normal edit" }
    241           unless $minor_edits;
    242         my @recent = $wiki->list_recent_changes( %criteria );
    243         @recent = map { {name          => $q->escapeHTML($_->{name}),
    244                          last_modified => $q->escapeHTML($_->{last_modified}),
    245                          comment       => $q->escapeHTML($_->{metadata}{comment}[0]),
    246                          username      => $q->escapeHTML($_->{metadata}{username}[0]),
    247                          host          => $q->escapeHTML($_->{metadata}{host}[0]),
    248                          username_param => $q->escape($_->{metadata}{username}[0]),
    249                          edit_type     => $q->escapeHTML($_->{metadata}{edit_type}[0]),
    250                          url           => "$script_name?"
    251           . $q->escape($formatter->node_name_to_node_param($_->{name})) }
    252                        } @recent;
    253         $tt_vars{recent_changes} = \@recent;
    254         $tt_vars{days} = 7;
    255         process_template("recent_changes.tt", $node, \%tt_vars);
    256     } elsif ($node eq "Home") {
    257         my @recent = $wiki->list_recent_changes(
    258             last_n_changes => 10,
    259             metadata_was   => { edit_type => "Normal edit" },
    260         );
    261         @recent = map { {name          => $q->escapeHTML($_->{name}),
    262                          last_modified => $q->escapeHTML($_->{last_modified}),
    263                          comment       => $q->escapeHTML($_->{metadata}{comment}[0]),
    264                          username      => $q->escapeHTML($_->{metadata}{username}[0]),
    265                          url           => "$script_name?"
    266           . $q->escape($formatter->node_name_to_node_param($_->{name})) }
    267                        } @recent;
    268         $tt_vars{recent_changes} = \@recent;
    269         process_template("home_node.tt", $node, \%tt_vars);
    270     } else {
    271         process_template("node.tt", $node, \%tt_vars);
    272     }
    273180}
    274181
     
    484391}
    485392
    486 sub make_geocache_link {
    487     return "" unless get_cookie( "include_geocache_link" );
    488     my $node = shift || $config->{_}->{home_name};
    489     my %current_data = $wiki->retrieve_node( $node );
    490     my %criteria     = ( name => $node );
    491     my %node_data    = $wiki->retrieve_node( %criteria );
    492     my %metadata     = %{$node_data{metadata}};
    493     my $latitude     = $metadata{latitude}[0];
    494     my $longitude    = $metadata{longitude}[0];
    495     my $geocache     = CGI::Wiki::Plugin::GeoCache->new();
    496     my $link_text    = "Look for nearby geocaches";
    497 
    498     if ($latitude && $longitude) {
    499         my $cache_url    = $geocache->make_link(
    500                                         latitude  => $latitude,
    501                                         longitude => $longitude,
    502                                         link_text => $link_text
    503                                 );
    504         return $cache_url;
    505     }
    506     else {
    507         return "";
    508     }
    509 }
    510 
    511393sub process_template {
    512394    my ($template, $node, $vars, $conf, $omit_header) = @_;
Note: See TracChangeset for help on using the changeset viewer.