The second fetch method we defined is nearly identical to the first, except for

the fact that instead of getting a single model instance back

we're getting an array of models.

Let's copy the method signature over from the protocol body, so

all the way up at the top here.

We're gonna grab this second one, hit CMD C to copy, and

we're going to add it to the extension like before,

along with a set of braces to provide an implementation, a default implementation.

For the body, let's go ahead and copy the implementation of the previous method

over, so everything from let task to task.resume.

CMD C, and then CMD V to paste,

we just have to make some minor modifications to get it to work.

So at the bottom here after getting the JSON out,

we'll use the parse function again to convert from our JSON to our end result.

The end result here isn't an optional t but an array of t, so for

starters we don't need an if let statement here.

With this approach, the failure is going to be indicated by an empty array.

So we can check to see if an array is not empty and then execute the success case.

So over here, we'll say, let value = parse(json).

And you'll see that the type of value now is an array of t.

Well, it'll be an error here because we have two values.

So instead of an if let here, we'll say if value or

if value is not empty, then hey this is a success case so we'll go ahead and

call it, otherwise it's the failure case because we couldn't parse the JSON.

So now if you option click you should see that this is an array of t.

Pretty simple.

The API client protocol can now power a lot of the functionality of our clients.

We still need a concrete type to act as the client though,

an interface with the Yelp API directly.

So to the networking group, right click, New File,

Swift File, And we'll call this YelpClient.

The Yelp client class is going to be the main point of

interaction with the Yelp API.

So it will define a class in here, again called Yelp client, and

this is going to conform to the API client protocol.

Conforming to the protocol is really easy since we've provided default

implementations for all the methods requirements.

All we need to add to this class is a session, so

we'll say let session of type URL session.

To instantiate this class we'll provide a concession configuration object and

the o auth token.

We need the o auth token to successfully execute any requests we make.

So in it with a configuration of type URL session configuration,

and an oauthToken, and this is a string.

Now in here we'll say self.session = URLSession and

we'll initialize it with this configuration and simply pass it through.

Use the argument in the init method, and self.token = oauthToken.

Now, we'll need a stored property for the token, so let's add that.

And we'll make it private, so private let token: String.

To make it easier to initialize this class, since we're just going to be using

the default config every time, let's go ahead and add a convenience init.

So convenience init (oauthToken: String).

And in here we'll just call self.init, and we'll say .default for

the configuration and pass the token through.

Okay, let's dive right in.

This was simple stuff.

We're going to define a method to search for Yelp businesses given a search term.

Now if you go to project navigator and navigate to Endpoint.swift,

which is in the Networking group, you'll see here that the search endpoint,

so, defined in the Yelp enum.

So look for the Yelp enum which is easier from the jump bar, should be right here.

And then there's a search case, and

you'll see here that this accepts a few associated values.

So the method we define needs to accept values for these parameters, as well, so

that we can use them to create a valid endpoint.

So back to Yelp client, we'll call this method, search.

For the arguments, we'll start with the search term and coordinate,

because we need to specify a location.

So we'll say search(with term), we'll give it a local name of search or term rather,

and this is of type String at a particular coordinate of type Coordinate.

These are more or less the required terms that we want to specify and we'll go

ahead and define a few more parameters to make the search as flexible as we need to.

So the next parameter,categories.

The next parameter we'll define here allows the caller

of the method to specify a list of categories to restrict the search to.

And this is going to be an array of YelpCategory.

YelpCategory is a type I defined earlier.

To use it you'll need to provide a categories title and an alias.

Now I don't expect us to use this much, so we'll go ahead and

give it a default value of a empty array.

If you want to use this perimeter, check out the teachers notes for

a link to the category list section of the Yelp docs.

When searching for

a business around you, Yelp also allows you to specify a radius to search in.

So let's add that to our parameters list as well.

We'll ask for a radius of type Int.

But we'll make this optional, and we'll give it a default value of nil.

This way if you want to specify a radius to narrow your search down or

broaden it, go for it.

Otherwise we'll use the server's default value.

Speaking of defaults, the Yelp server only returns 20 results for a search query.

I want more, so let's define a limit parameter of type int and

we'll give it a default value of 50.

We'll also specify how we want to sort the results from the search.

By default the value for this is best match, but we're going to go with rating.

So we'll say sort by, sort type, and

the type here is Yelp.Yelpsorttype.

So if we command click this is a nested enum, so under the Yelp enum,

we have another enum in here.

So YelpSortType is a type I've defined and

here we're going to give it a default value of .rating.

You can Command click again into that type and

check out the different possible values.

Finally after accepting all these different arguments,

we need to define a completion handler so

that we can execute some logic when this task is complete.

The signature of this completion handler, well first,

it's gonna be an escaping enclosure.

And the signature is a closure with a type of result.

So the agreements need to go inside parenthesis, so we'll say result.

Now we know result is a generic method so we need to specify types for t and u.

Since search is not a generic method,

we can finally specify concrete types for result.

When we search using the Yelp API, the results we get back in a success case

is not a single business but an array of businesses.

So t here, is, we're going to substitute it now, is an array of Yelp,

Business, and then u is APIError.

Let's take a break here.

In the next video, let's provide an implementation for this method, and

go ahead and use it.