docs/ru/basics/controllers.md
# Controllers
Controllers - is a class which may help you to organize requests and responses in a pretty way instead of writing closure functions inside routes itself.
## Create Controller
To create simple controller run the following command:
```
php broccoli new:middleware <Class/Name/Within/Folder>
```
Let's say you want to create `IsIhar` middleware inside `MyMiddleware` folder the command will be
```bash
php broccoli new:controller SimpleController
```
This will create `SimpleController.php` file with no information within
```php
namespace Theme;
use Brocooly\Http\Controllers\BaseController;
class SimpleController extends BaseController
{
}
```
### Options
If you want to create abstract base Controller inside `src/Http/Controllers` directory, specify `-b` flag.
```bash
php broccoli new:controller SimpleController -b
```
which will create
```php
namespace Theme\Http\Controllers;
use Brocooly\Http\Controllers\BaseController;
abstract class SimpleController extends BaseController
{
}
```
Sometimes you need to extend not `BaseController` but `AjaxController` - it has its own place inside theme folder. So the command would be
```bash
php broccoli new:controller SimpleController -a
```
and generated file is
```php
namespace Theme;
use Theme\Http\Controllers\AjaxController;
class SimpleController extends AjaxController
{
public function handle()
{
//...
}
}
```
it has already create `handle()` template to work with.
To create more methods you may specify any of these flags: `-i` for invokable, `-c` to create `__construct()` and `-r` to create both `index()` and `single()`. You may mix as many flags as you wish
```bash
php broccoli new:controller CustomDir/SimpleController -acr
```
will generate
```php
namespace Theme\CustomDir;
use Theme\Http\Controllers\AjaxController;
class SimpleController extends AjaxController
{
public function handle()
{
//...
}
public function __construct()
{
//...
}
public function index()
{
//...
}
public function single()
{
//...
}
}
```
### What is Resource Controller
Out of the box WordPress separate every post type or taxonomy into two pages - singular page, which is **single** model, and its archive - or **index** file where there are all (or at least part) of models together. Instead of regular CRUD we are dealing mostly with singular-archive pages, or single-index templates. That is why Brocooly prefers refer single-index as a resource controller and methods.
## Usage
Use of controllers was described in a [routing](getting-started/routing.md) part of documentation.
Most common use is to pass Controller name and its method
```php
use Theme\Http\Controllers\PostController;
Route::get( 'is_single', [ PostController::class, 'index' ] );
```
This line means for `is_single()` case will be fired `index` method of `PostController` controller.
An alternative syntax would be
```php
Route::get( 'is_single', 'Theme\Http\Controllers\PostController@index' );
```
where controller and its method joined in a single line string with `@` as a divider.
> Remember to use a valid namespace for your Controller in both cases
Finally you pass only class name if it is invokable controller - basically a class which no need for any method except one.
```php
use Theme\Http\Controllers\PostController;
Route::get( 'is_single', PostController::class );
```
and your controller would be like
```php
class PostController
{
public function __invoke()
{
// render the content
}
}
```
### Passing Parameters
If you want to pass an argument to your method you need to pass it as a third parameter and accept inside method
```php
use Theme\Http\Controllers\PostController;
Route::get( 'is_single', [ PostController::class, 'single', new IndexRequest() ] );
```
```php
class PostController
{
public function single( IndexRequest $request )
{
// dd( $request );
}
}
```