0:03
[MUSIC]
Hello, and welcome to our geolocation services demo,
where we integrate the 2D sphere implementation into our Zips application.
And the core focus of this demo will be again on the Mongo Db,
the geolocation services, the 2D sphere creation of an index and
of course, the rails, scaffold and all of that you have done in the past.
So I want to start and begin this by going over a demo and then we'll go back,
and look at the code implementation for each of the different pieces.
Now this is your Zips index page, when you bring up the index application.
Now if you go all the way to the bottom, you will see maps, right,
which is a pretty nice, easy,
cool way of integrating rich geo-location with your application.
So one thing you would need is a gem, which we will see in a minute.
You would need to add that gem and
to integrate the Google Maps into your application,
right, and so you get all this look and feel.
So if I go and click on one of these show, then I will get another view
where you will have the basic information about that city and state, and
the population and all that, and taking the location information.
The latitude and longitude, we will plot that on the map, and
we also have five cities, and that's because of the limit equal to five,
which we'll look at in a minute.
Our defined method will go and get the min distance and apply the min, the max, and
the limit to get this data.
Now you can also go and do additional things like send parameters like for
example, I can go and do this, which is sending the zip code of Baltimore,
right, and then max miles of 500, min miles of 10 and limit of 15,
then it'll go and get all the cities based on that search criteria.
To make it less cluttered, I can go to five, and
that should give me much more distributed because I'm only looking for
the five cities around that Baltimore.
For example, this one is Jacksonville, Baltimore, and this one, Jacksonville,
Maryland, I mean, and this is a different city and so on.
So let's go look at the code to see how all of these have
been integrated into our existing Zips application.
Now the very first thing that you will need is to create an index, right, and
you have all this documentation on the GitHub repository, so
you will have to go and create an index as shown here.
So this has to be done, so we can take advantage of this feature in our
application, and this is the command zip collection drop one,
this is the command so that you can remove this later on.
3:01
Now I talked about the maps gem, so this is the gem gmaps4rails.
So you can find more information about this on
the Readme documentation on the GitHub, so there's a video as well.
Plus, you can always find more information on the Internet on this gem and
the feature provided by this.
So this is what we are using to load the map, and
speaking of loading the maps, let's look at the two files,
the index.html page that comes up, and
this is the piece of code that it's actually using to build the map.
Now I want to focus on this location object here, right?
Now this is actually defined in the controller, so
I am kind of jumping around here but I want to show you where it's defined.
So notice how the index method and the show method both have location
populated by doing this code that you see, zip_markers @zips.
So this will have all the locations, right, and same thing here,
and this object will be used, this variable rather,
will be used in the in the HTMLs, when you click on the index or
when you click on a show, you'll actually see that data come up on the page.
4:26
Now the fundamental focus in this demo is the near method that has been implemented
in the zip.rbr which is our model in this class and the near has three arguments,
the max miles and the min miles and limit and we saw this.
Now if you don't provide any, then the default is set to 1,000, 0 and 5.
Now once the assignment is done, do max miles and min miles,
the one thing you see is the conversion of miles to meters.
So depending on the metrics, depending on the system you have on your UI,
whether it's miles or kilometres, you will do some translation.
This is very application specific for you to convert it to
5:12
whatever is your conversion that you have to do in your example.
And after all this is done, so here is the meat of our logic,
which is the near operator, and
this is using the minDistance, as the min that we converted back and
the max that we reconverted and this is the one that will go to the database.
The find call will actually make a find call to the database, hit the database and
extract the data and what we get back is a collection of zips.
So since we have 5 or 15, whatever is the limit,
5 being the default, you will get a default of 5 collection or
as you saw in the demo, I typed in 15, that will give me 15 zip code.
So based on the data that we have on the map,
what you see is 15 zip codes, or 5 or how many ever you passed based on
couple of other additional conditions like the min distance, and the max distance.
6:14
Okay, so let's wrap up the demo by going back to the main page.
So here is my Zips, let me go in and add a different search criteria.
I'm going to put in the zip code 90210 which should give us the Beverly Hills.
So that's the zip code, which is by the way,
this is an image that we have in our images folder, so
that would be the zip code that we are actually doing the search on and
then we have three additional parameters, the maxmiles, minimiles, and limit.
So that will go and
give us the remaining five cities based on the dataset that we have here.
So in a larger application, the more common application,
you might be looking for, Starbucks closer to this zip codes and
based on the data that you have, you will get the closest Starbucks
that are near to this zip code that you're looking for.
Now talking about the maps, we looked at the Gmaps for rails, right?
So this is the code in your index or the show,
show also has the same logic to build a map, right?
The main difference being index will show all the zips, or how many ever zips we
have, it's the first page, right whereas the show will have the limit of 5 or 15.
The limit will be applied, but the same logic.
And this is pretty much the logic for you to actually go and display the maps.
We take advantage of the gmaps.build, Google because that's the gem,
and the maps we are using, and you actually go and
call the build map and pass all the information that we need.
The main object that we have is the locations, right, and
we talked about the locations.
The controller is the one that defines the location, and this is basically the hash
to store really the hash representation of the zip location.
So this collection is read in by the index and the show page,
both, so we saw the example and each pin, each of those pins
that was see in the map, will tell you the city name associated with it.
So this is the one that'll have the name associated with it.
So that is actually being built with this little piece of
code from 27 to 32 in, for example, show.html,
which is the one specific representation for a given zip code.
Okay, so I think I covered all the core things that we needed to
cover in this demo, and once again, you have access to this.
So please feel free to download this, run this example and
make changes or play with the data and
build your own find queries to get the data that you like, okay?
So, that wraps up this lecture on geospatial geolocation services and
I will see you in the next lecture.
Thank you.
Kiran ChittargiAdjunct Professor, Graduate Computer Science
