<?php

use PhalconMvcModel;

class Robots extends Model
{
    public $id;

    public $name;

    public $price;
}

<?php

use PhalconMvcModel;

class Robots extends Model
{
    protected $id;

    protected $name;

    protected $price;

    public function getId()
    {
        return $this->id;
    }

    public function setName($name)
    {
        // The name is too short?
        if (strlen($name) < 10) {
            throw new InvalidArgumentException('The name is too short');
        }
        $this->name = $name;
    }

    public function getName()
    {
        return $this->name;
    }

    public function setPrice($price)
    {
        // Negative prices aren't allowed
        if ($price < 0) {
            throw new InvalidArgumentException('Price can't be negative');
        }
        $this->price = $price;
    }

    public function getPrice()
    {
        // Convert the value to double before be used
        return (double) $this->price;
    }
}

<?php

namespace StoreToys;

use PhalconMvcModel;

class Robots extends Model
{
    // ...
}

<?php

namespace StoreToys;

use PhalconMvcModel;

class Robots extends Model
{
    public $id;

    public $name;

    public function initialize()
    {
        $this->hasMany('id', 'StoreToysRobotsParts', 'robots_id');
    }
}

<?php

// Get all robots
$robots = Robots::find();

// Traversing with a foreach
foreach ($robots as $robot) {
    echo $robot->name, "n";
}

// Traversing with a while
$robots->rewind();
while ($robots->valid()) {
    $robot = $robots->current();
    echo $robot->name, "n";
    $robots->next();
}

// Count the resultset
echo count($robots);

// Alternative way to count the resultset
echo $robots->count();

// Move the internal cursor to the third robot
$robots->seek(2);
$robot = $robots->current();

// Access a robot by its position in the resultset
$robot = $robots[5];

// Check if there is a record in certain position
if (isset($robots[3])) {
   $robot = $robots[3];
}

// Get the first record in the resultset
$robot = $robots->getFirst();

// Get the last record
$robot = $robots->getLast();

<?php

// Query all records from model parts
$parts = Parts::find();

// Store the resultset into a file
file_put_contents("cache.txt", serialize($parts));

// Get parts from file
$parts = unserialize(file_get_contents("cache.txt"));

// Traverse the parts
foreach ($parts as $part) {
    echo $part->id;
}

<?php

$customers = Customers::find()->filter(
    function ($customer) {

        // Return only customers with a valid e-mail
        if (filter_var($customer->email, FILTER_VALIDATE_EMAIL)) {
            return $customer;
        }
    }
);

<?php

// Query robots binding parameters with string placeholders
$conditions = "name = :name: AND type = :type:";

// Parameters whose keys are the same as placeholders
$parameters = array(
    "name" => "Robotina",
    "type" => "maid"
);

// Perform the query
$robots = Robots::find(
    array(
        $conditions,
        "bind" => $parameters
    )
);

// Query robots binding parameters with integer placeholders
$conditions = "name = ?1 AND type = ?2";
$parameters = array(1 => "Robotina", 2 => "maid");
$robots     = Robots::find(
    array(
        $conditions,
        "bind" => $parameters
    )
);

// Query robots binding parameters with both string and integer placeholders
$conditions = "name = :name: AND type = ?1";

// Parameters whose keys are the same as placeholders
$parameters = array(
    "name" => "Robotina",
    1      => "maid"
);

// Perform the query
$robots = Robots::find(
    array(
        $conditions,
        "bind" => $parameters
    )
);

<?php

use PhalconDbColumn;

// Bind parameters
$parameters = array(
    "name" => "Robotina",
    "year" => 2008
);

// Casting Types
$types = array(
    "name" => Column::BIND_PARAM_STR,
    "year" => Column::BIND_PARAM_INT
);

// Query robots binding parameters with string placeholders
$robots = Robots::find(
    array(
        "name = :name: AND year = :year:",
        "bind"      => $parameters,
        "bindTypes" => $types
    )
);

<?php

$array = ["a","b","c"]; // $array: [[0] => "a", [1] => "b", [2] => "c"]

unset($array[1]); // $array: [[0] => "a", [2] => "c"]

// Now we have to renumber the keys
$array = array_values($array); // $array: [[0] => "a", [1] => "c"]

$robots = Robots::find(
    array(
        'letter IN ({letter:array})',
        'bind' => array(
            'letter' => $array
        )
    )
);

<?php

// Explicit query using bound parameters
$robots = Robots::find(
    array(
        "name = ?0",
        "bind" => ["Ultron"],
    )
);

// Implicit query using bound parameters
$robots = Robots::findByName("Ultron");

<?php

use PhalconMvcModel;

class Robots extends Model
{
    public $id;

    public $name;

    public function initialize()
    {
        $this->hasMany("id", "RobotsParts", "robots_id");
    }
}

<?php

use PhalconMvcModel;

class Parts extends Model
{
    public $id;

    public $name;

    public function initialize()
    {
        $this->hasMany("id", "RobotsParts", "parts_id");
    }
}

<?php

use PhalconMvcModel;

class RobotsParts extends Model
{
    public $id;

    public $robots_id;

    public $parts_id;

    public function initialize()
    {
        $this->belongsTo("robots_id", "Robots", "id");
        $this->belongsTo("parts_id", "Parts", "id");
    }
}

<?php

use PhalconMvcModel;

class Robots extends Model
{
    public $id;

    public $name;

    public function initialize()
    {
        $this->hasManyToMany(
            "id",
            "RobotsParts",
            "robots_id", "parts_id",
            "Parts",
            "id"
        );
    }
}

<?php

$robot = Robots::findFirst(2);
foreach ($robot->robotsParts as $robotPart) {
    echo $robotPart->parts->name, "n";
}

<?php

$robot       = Robots::findFirst();
$robotsParts = $robot->robotsParts; // All the related records in RobotsParts

<?php

$robot       = Robots::findFirst();
$robotsParts = $robot->getRobotsParts(); // All the related records in RobotsParts
$robotsParts = $robot->getRobotsParts(array('limit' => 5)); // Passing parameters

<?php

$robot       = Robots::findFirst(2);

// Robots model has a 1-n (hasMany)
// relationship to RobotsParts then
$robotsParts = $robot->robotsParts;

// Only parts that match conditions
$robotsParts = $robot->getRobotsParts("created_at = '2015-03-15'");

// Or using bound parameters
$robotsParts = $robot->getRobotsParts(
    array(
        "created_at = :date:",
        "bind" => array(
            "date" => "2015-03-15"
        )
    )
);

$robotPart   = RobotsParts::findFirst(1);

// RobotsParts model has a n-1 (belongsTo)
// relationship to RobotsParts then
$robot = $robotPart->robots;

<?php

$robot       = Robots::findFirst(2);

// Robots model has a 1-n (hasMany)
// relationship to RobotsParts, then
$robotsParts = RobotsParts::find("robots_id = '" . $robot->id . "'");

// Only parts that match conditions
$robotsParts = RobotsParts::find(
    "robots_id = '" . $robot->id . "' AND created_at = '2015-03-15'"
);

$robotPart   = RobotsParts::findFirst(1);

// RobotsParts model has a n-1 (belongsTo)
// relationship to RobotsParts then
$robot = Robots::findFirst("id = '" . $robotPart->robots_id . "'");

<?php

$robot = Robots::findFirst(2);
echo "The robot has ", $robot->countRobotsParts(), " partsn";

<?php

class RobotsSimilar extends PhalconMvcModel
{
    public function initialize()
    {
        $this->belongsTo('robots_id', 'Robots', 'id');
        $this->belongsTo('similar_robots_id', 'Robots', 'id');
    }
}

<?php

$robotsSimilar = RobotsSimilar::findFirst();

// Returns the related record based on the column (robots_id)
// Also as is a belongsTo it's only returning one record
// but the name 'getRobots' seems to imply that return more than one
$robot = $robotsSimilar->getRobots();

// but, how to get the related record based on the column (similar_robots_id)
// if both relationships have the same name?

<?php

use PhalconMvcModel;

class RobotsSimilar extends Model
{
    public function initialize()
    {
        $this->belongsTo(
            'robots_id',
            'Robots',
            'id',
            array(
                'alias' => 'Robot'
            )
        );

        $this->belongsTo(
            'similar_robots_id',
            'Robots',
            'id',
            array(
                'alias' => 'SimilarRobot'
            )
        );
    }
}

<?php

$robotsSimilar = RobotsSimilar::findFirst();

// Returns the related record based on the column (robots_id)
$robot = $robotsSimilar->getRobot();
$robot = $robotsSimilar->robot;

// Returns the related record based on the column (similar_robots_id)
$similarRobot = $robotsSimilar->getSimilarRobot();
$similarRobot = $robotsSimilar->similarRobot;

<?php

use PhalconMvcModel;

class Robots extends Model
{
    public $id;

    public $name;

    public function initialize()
    {
        $this->hasMany("id", "RobotsParts", "robots_id");
    }

    /**
     * Return the related "robots parts"
     *
     * @return RobotsParts[]
     */
    public function getRobotsParts($parameters = null)
    {
        return $this->getRelated('RobotsParts', $parameters);
    }
}

<?php

namespace StoreModels;

use PhalconMvcModel;
use PhalconMvcModelRelation;

class Robots extends Model
{
    public $id;

    public $name;

    public function initialize()
    {
        $this->hasMany(
            'id',
            'StoreModelsParts',
            'robots_id',
            array(
                'foreignKey' => array(
                    'action' => Relation::ACTION_CASCADE
                )
            )
        );
    }
}

<?php

$robot       = new Robots();
$robot->type = "mechanical";
$robot->name = "Astro Boy";
$robot->year = 1952;

// This record only must be created
if ($robot->create() == false) {
    echo "Umh, We can't store robots right now: n";
    foreach ($robot->getMessages() as $message) {
        echo $message, "n";
    }
} else {
    echo "Great, a new robot was created successfully!";
}

<?php

$robot->save();

echo "The generated id is: ", $robot->id;

<?php

use PhalconMvcModel;

class Robots extends Model
{
    public function getSequenceName()
    {
        return "robots_sequence_name";
    }
}

<?php

// Create an artist
$artist          = new Artists();
$artist->name    = 'Shinichi Osawa';
$artist->country = 'Japan';

// Create an album
$album         = new Albums();
$album->name   = 'The One';
$album->artist = $artist; // Assign the artist
$album->year   = 2008;

// Save both records
$album->save();

<?php

// Get an existing artist
$artist = Artists::findFirst('name = "Shinichi Osawa"');

// Create an album
$album         = new Albums();
$album->name   = 'The One';
$album->artist = $artist;

$songs = array();

// Create a first song
$songs[0]           = new Songs();
$songs[0]->name     = 'Star Guitar';
$songs[0]->duration = '5:54';

// Create a second song
$songs[1]           = new Songs();
$songs[1]->name     = 'Last Days';
$songs[1]->duration = '4:29';

// Assign the songs array
$album->songs = $songs;

// Save the album + its songs
$album->save();

<?php

if ($robot->save() == false) {
    foreach ($robot->getMessages() as $message) {
        echo "Message: ", $message->getMessage();
        echo "Field: ", $message->getField();
        echo "Type: ", $message->getType();
    }
}

<?php

use PhalconMvcModel;

class Robots extends Model
{
    public function getMessages()
    {
        $messages = array();
        foreach (parent::getMessages() as $message) {
            switch ($message->getType()) {
                case 'InvalidCreateAttempt':
                    $messages[] = 'The record cannot be created because it already exists';
                    break;
                case 'InvalidUpdateAttempt':
                    $messages[] = 'The record cannot be updated because it already exists';
                    break;
                case 'PresenceOf':
                    $messages[] = 'The field ' . $message->getField() . ' is mandatory';
                    break;
            }
        }

        return $messages;
    }
}

<?php

use PhalconMvcModel;

class Robots extends Model
{
    public function beforeValidationOnCreate()
    {
        echo "This is executed before creating a Robot!";
    }
}

<?php

use PhalconMvcModel;

class Products extends Model
{
    public function beforeCreate()
    {
        // Set the creation date
        $this->created_at = date('Y-m-d H:i:s');
    }

    public function beforeUpdate()
    {
        // Set the modification date
        $this->modified_in = date('Y-m-d H:i:s');
    }
}

<?php

use PhalconMvcModel;
use PhalconEventsManager as EventsManager;

class Robots extends Model
{
    public function initialize()
    {
        $eventsManager = new EventsManager();

        // Attach an anonymous function as a listener for "model" events
        $eventsManager->attach('model', function ($event, $robot) {
            if ($event->getType() == 'beforeSave') {
                if ($robot->name == 'Scooby Doo') {
                    echo "Scooby Doo isn't a robot!";
                    return false;
                }
            }

            return true;
        });

        // Attach the events manager to the event
        $this->setEventsManager($eventsManager);
    }
}

<?php

$robot       = new Robots();
$robot->name = 'Scooby Doo';
$robot->year = 1969;

$robot->save();

<?php

// Registering the modelsManager service
$di->setShared('modelsManager', function () {

    $eventsManager = new PhalconEventsManager();

    // Attach an anonymous function as a listener for "model" events
    $eventsManager->attach('model', function ($event, $model) {

        // Catch events produced by the Robots model
        if (get_class($model) == 'Robots') {

            if ($event->getType() == 'beforeSave') {
                if ($model->name == 'Scooby Doo') {
                    echo "Scooby Doo isn't a robot!";
                    return false;
                }
            }
        }

        return true;
    });

    // Setting a default EventsManager
    $modelsManager = new ModelsManager();
    $modelsManager->setEventsManager($eventsManager);

    return $modelsManager;
});

<?php

use PhalconMvcModel;

class Robots extends Model
{
    public function beforeSave()
    {
        if ($this->year < 0) {
            echo "Year cannot be smaller than zero!";
            return false;
        }
    }
}

<?php

use PhalconMvcModel;
use PhalconMvcModelValidatorUniqueness;
use PhalconMvcModelValidatorInclusionIn;

class Robots extends Model
{
    public function validation()
    {
        $this->validate(
            new InclusionIn(
                array(
                    "field"  => "type",
                    "domain" => array("Mechanical", "Virtual")
                )
            )
        );

        $this->validate(
            new Uniqueness(
                array(
                    "field"   => "name",
                    "message" => "The robot name must be unique"
                )
            )
        );

        return $this->validationHasFailed() != true;
    }
}

<?php

use PhalconMvcModelValidator;
use PhalconMvcModelValidatorInterface;
use PhalconMvcEntityInterface;

class MaxMinValidator extends Validator implements ValidatorInterface
{
    public function validate(EntityInterface $model)
    {
        $field = $this->getOption('field');

        $min   = $this->getOption('min');
        $max   = $this->getOption('max');

        $value = $model->$field;

        if ($min <= $value && $value <= $max) {
            $this->appendMessage(
                "The field doesn't have the right range of values",
                $field,
                "MaxMinValidator"
            );

            return false;
        }

        return true;
    }
}

<?php

use PhalconMvcModel;

class Customers extends Model
{
    public function validation()
    {
        $this->validate(
            new MaxMinValidator(
                array(
                    "field" => "price",
                    "min"   => 10,
                    "max"   => 100
                )
            )
        );

        if ($this->validationHasFailed() == true) {
            return false;
        }
    }
}

<?php

use PhalconMvcModel;
use PhalconMvcModelMessage;

class Robots extends Model
{
    public function validation()
    {
        if ($this->type == "Old") {
            $message = new Message(
                "Sorry, old robots are not allowed anymore",
                "type",
                "MyType"
            );

            $this->appendMessage($message);

            return false;
        }

        return true;
    }
}

<?php

$name           = 'Artichoke';
$price          = 10.5;
$active         = 'Y';
$productTypesId = 1;

$sql = 'INSERT INTO products VALUES (null, :productTypesId, :name, :price, :active)';
$sth = $dbh->prepare($sql);

$sth->bindParam(':productTypesId', $productTypesId, PDO::PARAM_INT);
$sth->bindParam(':name', $name, PDO::PARAM_STR, 70);
$sth->bindParam(':price', doubleval($price));
$sth->bindParam(':active', $active, PDO::PARAM_STR, 1);

$sth->execute();

<?php

$product                   = new Products();
$product->product_types_id = 1;
$product->name             = 'Artichoke';
$product->price            = 10.5;
$product->active           = 'Y';

$product->create();

<?php

use PhalconMvcModel;

class Robots extends Model
{
    public function initialize()
    {
        $this->useDynamicUpdate(true);
    }
}

<?php

use PhalconMvcModelBehaviorTimestampable;

public function initialize()
{
    $this->addBehavior(
        new Timestampable(
            array(
                'beforeCreate' => array(
                    'field'  => 'created_at',
                    'format' => 'Y-m-d'
                )
            )
        )
    );
}

<?php

use PhalconMvcModelBehaviorTimestampable;

public function initialize()
{
    $this->addBehavior(
        new Timestampable(
            array(
                'beforeCreate' => array(
                    'field'  => 'created_at',
                    'format' => function () {
                        $datetime = new Datetime(new DateTimeZone('Europe/Stockholm'));
                        return $datetime->format('Y-m-d H:i:sP');
                    }
                )
            )
        )
    );
}

<?php

use PhalconMvcModel;
use PhalconMvcModelBehaviorSoftDelete;

class Users extends Model
{
    const DELETED = 'D';

    const NOT_DELETED = 'N';

    public $id;

    public $name;

    public $status;

    public function initialize()
    {
        $this->addBehavior(
            new SoftDelete(
                array(
                    'field' => 'status',
                    'value' => Users::DELETED
                )
            )
        );
    }
}

<?php

Users::findFirst(2)->delete();

<?php

use PhalconMvcModelBehavior;
use PhalconMvcModelBehaviorInterface;

class Blameable extends Behavior implements BehaviorInterface
{
    public function notify($eventType, $model)
    {
        switch ($eventType) {

            case 'afterCreate':
            case 'afterDelete':
            case 'afterUpdate':

                $userName = // ... get the current user from session

                // Store in a log the username - event type and primary key
                file_put_contents(
                    'logs/blamable-log.txt',
                    $userName . ' ' . $eventType . ' ' . $model->id
                );

                break;

            default:
                /* ignore the rest of events */
        }
    }
}

<?php

use PhalconMvcModel;

class Profiles extends Model
{
    public function initialize()
    {
        $this->addBehavior(new Blameable());
    }
}

<?php

use PhalconTag;
use PhalconMvcModelBehavior;
use PhalconMvcModelBehaviorInterface;

class Sluggable extends Behavior implements BehaviorInterface
{
    public function missingMethod($model, $method, $arguments = array())
    {
        // If the method is 'getSlug' convert the title
        if ($method == 'getSlug') {
            return Tag::friendlyTitle($model->title);
        }
    }
}

<?php

$title = $post->getSlug();

<?php

trait MyTimestampable
{
    public function beforeCreate()
    {
        $this->created_at = date('r');
    }

    public function beforeUpdate()
    {
        $this->updated_at = date('r');
    }
}

<?php

use PhalconMvcModel;

class Products extends Model
{
    use MyTimestampable;
}

<?php

foreach ($robots->getParts() as $part) {
    $part->stock      = 100;
    $part->updated_at = time();

    if ($part->update() == false) {
        foreach ($part->getMessages() as $message) {
            echo $message;
        }

        break;
    }
}

<?php

$robots->getParts()->update(
    array(
        'stock'      => 100,
        'updated_at' => time()
    )
);

<?php

$data = array(
    'stock'      => 100,
    'updated_at' => time()
);

// Update all the parts except those whose type is basic
$robots->getParts()->update($data, function ($part) {
    if ($part->type == Part::TYPE_BASIC) {
        return false;
    }

    return true;
});

<?php

foreach ($robots->getParts() as $part) {
    if ($part->delete() == false) {
        foreach ($part->getMessages() as $message) {
            echo $message;
        }

        break;
    }
}

<?php

$robots->getParts()->delete();

<?php

// Delete only whose stock is greater or equal than zero
$robots->getParts()->delete(function ($part) {
    if ($part->stock < 0) {
        return false;
    }

    return true;
});