EV Charging Stations Availability

1
import { getPlacesWithEVAvailability } from '@tomtom-org/maps-sdk/services';
2
import { search } from '@tomtom-org/maps-sdk/services';
3

4
// First, search for EV charging stations
5
const chargingStations = await search({
6
    query: 'EV charging',
7
    position: [4.9041, 52.3676], // Amsterdam
8
    categorySet: ['ELECTRIC_VEHICLE_STATION'],
9
    limit: 10
10
});
11

12
// Fetch real-time availability data
13
const stationsWithAvailability = await getPlacesWithEVAvailability(chargingStations);

1
import { getPlaceWithEVAvailability } from '@tomtom-org/maps-sdk/services';
2

3
// Get a specific charging station (from search results)
4
const station = chargingStations.features[0];
5

6
// Get detailed availability information
7
const stationWithAvailability = await getPlaceWithEVAvailability(station);
8

9
// Access availability data
10
const availability = stationWithAvailability.properties.evChargingStationAvailability;
11
if (availability) {
12
    console.log(`Total connectors: ${availability.totalConnectors}`);
13
    console.log(`Available connectors: ${availability.availableConnectors}`);
14

15
    // Check individual connector types
16
    availability.connectorAvailability.forEach(connector => {
17
        console.log(`${connector.connectorType}: ${connector.availableConnectors}/${connector.totalConnectors} available`);
18
    });
19
}

1
const stationWithAvailability = await getPlaceWithEVAvailability(station);
2
const evData = stationWithAvailability.properties.evChargingStationAvailability;
3

4
if (evData) {
5
    // Overall availability
6
    console.log(`Station Status: ${evData.availabilityStatus}`); // 'Available', 'Busy', 'OutOfService'
7
    console.log(`Total Connectors: ${evData.totalConnectors}`);
8
    console.log(`Available Connectors: ${evData.availableConnectors}`);
9

10
    // Connector-specific availability
11
    evData.connectorAvailability.forEach(connector => {
12
        console.log(`Connector Type: ${connector.connectorType}`); // 'Type2', 'CCS', 'CHAdeMO', etc.
13
        console.log(`Power Level: ${connector.powerKW} kW`);
14
        console.log(`Available: ${connector.availableConnectors}/${connector.totalConnectors}`);
15
        console.log(`Status: ${connector.status}`); // 'Available', 'Occupied', 'OutOfOrder'
16
    });
17

18
    // Charging park information
19
    if (evData.chargingPark) {
20
        console.log(`Charging Park: ${evData.chargingPark.name}`);
21
        console.log(`Operator: ${evData.chargingPark.operator}`);
22
    }
23
}

1
import { PlacesModule } from '@tomtom-org/maps-sdk/map';
2

3
// Search and get availability data
4
const stations = await search({
5
    query: 'EV charging',
6
    position: [4.9041, 52.3676],
7
    categorySet: ['ELECTRIC_VEHICLE_STATION'],
8
    limit: 20
9
});
10

11
const stationsWithAvailability = await getPlacesWithEVAvailability(stations);
12

13
// Display on map with custom styling based on availability
14
const placesModule = await PlacesModule.get(map, {
15
    iconConfig: {
16
        customIcons: [
17
            {
18
                category: 'ELECTRIC_VEHICLE_STATION',
19
                iconFunction: (place) => {
20
                    const availability = place.properties.evChargingStationAvailability;
21

22
                    if (!availability) return 'ev-charging-default';
23

24
                    switch (availability.availabilityStatus) {
25
                        case 'Available':
26
                            return 'ev-charging-available'; // Green icon
27
                        case 'Busy':
28
                            return 'ev-charging-busy';      // Red icon
29
                        case 'OutOfService':
30
                            return 'ev-charging-offline';   // Gray icon
31
                        default:
32
                            return 'ev-charging-default';
33
                    }
34
                }
35
            }
36
        ]
37
    }
38
});
39

40
placesModule.show(stationsWithAvailability);

1
const filterByConnectorType = (stationsWithAvailability, connectorTypes) => {
2
    return {
3
        ...stationsWithAvailability,
4
        features: stationsWithAvailability.features.filter(station => {
5
            const availability = station.properties.evChargingStationAvailability;
6

7
            if (!availability) return false;
8

9
            return availability.connectorAvailability.some(connector =>
10
                connectorTypes.includes(connector.connectorType) &&
11
                connector.availableConnectors > 0
12
            );
13
        })
14
    };
15
};
16

17
// Find stations with available Type2 or CCS connectors
18
const compatibleStations = filterByConnectorType(stationsWithAvailability, ['Type2', 'CCS']);