Search responders by name

### Example Code

$search = 'John'; // Replace this with your search term
$data['responders'] = $coach->responders->filter(function ($responder) use ($search) {
    return str_contains(strtolower($responder->first_name), strtolower($search)) ||
           str_contains(strtolower($responder->last_name), strtolower($search));
});

### Explanation
1. **Collection Filter**:
– The `filter()` method is applied on the collection `$coach->responders`.
– The callback function checks if the `first_name` or `last_name` contains the search term.

2. **Case-Insensitive Search**:
– `strtolower()` is used to make the search case-insensitive.

3. **Contains Check**:
– `str_contains()` checks if the search term is found within the `first_name` or `last_name`.

### If You're Using Eloquent Query Builder
If `$coach->responders` is a relationship, and you want to filter results directly via a database query, consider using Eloquent like this:

$search = 'John'; // Replace this with your search term
$data['responders'] = $coach->responders()->where(function ($query) use ($search) {
    $query->where('first_name', 'like', "%$search%")
          ->orWhere('last_name', 'like', "%$search%");
})->get();

### Explanation
– The `where()` clause is used with `like` for a partial match.
– The `%` symbols are wildcards that allow matching any characters before or after the search term.
– `get()` retrieves the filtered responders.

This second approach is more efficient if you have a large dataset, as it offloads the search to the database instead of filtering in memory.

### For Collection-Based Filtering
If `$coach->responders` is a collection (i.e., you've already retrieved it from the database):

$search = request('search');

$data['responders'] = $coach->responders->when($search, function ($responders) use ($search) {
    return $responders->filter(function ($responder) use ($search) {
        return str_contains(strtolower($responder->first_name), strtolower($search)) ||
               str_contains(strtolower($responder->last_name), strtolower($search));
    });
});

### Explanation
1. **Check Request Parameter**:
– `request('search')` retrieves the `search` parameter from the incoming request.

2. **Conditional Filtering**:
– The `when()` method applies the filter only if a search term is present.
– The collection `filter()` method is used to search within `first_name` and `last_name`.

### For Query Builder (Eloquent Relationship)
If you want to handle this via the database query (which is more efficient for larger datasets):

$search = request('search');

$data['responders'] = $coach->responders()->when($search, function ($query) use ($search) {
    $query->where('first_name', 'like', "%$search%")
          ->orWhere('last_name', 'like', "%$search%");
})->get();

### Explanation
1. **Using Eloquent's `when()` Method**:
– This method conditionally applies the `where` clause only if `$search` is not empty.

2. **Partial Matching**:
– The `like` operator is used for partial matching with `%` wildcards.

### Notes
– The collection-based filtering is ideal if you already have a loaded collection and want to filter it in-memory.
– The query builder approach is preferred for performance if you can offload the search to the database.

### For Collection-Based Filtering
If `$coach->responders` is a collection that's already been loaded:

$search = request('search');

$data['responders'] = $coach->responders->when(!empty($search), function ($responders) use ($search) {
    return $responders->filter(function ($responder) use ($search) {
        return str_contains(strtolower($responder->first_name), strtolower($search)) ||
               str_contains(strtolower($responder->last_name), strtolower($search));
    });
});

### Explanation
1. **Check if `search` Has a Value**:
– `!empty($search)` ensures the search term is not empty or null.

2. **Conditional Filtering**:
– The `when()` method conditionally applies the filter if a search term exists.
– The `filter()` method iterates through each item to check if the `first_name` or `last_name` contains the search term.

### For Query Builder (Eloquent Relationship)
If `$coach->responders()` is a relationship that can be queried:

$search = request('search');

$data['responders'] = $coach->responders()->when(!empty($search), function ($query) use ($search) {
    $query->where('first_name', 'like', "%$search%")
          ->orWhere('last_name', 'like', "%$search%");
})->get();

### Explanation
1. **Checking if Search Has Value**:
– The `when()` method checks if the search term is not empty using `!empty($search)`.

2. **Applying Conditional `where` Clauses**:
– `like` with `%` wildcards allows for partial matches.

### Why Use `!empty()`?
– It ensures that the search term is not `null`, an empty string `''`, or any other "falsy" value that you don't want to filter by.

This way, the search filter only applies if the `search` parameter has an actual value.