DataSources (Sources de Données)¶

App::uses('HttpSocket', 'Network/Http');

class FarAwaySource extends DataSource {

/**
 * Une description optionnelle de votre source de données
 */
    public $description = 'A far away datasource';

/**
 * Nos options de config par défaut. Ces options seront personnalisées dans notre
 * ``app/Config/database.php`` et seront fusionnées dans le ``__construct()``.
 */
    public $config = array(
        'apiKey' => '',
    );

/**
 * Si nous voulons create() ou update(), nous avons besoin de spécifier la
 * disponibilité des champs. Nous utilisons le même tableau indicé comme nous le faisions avec CakeSchema, par exemple
 * fixtures et schema de migrations.
 */
    protected $_schema = array(
        'id' => array(
            'type' => 'integer',
            'null' => false,
            'key' => 'primary',
            'length' => 11,
        ),
        'name' => array(
            'type' => 'string',
            'null' => true,
            'length' => 255,
        ),
        'message' => array(
            'type' => 'text',
            'null' => true,
        ),
    );

/**
 * Créons notre HttpSocket et gérons any config tweaks.
 */
    public function __construct($config) {
        parent::__construct($config);
        $this->Http = new HttpSocket();
    }

/**
 * Puisque les sources de données se connectent normalement à une base de données
 * il y a quelques modifications à faire pour les faire marcher sans base de données.
 */

/**
 * listSources() est pour la mise en cache. Vous voulez implémenter la mise en cache
 * de votre façon avec une source de données personnalisée. Donc juste ``return null``.
 */
    public function listSources() {
        return null;
    }

/**
 * describe() dit au model votre schema pour ``Model::save()``.
 *
 * Vous voulez peut-être un schema différent pour chaque model mais utiliser
 * toujours une unique source de données. Si c'est votre cas, alors
 * définissez une propriété ``schema`` dans vos models et retournez
 * simplement ``$Model->schema`` ici à la place.
 */
    public function describe(Model $Model) {
        return $this->_schema;
    }

/**
 * calculate() est pour déterminer la façon dont nous allons compter
 * les enregistrements et est requis pour faire fonctionner ``update()``
 * et ``delete()``.
 *
 * Nous ne comptons pas les enregistrements ici mais retournons une chaîne
 * à passer à
 * ``read()`` qui va effectivement faire le comptage. La façon la plus
 * facile est de juste retourner la chaîne 'COUNT' et de la vérifier
 * dans ``read()`` où ``$data['fields'] === 'COUNT'``.
 */
    public function calculate(Model $model, $func, $params = array()) {
        return 'COUNT';
    }

/**
 * Implémente le R dans CRUD. Appel à ``Model::find()`` se trouve ici.
 */
    public function read(Model $model, $queryData = array(), $recursive = null) {
        /**
         * Ici nous faisons réellement le comptage comme demandé par notre
         * méthode calculate() ci-dessus. Nous pouvons soit vérifier la
         * source du dépôt, soit une autre façon pour récupérer le compte
         * de l\'enregistrement. Ici nous allons simplement retourner 1
         * ainsi ``update()`` et ``delete()`` vont estimer que l\'enregistrement
         * existe.
         */
        if ($queryData['fields'] === 'COUNT') {
            return array(array(array('count' => 1)));
        }
        /**
         * Maintenant nous récupérons, décodons et retournons les données du dépôt.
         */
        $queryData['conditions']['apiKey'] = $this->config['apiKey'];
        $json = $this->Http->get('http://example.com/api/list.json', $queryData['conditions']);
        $res = json_decode($json, true);
        if (is_null($res)) {
            $error = json_last_error();
            throw new CakeException($error);
        }
        return array($Model->alias => $res);
    }

/**
 * Implémente le C dans CRUD. Appel à ``Model::save()`` sans $model->id
 * défini se trouve ici.
 */
    public function create(Model $model, $fields = null, $values = null) {
        $data = array_combine($fields, $values);
        $data['apiKey'] = $this->config['apiKey'];
        $json = $this->Http->post('http://example.com/api/set.json', $data);
        $res = json_decode($json, true);
        if (is_null($res)) {
            $error = json_last_error();
            throw new CakeException($error);
        }
        return true;
    }

/**
 * Implémente le U dans CRUD. Appel à ``Model::save()`` avec $Model->id
 * défini se trouve ici. Selon la source du dépôt, vous pouvez juste appeler
 * ``$this->create()``.
 */
    public function update(Model $model, $fields = null, $values = null, $conditions = null) {
        return $this->create($model, $fields, $values);
    }

/**
 * Implémente le D de CRUD. Appel à ``Model::delete()`` se trouve ici.
 */
    public function delete(Model $model, $id = null) {
        $json = $this->Http->get('http://example.com/api/remove.json', array(
            'id' => $id[$model->alias . '.id'],
            'apiKey' => $this->config['apiKey'],
        ));
        $res = json_decode($json, true);
        if (is_null($res)) {
            $error = json_last_error();
            throw new CakeException($error);
        }
        return true;
    }

}

public $faraway = array(
    'datasource' => 'FarAwaySource',
    'apiKey'     => '1234abcd',
);

class MyModel extends AppModel {
    public $useDbConfig = 'faraway';
}

// Récupère tous les messages de 'Some Person'
$messages = $this->MyModel->find('all', array(
    'conditions' => array('name' => 'Some Person'),
));

$this->MyModel->save(array(
    'name' => 'Some Person',
    'message' => 'New Message',
));

$this->MyModel->id = 42;
$this->MyModel->save(array(
    'message' => 'Updated message',
));

$this->MyModel->delete(42);

public $faraway = array(
    'datasource' => 'MyPlugin.FarAwaySource',
    'apiKey'     => 'abcd1234',
);

Error: Database connection "Sqlserver" is missing, or could not be created.