Changeset 559


Ignore:
Timestamp:
Nov 23, 2004, 11:19:36 PM (17 years ago)
Author:
kake
Message:

Huge-ass pile of changes to make geo stuff work worldwide.

Location:
trunk
Files:
5 added
17 edited

Legend:

Unmodified
Added
Removed
  • trunk/Build.PL

    r558 r559  
    9090  default  => "United Kingdom"
    9191  },
     92{ question => "Contact email address for the site administrator?",
     93  variable => "contact_email"
     94  },
    9295{ question => "What language will the site be in? (Please give an ISO language code.)",
    9396  variable => "default_language",
    9497  default  => "en"
    95   },
    96 { question => "Contact email address for the site administrator?",
    97   variable => "contact_email"
    9898  },
    9999{ question => "What's the name of the node to use for the text formatting rules link?",
     
    219219}
    220220
     221# Now deal with the geo stuff.
     222my $geo_handler;
     223my $geo_handler_qu = "Distance calculation methods available are:"
     224                   . "\n  1) British National Grid"
     225                   . "\n  2) Irish National Grid"
     226                   . "\n  3) UTM ellipsoid"
     227                   . "\nWhich would you like to use?";
     228
     229if ( $skip_config ) {
     230    # We default to GB National Grid for historical reasons.
     231    $geo_handler = $existing_config{geo_handler} || 1;
     232} else {
     233    my $choice;
     234    until ( $choice ) {
     235        my $def = $existing_config{geo_handler} || 1;
     236        $choice = Module::Build->prompt("\n".$geo_handler_qu, $def);
     237        $choice =~ s/^\s*//;
     238        $choice =~ s/\s*$//;
     239        unless ( $choice eq "1" or $choice eq "2" or $choice eq "3" ) {
     240            undef $choice;
     241        }
     242    }
     243    $geo_handler = $choice;
     244}
     245
     246$geo_handler_qu =~ s/\n//gs;
     247push @answers, {
     248                 question => $geo_handler_qu,
     249                 variable => "geo_handler",
     250                 value    => $geo_handler,
     251               };
     252
     253if ( $geo_handler eq "3" ) {
     254    my $ellipsoid;
     255    if ( $skip_config ) {
     256        $ellipsoid = $existing_config{ellipsoid} || "International";
     257    } else {
     258        my $qu = "Which ellipsoid do you want to use? (eg 'Airy', 'WGS-84')";
     259        my $def = $existing_config{ellipsoid} || "International";
     260        my $choice = Module::Build->prompt("\n".$qu, $def);
     261        $choice =~ s/^\s*//;
     262        $choice =~ s/\s*$//;
     263        push @answers, {
     264                         question => $qu,
     265                         variable => "ellipsoid",
     266                         value    => $choice,
     267                       };
     268    }
     269}
     270
    221271# Create a user-friendly config file from answers to prompts.
    222272open FILE, ">wiki.conf" or die "Can't open wiki.conf for writing: $!";
     
    245295        'CGI::Wiki::Plugin::Categoriser'  => 0,
    246296        'CGI::Wiki::Plugin::Diff'         => '0.07', # earlier buggy
    247         'CGI::Wiki::Plugin::Locator::UK'  => '0.09',
     297        'CGI::Wiki::Plugin::Locator::Grid'=> 0,
    248298        'CGI::Wiki::Plugin::RSS::ModWiki' => '0.06', # for fancy stuff
    249299        'CGI::Wiki::Plugin::RSS::Reader'  => '1.3',  # earlier versions don't support RSS 2.0
     
    265315        'Module::Build' => '0.18', # earlier doesn't install script files
    266316        },
     317    recommends => {
     318        'DBD::SQLite'         => 0, # for testing
     319        'Test::HTML::Content' => 0, # for testing, oddly enough
     320    },
    267321    dynamic_config => 1,
    268322    create_makefile_pl => "passthrough"
  • trunk/Changes

    r558 r559  
    1         Fixed bug relating to lat/long representation.
    2         Removed debugging warn accidentally left in last release.
     1
     2        Made the geolocation stuff work worldwide.  Squeeeeeee!
     3        You can now choose between doing your distance calculations with
     4          the British National Grid, the Irish National Grid, or a UTM
     5          ellipsoid.  If you wish to use anything other than the British
     6          National Grid and you have pre-existing location data then you
     7          will need to save an edit of each node with location data before
     8          distance searches will work.
     9        In less exciting news:
     10          Fixed bug relating to lat/long representation.
     11          Removed debugging warn accidentally left in last release.
     12          Fixed some HTML validation errors.
    313
    4140.44    17 November 2004
  • trunk/INSTALL

    r558 r559  
    155155
    156156
     157  "What language will the site be in? (Please give an ISO language code.)"
     158
     159eg "en" for English, "it" for Italian.
     160See http://ftp.ics.uci.edu/pub/ietf/http/related/iso639.txt
     161
     162
    157163  "What's the name of the node to use for the text formatting rules link?"
    158164
     
    162168might want to call the node "Text Formatting Examples", "Text
    163169Formatting Rules", "House Style" or whatever.
     170
     171
     172  "Distance calculation methods available are:
     173      1) British National Grid
     174      2) Irish National Grid
     175      3) UTM ellipsoid
     176   Which would you like to use?"
     177
     178  (and if you choose UTM ellipsoid)
     179  "Which ellipsoid would you like to use? (eg 'Airy', 'WGS-84')"
     180
     181See http://www.vterrain.org/Projections/ for how this all works.
     182A UTM (Universal Transverse Mercator) ellipsoid maps latitude and
     183longitude to eastings and northings on a square grid, which allows
     184more accurate distance calculations within the guide.  The British and
     185Irish National Grids are scaled and parametrised versions of UTM
     186ellipsoids (Airy 1830 in the British case, Modified Airy in the Irish).
     187
     188Please note that at the moment there is no provision for changing your
     189mind later about which ellipsoid to use, but it shouldn't be too hard
     190to write a conversion script so don't worry too much about picking the
     191wrong one.  However do note that once you've entered some location
     192data you should not change this value in the config file without running
     193some kind of converter.
     194
     195If you decide to use the British or Irish National Grid, your users
     196will be able to choose between entering location data as lat/long
     197or as grid co-ordinates.
     198
     199You must have Geography::NationalGrid::GB installed to use the British
     200National Grid, Geography::NationalGrid::IE to use the Irish National
     201Grid, and Geo::Coordinates::UTM to use a UTM ellipsoid.
     202
    164203
    165204* Custom templates and CSS
  • trunk/PREREQUISITES

    r558 r559  
    1010CGI::Wiki::Plugin::Categoriser
    1111CGI::Wiki::Plugin::Diff (version 0.07 or later)
    12 CGI::Wiki::Plugin::Locator::UK (version 0.09 or later)
     12CGI::Wiki::Plugin::Locator::Grid
    1313CGI::Wiki::Plugin::RSS::ModWiki (version 0.06 or later)
    1414CGI::Wiki::Plugin::RSS::Reader (version 1.3 or later)
     
    2323)
    2424File::Spec::Functions
    25 Geography::NationalGrid
     25(
     26  Geography::NationalGrid::GB
     27    -- or --
     28  Geography::NationalGrid::IE
     29    -- or --
     30  Geo::Coordinates::UTM
     31)
    2632LWP::Simple
    2733Module::Build (version 0.18 or later)
  • trunk/lib/OpenGuides.pm

    r558 r559  
    55use CGI;
    66use CGI::Wiki::Plugin::Diff;
    7 use CGI::Wiki::Plugin::Locator::UK;
     7use CGI::Wiki::Plugin::Locator::Grid;
    88use OpenGuides::CGI;
    99use OpenGuides::Template;
     
    4646    $self->{wiki} = $wiki;
    4747    $self->{config} = $args{config};
    48     my $locator = CGI::Wiki::Plugin::Locator::UK->new;
     48    # Default to British National Grid for historical reasons.
     49    my $geo_handler = $self->config->{_}{geo_handler} || 1;
     50    my $locator;
     51    if ( $geo_handler == 1 ) {
     52        $locator = CGI::Wiki::Plugin::Locator::Grid->new(
     53                                             x => "os_x",    y => "os_y" );
     54    } elsif ( $geo_handler == 2 ) {
     55        $locator = CGI::Wiki::Plugin::Locator::Grid->new(
     56                                             x => "osie_x",  y => "osie_y" );
     57    } else {
     58        $locator = CGI::Wiki::Plugin::Locator::Grid->new(
     59                                             x => "easting", y => "northing" );
     60    }
    4961    $wiki->register_plugin( plugin => $locator );
    5062    $self->{locator} = $locator;
     
    183195                 language      => $config->{_}->{default_language},
    184196               );
    185 
    186197
    187198    # We've undef'ed $version above if this is the current version.
     
    574585printing the output to STDOUT.
    575586
     587The geographical data that you should provide in the L<CGI> object
     588depends on the handler you chose in C<wiki.conf>.
     589
     590=over
     591
     592=item *
     593
     594B<British National Grid> - provide either C<os_x> and C<os_y> or
     595C<latitude> and C<longitude>; whichever set of data you give, it will
     596be converted to the other and both sets will be stored.
     597
     598=item *
     599
     600B<Irish National Grid> - provide either C<osie_x> and C<osie_y> or
     601C<latitude> and C<longitude>; whichever set of data you give, it will
     602be converted to the other and both sets will be stored.
     603
     604=item *
     605
     606B<UTM ellipsoid> - provide C<latitude> and C<longitude>; these will be
     607converted to easting and northing and both sets of data will be stored.
     608
     609=back
     610
    576611=cut
    577612
  • trunk/lib/OpenGuides/SuperSearch.pm

    r558 r559  
    11package OpenGuides::SuperSearch;
    22use strict;
    3 our $VERSION = '0.08';
     3our $VERSION = '0.09';
    44
    55use CGI qw( :standard );
    6 use CGI::Wiki::Plugin::Locator::UK;
     6use CGI::Wiki::Plugin::Locator::Grid;
    77use File::Spec::Functions qw(:ALL);
    88use OpenGuides::Template;
     
    5555    $self->{head}     = $config->{_}{site_name} . " Search";
    5656
    57     my $locator = CGI::Wiki::Plugin::Locator::UK->new;
     57    my $geo_handler = $config->{_}{geo_handler};
     58    my %locator_params;
     59    if ( $geo_handler == 1 ) {
     60        %locator_params = ( x => "os_x", y => "os_y" );
     61    } elsif ( $geo_handler == 2 ) {
     62        %locator_params = ( x => "osie_x", y => "osie_y" );
     63    } elsif ( $geo_handler == 3 ) {
     64        %locator_params = ( x => "easting", y => "northing" );
     65    }
     66
     67    my $locator = CGI::Wiki::Plugin::Locator::Grid->new( %locator_params );
    5868    $wiki->register_plugin( plugin => $locator );
    5969    $self->{locator} = $locator;
     
    142152    # Run a distance search if we have sufficient criteria.
    143153    if ( defined $self->{distance_in_metres}
    144          && (
    145                  ( defined $self->{lat}  && defined $self->{long} )
    146               || ( defined $self->{os_x} && defined $self->{os_y} )
    147             )
    148        ) {
     154         && defined $self->{x} && defined $self->{y} ) {
    149155        $doing_search = 1;
    150156        $tt_vars{dist} = $self->{distance_in_metres};
    151         foreach my $param ( qw( os_x os_y lat long ) ) {
     157        foreach my $param ( qw( os_x os_y osie_x osie_y latitude longitude )) {
    152158            $tt_vars{$param} = $self->{$param};
    153159        }
     
    469475}
    470476
     477=back
     478
     479=head1 SEARCHING BY DISTANCE
     480
     481To perform a distance search, you need to supply one of the following
     482sets of criteria to specify the distance to search within, and the
     483origin (centre) of the search:
     484
     485=over
     486
     487=item B<os_dist, os_x, and os_y>
     488
     489Only works if you chose to use British National Grid in wiki.conf
     490
     491=item B<osie_dist, osie_x, and osie_y>
     492
     493Only works if you chose to use Irish National Grid in wiki.conf
     494
     495=item B<latlong_dist, latitude, and longitude>
     496
     497Should always work, but has a habit of "finding" things a couple of
     498metres away from themselves.
     499
     500=back
     501
     502You can perform both pure distance searches and distance searches in
     503combination with text searches.
     504
     505=cut
     506
    471507# Note this is called after any text search is run, and it is only called
    472508# if there are sufficient criteria to perform the search.
    473509sub run_distance_search {
    474510    my $self = shift;
    475     my $os_x = $self->{os_x};
    476     my $os_y = $self->{os_y};
    477     my $lat  = $self->{lat};
    478     my $long = $self->{long};
     511    my $x    = $self->{x};
     512    my $y    = $self->{y};
    479513    my $dist = $self->{distance_in_metres};
    480514
    481     my @close;
    482     if ( defined $lat && defined $long ) {
    483         @close = $self->{locator}->find_within_distance(
    484                                                          lat    => $lat,
    485                                                          long   => $long,
    486                                                          metres => $dist,
    487                                                        );
    488     } else {
    489         @close = $self->{locator}->find_within_distance(
    490                                                          os_x   => $os_x,
    491                                                          os_y   => $os_y,
    492                                                          metres => $dist,
    493                                                        );
    494     }
     515    my @close = $self->{locator}->find_within_distance(
     516                                                        x      => $x,
     517                                                        y      => $y,
     518                                                        metres => $dist,
     519                                                      );
     520
    495521    if ( $self->{results} ) {
    496522        my %close_hash = map { $_ => 1 } @close;
     
    501527                my $distance = $self->_get_distance(
    502528                                                     node => $node,
    503                                                      lat  => $lat,
    504                                                      long => $long,
    505                                                      os_x => $os_x,
    506                                                      os_y => $os_y,
     529                                                     x    => $x,
     530                                                     y    => $y,
    507531                                                   );
    508532                $results{$node}{distance} = $distance;
     
    517541            my $distance = $self->_get_distance (
    518542                                                     node => $node,
    519                                                      lat  => $lat,
    520                                                      long => $long,
    521                                                      os_x => $os_x,
    522                                                      os_y => $os_y,
     543                                                     x    => $x,
     544                                                     y    => $y,
    523545                                                   );
    524546            $results{$node} = {
     
    534556sub _get_distance {
    535557    my ($self, %args) = @_;
    536     my ($node, $lat, $long, $x, $y) = @args{ qw( node lat long os_x os_y ) };
    537     if ( defined $lat && defined $long ) {
    538         return $self->{locator}->distance(
    539                                            from_lat  => $lat,
    540                                            from_long => $long,
    541                                            to_node   => $node,
    542                                            unit      => "metres"
    543                                          );
    544     } else {
    545         return $self->{locator}->distance(
    546                                            from_os_x => $x,
    547                                            from_os_y => $y,
    548                                            to_node   => $node,
    549                                            unit      => "metres"
    550                                          );
    551     }
     558    my ($node, $x, $y) = @args{ qw( node x y ) };
     559    return $self->{locator}->distance(
     560                                       from_x  => $x,
     561                                       from_y  => $y,
     562                                       to_node => $node,
     563                                       unit    => "metres"
     564                                     );
    552565}
    553566
     
    556569    my %vars = %{ $vars_hashref || {} };
    557570
     571    # Make sure that we don't have any data left over from previous invocation.
     572    # This is useful for testing purposes at the moment and will be essential
     573    # for mod_perl implementations.
     574    delete $self->{x};
     575    delete $self->{y};
     576    delete $self->{distance_in_metres};
     577    delete $self->{search_string};
     578
    558579    # Strip out any non-digits from distance and OS co-ords.
    559     foreach my $param ( qw( os_x os_y os_dist latlong_dist ) ) {
     580    foreach my $param ( qw( os_x os_y osie_x osie_y
     581                            osie_dist os_dist latlong_dist ) ) {
    560582        if ( defined $vars{$param} ) {
    561583            $vars{$param} =~ s/[^0-9]//g;
    562584            # 0 is an allowed value but the empty string isn't.
    563585            delete $vars{$param} if $vars{$param} eq "";
    564             $self->{$param} = $vars{$param} if defined $vars{$param};
    565586        }
    566587    }
    567588
    568589    # Latitude and longitude are also allowed '-' and '.'
    569     foreach my $param( qw( lat long ) ) {
     590    foreach my $param( qw( latitude longitude ) ) {
    570591        if ( defined $vars{$param} ) {
    571592            $vars{$param} =~ s/[^-\.0-9]//g;
    572593            # 0 is an allowed value but the empty string isn't.
    573594            delete $vars{$param} if $vars{$param} eq "";
    574             $self->{$param} = $vars{$param} if defined $vars{$param};
    575595        }
    576596    }
    577597
    578     # Set $self->{distance_in_metres} depending on whether we got
    579     # OS co-ords or lat/long.
    580     if ( defined $self->{os_x} && defined $self->{os_y}
    581          && defined $self->{os_dist} ) {
    582         $self->{distance_in_metres} = $self->{os_dist};
    583     } elsif ( defined $self->{lat} && defined $self->{long}
    584               && defined $self->{latlong_dist} ) {
    585         $self->{distance_in_metres} = $self->{latlong_dist};
     598    # Set $self->{distance_in_metres}, $self->{x}, $self->{y},
     599    # depending on whether we got
     600    # OS co-ords or lat/long.  Only store parameters if they're complete,
     601    # and supported by our method of distance calculation.
     602    if ( defined $vars{os_x} && defined $vars{os_y} && defined $vars{os_dist}
     603         && $self->config->{_}{geo_handler} eq 1 ) {
     604        $self->{x} = $vars{os_x};
     605        $self->{y} = $vars{os_y};
     606        $self->{distance_in_metres} = $vars{os_dist};
     607    } elsif ( defined $vars{osie_x} && defined $vars{osie_y}
     608         && defined $vars{osie_dist}
     609         && $self->config->{_}{geo_handler} eq 2 ) {
     610        $self->{x} = $vars{osie_x};
     611        $self->{y} = $vars{osie_y};
     612        $self->{distance_in_metres} = $vars{osie_dist};
     613    } elsif ( defined $vars{latitude} && defined $vars{longitude}
     614              && defined $vars{latlong_dist} ) {
     615        # All handlers can do lat/long, but they all do it differently.
     616        if ( $self->config->{_}{geo_handler} eq 1 ) {
     617            require Geography::NationalGrid::GB;
     618            my $point = Geography::NationalGrid::GB->new(
     619                Latitude  => $vars{latitude},
     620                Longitude => $vars{longitude},
     621            );
     622            $self->{x} = $point->easting;
     623            $self->{y} = $point->northing;
     624        } elsif ( $self->config->{_}{geo_handler} eq 2 ) {
     625            require Geography::NationalGrid::IE;
     626            my $point = Geography::NationalGrid::IE->new(
     627                Latitude  => $vars{latitude},
     628                Longitude => $vars{longitude},
     629            );
     630            $self->{x} = $point->easting;
     631            $self->{y} = $point->northing;
     632        } elsif ( $self->config->{_}{geo_handler} eq 3 ) {
     633            require Geo::Coordinates::UTM;
     634            my ($zone, $x, $y) = Geo::Coordinates::UTM::latlon_to_utm(
     635                                                $self->config->{_}{ellipsoid},
     636                                                $vars{latitude},
     637                                                $vars{longitude},
     638                                              );
     639            $self->{x} = $x;
     640            $self->{y} = $y;
     641        }
     642        $self->{distance_in_metres} = $vars{latlong_dist};
     643    }
     644
     645    # Store os_x etc so we can pass them to template.
     646    foreach my $param ( qw( os_x os_y osie_x osie_y latitude longitude ) ) {
     647        $self->{$param} = $vars{$param};
    586648    }
    587649
     
    607669sub process_template {
    608670    my ($self, %args) = @_;
     671
    609672    my $tt_vars = $args{tt_vars} || {};
    610673    $tt_vars->{not_editable} = 1;
  • trunk/lib/OpenGuides/Template.pm

    r558 r559  
    169169        $header = CGI::header( -cookie => $args{cookies} );
    170170    }
     171
     172    # vile hack
     173    my %field_vars = OpenGuides::Template->extract_metadata_vars(
     174                                        wiki                 => $args{wiki},
     175                                        config               => $config,
     176                                        set_coord_field_vars => 1,
     177                                        metadata => {},
     178                                                           );
     179    $tt_vars = { %field_vars, %$tt_vars };
     180
    171181    my $output;
    172182    $tt->process( $args{template}, $tt_vars, \$output );
     
    211221C<metadata> and C<cgi_obj> then C<metadata> will take precedence, but
    212222don't do that.
     223
     224The variables C<dist_field>, C<coord_field_1>, C<coord_field_1_name>,
     225C<coord_field_1_value>, C<coord_field_2>, C<coord_field_2_name>, and
     226C<coord_field_2_value>, which are used to create various forms, will
     227only be set if I<either> C<metadata> is supplied I<or>
     228C<set_coord_field_vars> is true, to prevent these values from being
     229stored in the database on a node commit.
    213230
    214231=cut
     
    268285
    269286    if ( $args{metadata} ) {
    270         foreach my $var ( qw( phone fax address postcode os_x os_y
    271                               latitude longitude map_link website) ) {
     287        foreach my $var ( qw( phone fax address postcode os_x os_y osie_x
     288                              osie_y latitude longitude map_link website) ) {
    272289            $vars{$var} = $metadata{$var}[0];
    273290        }
     291        # Data for the distance search forms on the node display.
     292        my $geo_handler = $config->{_}{geo_handler} || 1;
     293        if ( $geo_handler == 1 ) {
     294            %vars = (
     295                      %vars,
     296                      coord_field_1       => "os_x",
     297                      coord_field_2       => "os_y",
     298                      dist_field          => "os_dist",
     299                      coord_field_1_name  => "OS X coordinate",
     300                      coord_field_2_name  => "OS Y coordinate",
     301                      coord_field_1_value => $metadata{os_x}[0],
     302                      coord_field_2_value => $metadata{os_y}[0],
     303                    );
     304        } elsif ( $geo_handler == 2 ) {
     305            %vars = (
     306                      %vars,
     307                      coord_field_1       => "osie_x",
     308                      coord_field_2       => "osie_y",
     309                      dist_field          => "osie_dist",
     310                      coord_field_1_name  =>"Irish National Grid X coordinate",
     311                      coord_field_2_name  =>"Irish National Grid Y coordinate",
     312                      coord_field_1_value => $metadata{osie_x}[0],
     313                      coord_field_2_value => $metadata{osie_y}[0],
     314                    );
     315        } else {
     316            %vars = (
     317                      %vars,
     318                      coord_field_1       => "latitude",
     319                      coord_field_2       => "longitude",
     320                      dist_field          => "latlong_dist",
     321                      coord_field_1_name  => "Latitude",
     322                      coord_field_2_name  => "Longitude",
     323                      coord_field_1_value => $metadata{latitude}[0],
     324                      coord_field_2_value => $metadata{longitude}[0],
     325                    );
     326        }
    274327    } else {
    275328        foreach my $var ( qw( phone fax address postcode map_link website) ) {
     
    277330        }
    278331
    279         my $os_x = $q->param("os_x");
    280         my $os_y = $q->param("os_y");
    281         # Trim whitespace - trailing whitespace buggers up the integerification
    282         # by postgres and it's an easy mistake to make when typing into a form.
    283         $os_x =~ s/\s+//;
    284         $os_y =~ s/\s+//;
    285         # Work out latitude and longitude for the preview display.
    286         if ($os_x and $os_y) {
    287             my $point = Geography::NationalGrid::GB->new( Easting  => $os_x,
    288                                                           Northing => $os_y );
    289             %vars = ( %vars,
    290                       latitude  => sprintf("%.6f", $point->latitude),
    291                       longitude => sprintf("%.6f", $point->longitude),
    292                       os_x      => $os_x,
    293                       os_y      => $os_y
    294             );
     332        my $geo_handler = $config->{_}{geo_handler};
     333        if ( $geo_handler == 1 ) {
     334            require Geography::NationalGrid::GB;
     335            my $os_x   = $q->param("os_x");
     336            my $os_y   = $q->param("os_y");
     337            my $lat    = $q->param("latitude");
     338            my $long   = $q->param("longitude");
     339
     340            # Trim whitespace - trailing whitespace buggers up the
     341            # integerification by postgres and it's an easy mistake to
     342            # make when typing into a form.
     343            $os_x =~ s/\s+//;
     344            $os_y =~ s/\s+//;
     345
     346            # If we were sent x and y, work out lat/long; and vice versa.
     347            if ( $os_x && $os_y ) {
     348                my $point = Geography::NationalGrid::GB->new( Easting =>$os_x,
     349                                                              Northing=>$os_y);
     350                $lat  = sprintf("%.6f", $point->latitude);
     351                $long = sprintf("%.6f", $point->longitude);
     352            } elsif ( $lat && $long ) {
     353                my $point = Geography::NationalGrid::GB->new(Latitude =>$lat,
     354                                                             Longitude=>$long);
     355                $os_x = $point->easting;
     356                $os_y = $point->northing;
     357            }
     358            %vars = (
     359                      %vars,
     360                      latitude  => $lat,
     361                      longitude => $long,
     362                      os_x      => $os_x,
     363                      os_y      => $os_y,
     364                    );
     365            if ( $args{set_coord_field_vars} ) {
     366                %vars = (
     367                          %vars,
     368                          coord_field_1       => "os_x",
     369                          coord_field_2       => "os_y",
     370                          dist_field          => "os_dist",
     371                          coord_field_1_name  => "OS X coordinate",
     372                          coord_field_2_name  => "OS Y coordinate",
     373                          coord_field_1_value => $os_x,
     374                          coord_field_2_value => $os_y,
     375                        );
     376            }
     377        } elsif ( $geo_handler == 2 ) {
     378            require Geography::NationalGrid::IE;
     379            my $osie_x = $q->param("osie_x");
     380            my $osie_y = $q->param("osie_y");
     381            my $lat    = $q->param("latitude");
     382            my $long   = $q->param("longitude");
     383
     384            # Trim whitespace - trailing whitespace buggers up the
     385            # integerification by postgres and it's an easy mistake to
     386            # make when typing into a form.
     387            $osie_x =~ s/\s+//;
     388            $osie_y =~ s/\s+//;
     389
     390            # If we were sent x and y, work out lat/long; and vice versa.
     391            if ( $osie_x && $osie_y ) {
     392                my $point = Geography::NationalGrid::IE->new(Easting=>$osie_x,
     393                                                            Northing=>$osie_y);
     394                $lat = sprintf("%.6f", $point->latitude);
     395                $long = sprintf("%.6f", $point->longitude);
     396            } elsif ( $lat && $long ) {
     397                my $point = Geography::NationalGrid::GB->new(Latitude =>$lat,
     398                                                             Longitude=>$long);
     399                $osie_x = $point->easting;
     400                $osie_y = $point->northing;
     401            }
     402            %vars = (
     403                      %vars,
     404                      latitude  => $lat,
     405                      longitude => $long,
     406                      osie_x    => $osie_x,
     407                      osie_y    => $osie_y,
     408                    );
     409            if ( $args{set_coord_field_vars} ) {
     410                %vars = (
     411                          %vars,
     412                          coord_field_1       => "osie_x",
     413                          coord_field_2       => "osie_y",
     414                          dist_field          => "osie_dist",
     415                     coord_field_1_name  => "Irish National Grid X coordinate",
     416                     coord_field_2_name  => "Irish National Grid Y coordinate",
     417                          coord_field_1_value => $osie_x,
     418                          coord_field_2_value => $osie_y,
     419                        );
     420            }
     421        } elsif ( $geo_handler == 3 ) {
     422            require Geo::Coordinates::UTM;
     423            my $lat    = $q->param("latitude");
     424            my $long   = $q->param("longitude");
     425            if ( $lat && $long ) {
     426                my ($zone, $easting, $northing) =
     427                 Geo::Coordinates::UTM::latlon_to_utm( $config->{_}{ellipsoid},
     428                                                       $lat, $long );
     429                $easting  =~ s/\..*//; # chop off decimal places
     430                $northing =~ s/\..*//; # - metre accuracy enough
     431                %vars = ( %vars,
     432                          latitude  => $lat,
     433                          longitude => $long,
     434                          easting   => $easting,
     435                          northing  => $northing,
     436                        );
     437            }
     438            if ( $args{set_coord_field_vars} ) {
     439                %vars = (
     440                          %vars,
     441                          coord_field_1       => "latitude",
     442                          coord_field_2       => "longitude",
     443                          dist_field          => "latlong_dist",
     444                          coord_field_1_name  => "Latitude",
     445                          coord_field_2_name  => "Longitude",
     446                          coord_field_1_value => $lat,
     447                          coord_field_2_value => $long,
     448                        );
     449            }
    295450        }
    296451    }
  • trunk/t/33_supersearch_advanced_search.t

    r558 r559  
    11use strict;
     2use CGI::Wiki::Plugin::Locator::Grid; # use directly to help debug
    23use CGI::Wiki::Setup::SQLite;
    34use Config::Tiny;
    45use OpenGuides::SuperSearch;
    5 use Test::More tests => 8;
     6use Test::More;
    67
    78eval { require DBD::SQLite; };
    8 my $have_sqlite = $@ ? 0 : 1;
    9 
    10 SKIP: {
    11     skip "DBD::SQLite not installed - no database to test with", 8
    12       unless $have_sqlite;
    13 
    14     # Clear out the database from any previous runs.
    15     unlink "t/node.db";
    16     unlink <t/indexes/*>;
    17 
    18     CGI::Wiki::Setup::SQLite::setup( { dbname => "t/node.db" } );
    19     my $config = Config::Tiny->new;
    20     $config->{_} = {
    21                      dbtype             => "sqlite",
    22                      dbname             => "t/node.db",
    23                      indexing_directory => "t/indexes",
    24                      script_name        => "wiki.cgi",
    25                      script_url         => "http://example.com/",
    26                      site_name          => "Test Site",
    27                      template_path      => "./templates",
    28                    };
    29 
    30     # Plucene is the recommended searcher now.
    31     eval { require CGI::Wiki::Search::Plucene; };
    32     unless ( $@ ) {
    33         $config->{_}{use_plucene} = 1;
    34     }
    35 
    36     my $search = OpenGuides::SuperSearch->new( config => $config );
    37 
    38     # Add some data.  Write more than one pub to avoid hitting the redirect.
    39     my $wiki = $search->{wiki}; # white boxiness
    40     my $ctdata = {
    41                    os_x      => 523465,
    42                    os_y      => 177490,
    43                    latitude  => 51.482385,
    44                    longitude => -0.221743,
    45                    category  => "Pubs",
    46                  };
    47     $wiki->write_node( "Crabtree Tavern",
    48                        "Nice pub on the riverbank.",
    49                        undef,
    50                        $ctdata,
    51                      ) or die "Couldn't write node";
    52     my $badata = {
    53                    os_x      => 522909,
    54                    os_y      => 178232,
    55                    latitude  => 51.489176,
    56                    longitude => -0.229488,
    57                    category  => "Pubs",
    58                  };
    59     $wiki->write_node( "Blue Anchor",
    60                        "Another pub.",
    61                        undef,
    62                        $badata,
    63                      ) or die "Couldn't write node";
    64     my $stdata = {
    65                    os_x      => 528107,
    66                    os_y      => 179347,
    67                    latitude  => 51.498043,
    68                    longitude => -0.154247,
    69                    category  => "Pubs",
    70                  };
    71     $wiki->write_node( "Star Tavern",
    72                        "A most excellent pub.",
    73                        undef,
    74                        $stdata,
    75                      ) or die "Couldn't write node";
    76     my $hbdata = {
    77                    os_x      => 522983,
    78                    os_y      => 178118,
    79                    latitude  => 51.488135,
    80                    longitude => -0.228463,
    81                  };
    82     $wiki->write_node( "Hammersmith Bridge",
    83                        "It's a bridge.",
    84                        undef,
    85                        $hbdata,
    86                      ) or die "Couldn't write node";
    87 
    88     # Sanity check.
    89     print "# Distances should be:\n";
    90     use CGI::Wiki::Plugin::Locator::UK;
    91     my $locator = CGI::Wiki::Plugin::Locator::UK->new;
    92     $wiki->register_plugin( plugin => $locator );
    93     foreach my $node ( "Blue Anchor", "Crabtree Tavern", "Hammersmith Bridge"){
    94         print "# $node: " . $locator->distance( from_lat  => 51.484320,
    95                                                 from_long => -0.223484,
    96                                                 to_node   => $node ) . "\n";
    97     }
    98 
    99     # Check that a distance search finds them.
    100     my %tt_vars = $search->run(
    101                                 return_tt_vars => 1,
    102                                 vars => {
    103                                           lat  => 51.484320,
    104                                           long => -0.223484,
    105                                           latlong_dist => 1000,
    106                                         },
    107                               );
    108     my @ordered = map { $_->{name} } @{ $tt_vars{results} || [] };
    109     my @found = sort @ordered;
    110     is_deeply( \@found,
    111                [ "Blue Anchor", "Crabtree Tavern", "Hammersmith Bridge" ],
    112                "distance search finds the right things" );
    113     is_deeply( \@ordered,
    114                [ "Crabtree Tavern", "Hammersmith Bridge", "Blue Anchor" ],
    115                "...and returns them in the right order" );
    116 
    117     %tt_vars = $search->run(
    118                              return_tt_vars => 1,
    119                              vars => {
    120                                        lat  => 51.484320,
    121                                        long => -0.223484,
    122                                        latlong_dist => 1000,
    123                                        search => " ",
    124                                      },
    125                            );
    126     @ordered = map { $_->{name} } @{ $tt_vars{results} || [] };
    127     @found = sort @ordered;
    128     is_deeply( \@found,
    129                [ "Blue Anchor", "Crabtree Tavern", "Hammersmith Bridge" ],
    130                "...still works if whitespace-only search text supplied" );
    131 
    132     %tt_vars = $search->run(
    133                              return_tt_vars => 1,
    134                              vars => {
    135                                        os_x => 523450,
    136                                        os_y => 177650,
    137                                        latlong_dist => 1000,
    138                                        search => " ",
    139                                      },
    140                            );
    141     @ordered = map { $_->{name} } @{ $tt_vars{results} || [] };
    142     @found = sort @ordered;
    143     is_deeply( \@found,
    144                [ "Blue Anchor", "Crabtree Tavern", "Hammersmith Bridge" ],
    145                "...works with OS co-ords" );
    146 
    147     %tt_vars = eval {
    148                $search->run(
    149                              return_tt_vars => 1,
    150                              vars => {
    151                                        os_x => 523450,
    152                                        os_y => 177650,
    153                                        latlong_dist => 1000,
    154                                        search => " ",
    155                                        lat => " ",
    156                                        long => " ",
    157                                      },
    158                            );
    159     };
    160     is( $@, "", "...works with OS co-ords and whitespace-only lat/long" );
    161     @ordered = map { $_->{name} } @{ $tt_vars{results} || [] };
    162     @found = sort @ordered;
    163     is_deeply( \@found,
    164                [ "Blue Anchor", "Crabtree Tavern", "Hammersmith Bridge" ],
    165                  "...returns the right stuff" );
    166 
    167     %tt_vars = $search->run(
    168                              return_tt_vars => 1,
    169                              vars => {
    170                                        lat  => 51.484320,
    171                                        long => -0.223484,
    172                                        latlong_dist => 1000,
    173                                        search => "pubs",
    174                                      },
    175                            );
    176     @found = sort map { $_->{name} } @{ $tt_vars{results} || [] };
    177     is_deeply( \@found, [ "Blue Anchor", "Crabtree Tavern", ],
    178                "distance search in combination with text search works" );
    179 
    180     %tt_vars = $search->run(
    181                              return_tt_vars => 1,
    182                              vars => {
    183                                        os_x => 523450,
    184                                        os_y => 177650,
    185                                        latlong_dist => 1000,
    186                                        search => "pubs",
    187                                      },
    188                            );
    189     @found = sort map { $_->{name} } @{ $tt_vars{results} || [] };
    190     is_deeply( \@found, [ "Blue Anchor", "Crabtree Tavern", ],
    191                "...works with OS co-ords too" );
    192 }
     9if ( $@ ) {
     10    plan skip_all => "DBD::SQLite not installed";
     11}
     12
     13eval { require Plucene; };
     14if ( $@ ) {
     15    plan skip_all => "Plucene not installed";
     16}
     17
     18eval { require Geography::NationalGrid::GB; };
     19if ( $@ ) {
     20    plan skip_all => "Geography::NationalGrid::GB not installed";
     21}
     22
     23plan tests => 8;
     24
     25# Clear out the database from any previous runs.
     26unlink "t/node.db";
     27unlink <t/indexes/*>;
     28CGI::Wiki::Setup::SQLite::setup( { dbname => "t/node.db" } );
     29
     30my $config = Config::Tiny->new;
     31$config->{_} = {
     32                 dbtype             => "sqlite",
     33                 dbname             => "t/node.db",
     34                 indexing_directory => "t/indexes",
     35                 script_name        => "wiki.cgi",
     36                 script_url         => "http://example.com/",
     37                 site_name          => "Test Site",
     38                 template_path      => "./templates",
     39                 use_plucene        => 1,
     40                 geo_handler        => 1,
     41           };
     42my $search = OpenGuides::SuperSearch->new( config => $config );
     43my $guide = OpenGuides->new( config => $config );
     44
     45# Write some data.
     46write_data(
     47            guide      => $guide,
     48            node       => "Crabtree Tavern",
     49            os_x       => 523465,
     50            os_y       => 177490,
     51            categories => "Pubs",
     52          );
     53
     54write_data(
     55            guide      => $guide,
     56            node       => "Blue Anchor",
     57            os_x       => 522909,
     58            os_y       => 178232,
     59            categories => "Pubs",
     60          );
     61
     62write_data(
     63            guide      => $guide,
     64            node       => "Star Tavern",
     65            os_x       => 528107,
     66            os_y       => 179347,
     67            categories => "Pubs",
     68          );
     69
     70write_data(
     71            guide      => $guide,
     72            node       => "Hammersmith Bridge",
     73            os_x       => 522983,
     74            os_y       => 178118,
     75          );
     76
     77# Sanity check.
     78print "# Distances should be:\n";
     79my $locator = CGI::Wiki::Plugin::Locator::Grid->new(x => "os_x", y => "os_y");
     80my $wiki = $guide->wiki;
     81$wiki->register_plugin( plugin => $locator );
     82foreach my $node ( "Blue Anchor", "Crabtree Tavern", "Hammersmith Bridge"){
     83    print "# $node: " . $locator->distance( from_x  => 523450,
     84                                            from_y  => 177650,
     85                                            to_node => $node ) . "\n";
     86}
     87
     88# Check that a lat/long distance search finds them.
     89my %tt_vars = $search->run(
     90                            return_tt_vars => 1,
     91                            vars => {
     92                                      latitude     => 51.484320,
     93                                      longitude    => -0.223484,
     94                                      latlong_dist => 1000,
     95                                    },
     96                          );
     97my @ordered = map { $_->{name} } @{ $tt_vars{results} || [] };
     98my @found = sort @ordered;
     99is_deeply( \@found,
     100           [ "Blue Anchor", "Crabtree Tavern", "Hammersmith Bridge" ],
     101           "distance search finds the right things" );
     102is_deeply( \@ordered,
     103           [ "Crabtree Tavern", "Hammersmith Bridge", "Blue Anchor" ],
     104           "...and returns them in the right order" );
     105
     106%tt_vars = $search->run(
     107                         return_tt_vars => 1,
     108                         vars => {
     109                                   latitude     => 51.484320,
     110                                   longitude    => -0.223484,
     111                                   latlong_dist => 1000,
     112                                   search       => " ",
     113                                 },
     114                       );
     115@ordered = map { $_->{name} } @{ $tt_vars{results} || [] };
     116@found = sort @ordered;
     117is_deeply( \@found,
     118           [ "Blue Anchor", "Crabtree Tavern", "Hammersmith Bridge" ],
     119           "...still works if whitespace-only search text supplied" );
     120
     121%tt_vars = $search->run(
     122                         return_tt_vars => 1,
     123                         vars => {
     124                                   os_x    => 523450,
     125                                   os_y    => 177650,
     126                                   os_dist => 1000,
     127                                   search  => " ",
     128                                 },
     129                       );
     130@ordered = map { $_->{name} } @{ $tt_vars{results} || [] };
     131@found = sort @ordered;
     132is_deeply( \@found,
     133       [ "Blue Anchor", "Crabtree Tavern", "Hammersmith Bridge" ],
     134       "...works with OS co-ords" );
     135
     136%tt_vars = eval {
     137       $search->run(
     138                     return_tt_vars => 1,
     139                     vars => {
     140                               os_x      => 523450,
     141                               os_y      => 177650,
     142                               os_dist   => 1000,
     143                               search    => " ",
     144                               latitude  => " ",
     145                               longitude => " ",
     146                             },
     147                   );
     148};
     149is( $@, "", "...works with OS co-ords and whitespace-only lat/long" );
     150@ordered = map { $_->{name} } @{ $tt_vars{results} || [] };
     151@found = sort @ordered;
     152is_deeply( \@found,
     153       [ "Blue Anchor", "Crabtree Tavern", "Hammersmith Bridge" ],
     154         "...returns the right stuff" );
     155
     156%tt_vars = $search->run(
     157                     return_tt_vars => 1,
     158                     vars => {
     159                               latitude     => 51.484320,
     160                               longitude    => -0.223484,
     161                               latlong_dist => 1000,
     162                               search       => "pubs",
     163                             },
     164                   );
     165@found = sort map { $_->{name} } @{ $tt_vars{results} || [] };
     166is_deeply( \@found, [ "Blue Anchor", "Crabtree Tavern", ],
     167       "distance search in combination with text search works" );
     168
     169%tt_vars = $search->run(
     170                     return_tt_vars => 1,
     171                     vars => {
     172                               os_x    => 523450,
     173                               os_y    => 177650,
     174                               os_dist => 1000,
     175                               search  => "pubs",
     176                             },
     177                   );
     178@found = sort map { $_->{name} } @{ $tt_vars{results} || [] };
     179is_deeply( \@found, [ "Blue Anchor", "Crabtree Tavern", ],
     180       "...works with OS co-ords too" );
     181
     182
     183sub write_data {
     184    my %args = @_;
     185   
     186    # Set up CGI parameters ready for a node write.
     187    # Most of these are in here to avoid uninitialised value warnings.
     188    my $q = CGI->new( "" );
     189    $q->param( -name => "content", -value => "foo" );
     190    $q->param( -name => "categories", -value => $args{categories} || "" );
     191    $q->param( -name => "locales", -value => "" );
     192    $q->param( -name => "phone", -value => "" );
     193    $q->param( -name => "fax", -value => "" );
     194    $q->param( -name => "website", -value => "" );
     195    $q->param( -name => "hours_text", -value => "" );
     196    $q->param( -name => "address", -value => "" );
     197    $q->param( -name => "postcode", -value => "" );
     198    $q->param( -name => "map_link", -value => "" );
     199    $q->param( -name => "os_x", -value => $args{os_x} );
     200    $q->param( -name => "os_y", -value => $args{os_y} );
     201    $q->param( -name => "username", -value => "Kake" );
     202    $q->param( -name => "comment", -value => "foo" );
     203    $q->param( -name => "edit_type", -value => "Normal edit" );
     204    $ENV{REMOTE_ADDR} = "127.0.0.1";
     205   
     206    $args{guide}->commit_node(
     207                               return_output => 1,
     208                               id => $args{node},
     209                               cgi_obj => $q,
     210                             );
     211}
  • trunk/t/34_supersearch_paging.t

    r558 r559  
    88if ( $@ ) {
    99    plan skip_all => "DBD::SQLite not installed";
    10 } else {
    11     plan tests => 1;
     10}
    1211
    13     # Clear out the database from any previous runs.
    14     unlink "t/node.db";
    15     unlink <t/indexes/*>;
     12eval { require Plucene; };
     13if ( $@ ) {
     14    plan skip_all => "Plucene not installed";
     15}
    1616
    17     CGI::Wiki::Setup::SQLite::setup( { dbname => "t/node.db" } );
    18     my $config = Config::Tiny->new;
    19     $config->{_} = {
    20                      dbtype             => "sqlite",
    21                      dbname             => "t/node.db",
    22                      indexing_directory => "t/indexes",
    23                      script_name        => "wiki.cgi",
    24                      script_url         => "http://example.com/",
    25                      site_name          => "Test Site",
    26                      template_path      => "./templates",
    27                    };
     17eval { require Geography::NationalGrid::GB; };
     18if ( $@ ) {
     19    plan skip_all => "Geography::NationalGrid::GB not installed";
     20}
    2821
    29     # Plucene is the recommended searcher now.
    30     eval { require CGI::Wiki::Search::Plucene; };
    31     unless ( $@ ) {
    32         $config->{_}{use_plucene} = 1;
    33     }
     22plan tests => 1;
    3423
    35     my $search = OpenGuides::SuperSearch->new( config => $config );
    36     my $wiki = $search->wiki;
     24# Clear out the database from any previous runs.
     25unlink "t/node.db";
     26unlink <t/indexes/*>;
    3727
    38     foreach my $i ( 1 .. 30 ) {
    39         $wiki->write_node( "Crabtree Tavern $i",
    40                            "Nice pub on the riverbank.",
    41                            undef,
    42                            {
    43                              os_x      => 523465,
    44                              os_y      => 177490,
    45                              latitude  => 51.482385,
    46                              longitude => -0.221743,
    47                              category  => "Pubs",
    48                            }
    49                          ) or die "Couldn't write node";
    50     }
     28CGI::Wiki::Setup::SQLite::setup( { dbname => "t/node.db" } );
     29my $config = Config::Tiny->new;
     30$config->{_} = {
     31                 dbtype             => "sqlite",
     32                 dbname             => "t/node.db",
     33                 indexing_directory => "t/indexes",
     34                 script_name        => "wiki.cgi",
     35                 script_url         => "http://example.com/",
     36                 site_name          => "Test Site",
     37                 template_path      => "./templates",
     38                 use_plucene        => 1,
     39                 geo_handler        => 1,
     40               };
    5141
    52     my $output = $search->run(
     42my $search = OpenGuides::SuperSearch->new( config => $config );
     43my $guide = OpenGuides->new( config => $config );
     44
     45foreach my $i ( 1 .. 30 ) {
     46    write_data(
     47                guide      => $guide,
     48                node       => "Crabtree Tavern $i",
     49                os_x       => 523465,
     50                os_y       => 177490,
     51                categories => "Pubs",
     52              );
     53}
     54
     55my $output = $search->run(
     56                           return_output => 1,
     57                           vars          => {
     58                                              os_dist => 1500,
     59                                              os_x => 523500,
     60                                              os_y => 177500,
     61                                            },
     62                         );
     63like( $output, qr/supersearch.cgi\?.*os_x=523500.*Next.*results/s,
     64      "os_x retained in next page link" );
     65
     66
     67sub write_data {
     68    my %args = @_;
     69   
     70    # Set up CGI parameters ready for a node write.
     71    # Most of these are in here to avoid uninitialised value warnings.
     72    my $q = CGI->new( "" );
     73    $q->param( -name => "content", -value => "foo" );
     74    $q->param( -name => "categories", -value => $args{categories} || "" );
     75    $q->param( -name => "locales", -value => "" );
     76    $q->param( -name => "phone", -value => "" );
     77    $q->param( -name => "fax", -value => "" );
     78    $q->param( -name => "website", -value => "" );
     79    $q->param( -name => "hours_text", -value => "" );
     80    $q->param( -name => "address", -value => "" );
     81    $q->param( -name => "postcode", -value => "" );
     82    $q->param( -name => "map_link", -value => "" );
     83    $q->param( -name => "os_x", -value => $args{os_x} );
     84    $q->param( -name => "os_y", -value => $args{os_y} );
     85    $q->param( -name => "username", -value => "Kake" );
     86    $q->param( -name => "comment", -value => "foo" );
     87    $q->param( -name => "edit_type", -value => "Normal edit" );
     88    $ENV{REMOTE_ADDR} = "127.0.0.1";
     89   
     90    $args{guide}->commit_node(
    5391                               return_output => 1,
    54                                vars          => {
    55                                                   os_dist => 1500,
    56                                                   os_x => 523500,
    57                                                   os_y => 177500,
    58                                                 },
     92                               id => $args{node},
     93                               cgi_obj => $q,
    5994                             );
    60     like( $output, qr/supersearch.cgi\?.*os_x=523500.*Next.*results/s,
    61           "os_x retained in next page link" );
    6295}
  • trunk/t/35_supersearch_two_searches.t

    r558 r559  
    88if ( $@ ) {
    99    plan skip_all => "DBD::SQLite not installed";
    10 } else {
    11     plan tests => 2;
     10}
    1211
    13     # Clear out the database from any previous runs.
    14     unlink "t/node.db";
    15     unlink <t/indexes/*>;
     12# Strictly speaking we don't need to skip _all_ tests if we don't have
     13# the modules below.  Revisit this when not in a hurry.
     14# We only actually need the former for the National Grid tests and the
     15# latter for the UTM tests.
     16eval { require Geography::NationalGrid; };
     17if ( $@ ) {
     18    plan skip_all => "Geography::NationalGrid not installed";
     19}
    1620
    17     CGI::Wiki::Setup::SQLite::setup( { dbname => "t/node.db" } );
    18     my $config = Config::Tiny->new;
    19     $config->{_} = {
    20                      dbtype             => "sqlite",
    21                      dbname             => "t/node.db",
    22                      indexing_directory => "t/indexes",
    23                      script_name        => "wiki.cgi",
    24                      script_url         => "http://example.com/",
    25                      site_name          => "Test Site",
    26                      template_path      => "./templates",
    27                    };
     21eval { require Geo::Coordinates::UTM; };
     22if ( $@ ) {
     23    plan skip_all => "Geo::Coordinates::UTM not installed";
     24}
    2825
    29     # Plucene is the recommended searcher now.
    30     eval { require CGI::Wiki::Search::Plucene; };
    31     unless ( $@ ) {
    32         $config->{_}{use_plucene} = 1;
    33     }
     26plan tests => 10;
    3427
    35     my $search = OpenGuides::SuperSearch->new( config => $config );
     28# Clear out the database from any previous runs.
     29unlink "t/node.db";
     30unlink <t/indexes/*>;
    3631
    37     # Write some data.
    38     my $wiki = $search->{wiki};
    39     $wiki->write_node( "Wandsworth Common", "A common.", undef,
    40                        { category => "Parks" } )
    41         or die "Can't write node";
    42     $wiki->write_node( "Hammersmith", "A page about Hammersmith." )
    43         or die "Can't write node";
     32CGI::Wiki::Setup::SQLite::setup( { dbname => "t/node.db" } );
     33my $config = Config::Tiny->new;
     34$config->{_} = {
     35                 dbtype             => "sqlite",
     36                 dbname             => "t/node.db",
     37                 indexing_directory => "t/indexes",
     38                 script_name        => "wiki.cgi",
     39                 script_url         => "http://example.com/",
     40                 site_name          => "Test Site",
     41                 template_path      => "./templates",
     42                 geo_handler        => 1,
     43               };
    4444
    45     my (%tt_vars, @results);
    46     %tt_vars = $search->run(
    47                              return_tt_vars => 1,
    48                              vars           => { search => "parks" },
    49                            );
    50     @results = sort map { $_->{name} } @{ $tt_vars{results} || [] };
    51     is_deeply( \@results, [ "Wandsworth Common" ],
    52                "first search returns expected results" );
    53     %tt_vars = $search->run(
    54                              return_tt_vars => 1,
    55                              vars           => { search => "hammersmith" },
    56                            );
    57     @results = sort map { $_->{name} } @{ $tt_vars{results} || [] };
    58     is_deeply( \@results, [ "Hammersmith" ],
    59                "so does second" );
     45# Plucene is the recommended searcher now.
     46eval { require CGI::Wiki::Search::Plucene; };
     47unless ( $@ ) {
     48    $config->{_}{use_plucene} = 1;
     49}
    6050
    61 }
     51my $search = OpenGuides::SuperSearch->new( config => $config );
     52
     53# Write some data.
     54my $wiki = $search->{wiki};
     55$wiki->write_node( "Wandsworth Common", "A common.", undef,
     56                   { category => "Parks" } )
     57    or die "Can't write node";
     58$wiki->write_node( "Hammersmith", "A page about Hammersmith." )
     59    or die "Can't write node";
     60
     61# Check that the search forgets input search term between invocations.
     62$search->run(
     63              return_output => 1,
     64              vars          => { search => "parks" },
     65            );
     66ok( $search->{search_string}, "search_string set" );
     67$search->run(
     68              return_output => 1,
     69            );
     70ok( !$search->{search_string}, "...and forgotten" );
     71
     72# Sanity check.
     73my (@results, %tt_vars);
     74%tt_vars = $search->run(
     75                         return_tt_vars => 1,
     76                         vars           => { search => "parks" },
     77                       );
     78@results = sort map { $_->{name} } @{ $tt_vars{results} || [] };
     79is_deeply( \@results, [ "Wandsworth Common" ],
     80           "first search returns expected results" );
     81%tt_vars = $search->run(
     82                         return_tt_vars => 1,
     83                         vars           => { search => "hammersmith" },
     84                       );
     85@results = sort map { $_->{name} } @{ $tt_vars{results} || [] };
     86is_deeply( \@results, [ "Hammersmith" ],
     87           "so does second" );
     88
     89# Check that the search forgets input geodata between invocations.
     90# First with British National Grid.
     91$search->run(
     92              return_output => 1,
     93              vars => { os_x => 500000, os_y => 100000, os_dist => 1000 },
     94            );
     95ok( $search->{x}, "x-coord set" );
     96$search->run(
     97              return_output => 1,
     98              vars => { search => "foo" },
     99            );
     100ok( !$search->{x}, "...and forgotten" );
     101
     102# Now with Irish National Grid.
     103$config->{_}{geo_handler} = 2;
     104$search = OpenGuides::SuperSearch->new( config => $config );
     105$search->run(
     106              return_output => 1,
     107              vars => { osie_x => 100000, osie_y => 200000, osie_dist => 100 },
     108            );
     109ok( $search->{x}, "x-coord set" );
     110$search->run(
     111              return_output => 1,
     112              vars => { search => "foo" },
     113            );
     114ok( !$search->{x}, "...and forgotten" );
     115
     116# Now with UTM.
     117$config->{_}{geo_handler} = 3;
     118$config->{_}{ellipsoid} = "Airy";
     119$search = OpenGuides::SuperSearch->new( config => $config );
     120$search->run(
     121              return_output => 1,
     122              vars => { latitude => 10, longitude => 0, latlong_dist => 1000 },
     123            );
     124ok( $search->{x}, "x-coord set" );
     125$search->run(
     126              return_output => 1,
     127              vars => { search => "foo" },
     128            );
     129ok( !$search->{x}, "...and forgotten" );
     130
     131
  • trunk/t/38_supersearch_params.t

    r558 r559  
    1818}
    1919
    20 plan tests => 4;
     20# Strictly speaking we don't need to skip _all_ tests if we don't have
     21# the modules below.  Revisit this when not in a hurry.
     22# We only actually need them for the tests where lat/long are converted.
     23eval { require Geography::NationalGrid; };
     24if ( $@ ) {
     25    plan skip_all => "Geography::NationalGrid not installed";
     26}
     27
     28eval { require Geo::Coordinates::UTM; };
     29if ( $@ ) {
     30    plan skip_all => "Geo::Coordinates::UTM not installed";
     31}
     32
     33plan tests => 19;
    2134
    2235# Clear out the database from any previous runs.
     
    3447                 site_name          => "Test Site",
    3548                 template_path      => "./templates",
    36                  use_plucene        => 1
     49                 use_plucene        => 1,
     50                 geo_handler        => 1, # British National Grid
    3751               };
    3852
    39 # Check we get the right distance when we supply OS co-ords.
    40 my $search = OpenGuides::SuperSearch->new( config => $config );
    41 isa_ok( $search, "OpenGuides::SuperSearch" );
    42 
    43 my $q = CGI->new;
     53# Check the British National Grid case.
     54my $q = CGI->new( "" );
    4455$q->param( -name => "os_x",         -value => 500000 );
    4556$q->param( -name => "os_y",         -value => 200000 );
    4657$q->param( -name => "os_dist",      -value => 500    );
    47 $q->param( -name => "latlong_dist", -value => 600    );
     58$q->param( -name => "osie_dist",    -value => 600    );
     59$q->param( -name => "latlong_dist", -value => 700    );
    4860my %vars = $q->Vars();
    49 
     61my $search = OpenGuides::SuperSearch->new( config => $config );
    5062$search->run( vars => \%vars, return_output => 1 );
    5163is( $search->{distance_in_metres}, 500,
    52     "os_dist picked up in pref. to latlong_dist when OS co-ords given" );
    53 
    54 # Check we get the right distance when we supply lat/long.
    55 $search = OpenGuides::SuperSearch->new( config => $config );
    56 isa_ok( $search, "OpenGuides::SuperSearch" );
     64    "os_dist picked up when OS co-ords given and using British grid" );
     65is( $search->{x}, 500000, "...x set from os_x" );
     66is( $search->{y}, 200000, "...y set from os_y" );
    5767
    5868$q = CGI->new( "" );
    59 $q->param( -name => "lat",          -value => 51  );
    60 $q->param( -name => "long",         -value => 1   );
     69$q->param( -name => "osie_x",       -value => 500000 );
     70$q->param( -name => "osie_y",       -value => 200000 );
     71$q->param( -name => "os_dist",      -value => 500    );
     72$q->param( -name => "osie_dist",    -value => 600    );
     73$q->param( -name => "latlong_dist", -value => 700    );
     74%vars = $q->Vars();
     75$search = OpenGuides::SuperSearch->new( config => $config );
     76$search->run( vars => \%vars, return_output => 1 );
     77ok( !defined $search->{distance_in_metres},
     78    "OSIE co-ords ignored when using British grid" );
     79
     80$q = CGI->new( "" );
     81$q->param( -name => "latitude",     -value => 51  );
     82$q->param( -name => "longitude",    -value => 1   );
    6183$q->param( -name => "os_dist",      -value => 500 );
    62 $q->param( -name => "latlong_dist", -value => 600 );
     84$q->param( -name => "osie_dist",    -value => 600 );
     85$q->param( -name => "latlong_dist", -value => 700 );
    6386%vars = $q->Vars();
     87$search = OpenGuides::SuperSearch->new( config => $config );
     88$search->run( vars => \%vars, return_output => 1 );
     89is( $search->{distance_in_metres}, 700,
     90    "latlong_dist picked up when lat/long given and using British grid" );
     91ok( defined $search->{x}, "...x set" );
     92ok( defined $search->{y}, "...y set" );
    6493
     94
     95# Check the Irish National Grid case.
     96$config->{_}{geo_handler} = 2; # Irish National Grid
     97
     98$q = CGI->new( "" );
     99$q->param( -name => "osie_x",       -value => 500000 );
     100$q->param( -name => "osie_y",       -value => 200000 );
     101$q->param( -name => "os_dist",      -value => 500    );
     102$q->param( -name => "osie_dist",    -value => 600    );
     103$q->param( -name => "latlong_dist", -value => 700    );
     104%vars = $q->Vars();
     105$search = OpenGuides::SuperSearch->new( config => $config );
    65106$search->run( vars => \%vars, return_output => 1 );
    66107is( $search->{distance_in_metres}, 600,
    67     "latlong_dist picked up in pref. to os_dist when lat/long given" );
     108    "osie_dist picked up when OS co-ords given and using Irish grid" );
     109is( $search->{x}, 500000, "...x set from osie_x" );
     110is( $search->{y}, 200000, "...y set from osie_y" );
     111
     112$q = CGI->new( "" );
     113$q->param( -name => "os_x",         -value => 500000 );
     114$q->param( -name => "os_y",         -value => 200000 );
     115$q->param( -name => "os_dist",      -value => 500    );
     116$q->param( -name => "osie_dist",    -value => 600    );
     117$q->param( -name => "latlong_dist", -value => 700    );
     118%vars = $q->Vars();
     119$search = OpenGuides::SuperSearch->new( config => $config );
     120$search->run( vars => \%vars, return_output => 1 );
     121ok( !defined $search->{distance_in_metres},
     122    "OS co-ords ignored when using Irish grid" );
     123
     124$q = CGI->new( "" );
     125$q->param( -name => "latitude",     -value => 55  );
     126$q->param( -name => "longitude",    -value => -5  );
     127$q->param( -name => "os_dist",      -value => 500 );
     128$q->param( -name => "osie_dist",    -value => 600 );
     129$q->param( -name => "latlong_dist", -value => 700 );
     130%vars = $q->Vars();
     131$search = OpenGuides::SuperSearch->new( config => $config );
     132$search->run( vars => \%vars, return_output => 1 );
     133is( $search->{distance_in_metres}, 700,
     134    "latlong_dist picked up when lat/long given and using Irish grid" );
     135ok( defined $search->{x}, "...x set" );
     136ok( defined $search->{y}, "...y set" );
     137
     138
     139# Check the UTM case.
     140$config->{_}{geo_handler} = 3; # UTM
     141$config->{_}{ellipsoid} = "Airy";
     142
     143$q = CGI->new( "" );
     144$q->param( -name => "os_x",         -value => 500000 );
     145$q->param( -name => "os_y",         -value => 200000 );
     146$q->param( -name => "os_dist",      -value => 500    );
     147$q->param( -name => "osie_dist",    -value => 600    );
     148$q->param( -name => "latlong_dist", -value => 700    );
     149%vars = $q->Vars();
     150$search = OpenGuides::SuperSearch->new( config => $config );
     151$search->run( vars => \%vars, return_output => 1 );
     152ok( !defined $search->{distance_in_metres},
     153    "OS co-ords ignored when using UTM" );
     154
     155$q = CGI->new( "" );
     156$q->param( -name => "osie_x",       -value => 500000 );
     157$q->param( -name => "osie_y",       -value => 200000 );
     158$q->param( -name => "os_dist",      -value => 500    );
     159$q->param( -name => "osie_dist",    -value => 600    );
     160$q->param( -name => "latlong_dist", -value => 700    );
     161%vars = $q->Vars();
     162$search = OpenGuides::SuperSearch->new( config => $config );
     163$search->run( vars => \%vars, return_output => 1 );
     164ok( !defined $search->{distance_in_metres},
     165    "OSIE co-ords ignored when using UTM" );
     166
     167$q = CGI->new( "" );
     168$q->param( -name => "latitude",     -value => 51  );
     169$q->param( -name => "longitude",    -value => 1   );
     170$q->param( -name => "os_dist",      -value => 500 );
     171$q->param( -name => "osie_dist",    -value => 600 );
     172$q->param( -name => "latlong_dist", -value => 700 );
     173%vars = $q->Vars();
     174$search = OpenGuides::SuperSearch->new( config => $config );
     175$search->run( vars => \%vars, return_output => 1 );
     176is( $search->{distance_in_metres}, 700,
     177    "latlong_dist picked up when lat/long given and using UTM" );
     178ok( defined $search->{x}, "...x set" );
     179ok( defined $search->{y}, "...y set" );
  • trunk/t/62_bug_os_coords.t

    r558 r559  
    2323                     site_name          => "Test Site",
    2424                     template_path      => cwd . "/templates",
     25                     geo_handler        => 1,
    2526                   };
    2627
  • trunk/t/66_bug_latlong_representation.t

    r558 r559  
    1010if ( $@ ) {
    1111    plan skip_all => "DBD::SQLite not installed";
    12 } else {
    13     plan tests => 4;
     12}
    1413
    15     # Clear out the database from any previous runs.
    16     unlink "t/node.db";
    17     unlink <t/indexes/*>;
     14eval { require Geo::Coordinates::UTM; };
     15if ( $@ ) {
     16    plan skip_all => "Geo::Coordinates::UTM not installed";
     17}
    1818
    19     CGI::Wiki::Setup::SQLite::setup( { dbname => "t/node.db" } );
    20     my $config = Config::Tiny->new;
    21     $config->{_} = {
    22                      dbtype             => "sqlite",
    23                      dbname             => "t/node.db",
    24                      indexing_directory => "t/indexes",
    25                      script_name        => "wiki.cgi",
    26                      script_url         => "http://example.com/",
    27                      site_name          => "Test Site",
    28                      template_path      => "./templates",
    29                      home_name          => "Home",
    30                    };
     19plan tests => 4;
    3120
    32     # Plucene is the recommended searcher now.
    33     eval { require CGI::Wiki::Search::Plucene; };
    34     unless ( $@ ) {
    35         $config->{_}{use_plucene} = 1;
    36     }
     21# Clear out the database from any previous runs.
     22unlink "t/node.db";
     23unlink <t/indexes/*>;
    3724
    38     my $guide = OpenGuides->new( config => $config );
     25CGI::Wiki::Setup::SQLite::setup( { dbname => "t/node.db" } );
     26my $config = Config::Tiny->new;
     27$config->{_} = {
     28                 dbtype             => "sqlite",
     29                 dbname             => "t/node.db",
     30                 indexing_directory => "t/indexes",
     31                 script_name        => "wiki.cgi",
     32                 script_url         => "http://example.com/",
     33                 site_name          => "Test Site",
     34                 template_path      => "./templates",
     35                 home_name          => "Home",
     36                 geo_handler        => 3, # Test w/ UTM - nat grids use X/Y
     37                 ellipsoid          => "Airy",
     38               };
    3939
    40     # Set preferences to have lat/long displayed in deg/min/sec.
    41     my $cookie = OpenGuides::CGI->make_prefs_cookie(
    42         config                     => $config,
    43         username                   => "Kake",
    44         include_geocache_link      => 1,
    45         preview_above_edit_box     => 1,
    46         latlong_traditional        => 1,  # this is the important bit
    47         omit_help_links            => 1,
    48         show_minor_edits_in_rc     => 1,
    49         default_edit_type          => "tidying",
    50         cookie_expires             => "never",
    51         track_recent_changes_views => 1,
    52     );
    53     $ENV{HTTP_COOKIE} = $cookie;
     40# Plucene is the recommended searcher now.
     41eval { require CGI::Wiki::Search::Plucene; };
     42unless ( $@ ) {
     43    $config->{_}{use_plucene} = 1;
     44}
    5445
     46my $guide = OpenGuides->new( config => $config );
     47
     48# Set preferences to have lat/long displayed in deg/min/sec.
     49my $cookie = OpenGuides::CGI->make_prefs_cookie(
     50    config                     => $config,
     51    username                   => "Kake",
     52    include_geocache_link      => 1,
     53    preview_above_edit_box     => 1,
     54    latlong_traditional        => 1,  # this is the important bit
     55    omit_help_links            => 1,
     56    show_minor_edits_in_rc     => 1,
     57    default_edit_type          => "tidying",
     58    cookie_expires             => "never",
     59    track_recent_changes_views => 1,
     60);
     61$ENV{HTTP_COOKIE} = $cookie;
     62
     63write_data(
     64            guide      => $guide,
     65            node       => "Test Page",
     66            latitude   => 51.368,
     67            longitude  => -0.0973,
     68          );
     69
     70my %data = $guide->wiki->retrieve_node( "Test Page" );
     71my $lat = $data{metadata}{latitude}[0];
     72unlike( $lat, qr/d/,
     73    "lat not stored in dms format even if prefs set to display that way" );
     74
     75# Check the distance search form has unmunged lat/long.
     76my $output = $guide->display_node(
     77                                   return_output => 1,
     78                                   id => "Test Page",
     79                                 );
     80unlike( $output, qr/name="latitude"\svalue="[-0-9]*d/,
     81        "latitude in non-dms format in distance search form" );
     82
     83# Now write a node with no location data, and check that it doesn't
     84# claim to have any when we display it.
     85eval {
     86    local $SIG{__WARN__} = sub { die $_[0]; };
     87    write_data(
     88                guide      => $guide,
     89                node       => "Locationless Page",
     90              );
     91};
     92is( $@, "",
     93    "commit doesn't warn when prefs say dms format and node has no loc data" );
     94
     95$output = $guide->display_node(
     96                                return_output => 1,
     97                                id => "Locationless Page",
     98                              );
     99unlike( $output, qr/latitude:/i,
     100        "node with no location data doesn't display a latitude" );
     101
     102
     103
     104sub write_data {
     105    my %args = @_;
     106   
    55107    # Set up CGI parameters ready for a node write.
    56108    # Most of these are in here to avoid uninitialised value warnings.
    57     my $q = CGI->new;
     109    my $q = CGI->new( "" );
    58110    $q->param( -name => "content", -value => "foo" );
    59     $q->param( -name => "categories", -value => "" );
     111    $q->param( -name => "categories", -value => $args{categories} || "" );
    60112    $q->param( -name => "locales", -value => "" );
    61113    $q->param( -name => "phone", -value => "" );
     
    66118    $q->param( -name => "postcode", -value => "" );
    67119    $q->param( -name => "map_link", -value => "" );
    68     $q->param( -name => "os_x", -value => "532125" );   # these two lines are
    69     $q->param( -name => "os_y", -value => "165504" );   # the important ones
     120    $q->param( -name => "os_x", -value => $args{os_x} || "" );
     121    $q->param( -name => "os_y", -value => $args{os_y} || "" );
     122    $q->param( -name => "osie_x", -value => $args{osie_x} || "" );
     123    $q->param( -name => "osie_y", -value => $args{osie_y} || "" );
     124    $q->param( -name => "latitude", -value => $args{latitude} || "" );
     125    $q->param( -name => "longitude", -value => $args{longitude} || "" );
    70126    $q->param( -name => "username", -value => "Kake" );
    71127    $q->param( -name => "comment", -value => "foo" );
    72     $q->param( -name => "edit_type", -value => "Minor tidying" );
     128    $q->param( -name => "edit_type", -value => "Normal edit" );
    73129    $ENV{REMOTE_ADDR} = "127.0.0.1";
    74 
    75     # Write a node.
    76     my $output = $guide->commit_node(
    77                                       return_output => 1,
    78                                       id => "Test Page",
    79                                       cgi_obj => $q,
    80                                     );
    81 
    82     # Read it.
    83     my %data = $guide->wiki->retrieve_node( "Test Page" );
    84     my $lat = $data{metadata}{latitude}[0];
    85     unlike( $lat, qr/d/,
    86         "lat not stored in dms format even if prefs set to display that way" );
    87 
    88     # Look at it, check the distance search form has unmunged lat/long.
    89     $output = $guide->display_node(
    90                                     return_output => 1,
    91                                     id => "Test Page",
    92                                   );
    93     unlike( $output, qr/name="lat"\svalue="[-0-9]*d/,
    94             "lat in non-dms format in distance search form" );
    95 
    96     # Now write a node with no location data, and check that it doesn't
    97     # claim to have any when we display it.
    98     $q->param( -name => "os_x", -value => "" );
    99     $q->param( -name => "os_y", -value => "" );
    100     eval {
    101         local $SIG{__WARN__} = sub { die $_[0]; };
    102         $output = $guide->commit_node(
    103                                        return_output => 1,
    104                                        id => "Locationless Page",
    105                                        cgi_obj => $q,
    106                                      );
    107     };
    108     is( $@, "",
    109     "commit doesn't warn when prefs say dms format and node has no loc data" );
    110 
    111     $output = $guide->display_node(
    112                                     return_output => 1,
    113                                     id => "Locationless Page",
    114                                   );
    115     unlike( $output, qr/latitude:/i,
    116             "node with no location data doesn't display a latitude" );
     130   
     131    $args{guide}->commit_node(
     132                               return_output => 1,
     133                               id => $args{node},
     134                               cgi_obj => $q,
     135                             );
    117136}
  • trunk/templates/edit_form.tt

    r558 r559  
    8383            </tr>
    8484            <tr>
    85               <td class="label"><label for="os_x">OS X coordinate:</label></td>
    86               <td><input type="text" size="50" id="os_x" name="os_x" value="[% os_x %]" /></td>
     85              <td class="label"><label for="[% coord_field_1 %]">[% coord_field_1_name %]:</label></td>
     86              <td><input type="text" size="50" id="[% coord_field_1 %]" name="[% coord_field_1 %]" value="[% coord_field_1_value %]" /></td>
    8787            </tr>
    8888            <tr>
    89               <td class="label"><label for="os_y">OS Y coordinate:</label></td>
    90               <td><input type="text" size="50" id="os_y" name="os_y" value="[% os_y %]" /></td>
     89              <td class="label"><label for="[% coord_field_2 %]">[% coord_field_2_name %]:</label></td>
     90              <td><input type="text" size="50" id="[% coord_field_2 %]" name="[% coord_field_2 %]" value="[% coord_field_2_value %]" /></td>
    9191            </tr>
    9292            <tr>
  • trunk/templates/node.tt

    r558 r559  
    2121<!-- NODE CONTENT ENDS -->
    2222
    23 [% IF latitude AND longitude %]
    24 <br clear="all" />
    25 <div id="find_within_distance">
    26   <form action="supersearch.cgi">
    27     <label for="distance">Find all things within</label>
    28     <select name="latlong_dist" id="distance">
    29       <option value="500">500 metres</option>
    30       <option value="1000">1 kilometre</option>
    31       <option value="1500">1.5 kilometres</option>
    32       <option value="2000">2 kilometres</option>
    33     </select>
    34     of here.
    35     <input type="hidden" name="lat" value="[% IF latitude_unmunged %][% latitude_unmunged %][% ELSE %][% latitude %][% END %]" />
    36     <input type="hidden" name="long" value="[% IF longitude_unmunged %][% longitude_unmunged %][% ELSE %][% longitude %][% END %]" />
    37     <input type="submit" name="Go" value="Go" class="form_button" />
    38   </form>
    39 </div>
     23[% IF coord_field_1_value AND coord_field_2_value %]
     24  <br clear="all" />
     25  <div id="find_within_distance">
     26    <form action="supersearch.cgi">
     27      <label for="distance">Find all things within</label>
     28      <select name="[% dist_field %]" id="distance">
     29        <option value="500">500 metres</option>
     30        <option value="1000">1 kilometre</option>
     31        <option value="1500">1.5 kilometres</option>
     32        <option value="2000">2 kilometres</option>
     33      </select>
     34      of here.
     35      <input type="hidden" name="[% coord_field_1 %]" value="[% coord_field_1_value %]" />
     36      <input type="hidden" name="[% coord_field_2 %]" value="[% coord_field_2_value %]" />
     37      <input type="submit" name="Go" value="Go" class="form_button" />
     38    </form>
     39  </div>
    4040[% END %]
    4141[% IF (latitude AND longitude) OR (os_x AND os_y) %]
  • trunk/templates/supersearch.tt

    r558 r559  
    3939        <td>
    4040          <ul>
     41            [% IF coord_field_1 == 'os_x' OR coord_field_1 == 'osie_x' %]
     42              <li>
     43                within <input type="text" name="[% dist_field %]" value="[% dist %]" size="5" maxlength="5" /> metres
     44                of [% coord_field_1_name %]
     45                <input type="text" name="[% coord_field_1 %]" value="[% coord_field_1_value %]" size="10" maxlength="10" />,
     46                [% coord_field_2_name %]
     47                <input type="text" name="[% coord_field_2 %]" value="[% coord_field_2_value %]" size="10" maxlength="10" />
     48              </li>
     49            [% END %]
    4150            <li>
    4251              within <input type="text" name="latlong_dist" value="[% dist %]" size="5" maxlength="5" /> metres
    43               of latitude <input type="text" name="lat" value="[% lat %]" size="10" maxlength="10" />
    44               longitude <input type="text" name="long" value="[% long %]" size="10" maxlength="10" />
    45             </li>
    46             <li>
    47               within <input type="text" name="os_dist" value="[% dist %]" size="5" maxlength="5" /> metres
    48               of OS co-ordinates
    49               <input type="text" name="os_x" value="[% os_x %]" size="10" maxlength="10" />,
    50               <input type="text" name="os_y" value="[% os_y %]" size="10" maxlength="10" />
     52              of latitude <input type="text" name="latitude" value="[% latitude %]" size="10" maxlength="10" />
     53              longitude <input type="text" name="longitude" value="[% longitude %]" size="10" maxlength="10" />
    5154            </li>
    5255          </ul>
  • trunk/wiki.cgi

    r558 r559  
    181181
    182182    my %tt_metadata_vars = OpenGuides::Template->extract_metadata_vars(
    183                                                    wiki    => $wiki,
    184                                                    config  => $config,
    185                                                    cgi_obj => $q );
     183                                               wiki                 => $wiki,
     184                                               config               => $config,
     185                                               cgi_obj              => $q,
     186                                               set_coord_field_vars => 1,
     187    );
    186188    foreach my $var ( qw( username comment edit_type ) ) {
    187189        $tt_metadata_vars{$var} = $q->escapeHTML($q->param($var));
Note: See TracChangeset for help on using the changeset viewer.