We're going to use a service called Postman to poke around the iTunes

search API and see what the JSON looks like when we make a request.

In doing this, we'll get a better understanding of how to structure our data

models to work with the API, and how we can define some fake data to make

the initial parts of the project easier to build.

Let's open up a new tab and head over to getpostman.com.

Now you should go ahead and download the Mac client and

explore this website to see what this app is about.

Basically, Postman is a feature rich client that allows us to

pass a request in and inspect the response pretty easily.

It also happens to be free which is great for use in this course, now,

once you've downloaded the app it should look like this.

Services like Postman, again are made for exploring and building APIs,

without having to deal with all those tricky aspects like proper URL and coding.

So up at the very top over here, we have a search bar, essentially,

where we can enter a request URL.

And here we're going to add a URL and then hit Send to send off a request.

In the section below marked Response, we get a response, and we can inspect it.

Okay, so let's go back to our browsers and go back to the docs page,

and let's scroll up to that section marked Searching.

And we're gonna grab this base URL and path, so itunes.apple.com/search,

we'll hit copy, and then we'll go back to Postman.

And in this bar here, in the fields, let's enter that URL,

okay, I just hit Send by mistake but ignore that, we're not done just yet.

Now this isn't enough, as you can see my response doesn't contain anything.

We need to provide a set of parameters,

again some required, some optional to get the right data.

So, at the end of this box here, there's a button named Params.

If you click on here, in this vaguely visible section below,

we can list parameters as key value pairs.

Postman then takes care of the encoding and fires off the request for us.

We're going to explore a couple different requests, but for

now, let's see what information we get back when we search for a term.

So remember the first parameter key is term, and this is required,

and for the value I'm going to specify taylor.

If we send the request now, remember that we'll be searching for this term across

all the stores and getting back a result set of every possible match.

So let's go ahead and restrict this to music, and

the way that we do that is to specify a media type.

They key here is media, the value is music.

When you add these key value pairs to this list,

you can see in the URL text field how these values are added to that base URL.

We'll cover all of that in detail though, so if you're confused, don't worry.

Now searching in the music store should be sufficient, but

just to make things easier, I want the server to match our search term

only to artist names, and not songs or albums or anything else.

For that, we need to specify an entity or an attribute.

For the entity, the key is entity and

the value is musicArtist, written out just like that.

Lastly, the attribute key, so that is attribute and the value is artistTerm.

Now just as an FYI, in case you're confused about how at least I know whether

these are the right terms or how did I figure out what I need to type in here to

get this URL constructed properly.

Well, I had to play around with these for a bit before I actually understood how,

exactly, these attributes affected my query.

Like I said, the documentation isn't great, so some experimentation will be

required on your part if you want to modify this, but the great thing is with

an app like Postman, it should be relatively easy to do.

You don't have to write code just yet, okay, so

now we have a URL that models the kind of information we're searching for.

Just for the sake of this example, since we only want to see what

kind of data we get back, let's add another key value pair, and limit

the results to just 5 data points, so that we don't have a giant wall of JSON.

Now with all this set up, hit Send, and

you should get back a response in the section below.

Now by default, this section has a format of auto,

it tries to detect what data format this is in automatically.

But if we drop down and select JSON and

make sure it's on pretty, you'll see it's formatted better.

So this is what a response looks like,

we get an array called results at the top level.

And each item in this array is a nested dictionary,

the dictionary includes information about what type of result this is.

And as you see here, this is an artist, for

our purposes this is always going to be an artist, because we restricted the search.

But you can imagine how this is useful,

this wrapper type, if you wanted to search across all the stores and

show categorize results on one page, just like the actual iTunes app.

So what do we care about from the values here?

Well we want the name, the artist name, since we need to display it,

we also want the artist's ID if we want to query that artist further, and

maybe we want some information about the genre.

You'll notice there's no information here about any of the music this

artist has created, to get that, we need to send another request

with a different set of information using the lookup end point.

All in due time, now that we understand better how this initial JSON is going to

be structured, let's head over to Xcode, create a new project, and our first model.

This time, let's go with a single page application template,

a single view application, and build from there.

We could go with the master detail because as you saw, our app had just a list of

series of table views, but we don't want any of the boilerplate code.

We wanna just start from scratch, so single view it is, and

I'm going to call this iTuneClient, make sure the language is Swift.

I'm gonna select a Team just so it doesn't have that initial error

in the signing identities spot, and then figure out where you wanna save it.

Let's put this in a folder called iTunesClient, there we go.

Let's create a couple groups in here to start out so

that our project remains somewhat sane and organized.

So New Group, Models, or Models, there we go,

New Group, Views, and finally Controllers.

In the Model group let's create our first new file, so

New File empty Swift File and we'll call this Artist.

We usually define our models as struts, but

we need reference types this time around.

We're going to be passing objects around from one view controller to the next and

mutating certain properties based on user input.

With a copy behavior of value types this can get messy.

We'll also need to maintain some state across our models and

value types aren't good at that.

Initially it's going to seem like there really isn't a reason for

classes, as we write our networking code you'll see why.

So class Artist, and

to start with let's add two simple properties to store the ID and name.

So let id of type Int and let name of type String,

that's not all we wanna store though.

How about the genre?

That would certainly be useful to display, if you go back and inspect the response,

you can see that there are two data points returned here, a genre name and an ID.

Since I've already explored the API, I know that there are some cases where only

a name is returned, and some, like this one, where we could get an ID as well.

We could simply store the name of the genre as a string in our model, but

we should try news types wherever we can to avoid mistakes and

to get the compiler to help us.

If we go back to the documentation that is the iTunes documentation.

Go up to the URL over here and

get rid of all of this until documentation and hit enter.

You should go to kinda the main reference page,

and if you scroll down there is a link to a Genre IDs Appendix.

As you can see here, there are a lot of genres, this list is pretty long.

But thankfully, not all of these pertain to music, so if you scroll around a bit,

you can find the music section right here.

But even under music there are quite a few genres and then even more sub genres.

So let's model just the top level genres under music for our app, so blues,

comedy and so on.

Your first thought might be to create a tiny struct to model these points, but

as you can see the list of genres is a finite one.

So we can use an enum to model this,

we're going to give this enum a raw value of int to store this genre ID.

And then add an init method that lets us

initialize the type using a stringly type name.

This way we can easily create a genre value from either the ID or name.

Now, this is a lot of typing if we were going to model all this,

so in the teacher's notes to this video there is a link to a Genre.swift.

Create a new file under Models named genre,

Genre, and then just drop in the code.

At this point you should be extremely familiar with creating models and

working with Swift types, so

unless we're doing something extraordinary we'll be adding a good amount of code in,

especially in cases like this, where most of the work is just typing.

Now back in the Artist model let's add a property for the genre.

We need to add one more property, an artist has albums to their name and

we'll model that as an array on the Artist type.

Initially, when we create an instance of an Artist to display in the search

results, we won't have any album data.

Well that's okay, because we can just initialize the property to an empty array.

When we fetch relevant album data, we'll mutate that value.

So this needs to be a variable property, but

first we need an album type, so in the Models group let's add a new file.

We'll name it Album, and in here we'll create an empty class,

named Album, just for now, we'll get to this in a second.

But now back in Artist we can say var albums an array of Album.

Let's finish this type up by adding in a simple initializer,

so we'll end it with id, type Int, name type String,

primaryGenre of type Genre albums, which is an array of Album, and then easy stuff.

We'll just assign each one back to the stored property is self.name

= name self.primaryGenre = primaryGenre, and albums = albums.