source: trunk/wiki.cgi @ 825

Last change on this file since 825 was 825, checked in by nick, 15 years ago

Few missing metadata related tweaks

  • Property svn:eol-style set to native
  • Property svn:executable set to *
  • Property svn:keywords set to Author Date Id Revision
File size: 16.0 KB
Line 
1#!/usr/local/bin/perl
2
3use strict;
4use warnings;
5
6use vars qw( $VERSION );
7$VERSION = '0.56';
8
9use CGI qw/:standard/;
10use CGI::Carp qw(croak);
11use Wiki::Toolkit;
12use Geography::NationalGrid;
13use Geography::NationalGrid::GB;
14use OpenGuides;
15use OpenGuides::CGI;
16use OpenGuides::Config;
17use OpenGuides::RDF;
18use OpenGuides::Utils;
19use OpenGuides::Template;
20use Time::Piece;
21use URI::Escape;
22
23my $config_file = $ENV{OPENGUIDES_CONFIG_FILE} || "wiki.conf";
24my $config = OpenGuides::Config->new( file => $config_file );
25
26my $script_name = $config->script_name;
27my $script_url  = $config->script_url;
28
29my ($guide, $wiki, $formatter, $q);
30eval {
31    $guide = OpenGuides->new( config => $config );
32    $wiki = $guide->wiki;
33    $formatter = $wiki->formatter;
34
35    # Get CGI object, find out what to do.
36    $q = CGI->new;
37
38    # Note $q->param('keywords') gives you the entire param string.
39    # We need this to do URLs like foo.com/wiki.cgi?This_Page
40    my $node = $q->param('id') || $q->param('title') || $q->param('keywords') || "";
41    $node = $formatter->node_param_to_node_name( $node );
42
43    my $action       = $q->param('action')  || 'display';
44    my $commit       = $q->param('Save')    || 0;
45    my $preview      = $q->param('preview') || 0;
46    my $search_terms = $q->param('terms')   || $q->param('search') || '';
47    my $format       = $q->param('format')  || '';
48    my $oldid        = $q->param('oldid')   || '';
49
50    # Alternative method of calling search, supported by usemod.
51    $action = 'search' if $q->param("search");
52
53    if ($commit) {
54        $guide->commit_node(
55                             id      => $node,
56                             cgi_obj => $q,
57                           );
58    } elsif ($preview) {
59        preview_node($node);
60    } elsif ($action eq 'edit') {
61        edit_node($node);
62    } elsif ($action eq 'search') {
63        do_search($search_terms);
64    } elsif ($action eq 'show_backlinks') {
65        $guide->show_backlinks( id => $node );
66    } elsif ($action eq 'show_wanted_pages') {
67        show_wanted_pages();
68    } elsif ($action eq 'show_needing_moderation') {
69        show_needing_moderation();
70    } elsif ($action eq 'index') {
71        $guide->show_index(
72                            type   => $q->param("index_type") || "Full",
73                            value  => $q->param("index_value") || "",
74                            format => $format,
75                          );
76    } elsif ($action eq 'random') {
77        my @nodes = $wiki->list_all_nodes();
78        $node = $nodes[int(rand(scalar(@nodes) + 1)) + 1];
79        print $guide->redirect_to_node($node);
80    } elsif ($action eq 'find_within_distance') {
81        $guide->find_within_distance(
82                                      id => $node,
83                                      metres => $q->param("distance_in_metres")
84                                    );
85    } elsif ( $action eq 'admin' ) {
86        $guide->display_admin_interface();
87    } elsif ( $action eq 'show_missing_metadata' ) {
88        $guide->show_missing_metadata(
89                   metadata_type  => $q->param("metadata_type") || "",
90                   metadata_value => $q->param("metadata_value") || "",
91                   exclude_locales => $q->param("exclude_locales") || "",
92                   exclude_categories => $q->param("exclude_categories") || ""
93        );
94    } elsif ( $action eq 'set_moderation' ) {
95        $guide->set_node_moderation(
96                             id       => $node,
97                             password => $q->param("password") || "",
98                             moderation_flag => $q->param("moderation_flat") || "",
99                           );
100    } elsif ( $action eq 'moderate' ) {
101        $guide->moderate_node(
102                             id       => $node,
103                             version  => $q->param("version") || "",
104                             password => $q->param("password") || "",
105                           );
106    } elsif ( $action eq 'delete'
107              and ( lc($config->enable_page_deletion) eq "y"
108                    or $config->enable_page_deletion eq "1" )
109            ) {
110        $guide->delete_node(
111                             id       => $node,
112                             version  => $q->param("version") || "",
113                             password => $q->param("password") || "",
114                           );
115    } elsif ($action eq 'userstats') {
116        show_userstats(
117                        username => $q->param("username") || "",
118                        host     => $q->param("host") || "",
119                      );
120    } elsif ($action eq 'list_all_versions') {
121        if($format && ($format eq "rss" || $format eq "atom")) {
122            my %args = (
123                            feed_type    => $format,
124                            feed_listing => 'node_all_versions',
125                            name         => $node
126            );
127            $guide->display_feed( %args );
128        } else {
129            $guide->list_all_versions( id => $node );
130        }
131    } elsif ($action eq 'rc') {
132        if ($format && $format eq 'rss') {
133            my $feed = $q->param("feed");
134            if ( !defined $feed or $feed eq "recent_changes" ) {
135                my %args = map { $_ => ( $q->param($_) || "" ) }
136                           qw( feed items days ignore_minor_edits username
137                               category locale );
138                $args{feed_type} = 'rss';
139                $args{feed_listing} = 'recent_changes';
140                $guide->display_feed( %args );
141            } elsif ( $feed eq "chef_dan" ) {
142                display_node_rdf( node => $node );
143            } else {
144                croak "Unknown RSS feed type '$feed'";
145            }
146        } elsif ($format && $format eq 'atom') {
147            my %args = map { $_ => ( $q->param($_) || "" ) }
148                       qw( feed items days ignore_minor_edits username
149                           category locale );
150            $args{feed_type} = 'atom';
151            $args{feed_listing} = 'recent_changes';
152            $guide->display_feed( %args );
153        } else {
154            $guide->display_node( id => 'RecentChanges' );
155        }
156    } elsif ($action eq 'rss') {
157        my $redir_target = $script_url . $script_name . '?action=rc;format=rss';
158        my %args = map { $_ => ( $q->param($_) || "" ) }
159            qw( feed items days ignore_minor_edits username
160                category locale );
161        foreach my $arg (sort keys %args) {
162            if ($args{$arg} ne "") {
163                $redir_target .= ";$arg=$args{$arg}";
164            }
165        }
166        print $q->redirect( $redir_target );
167    } elsif ($action eq 'about') {
168        $guide->display_about(format => $format);
169    } else { # Default is to display a node.
170        if ( $format and $format eq "rdf" ) {
171            display_node_rdf( node => $node );
172        } elsif ( $format and $format eq 'raw' ) {
173            $guide->display_node(
174                                  id       => $node,
175                                  format   => 'raw',
176                                );
177        } else {
178            my $version = $q->param("version");
179            my $other_ver = $q->param("diffversion");
180            if ( $other_ver ) {
181                $guide->display_diffs(
182                                       id            => $node,
183                                       version       => $version,
184                                       other_version => $other_ver,
185                                     );
186            } else {
187                my $redirect;
188               
189                if ((defined $q->param("redirect")) && ($q->param("redirect") == 0)) {
190                  $redirect = 0;
191                } else {
192                  $redirect = 1;               
193                }
194               
195                $guide->display_node(
196                                      id       => $node,
197                                      version  => $version,
198                                      oldid    => $oldid,
199                                      redirect => $redirect,
200                                    );
201            }
202        }
203    }
204};
205
206if ($@) {
207    my $error = $@;
208    warn $error;
209    print $q->header;
210    my $contact_email = $config->contact_email;
211    print qq(<html><head><title>ERROR</title></head><body>
212             <p>Sorry!  Something went wrong.  Please contact the
213             Wiki administrator at
214             <a href="mailto:$contact_email">$contact_email</a> and quote
215             the following error message:</p><blockquote>)
216      . $q->escapeHTML($error)
217      . qq(</blockquote><p><a href="$script_name">Return to the Wiki home page</a>
218           </body></html>);
219}
220
221############################ subroutines ###################################
222
223sub show_userstats {
224    my %args = @_;
225    my ($username, $host) = @args{ qw( username host ) };
226    croak "No username or host supplied to show_userstats"
227        unless $username or $host;
228    my %criteria = ( last_n_changes => 5 );
229    $criteria{metadata_was} = $username ? { username => $username }
230                                        : { host     => $host };
231    my @nodes = $wiki->list_recent_changes( %criteria );
232    @nodes = map { {name          => $q->escapeHTML($_->{name}),
233            last_modified => $q->escapeHTML($_->{last_modified}),
234            comment       => $q->escapeHTML($_->{metadata}{comment}[0]),
235            url           => "$script_name?"
236          . $q->escape($formatter->node_name_to_node_param($_->{name})) }
237                       } @nodes;
238    my %tt_vars = ( last_five_nodes => \@nodes,
239            username        => $username,
240            username_param  => $wiki->formatter->node_name_to_node_param($username),
241                    host            => $host,
242                  );
243    process_template("userstats.tt", "", \%tt_vars);
244}
245
246sub preview_node {
247    my $node = shift;
248    my $content  = $q->param('content');
249    $content     =~ s/\r\n/\n/gs;
250    my $checksum = $q->param('checksum');
251
252    my %tt_metadata_vars = OpenGuides::Template->extract_metadata_vars(
253                                               wiki                 => $wiki,
254                           config               => $config,
255                           cgi_obj              => $q,
256                                               set_coord_field_vars => 1,
257    );
258    foreach my $var ( qw( username comment edit_type ) ) {
259        $tt_metadata_vars{$var} = $q->escapeHTML($q->param($var));
260    }
261
262    if ($wiki->verify_checksum($node, $checksum)) {
263        my %tt_vars = (
264            %tt_metadata_vars,
265            content                => $q->escapeHTML($content),
266            preview_html           => $wiki->format($content),
267            preview_above_edit_box => get_cookie( "preview_above_edit_box" ),
268            checksum               => $q->escapeHTML($checksum)
269    );
270        process_template("edit_form.tt", $node, \%tt_vars);
271    } else {
272        my %node_data = $wiki->retrieve_node($node);
273        my %tt_vars = ( checksum       => $node_data{checksum},
274                        new_content    => $content,
275                        stored_content => $node_data{content} );
276        foreach my $mdvar ( keys %tt_metadata_vars ) {
277            if ($mdvar eq "locales") {
278                $tt_vars{"stored_$mdvar"} = $node_data{metadata}{locale};
279                $tt_vars{"new_$mdvar"}    = $tt_metadata_vars{locale};
280            } elsif ($mdvar eq "categories") {
281                $tt_vars{"stored_$mdvar"} = $node_data{metadata}{category};
282                $tt_vars{"new_$mdvar"}    = $tt_metadata_vars{category};
283            } elsif ($mdvar eq "username" or $mdvar eq "comment"
284                      or $mdvar eq "edit_type" ) {
285                $tt_vars{$mdvar} = $tt_metadata_vars{$mdvar};
286            } else {
287                $tt_vars{"stored_$mdvar"} = $node_data{metadata}{$mdvar}[0];
288                $tt_vars{"new_$mdvar"}    = $tt_metadata_vars{$mdvar};
289            }
290        }
291        process_template("edit_conflict.tt", $node, \%tt_vars);
292    }
293}
294
295sub edit_node {
296    my $node = shift;
297    my %node_data = $wiki->retrieve_node($node);
298    my ($content, $checksum) = @node_data{ qw( content checksum ) };
299    my $username = get_cookie( "username" );
300    my $edit_type = get_cookie( "default_edit_type" ) eq "normal" ?
301                        "Normal edit" : "Minor tidying";
302
303    my %metadata_vars = OpenGuides::Template->extract_metadata_vars(
304                             wiki     => $wiki,
305                             config   => $config,
306                 metadata => $node_data{metadata} );
307
308    $metadata_vars{website} ||= 'http://';
309
310    my %tt_vars = ( content         => $q->escapeHTML($content),
311                    checksum        => $q->escapeHTML($checksum),
312                    %metadata_vars,
313            username        => $username,
314                    edit_type       => $edit_type,
315                    deter_robots    => 1,
316    );
317
318    process_template("edit_form.tt", $node, \%tt_vars);
319}
320
321sub get_cookie {
322    my $pref_name = shift or return "";
323    my %cookie_data = OpenGuides::CGI->get_prefs_from_cookie(config=>$config);
324    return $cookie_data{$pref_name};
325}
326
327sub display_node_rdf {
328    my %args = @_;
329    my $rdf_writer = OpenGuides::RDF->new( wiki      => $wiki,
330                       config => $config );
331    print "Content-type: application/rdf+xml\n\n";
332    print $rdf_writer->emit_rdfxml( node => $args{node} );
333}
334
335sub process_template {
336    my ($template, $node, $vars, $conf, $omit_header) = @_;
337
338    my %output_conf = ( wiki     => $wiki,
339            config   => $config,
340                        node     => $node,
341            template => $template,
342            vars     => $vars
343    );
344    $output_conf{content_type} = "" if $omit_header; # defaults otherwise
345    print OpenGuides::Template->output( %output_conf );
346}
347
348
349sub do_search {
350    my $terms = shift;
351    my %finds = $wiki->search_nodes($terms);
352#    my @sorted = sort { $finds{$a} cmp $finds{$b} } keys %finds;
353    my @sorted = sort keys %finds;
354    my @results = map {
355        { url   => $q->escape($formatter->node_name_to_node_param($_)),
356      title => $q->escapeHTML($_)
357        }             } @sorted;
358    my %tt_vars = ( results      => \@results,
359                    num_results  => scalar @results,
360                    not_editable => 1,
361                    search_terms => $q->escapeHTML($terms) );
362    process_template("search_results.tt", "", \%tt_vars);
363}
364
365sub show_wanted_pages {
366    my @dangling = $wiki->list_dangling_links;
367    my @wanted;
368    my %backlinks_count;
369    foreach my $node_name (@dangling) {
370        $backlinks_count{$node_name} = scalar($wiki->list_backlinks( node => $node_name ));
371    }
372    foreach my $node_name (sort { $backlinks_count{$b} <=> $backlinks_count{$a} } @dangling) {
373        my $node_param =
374         uri_escape($formatter->node_name_to_node_param($node_name));
375        push @wanted, {
376            name          => $q->escapeHTML($node_name),
377            edit_link     => $script_url . uri_escape($script_name)
378                           . "?action=edit;id=$node_param",
379            backlink_link => $script_url . uri_escape($script_name)
380                    . "?action=show_backlinks;id=$node_param",
381            backlinks_count => $backlinks_count{$node_name}
382        };
383    }
384    process_template( "wanted_pages.tt",
385                      "",
386                      { not_editable  => 1,
387                        not_deletable => 1,
388                        deter_robots  => 1,
389                        wanted        => \@wanted } );
390}
391
392sub show_needing_moderation {
393    my @nodes = $wiki->list_unmoderated_nodes;
394
395    # Build the moderate link
396    foreach my $node (@nodes) {
397        my $node_param =
398            uri_escape($formatter->node_name_to_node_param($node->{'name'}));
399        $node->{'moderate_url'} = $script_url . "?action=moderate&id=".$node_param."&version=".$node->{'version'};
400        $node->{'diff_url'} = $script_url . "?id=".$node_param."&version=".$node->{'moderated_version'}."&diffversion=".$node->{'version'};
401    }
402
403    process_template( "needing_moderation.tt",
404                      "",
405                      { not_editable  => 1,
406                        not_deletable => 1,
407                        deter_robots  => 1,
408                        nodes        => \@nodes } );
409}
Note: See TracBrowser for help on using the repository browser.