Get a User’s Geolocation in a PHPRunner Web Application

A PHPRunner application can use the browser Geolocation API to request the user’s current latitude and longitude. Those coordinates can then be passed to the server and used for features such as nearby results, maps, service-area checks or location-aware filtering.

The basic flow is:

1. Request the user’s location in JavaScript.
2. Read the latitude and longitude returned by the browser.
3. Send those values to the server.
4. Store or use the coordinates in the PHPRunner application.

Before you start

Browser geolocation requires the user’s permission. The browser may display a prompt asking whether the user wants to share their location, and your application should continue to work if permission is denied.

Geolocation also requires a secure context. In production, the application should be served over HTTPS. Browsers generally allow geolocation on localhost for development as well.

The accuracy of the returned coordinates depends on the user’s device and environment. A phone with GPS may provide a very accurate location, while a desktop computer may return a less precise estimate based on Wi-Fi or other available information.

1. Request the user’s location

Add the following code to the JavaScript OnLoad event of the page where you want to request the user’s location. The Login or Menu page can be a convenient choice if you want the coordinates available throughout the user’s session.

if (navigator.geolocation) {

    navigator.geolocation.getCurrentPosition(
        locationFound,
        locationError,
        {
            enableHighAccuracy: false,
            timeout: 10000,
            maximumAge: 60000
        }
    );

} else {
    console.log("Geolocation is not supported by this browser.");
}

function locationFound(position) {

    var lat = position.coords.latitude;
    var lng = position.coords.longitude;

    $.post("", {
        lat: lat,
        lng: lng
    });
}

function locationError(error) {

    switch (error.code) {

        case error.PERMISSION_DENIED:
            console.log("Location permission was denied.");
            break;

        case error.POSITION_UNAVAILABLE:
            console.log("Location information is unavailable.");
            break;

        case error.TIMEOUT:
            console.log("The location request timed out.");
            break;

        default:
            console.log("Unable to retrieve the user's location.");
    }
}

The browser calls locationFound() when a location is available. The latitude and longitude are then posted back to the current application page.

The error callback is important because location access is never guaranteed. The user can deny permission, the device may be unable to determine its location, or the request may take too long.

2. Store the coordinates on the server

The following example stores the coordinates in session variables. Add it to the AfterAppInit event.

PHP

$lat = postvalue("lat");
$lng = postvalue("lng");

if ($lat !== "" && $lng !== "") {
    $_SESSION["lat"] = $lat;
    $_SESSION["lng"] = $lng;
}

It is better to check whether the values were actually supplied instead of simply testing them as true or false. Latitude or longitude can legitimately be zero.

C#

dynamic lat = MVCFunctions.postvalue("lat");
dynamic lng = MVCFunctions.postvalue("lng");

if(lat.ToString() != "" && lng.ToString() != "")
{
    XSession.Session["lat"] = lat;
    XSession.Session["lng"] = lng;
}

3. Use the location elsewhere in the application

Once the coordinates are stored in the session, they can be used by other pages and events in the application.

For example, the PHP values are available as:

$lat = $_SESSION["lat"];
$lng = $_SESSION["lng"];

You could use these coordinates to:

• show locations nearest to the current user;
• calculate the distance to stores, offices or service locations;
• display the user’s approximate position on a map;
• filter records to a geographic service area;
• save the location together with a newly created record.

Optional: store the coordinates in the database

Session variables are useful when the location only needs to be available temporarily. If the location should be associated with a user, order, visit or another record, save the coordinates to the appropriate database fields instead.

For example, after obtaining the coordinates you could use PHPRunner’s Database API to update a record:

$data = array();
$data["latitude"] = $_SESSION["lat"];
$data["longitude"] = $_SESSION["lng"];

DB::Update("users", $data, array("id" => $_SESSION["UserID"]));

Adapt the table name, field names and key value to your own database structure.

Privacy and user experience

Location data can be sensitive, so request it only when the application has a clear reason to use it. It is usually better to request location at the point where it provides an obvious benefit rather than asking every visitor immediately after opening the application.

Your application should also have a fallback for users who decline location access. Depending on the use case, this might be a manually entered address, ZIP code, city or other location selection.

The browser Geolocation API gives PHPRunner applications a straightforward way to add location-aware functionality. The main considerations are permission, HTTPS, error handling and deciding how the coordinates should be used once they reach the server.