Using the TomTom Maps SDK for Web with ASP.NET Core, Part 2

Developer Portal

Aug 11, 2020 • Last edit on Sep 20, 2022 • 7 min read

In our last article, we've shown how to quickly create and run a mapping-enabled website with ASP.NET Core MVC as a server component and TomTom Maps SDK for Web as our client JavaScript mapping library. The solution featured markers that helped users quickly visualize the location of landmarks on the map.

This time, we'll improve the existing website by building new features on top of the existing codebase. We'll learn how to draw polygons to highlight landmark boundaries, which separate famous places from their surroundings. Also, we'll add hyperlinks to the markers to zoom in to the selected locations.

To follow the separation of concerns principle, we'll modify our solution's architecture by creating a new ASP.NET Core Web API and make it store and serve mapping-related data to the MVC project.

Adding Areas

Let’s improve our web app to provide a rectangle to represent the perimeter of the landmark. The first step is to provide additional coordinates to our JSON file:

1{
2
3  "Places": [
4
5    {
6
7      "id": 1,
8
9      "name": "Central Park, N.Y., United States",
10
11      "zoom": 12,
12
13      "center": [ -73.9712, 40.7831 ],
14
15      "coordinates": [
16
17        [
18
19          [ -73.9582, 40.8007 ],
20
21          [ -73.9491, 40.7968 ],
22
23          [ -73.9730, 40.7642 ],
24
25          [ -73.9819, 40.7681 ],
26
27          [ -73.9582, 40.8007 ]
28
29        ]
30
31      ]
32
33    },
34
35    {
36
37      "id": 2,
38
39      "name": "Plaza Mayor, Madrid, Spain",
40
41      "zoom": 17,
42
43      "center": [ -3.7074, 40.4155 ],
44
45      "coordinates": [
46
47        [
48
49          [ -3.70670, 40.41584 ],
50
51          [ -3.70815, 40.41579 ],
52
53          [ -3.70805, 40.41493 ],
54
55          [ -3.70664, 40.41500 ],
56
57          [ -3.70670, 40.41584 ]
58
59        ]
60
61      ]
62
63    },
64
65    {
66
67      "id": 3,
68
69      "name": "Taj Mahal Garden, Agra, India",
70
71      "zoom": 13,
72
73      "center": [ 78.0421, 27.1732 ],
74
75      "coordinates": [
76
77        [
78
79          [ 78.04379, 27.17450 ],
80
81          [ 78.04040, 27.17450 ],
82
83          [ 78.04040, 27.17172 ],
84
85          [ 78.04379, 27.17172 ],
86
87          [ 78.04379, 27.17450 ]
88
89        ]
90
91      ]
92
93    },
94
95    {
96
97      "id": 4,
98
99      "name": "Red Square, Moscow, Russia",
100
101      "zoom": 15,
102
103      "center": [ 37.61970, 55.75432 ],
104
105      "coordinates": [
106
107        [
108
109          [ 37.61897, 55.75521 ],
110
111          [ 37.61825, 55.75478 ],
112
113          [ 37.62172, 55.75322 ],
114
115          [ 37.62222, 55.75363 ],
116
117          [ 37.61897, 55.75521 ]
118
119        ]
120
121      ]
122
123    }
124
125  ]
126
127}

Now we have two new properties: zoom, to adjust the map view, and coordinates, to provide the perimeter points. We’ll create those properties in the Place class as well:

1public class Place
2
3{
4
5    ...
6
7    public long zoom { get; set; }
8
9    public double[][][] coordinates { get; set; }
10
11}

Let’s then modify the showPlace() function to use the new zoom property:

1function showPlace(id) {
2
3    $.ajax('http://localhost:5000/Home/GetPlace/' + id)
4
5        .done(function (place) {
6
7            $('#placeName').html(place.name);
8
9            map.jumpTo({
10
11                zoom: place.zoom,
12
13                center: place.center
14
15            });
16
17        });
18
19}

With TomTom Maps SDK for Web, we can add a new layer where a polygon can be rendered to highlight the place of interest:

1function initialize() {
2
3    map = tt.map({
4
5        key: myTomTomKey,
6
7        container: 'map',
8
9        style: 'tomtom://vector/1/basic-main'
10
11    });
12
13    map.on('load', function () {
14
15        for (var i = 0; i < famousPlaces.length; i++) {
16
17            let place = famousPlaces[i];
18
19            var marker = new tt.Marker().setLngLat(place.center).addTo(map);
20
21            var popupOffsets = {
22
23                bottom: [0, -40]
24
25            }
26
27            var popup = new tt.Popup({ offset: popupOffsets }).setHTML(place.name);
28
29            marker.setPopup(popup);
30
31            map.addLayer({
32
33                'id': 'overlay' + place.id,
34
35                'type': 'fill',
36
37                'source': {
38
39                    'type': 'geojson',
40
41                    'data': {
42
43                        'type': 'Feature',
44
45                        'geometry': {
46
47                            'type': 'Polygon',
48
49                            'coordinates': place.coordinates
50
51                        }
52
53                    }
54
55                },
56
57                'layout': {},
58
59                'paint': {
60
61                    'fill-color': '#db356c',
62
63                    'fill-opacity': 0.5,
64
65                    'fill-outline-color': 'black'
66
67                }
68
69            });
70
71        }
72
73    });
74
75}

When we run the app, we can see the borders of our landmarks:

Let’s make our markers show a link for navigating to the particular map of each landmark:

var popup = new tt.Popup({ offset: popupOffsets }).setHTML('<a href="javascript:  showPlace(' + place.id + ');">' + place.name + '</a>');

And voilà! Now we can easily navigate to the Taj Mahal map:

Serving Data with the ASP.NET Core Web API

So far, we’ve been able to develop our web application using only the ASP.NET Core MVC Project. Working with a single ASP.NET Core project is quite simple. However, real-world scenarios might demand a more complex architecture.

Best practices and guidelines advise developers to split a solution into different projects, each with a distinct set of responsibilities. For example, an MVC project will deal with web application execution, but will not involve data storage or manipulation. Thus, we need a new project to fulfill those roles.

Let’s fill this gap by creating a new ASP.NET Core Web API project, and moving the data management from the MVC project to the Web API project.

First, create a new project as in the first part of this tutorial. Then right-click the project name, choose the Debug tab, and assign port 5001 to the Web API project URL:

Now we have a solution with two projects, which must run at the same time. Right-click the solution name, choose the Set Startup Projects menu, then choose Multiple startup projects:

Create a new \Models folder for the project, then copy and paste the Places.cs file we’re using in the MVC project into that folder:

Next, create a new \Data folder and copy the famous-places.json file to that folder:

Now add a new controller, named PlacesController, to the Web API project. Include in it the following code, which is similar to what we created for the MVC project.

1[ApiController]
2
3[Route("[controller]")]
4
5public class PlacesController : ControllerBase
6
7{
8
9    private readonly ILogger<PlacesController> _logger;
10
11    public PlacesController(ILogger<PlacesController> logger)
12
13    {
14
15        _logger = logger;
16
17    }
18
19    [HttpGet]
20
21    public async Task<PlaceCollection> Get()
22
23    {
24
25        return await GetPlaceCollection();
26
27    }
28
29    [HttpGet("{id}")]
30
31    public async Task<Place> Get(int id)
32
33    {
34
35        var collection = await GetPlaceCollection();
36
37        return collection.Places.Where(p => p.id == id).Single();
38
39    }
40
41    private async Task<PlaceCollection> GetPlaceCollection()
42
43    {
44
45        var file = Path.Combine(Directory.GetCurrentDirectory(),
46
47            "Data", "famous-places.json");
48
49        string json = await System.IO.File.ReadAllTextAsync(file);
50
51        return PlaceCollection.FromJson(json);
52
53    }
54
55}

When the Web API app runs, you can test two endpoints. The first one gives you the full landmark collection:

The second endpoint returns detailed data on a specific location:

Now let’s go back to the MVC project and refactor both the IndexAsync() and GetPlace() actions. Here, we implement calls to the Web API endpoints through the HttpClient class, and return the results as deserialized objects:

1public async Task<IActionResult> IndexAsync()
2
3{
4
5    ViewData["MyTomTomKey"] = MyTomTomKey;
6
7    using (var client = new HttpClient())
8
9    {
10
11        var response = await client.GetAsync("http://localhost:5001/places");
12
13        var json = await response.Content.ReadAsStringAsync();
14
15        var placeCollection = PlaceCollection.FromJson(json);
16
17        return View("Index", placeCollection);
18
19    }
20
21}
22
23public async Task<JsonResult> GetPlace(int id)
24
25{
26
27    using (var client = new HttpClient())
28
29    {
30
31        var response = await client.GetAsync($"http://localhost:5001/places/{id}");
32
33        var json = await response.Content.ReadAsStringAsync();
34
35        var place = Place.FromJson(json);
36
37        return new JsonResult(place);
38
39    }
40
41}

After these changes, the responsibility for providing data will belong to the Web API project. If you want to secure the Web API connections, read the relevant Microsoft documentation.

Conclusion

As you can see, TomTom Maps SDK is easy to use for developers and software engineers working with the powerful ASP.NET Core.

Although TomTom Maps SDK for Web is a JavaScript library, data can be easily pushed to the client-side code using the ASP.NET Core’s Razor engine to dynamically render UI content. In addition to ASP.NET Core, developers can use TomTom Map SDK for Web with other server-side stacks, like Node.JS, Java/Spring, Python/Django, and Ruby on Rails. JavaScript code can also retrieve mapping data residing on the server side using AJAX requests.

Since ASP.NET Core is a server-side framework, it provides the ideal place to securely deliver data using RESTful web API data services to the client-side code.

Maps

web

Code

Using the TomTom Maps SDK for Web with ASP.NET Core, Part 2

Adding Areas

Serving Data with the ASP.NET Core Web API

Conclusion

Get the developernewsletter.

Get the developer
newsletter.