Phalcon Mvc

use Phalcon\Mvc\Application;

class MyApp extends Application
{
    /**
     * Register the services here to make them general or register
     * in the ModuleDefinition to make them module-specific
     *\/
    protected function registerServices()
    {

    }

    /**
     * This method registers all the modules in the application
     *\/
    public function main()
    {
        $this->registerModules(
            [
                "frontend" => [
                    "className" => "Multiple\\Frontend\\Module",
                    "path"      => "../apps/frontend/Module.php",
                ],
                "backend" => [
                    "className" => "Multiple\\Backend\\Module",
                    "path"      => "../apps/backend/Module.php",
                ],
            ]
        );
    }
}

$application = new MyApp();

$application->main();

public function handle( string $uri ): ResponseInterface|bool;

public function sendCookiesOnHandleRequest( bool $sendCookies ): static;

public function sendHeadersOnHandleRequest( bool $sendHeaders ): static;

public function useImplicitView( bool $implicitView ): static;

public function __construct();

public function __construct(
    string|null $name = null,
    string|null $reason = null
);

public function __construct( string $path );

<?php

class PeopleController extends \Phalcon\Mvc\Controller
{
    // This action will be executed by default
    public function indexAction()
    {

    }

    public function findAction()
    {

    }

    public function saveAction()
    {
        // Forwards flow to the index action
        return $this->dispatcher->forward(
            [
                "controller" => "people",
                "action"     => "index",
            ]
        );
    }
}

final public function __construct();

public function getEventsManager(): ManagerInterface|null;

public function setEventsManager( ManagerInterface $eventsManager ): void;

protected function fireManagerEvent(
    string $eventName,
    mixed $data = null,
    bool $cancellable = true
): mixed|bool;

public static function getModelName(): string;

$di = new \Phalcon\Di\Di();

$dispatcher = new \Phalcon\Mvc\Dispatcher();

$dispatcher->setDI($di);

$dispatcher->setControllerName("posts");
$dispatcher->setActionName("index");
$dispatcher->setParams([]);

$controller = $dispatcher->dispatch();

public function forward( array $forward ): void;

use Phalcon\Events\Event;
use Phalcon\Mvc\Dispatcher;
use App\Backend\Bootstrap as Backend;
use App\Frontend\Bootstrap as Frontend;

// Registering modules
$modules = [
    "frontend" => [
        "className" => Frontend::class,
        "path"      => __DIR__ . "/app/Modules/Frontend/Bootstrap.php",
        "metadata"  => [
            "controllersNamespace" => "App\Frontend\Controllers",
        ],
    ],
    "backend" => [
        "className" => Backend::class,
        "path"      => __DIR__ . "/app/Modules/Backend/Bootstrap.php",
        "metadata"  => [
            "controllersNamespace" => "App\Backend\Controllers",
        ],
    ],
];

$application->registerModules($modules);

// Setting beforeForward listener
$eventsManager  = $di->getShared("eventsManager");

$eventsManager->attach(
    "dispatch:beforeForward",
    function(Event $event, Dispatcher $dispatcher, array $forward) use ($modules) {
        $metadata = $modules[$forward["module"]]["metadata"];

        $dispatcher->setModuleName(
            $forward["module"]
        );

        $dispatcher->setNamespaceName(
            $metadata["controllersNamespace"]
        );
    }
);

// Forward
$this->dispatcher->forward(
    [
        "module"     => "backend",
        "controller" => "posts",
        "action"     => "index",
    ]
);

public function getActiveController(): ControllerInterface;

public function getControllerClass(): string;

public function getControllerName(): string;

public function getLastController(): ControllerInterface;

public function getPreviousControllerName(): string;

public function setControllerName( string $controllerName ): DispatcherInterface;

public function setControllerSuffix( string $controllerSuffix ): DispatcherInterface;

public function setDefaultController( string $controllerName ): DispatcherInterface;

protected function handleException( \Exception $exception );

protected function throwDispatchException(
    string $message,
    int $exceptionCode = 0
);

public function __construct();

public function readAttribute( string $attribute ): mixed|null;

public function writeAttribute(
    string $attribute,
    mixed $value
);

$app = new \Phalcon\Mvc\Micro();

$app->get(
    "/say/welcome/{name}",
    function ($name) {
        echo "<h1>Welcome $name!</h1>";
    }
);

$app->handle("/say/welcome/Phalcon");

public function __construct( DiInterface|null $container = null );

public function after( mixed $handler ): static;

public function afterBinding( mixed $handler ): static;

public function before( mixed $handler ): static;

public function delete(
    string $routePattern,
    mixed $handler
): RouteInterface;

public function error( mixed $handler ): static;

public function finish( mixed $handler ): static;

public function get(
    string $routePattern,
    mixed $handler
): RouteInterface;

public function getActiveHandler();

public function getBoundModels(): array;

public function getEventsManager(): ManagerInterface|null;

public function getHandlers(): array;

public function getModelBinder(): BinderInterface|null;

public function getReturnedValue();

public function getRouter(): RouterInterface;

public function getService( string $serviceName );

public function getSharedService( string $serviceName );

public function handle( string $uri );

public function hasService( string $serviceName ): bool;

public function head(
    string $routePattern,
    mixed $handler
): RouteInterface;

public function map(
    string $routePattern,
    mixed $handler
): RouteInterface;

public function mount( CollectionInterface $collection ): static;

public function notFound( mixed $handler ): static;

public function offsetExists( mixed $offset ): bool;

public function offsetGet( mixed $offset ): mixed;

var_dump(
    $app["request"]
);

public function offsetSet(
    mixed $offset,
    mixed $value
): void;

   $app["request"] = new \Phalcon\Http\Request();

public function offsetUnset( mixed $offset ): void;

public function options(
    string $routePattern,
    mixed $handler
): RouteInterface;

public function patch(
    string $routePattern,
    mixed $handler
): RouteInterface;

public function post(
    string $routePattern,
    mixed $handler
): RouteInterface;

public function put(
    string $routePattern,
    mixed $handler
): RouteInterface;

public function setActiveHandler( mixed $activeHandler ): self;

public function setDI( DiInterface $container ): void;

public function setEventsManager( ManagerInterface $eventsManager ): void;

public function setModelBinder(
    BinderInterface $modelBinder,
    mixed $cache = null
): static;

$micro = new Micro($di);

$micro->setModelBinder(
    new Binder(),
    'cache'
);

public function setResponseHandler( mixed $handler ): static;

public function setService(
    string $serviceName,
    mixed $definition,
    bool $isShared = false
): ServiceInterface;

public function stop(): void;

$app = new \Phalcon\Mvc\Micro();

$collection = new Collection();

$collection->setHandler(
    new PostsController()
);

$collection->get("/posts/edit/{id}", "edit");

$app->mount($collection);

public function delete(
    string $routePattern,
    callable $handler,
    string|null $name = null
): CollectionInterface;

public function get(
    string $routePattern,
    callable $handler,
    string|null $name = null
): CollectionInterface;

public function getHandler(): mixed;

public function getHandlers(): array;

public function getPrefix(): string;

public function head(
    string $routePattern,
    callable $handler,
    string|null $name = null
): CollectionInterface;

public function isLazy(): bool;

public function map(
    string $routePattern,
    callable $handler,
    string|null $name = null
): CollectionInterface;

public function mapVia(
    string $routePattern,
    callable $handler,
    mixed $method,
    string|null $name = null
): CollectionInterface;

$collection->mapVia(
    "/test",
    "indexAction",
    ["POST", "GET"],
    "test"
);

public function options(
    string $routePattern,
    callable $handler,
    string|null $name = null
): CollectionInterface;

public function patch(
    string $routePattern,
    callable $handler,
    string|null $name = null
): CollectionInterface;

public function post(
    string $routePattern,
    callable $handler,
    string|null $name = null
): CollectionInterface;

public function put(
    string $routePattern,
    callable $handler,
    string|null $name = null
): CollectionInterface;

public function setHandler(
    mixed $handler,
    bool $isLazy = false
): CollectionInterface;

public function setLazy( bool $isLazy ): CollectionInterface;

public function setPrefix( string $prefix ): CollectionInterface;

protected function addMap(
    mixed $method,
    string $routePattern,
    callable $handler,
    string|null $name = null
): void;

public function delete(
    string $routePattern,
    callable $handler,
    string|null $name = null
): CollectionInterface;

public function get(
    string $routePattern,
    callable $handler,
    string|null $name = null
): CollectionInterface;

public function getHandler(): mixed;

public function getHandlers(): array;

public function getPrefix(): string;

public function head(
    string $routePattern,
    callable $handler,
    string|null $name = null
): CollectionInterface;

public function isLazy(): bool;

public function map(
    string $routePattern,
    callable $handler,
    string|null $name = null
): CollectionInterface;

public function options(
    string $routePattern,
    callable $handler,
    string|null $name = null
): CollectionInterface;

public function patch(
    string $routePattern,
    callable $handler,
    string|null $name = null
): CollectionInterface;

public function post(
    string $routePattern,
    callable $handler,
    string|null $name = null
): CollectionInterface;

public function put(
    string $routePattern,
    callable $handler,
    string|null $name = null
): CollectionInterface;

public function setHandler(
    mixed $handler,
    bool $isLazy = false
): CollectionInterface;

public function setLazy( bool $isLazy ): CollectionInterface;

public function setPrefix( string $prefix ): CollectionInterface;

public function __construct();

public function __construct();

public function __construct( string $type );

public function __construct();

public function __construct( string $definition );

public function __construct();

public function __construct();

public function __construct();

public function __construct();

public function __construct();

public function __construct( string $definition );

public function callMethod(
    string $method,
    mixed $arguments,
    BinderInterface|null $modelBinder = null
);

public function getDefinition(): string;

public function getHandler(): object|null;

public function call( Micro $application );

$invoice = new Invoices();

$invoice->inv_status_flag = "mechanical";
$invoice->inv_title = "Test Invoice";
$invoice->inv_total = 1952;

if ($invoice->save() === false) {
    echo "Umh, We can store invoices: ";

    $messages = $invoice->getMessages();

    foreach ($messages as $message) {
        echo $message;
    }
} else {
    echo "Great, a new invoice was saved successfully!";
}

public function __call(
    string $method,
    array $arguments
);

public static function __callStatic(
    string $method,
    array $arguments
);

final public function __construct(
    mixed $data = null,
    DiInterface|null $container = null,
    ManagerInterface|null $modelsManager = null
);

public function __get( string $property );

public function __isset( string $property ): bool;

public function __serialize(): array;

public function __set(
    string $property,
    mixed $value
);

public function __unserialize( array $data ): void;

public function addBehavior( BehaviorInterface $behavior ): void;

use Phalcon\Mvc\Model;
use Phalcon\Mvc\Model\Behavior\Timestampable;

class Invoices extends Model
{
    public function initialize()
    {
        $this->addBehavior(
            new Timestampable(
                [
                    "beforeCreate" => [
                        "field"  => "created_at",
                        "format" => "Y-m-d",
                    ],
                ]
            )
        );

        $this->addBehavior(
            new Timestampable(
                [
                    "beforeUpdate" => [
                        "field"  => "updated_at",
                        "format" => "Y-m-d",
                    ],
                ]
            )
        );
    }
}

public function appendMessage( MessageInterface $message ): ModelInterface;

use Phalcon\Mvc\Model;
use Phalcon\Messages\Message as Message;

class Invoices extends Model
{
    public function beforeSave()
    {
        if ($this->name === "Peter") {
            $message = new Message(
                "Sorry, but an invoice cannot be named Peter"
            );

            $this->appendMessage($message);
        }
    }
}

public inline function appendMessagesFrom( mixed $model ): void;

public function assign(
    array $data,
    mixed $whiteList = null,
    mixed $dataColumnMap = null
): ModelInterface;

$invoice->assign(
    [
        "type" => "mechanical",
        "name" => "Test Invoice",
        "year" => 1952,
    ]
);

// Assign by db row, column map needed
$invoice->assign(
    $dbRow,
    [
        "db_type" => "type",
        "db_name" => "name",
        "db_year" => "year",
    ]
);

// Allow assign only name and year
$invoice->assign(
    $_POST,
    [
        "name",
        "year",
    ]
);

// By default assign method will use setters if exist, you can disable it by using ini_set to directly use properties

ini_set("phalcon.orm.disable_assign_setters", true);

$invoice->assign(
    $_POST,
    [
        "name",
        "year",
    ]
);

public static function average( array $parameters = [] ): float|ResultsetInterface;

// What's the average price of invoices?
$average = Invoices::average(
    [
        "column" => "inv_total",
    ]
);

echo "The average price is ", $average, "\n";

// What's the average price of paid invoices?
$average = Invoices::average(
    [
        "inv_status_flag = 1",
        "column" => "inv_total",
    ]
);

echo "The average price of paid invoices is ", $average, "\n";

public static function cloneResult(
    ModelInterface $base,
    array $data,
    int $dirtyState = 0
): ModelInterface;

$invoice = Phalcon\Mvc\Model::cloneResult(
    new Invoices(),
    [
        "type" => "mechanical",
        "name" => "Test Invoice",
        "year" => 1952,
    ]
);

public static function cloneResultMap(
    mixed $base,
    array $data,
    mixed $columnMap,
    int $dirtyState = 0,
    bool|null $keepSnapshots = null
): ModelInterface;

$invoice = \Phalcon\Mvc\Model::cloneResultMap(
    new Invoices(),
    [
        "type" => "mechanical",
        "name" => "Test Invoice",
        "year" => 1952,
    ]
);

public static function cloneResultMapHydrate(
    array $data,
    mixed $columnMap,
    int $hydrationMode
);

public static function count( mixed $parameters = null ): int|ResultsetInterface;

// How many invoices are there?
$number = Invoices::count();

echo "There are ", $number, "\n";

// How many paid invoices are there?
$number = Invoices::count("inv_status_flag = 1");

echo "There are ", $number, " paid invoices\n";

public function create(): bool;

// Creating a new invoice
$invoice = new Invoices();

$invoice->inv_status_flag = "mechanical";
$invoice->inv_title = "Test Invoice";
$invoice->inv_total = 1952;

$invoice->create();

// Passing an array to create
$invoice = new Invoices();

$invoice->assign(
    [
        "type" => "mechanical",
        "name" => "Test Invoice",
        "year" => 1952,
    ]
);

$invoice->create();

public function delete(): bool;

$invoice = Invoices::findFirst("id=100");

$invoice->delete();

$invoices = Invoices::find("inv_status_flag = 1");

foreach ($invoices as $invoice) {
    $invoice->delete();
}

public function doSave( CollectionInterface $visited ): bool;

public function dump(): array;

var_dump(
    $invoice->dump()
);

public static function find( mixed $parameters = null ): ResultsetInterface;

// How many invoices are there?
$invoices = Invoices::find();

echo "There are ", count($invoices), "\n";

// How many paid invoices are there?
$invoices = Invoices::find(
    "inv_status_flag = 1"
);

echo "There are ", count($invoices), "\n";

// Get and print virtual invoices ordered by name
$invoices = Invoices::find(
    [
        "type = 'virtual'",
        "order" => "name",
    ]
);

foreach ($invoices as $invoice) {
    echo $invoice->inv_title, "\n";
}

// Get first 100 virtual invoices ordered by name
$invoices = Invoices::find(
    [
        "type = 'virtual'",
        "order" => "name",
        "limit" => 100,
    ]
);

foreach ($invoices as $invoice) {
    echo $invoice->inv_title, "\n";
}

// encapsulate find it into an running transaction esp. useful for application unit-tests
// or complex business logic where we wanna control which transactions are used.

$myTransaction = new Transaction(\Phalcon\Di\Di::getDefault());
$myTransaction->begin();

$newInvoices = new Invoices();
$newInvoices->setTransaction($myTransaction);

$newInvoices->assign(
    [
        'name' => 'test',
        'type' => 'mechanical',
        'year' => 1944,
    ]
);

$newInvoices->save();

$resultInsideTransaction = Invoices::find(
    [
        'name' => 'test',
        Model::TRANSACTION_INDEX => $myTransaction,
    ]
);

$resultOutsideTransaction = Invoices::find(['name' => 'test']);

foreach ($setInsideTransaction as $invoice) {
    echo $invoice->inv_title, "\n";
}

foreach ($setOutsideTransaction as $invoice) {
    echo $invoice->inv_title, "\n";
}

// reverts all not commited changes
$myTransaction->rollback();

// creating two different transactions
$myTransaction1 = new Transaction(\Phalcon\Di\Di::getDefault());
$myTransaction1->begin();
$myTransaction2 = new Transaction(\Phalcon\Di\Di::getDefault());
$myTransaction2->begin();

 // add a new invoices
$firstNewInvoices = new Invoices();
$firstNewInvoices->setTransaction($myTransaction1);
$firstNewInvoices->assign(
    [
        'name' => 'first-transaction-invoice',
        'type' => 'mechanical',
        'year' => 1944,
    ]
);
$firstNewInvoices->save();

$secondNewInvoices = new Invoices();
$secondNewInvoices->setTransaction($myTransaction2);
$secondNewInvoices->assign(
    [
        'name' => 'second-transaction-invoice',
        'type' => 'fictional',
        'year' => 1984,
    ]
);
$secondNewInvoices->save();

// this transaction will find the invoice.
$resultInFirstTransaction = Invoices::find(
    [
        'name'                   => 'first-transaction-invoice',
        Model::TRANSACTION_INDEX => $myTransaction1,
    ]
);

// this transaction won't find the invoice.
$resultInSecondTransaction = Invoices::find(
    [
        'name'                   => 'first-transaction-invoice',
        Model::TRANSACTION_INDEX => $myTransaction2,
    ]
);

// this transaction won't find the invoice.
$resultOutsideAnyExplicitTransaction = Invoices::find(
    [
        'name' => 'first-transaction-invoice',
    ]
);

// this transaction won't find the invoice.
$resultInFirstTransaction = Invoices::find(
    [
        'name'                   => 'second-transaction-invoice',
        Model::TRANSACTION_INDEX => $myTransaction2,
    ]
);

// this transaction will find the invoice.
$resultInSecondTransaction = Invoices::find(
    [
        'name'                   => 'second-transaction-invoice',
        Model::TRANSACTION_INDEX => $myTransaction1,
    ]
);

// this transaction won't find the invoice.
$resultOutsideAnyExplicitTransaction = Invoices::find(
    [
        'name' => 'second-transaction-invoice',
    ]
);

$transaction1->rollback();
$transaction2->rollback();

public static function findFirst( mixed $parameters = null ): mixed|null;

// What's the first invoice in invoices table?
$invoice = Invoices::findFirst();

echo "The invoice name is ", $invoice->inv_title;

// What's the first paid invoice in invoices table?
$invoice = Invoices::findFirst(
    "inv_status_flag = 1"
);

echo "The first paid invoice name is ", $invoice->inv_title;

// Get first virtual invoice ordered by name
$invoice = Invoices::findFirst(
    [
        "type = 'virtual'",
        "order" => "name",
    ]
);

echo "The first virtual invoice name is ", $invoice->inv_title;

// behavior with transaction
$myTransaction = new Transaction(\Phalcon\Di\Di::getDefault());
$myTransaction->begin();

$newInvoices = new Invoices();
$newInvoices->setTransaction($myTransaction);
$newInvoices->assign(
    [
        'name' => 'test',
        'type' => 'mechanical',
        'year' => 1944,
    ]
);
$newInvoices->save();

$findsAInvoices = Invoices::findFirst(
    [
        'name'                   => 'test',
        Model::TRANSACTION_INDEX => $myTransaction,
    ]
);

$doesNotFindAInvoices = Invoices::findFirst(
    [
        'name' => 'test',
    ]
);

var_dump($findAInvoices);
var_dump($doesNotFindAInvoices);

$transaction->commit();

$doesFindTheInvoicesNow = Invoices::findFirst(
    [
        'name' => 'test',
    ]
);