Changeset 559

Timestamp:

11/23/04 23:19:36 (4 years ago)

Author:

kake

Message:

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

Location:

trunk

Files:

• Build.PL (modified) (4 diffs)
• Changes (modified) (1 diff)
• INSTALL (modified) (2 diffs)
• PREREQUISITES (modified) (2 diffs)
• lib/OpenGuides.pm (modified) (4 diffs)
• lib/OpenGuides/SuperSearch.pm (modified) (9 diffs)
• lib/OpenGuides/Template.pm (modified) (4 diffs)
• t/25_write_geo_data.t (added)
• t/26_geo_data_search_form.t (added)
• t/27_geo_data_edit_form.t (added)
• t/33_supersearch_advanced_search.t (modified) (1 diff)
• t/33_supersearch_advanced_search_utm.t (added)
• t/34_supersearch_paging.t (modified) (1 diff)
• t/35_supersearch_two_searches.t (modified) (1 diff)
• t/38_supersearch_params.t (modified) (2 diffs)
• t/39_supersearch_form.t (added)
• t/62_bug_os_coords.t (modified) (1 diff)
• t/66_bug_latlong_representation.t (modified) (2 diffs)
• templates/edit_form.tt (modified) (1 diff)
• templates/node.tt (modified) (1 diff)
• templates/supersearch.tt (modified) (1 diff)
• wiki.cgi (modified) (1 diff)

trunk/Build.PL

@@ -90 +90 @@
   default  => "United Kingdom"
   },
+{ question => "Contact email address for the site administrator?",
+  variable => "contact_email"
+  },
 { question => "What language will the site be in? (Please give an ISO language code.)",
   variable => "default_language",
   default  => "en"
-  },
-{ question => "Contact email address for the site administrator?",
-  variable => "contact_email"
   },
 { question => "What's the name of the node to use for the text formatting rules link?",
@@ -219 +219 @@
 }
 
+# Now deal with the geo stuff.
+my $geo_handler;
+my $geo_handler_qu = "Distance calculation methods available are:"
+                   . "\n  1) British National Grid"
+                   . "\n  2) Irish National Grid"
+                   . "\n  3) UTM ellipsoid"
+                   . "\nWhich would you like to use?";
+
+if ( $skip_config ) {
+    # We default to GB National Grid for historical reasons.
+    $geo_handler = $existing_config{geo_handler} || 1;
+} else {
+    my $choice;
+    until ( $choice ) {
+        my $def = $existing_config{geo_handler} || 1;
+        $choice = Module::Build->prompt("\n".$geo_handler_qu, $def);
+        $choice =~ s/^\s*//;
+        $choice =~ s/\s*$//;
+        unless ( $choice eq "1" or $choice eq "2" or $choice eq "3" ) {
+            undef $choice;
+        }
+    }
+    $geo_handler = $choice;
+}
+
+$geo_handler_qu =~ s/\n//gs;
+push @answers, {
+                 question => $geo_handler_qu,
+                 variable => "geo_handler",
+                 value    => $geo_handler,
+               };
+
+if ( $geo_handler eq "3" ) {
+    my $ellipsoid;
+    if ( $skip_config ) {
+        $ellipsoid = $existing_config{ellipsoid} || "International";
+    } else {
+        my $qu = "Which ellipsoid do you want to use? (eg 'Airy', 'WGS-84')";
+        my $def = $existing_config{ellipsoid} || "International";
+        my $choice = Module::Build->prompt("\n".$qu, $def);
+        $choice =~ s/^\s*//;
+        $choice =~ s/\s*$//;
+        push @answers, {
+                         question => $qu,
+                         variable => "ellipsoid",
+                         value    => $choice,
+                       };
+    }
+}
+
 # Create a user-friendly config file from answers to prompts.
 open FILE, ">wiki.conf" or die "Can't open wiki.conf for writing: $!";
@@ -245 +295 @@
         'CGI::Wiki::Plugin::Categoriser'  => 0,
         'CGI::Wiki::Plugin::Diff'         => '0.07', # earlier buggy
-        'CGI::Wiki::Plugin::Locator::UK'  => '0.09',
+        'CGI::Wiki::Plugin::Locator::Grid'=> 0,
         'CGI::Wiki::Plugin::RSS::ModWiki' => '0.06', # for fancy stuff
         'CGI::Wiki::Plugin::RSS::Reader'  => '1.3',  # earlier versions don't support RSS 2.0
@@ -265 +315 @@
         'Module::Build' => '0.18', # earlier doesn't install script files
         },
+    recommends => {
+        'DBD::SQLite'         => 0, # for testing
+        'Test::HTML::Content' => 0, # for testing, oddly enough
+    },
     dynamic_config => 1,
     create_makefile_pl => "passthrough"

trunk/Changes

@@ -1 @@
-        Fixed bug relating to lat/long representation.
-        Removed debugging warn accidentally left in last release.
+
+        Made the geolocation stuff work worldwide.  Squeeeeeee!
+        You can now choose between doing your distance calculations with
+          the British National Grid, the Irish National Grid, or a UTM
+          ellipsoid.  If you wish to use anything other than the British
+          National Grid and you have pre-existing location data then you
+          will need to save an edit of each node with location data before
+          distance searches will work.
+        In less exciting news:
+          Fixed bug relating to lat/long representation.
+          Removed debugging warn accidentally left in last release.
+          Fixed some HTML validation errors.
 
 0.44    17 November 2004

trunk/INSTALL

@@ -155 +155 @@
 
 
+  "What language will the site be in? (Please give an ISO language code.)"
+
+eg "en" for English, "it" for Italian.
+See http://ftp.ics.uci.edu/pub/ietf/http/related/iso639.txt
+
+
   "What's the name of the node to use for the text formatting rules link?"
 
@@ -162 +168 @@
 might want to call the node "Text Formatting Examples", "Text
 Formatting Rules", "House Style" or whatever.
+
+
+  "Distance calculation methods available are:
+      1) British National Grid
+      2) Irish National Grid
+      3) UTM ellipsoid
+   Which would you like to use?"
+
+  (and if you choose UTM ellipsoid)
+  "Which ellipsoid would you like to use? (eg 'Airy', 'WGS-84')"
+
+See http://www.vterrain.org/Projections/ for how this all works.
+A UTM (Universal Transverse Mercator) ellipsoid maps latitude and
+longitude to eastings and northings on a square grid, which allows
+more accurate distance calculations within the guide.  The British and
+Irish National Grids are scaled and parametrised versions of UTM
+ellipsoids (Airy 1830 in the British case, Modified Airy in the Irish).
+
+Please note that at the moment there is no provision for changing your
+mind later about which ellipsoid to use, but it shouldn't be too hard
+to write a conversion script so don't worry too much about picking the
+wrong one.  However do note that once you've entered some location
+data you should not change this value in the config file without running
+some kind of converter.
+
+If you decide to use the British or Irish National Grid, your users
+will be able to choose between entering location data as lat/long
+or as grid co-ordinates.
+
+You must have Geography::NationalGrid::GB installed to use the British
+National Grid, Geography::NationalGrid::IE to use the Irish National
+Grid, and Geo::Coordinates::UTM to use a UTM ellipsoid.
+
 
 * Custom templates and CSS

trunk/PREREQUISITES

@@ -10 +10 @@
 CGI::Wiki::Plugin::Categoriser
 CGI::Wiki::Plugin::Diff (version 0.07 or later)
-CGI::Wiki::Plugin::Locator::UK (version 0.09 or later)
+CGI::Wiki::Plugin::Locator::Grid
 CGI::Wiki::Plugin::RSS::ModWiki (version 0.06 or later)
 CGI::Wiki::Plugin::RSS::Reader (version 1.3 or later)
@@ -23 +23 @@
 )
 File::Spec::Functions
-Geography::NationalGrid
+(
+  Geography::NationalGrid::GB
+    -- or --
+  Geography::NationalGrid::IE
+    -- or --
+  Geo::Coordinates::UTM
+)
 LWP::Simple
 Module::Build (version 0.18 or later)

trunk/lib/OpenGuides.pm

@@ -5 +5 @@
 use CGI;
 use CGI::Wiki::Plugin::Diff;
-use CGI::Wiki::Plugin::Locator::UK;
+use CGI::Wiki::Plugin::Locator::Grid;
 use OpenGuides::CGI;
 use OpenGuides::Template;
@@ -46 +46 @@
     $self->{wiki} = $wiki;
     $self->{config} = $args{config};
-    my $locator = CGI::Wiki::Plugin::Locator::UK->new;
+    # Default to British National Grid for historical reasons.
+    my $geo_handler = $self->config->{_}{geo_handler} || 1;
+    my $locator;
+    if ( $geo_handler == 1 ) {
+        $locator = CGI::Wiki::Plugin::Locator::Grid->new(
+                                             x => "os_x",    y => "os_y" );
+    } elsif ( $geo_handler == 2 ) {
+        $locator = CGI::Wiki::Plugin::Locator::Grid->new(
+                                             x => "osie_x",  y => "osie_y" );
+    } else {
+        $locator = CGI::Wiki::Plugin::Locator::Grid->new(
+                                             x => "easting", y => "northing" );
+    }
     $wiki->register_plugin( plugin => $locator );
     $self->{locator} = $locator;
@@ -183 +195 @@
                  language      => $config->{_}->{default_language},
                );
-
 
     # We've undef'ed $version above if this is the current version.
@@ -574 +585 @@
 printing the output to STDOUT.
 
+The geographical data that you should provide in the L<CGI> object
+depends on the handler you chose in C<wiki.conf>.
+
+=over
+
+=item *
+
+B<British National Grid> - provide either C<os_x> and C<os_y> or
+C<latitude> and C<longitude>; whichever set of data you give, it will
+be converted to the other and both sets will be stored.
+
+=item *
+
+B<Irish National Grid> - provide either C<osie_x> and C<osie_y> or
+C<latitude> and C<longitude>; whichever set of data you give, it will
+be converted to the other and both sets will be stored.
+
+=item *
+
+B<UTM ellipsoid> - provide C<latitude> and C<longitude>; these will be
+converted to easting and northing and both sets of data will be stored.
+
+=back
+
 =cut
 

trunk/lib/OpenGuides/SuperSearch.pm

@@ -1 +1 @@
 package OpenGuides::SuperSearch;
 use strict;
-our $VERSION = '0.08';
+our $VERSION = '0.09';
 
 use CGI qw( :standard );
-use CGI::Wiki::Plugin::Locator::UK;
+use CGI::Wiki::Plugin::Locator::Grid;
 use File::Spec::Functions qw(:ALL);
 use OpenGuides::Template;
@@ -55 +55 @@
     $self->{head}     = $config->{_}{site_name} . " Search";
 
-    my $locator = CGI::Wiki::Plugin::Locator::UK->new;
+    my $geo_handler = $config->{_}{geo_handler};
+    my %locator_params;
+    if ( $geo_handler == 1 ) {
+        %locator_params = ( x => "os_x", y => "os_y" );
+    } elsif ( $geo_handler == 2 ) {
+        %locator_params = ( x => "osie_x", y => "osie_y" );
+    } elsif ( $geo_handler == 3 ) {
+        %locator_params = ( x => "easting", y => "northing" );
+    }
+
+    my $locator = CGI::Wiki::Plugin::Locator::Grid->new( %locator_params );
     $wiki->register_plugin( plugin => $locator );
     $self->{locator} = $locator;
@@ -142 +152 @@
     # Run a distance search if we have sufficient criteria.
     if ( defined $self->{distance_in_metres}
-         && (
-                 ( defined $self->{lat}  && defined $self->{long} )
-              || ( defined $self->{os_x} && defined $self->{os_y} )
-            )
-       ) {
+         && defined $self->{x} && defined $self->{y} ) {
         $doing_search = 1;
         $tt_vars{dist} = $self->{distance_in_metres};
-        foreach my $param ( qw( os_x os_y lat long ) ) {
+        foreach my $param ( qw( os_x os_y osie_x osie_y latitude longitude )) {
             $tt_vars{$param} = $self->{$param};
         }
@@ -469 +475 @@
 }
 
+=back
+
+=head1 SEARCHING BY DISTANCE
+
+To perform a distance search, you need to supply one of the following
+sets of criteria to specify the distance to search within, and the
+origin (centre) of the search:
+
+=over
+
+=item B<os_dist, os_x, and os_y>
+
+Only works if you chose to use British National Grid in wiki.conf
+
+=item B<osie_dist, osie_x, and osie_y>
+
+Only works if you chose to use Irish National Grid in wiki.conf
+
+=item B<latlong_dist, latitude, and longitude>
+
+Should always work, but has a habit of "finding" things a couple of
+metres away from themselves.
+
+=back
+
+You can perform both pure distance searches and distance searches in
+combination with text searches.
+
+=cut
+
 # Note this is called after any text search is run, and it is only called
 # if there are sufficient criteria to perform the search.
 sub run_distance_search {
     my $self = shift;
-    my $os_x = $self->{os_x};
-    my $os_y = $self->{os_y};
-    my $lat  = $self->{lat};
-    my $long = $self->{long};
+    my $x    = $self->{x};
+    my $y    = $self->{y};
     my $dist = $self->{distance_in_metres};
 
-    my @close;
-    if ( defined $lat && defined $long ) {
-        @close = $self->{locator}->find_within_distance(
-                                                         lat    => $lat,
-                                                         long   => $long,
-                                                         metres => $dist,
-                                                       );
-    } else {
-        @close = $self->{locator}->find_within_distance(
-                                                         os_x   => $os_x,
-                                                         os_y   => $os_y,
-                                                         metres => $dist,
-                                                       );
-    }
+    my @close = $self->{locator}->find_within_distance(
+                                                        x      => $x,
+                                                        y      => $y,
+                                                        metres => $dist,
+                                                      );
+
     if ( $self->{results} ) {
         my %close_hash = map { $_ => 1 } @close;
@@ -501 +527 @@
                 my $distance = $self->_get_distance(
                                                      node => $node,
-                                                     lat  => $lat,
-                                                     long => $long,
-                                                     os_x => $os_x,
-                                                     os_y => $os_y,
+                                                     x    => $x,
+                                                     y    => $y,
                                                    );
                 $results{$node}{distance} = $distance;
@@ -517 +541 @@
             my $distance = $self->_get_distance (
                                                      node => $node,
-                                                     lat  => $lat,
-                                                     long => $long,
-                                                     os_x => $os_x,
-                                                     os_y => $os_y,
+                                                     x    => $x,
+                                                     y    => $y,
                                                    );
             $results{$node} = {
@@ -534 +556 @@
 sub _get_distance {
     my ($self, %args) = @_;
-    my ($node, $lat, $long, $x, $y) = @args{ qw( node lat long os_x os_y ) };
-    if ( defined $lat && defined $long ) {
-        return $self->{locator}->distance(
-                                           from_lat  => $lat,
-                                           from_long => $long,
-                                           to_node   => $node,
-                                           unit      => "metres"
-                                         );
-    } else {
-        return $self->{locator}->distance(
-                                           from_os_x => $x,
-                                           from_os_y => $y,
-                                           to_node   => $node,
-                                           unit      => "metres"
-                                         );
-    }
+    my ($node, $x, $y) = @args{ qw( node x y ) };
+    return $self->{locator}->distance(
+                                       from_x  => $x,
+                                       from_y  => $y,
+                                       to_node => $node,
+                                       unit    => "metres"
+                                     );
 }
 
@@ -556 +569 @@
     my %vars = %{ $vars_hashref || {} };
 
+    # Make sure that we don't have any data left over from previous invocation.
+    # This is useful for testing purposes at the moment and will be essential
+    # for mod_perl implementations.
+    delete $self->{x};
+    delete $self->{y};
+    delete $self->{distance_in_metres};
+    delete $self->{search_string};
+
     # Strip out any non-digits from distance and OS co-ords.
-    foreach my $param ( qw( os_x os_y os_dist latlong_dist ) ) {
+    foreach my $param ( qw( os_x os_y osie_x osie_y
+                            osie_dist os_dist latlong_dist ) ) {
         if ( defined $vars{$param} ) {
             $vars{$param} =~ s/[^0-9]//g;
             # 0 is an allowed value but the empty string isn't.
             delete $vars{$param} if $vars{$param} eq "";
-            $self->{$param} = $vars{$param} if defined $vars{$param};
         }
     }
 
     # Latitude and longitude are also allowed '-' and '.'
-    foreach my $param( qw( lat long ) ) {
+    foreach my $param( qw( latitude longitude ) ) {
         if ( defined $vars{$param} ) {
             $vars{$param} =~ s/[^-\.0-9]//g;
             # 0 is an allowed value but the empty string isn't.
             delete $vars{$param} if $vars{$param} eq "";
-            $self->{$param} = $vars{$param} if defined $vars{$param};
         }
     }
 
-    # Set $self->{distance_in_metres} depending on whether we got
-    # OS co-ords or lat/long.
-    if ( defined $self->{os_x} && defined $self->{os_y}
-         && defined $self->{os_dist} ) {
-        $self->{distance_in_metres} = $self->{os_dist};
-    } elsif ( defined $self->{lat} && defined $self->{long}
-              && defined $self->{latlong_dist} ) {
-        $self->{distance_in_metres} = $self->{latlong_dist};
+    # Set $self->{distance_in_metres}, $self->{x}, $self->{y},
+    # depending on whether we got
+    # OS co-ords or lat/long.  Only store parameters if they're complete,
+    # and supported by our method of distance calculation.
+    if ( defined $vars{os_x} && defined $vars{os_y} && defined $vars{os_dist}
+         && $self->config->{_}{geo_handler} eq 1 ) {
+        $self->{x} = $vars{os_x};
+        $self->{y} = $vars{os_y};
+        $self->{distance_in_metres} = $vars{os_dist};
+    } elsif ( defined $vars{osie_x} && defined $vars{osie_y}
+         && defined $vars{osie_dist}
+         && $self->config->{_}{geo_handler} eq 2 ) {
+        $self->{x} = $vars{osie_x};
+        $self->{y} = $vars{osie_y};
+        $self->{distance_in_metres} = $vars{osie_dist};
+    } elsif ( defined $vars{latitude} && defined $vars{longitude}
+              && defined $vars{latlong_dist} ) {
+        # All handlers can do lat/long, but they all do it differently.
+        if ( $self->config->{_}{geo_handler} eq 1 ) {
+            require Geography::NationalGrid::GB;
+            my $point = Geography::NationalGrid::GB->new(
+                Latitude  => $vars{latitude},
+                Longitude => $vars{longitude},
+            );
+            $self->{x} = $point->easting;
+            $self->{y} = $point->northing;
+        } elsif ( $self->config->{_}{geo_handler} eq 2 ) {
+            require Geography::NationalGrid::IE;
+            my $point = Geography::NationalGrid::IE->new(
+                Latitude  => $vars{latitude},
+                Longitude => $vars{longitude},
+            );
+            $self->{x} = $point->easting;
+            $self->{y} = $point->northing;
+        } elsif ( $self->config->{_}{geo_handler} eq 3 ) {
+            require Geo::Coordinates::UTM;
+            my ($zone, $x, $y) = Geo::Coordinates::UTM::latlon_to_utm(
+                                                $self->config->{_}{ellipsoid},
+                                                $vars{latitude},
+                                                $vars{longitude},
+                                              );
+            $self->{x} = $x;
+            $self->{y} = $y;
+        }
+        $self->{distance_in_metres} = $vars{latlong_dist};
+    }
+
+    # Store os_x etc so we can pass them to template.
+    foreach my $param ( qw( os_x os_y osie_x osie_y latitude longitude ) ) {
+        $self->{$param} = $vars{$param};
     }
 
@@ -607 +669 @@
 sub process_template {
     my ($self, %args) = @_;
+
     my $tt_vars = $args{tt_vars} || {};
     $tt_vars->{not_editable} = 1;

trunk/lib/OpenGuides/Template.pm

@@ -169 +169 @@
         $header = CGI::header( -cookie => $args{cookies} );
     }
+
+    # vile hack
+    my %field_vars = OpenGuides::Template->extract_metadata_vars(
+                                        wiki                 => $args{wiki},
+                                        config               => $config,
+                                        set_coord_field_vars => 1,
+                                        metadata => {},
+                                                           );
+    $tt_vars = { %field_vars, %$tt_vars };
+
     my $output;
     $tt->process( $args{template}, $tt_vars, \$output );
@@ -211 +221 @@
 C<metadata> and C<cgi_obj> then C<metadata> will take precedence, but
 don't do that.
+
+The variables C<dist_field>, C<coord_field_1>, C<coord_field_1_name>,
+C<coord_field_1_value>, C<coord_field_2>, C<coord_field_2_name>, and
+C<coord_field_2_value>, which are used to create various forms, will
+only be set if I<either> C<metadata> is supplied I<or>
+C<set_coord_field_vars> is true, to prevent these values from being
+stored in the database on a node commit.
 
 =cut
@@ -268 +285 @@
 
     if ( $args{metadata} ) {
-        foreach my $var ( qw( phone fax address postcode os_x os_y
-                              latitude longitude map_link website) ) {
+        foreach my $var ( qw( phone fax address postcode os_x os_y osie_x
+                              osie_y latitude longitude map_link website) ) {
             $vars{$var} = $metadata{$var}[0];
         }
+        # Data for the distance search forms on the node display.
+        my $geo_handler = $config->{_}{geo_handler} || 1;
+        if ( $geo_handler == 1 ) {
+            %vars = (
+                      %vars,
+                      coord_field_1       => "os_x",
+                      coord_field_2       => "os_y",
+                      dist_field          => "os_dist",
+                      coord_field_1_name  => "OS X coordinate",
+                      coord_field_2_name  => "OS Y coordinate",
+                      coord_field_1_value => $metadata{os_x}[0],
+                      coord_field_2_value => $metadata{os_y}[0],
+                    );
+        } elsif ( $geo_handler == 2 ) {
+            %vars = (
+                      %vars,
+                      coord_field_1       => "osie_x",
+                      coord_field_2       => "osie_y",
+                      dist_field          => "osie_dist",
+                      coord_field_1_name  =>"Irish National Grid X coordinate",
+                      coord_field_2_name  =>"Irish National Grid Y coordinate",
+                      coord_field_1_value => $metadata{osie_x}[0],
+                      coord_field_2_value => $metadata{osie_y}[0],
+                    );
+        } else {
+            %vars = (
+                      %vars,
+                      coord_field_1       => "latitude",
+                      coord_field_2       => "longitude",
+                      dist_field          => "latlong_dist",
+                      coord_field_1_name  => "Latitude",
+                      coord_field_2_name  => "Longitude",
+                      coord_field_1_value => $metadata{latitude}[0],
+                      coord_field_2_value => $metadata{longitude}[0],
+                    );
+        }
     } else {