The service we're going to be using for this app is called Dark Sky,

and can be found at the website darksky.net/dev.

This service is called an API, something that will define very soon.

To use this service you need to register.

But we're going to hold off from doing that just yet.

We're here to read the documentation so

that we can see how this service provides data.

What we're going to do with this project is create our data models first.

And set up the app to make sure that everything works with some fake hard

coded data.

Why are we doing this?

Well in a previous course we learned that it is good design to

separate the data model from the source of the data.

We want the model we're going to design to display some basic

information about the weather.

We can design the model independent of the data source, and

then configure our UI to use the model to set itself up.

This way when we implement the data source the model doesn't care where the data

comes from just that it receives it in a particular format.

Also by verifying that the rest of the app works as intended first,

we know that if something goes wrong later on it is most likely our networking code.

We've talked about the MBC patter before.

Now in our starter files, we already have the view setup and

there's a controller provided as well.

Once we have the model in place and loaded with some fake data,

that's actually enough to write the logic to configure the views to display it.

Now from there changing out the source of the data shouldn't affect how

the rest of the app works.

Okay.

So back to the Dark Sky documentation.

Up at the top there should be a link to the docs.

And if we had over there you can click through to a section labeled forecast

request.

So down here under weather API call types you will see a link written forecast

request.

Here its says that if we make a request, we'll talk what request are.

But if we make a networking request using this URL structure

we get a bunch of data back that looks like this.

Don't worry about how all of that will happen, I'll explain it in due time.

Now if you look at the data, there's a lot of it here.

But since our app is going to display the current weather,

I'm mostly concerned about the data in this currently segment.

And if you look at this data inside of currently you'll see that there's some

very specific names for values, time, summary, icon, and so on.

To figure out what each of these mean, and the type of data they return

we can head over in the link section here, head over to the response format section.

Okay, that didn't work.

Let me click it again.

Let's go back to the docs.

And this is just actually all the way at the bottom.

So I'm gonna scroll down since that link doesn't seem to work.

And here we go, Response Format.

So in this section you'll see that you have information about each of those data

points provided.

Scroll around, and you'll see that the information we care about, the data

that we're modeling is represented by the currently type, currently key.

Now if you click through to this data point thing again, and go right down.

You'll see that there is actually tons more data that we get back by requesting

the current weather.

We don't really care about all of these things, so

if you inspect them further you'll see that some of these things like Sunrise and

Sunset for example are only relevant if you are looking at the daily weather.

Others apparent temperature, it is not there on the daily weather information.

So when we look at the current weather what do we really care about?

Well we care about the temperature mostly,

which is down on this list, right at the bottom.

This is ordered alphabetically so temperature is right here.

We'd also like to know the humidity level, maybe the chance of rain,

a text summary, and finally we'd like to show our users an icon.

So all of that is available under this currently structure,

that should be good enough.

So using this information let's build our model.

Let's add an empty Swift file.

So if we go back to our projects, we'll add an empty Swift file, and

we'll call it current weather.

We're going to use a struct as our data model.

Containing the few properties we established as necessary

to display the current weather.

So struct CurrentWeather.

First thing we need to store the temperature.

Now if we go back and look at the documentation under these data points.

So go to Response Format, then these data points under currently.

On each of these it says that these objects may contain

the following information.

Because as you can see a lot of these properties are optional.

The type of information we're looking for

is pretty specific to the type of requests that we're making.

So on temperature here for example, you'll see that it is an optional property,

but it's not a defined on minutely.

Which means that we can guarantee that it is defined on the currently information,

which is what we want.

Now since some of these data points may not be available for

the type of request we're making, we may need to use optionals.

So if you are modeling the minute to minute weather,

then temperature will be an optional property.

Because it's guaranteed to be available for

current weather we're going to model it as a non optional.

So then going back we'll say let temperature of time double.

Next step is humidity.

There are no notes about humidity not being available for the CurrentWeather.

So again let humidity, and this is going to be a non optional Double.

After humidity, we'd like to let users know if it's going to rain.

Back on the list this is listed as Precip Probability.

Again there doesn't seem to be any notes about it not being available for

a particular type.

So we can be confident, somewhat confident that we don't need an optional.

So let's say let precipProbability, and this is of type Double.

Next up is the text summary of type String.

And finally we'd like to show an icon.

Now let's go back to the docs for a second, and navigate to icon right here.

According to the docs the icon property returns a string

describing a type of icon to show.

At the start of files for

the project already include a set of icons in the assets folder.

So it's just the matter of matching an icon based on the streams values that you

see here, that this property returns.

So back in the CurrentWeather struct let's define an icon as a string, and

just store the name of the icon, okay?

And that should be if for a current weather object, quite simple.