Download the Cipher Behavior Source on Github

First things first – you need to throw a couple of libraries from the Zend Framework into your vendors folder. Yup, I love my Zend! CakePHP teams up very well with ZF.

You’ll need the following Zend Framework libraries (download the framework):

• Zend_Filter (Zend/Filter.php and Zend/Filter)
• Zend_Loader (Zend/Loader.php and Zend/Loader)

Put those files in your vendors folder. You’ll also need to update your include_path somewhere (say, app/bootstrap.php) with the following:

ini_set('include_path', ini_get('include_path') . ':' . APP . '/vendors');

I also recommend defining an autoload function somewhere for Zend classes (again, bootstrap.php is a good choice). A simple, Zend-only autoloader might look like this:

function __autoload($path) {
	if (substr($path, 0, 5) == 'Zend_') {
		include str_replace('_', '/', $path) . '.php';
	}
	return $path;
}

The behavior has three config options:

• key: the encryption key to use. If null (default), then it’ll use the value of Configure::read(‘Security.salt’).
• automatic: whether to automatically encrypt and decrypt data as it’s saved/retrieved. Defaults to true.
• fields: an array of fields belong to the model that should be encrypted

Usage of the behavior itself is straightforward: just add Cipher to the $actsAs array of any model you’d like:

Class User extends AppModel {
    var $actsAs = array('Cipher');
}

Class Order extends AppModel {
    var $actsAs = array('Cipher' => array('fields' => array('credit_card', 'expiry')));
}

You can also manually decrypt and encrypt data, either by passing an array of find results (in which case the fields specified in ‘fields’ will be encrypted/decrypted), or by passing a string:

// Manually encrypt/decrypt the results of Model::find()
$encrypted = $this->encrypt($findResults);
$decrypted = $this->decrypt($encrypted );

// Manually encrypt/decrypt a string
$encryptedSecretString= $this->encrypt('my secret string');
$decryptedString = $this->decrypt($encryptedSecretString);

Just out of the oven – a Zend_Search_Lucene datasource for CakePHP (built with 1.2 but probably works just fine in 1.3) that I originally wrote for an in-house CMS site search plugin. I can’t release the plugin itself (and there’s so much CMS-specific code that it would need a lot of work to make it generic anyway), but I thought that someone might find the datasource itself useful. It’s pretty basic at this point and doesn’t implement some of the fancier Zend_Search_Lucene features such as sorting (it just returns sorted in score order, which is probably what you want anyway).

Zend_Search_Lucene is a text-based search index system for developers who don’t want to (or can’t) use a database for search indexing.

Download the current version of the ZendSearchLuceneDatsource from my Github repository.

I won’t go into detail about how to add data into the Lucene database since the Zend Framework documention is so good (CakePHP should be jealous!). You’ll find all the info you need there. There are also a couple of older articles out there that show how you can integrate Zend_Search_Lucene into CakePHP:

• Build your own search engine in PHP
• Integrating Zend Framework Lucene with your Cake Application

Setup

First, copy zend_search_lucene.php to models/datasources.

Then, you’ll need to download the Zend_Search_Lucene library from the Zend Framework website and put some files into your /vendors directory:

• Zend/Search (the directory and all of its contents)
• Zend/Exception.php

You’ll also need to update your include path to include app/vendors, since the Zend Framework loads a lot of classes on its own. I also made a little autoload function to make the loading of Zend Framework classes easier. Put the following code somewhere common, such as app/bootstrap.php:

ini_set('include_path', ini_get('include_path') . ':' . CAKE_CORE_INCLUDE_PATH . DS . '/vendors');
function __autoload($path) {
if (substr($path, 0, 5) == 'Zend_') {
include str_replace('_', '/', $path) . '.php';
}
return $path;
}

You also need to put the DB config for the datasource in config/database.php (updated Jan 20/2010 for better DebugKit compatibility):

var $zendSearchLucene = array(
	'datasource' => 'ZendSearchLucene',
	'indexFile' => 'lucene', // stored in the cache dir.
	'driver' => '',
	'source' => 'search_indices'
);

Then, in the model that’ll act as your search index (say, for example, SearchIndex), specify the DB config:

<?php class SearchIndex extends AppModel {
var $useDbConfig = 'zendSearchLucene';
}
?>

Saving/Indexing

I’ve tried to keep the datasource functions as simple and familiar as possible. When saving an item to the index, the datasource expects a multidimensional array for each item. For compatibility with CakePHP’s datasource code, the ‘meat’ of the data is nested in the third level of the array. Each sub-array contains information about a field to be stored. For example:

$saveData = array('SearchIndex' => array(
  	'document' => array(
		array(
			'key' => 'name',
			'value' => $record[$Model->alias][$this->settings[$Model->alias]['name']],
			'type' => 'Text'
		),
		array(
			'key' => 'description',
			'value' => $record[$Model->alias][$this->settings[$Model->alias]['description']],
			'type' => 'Text'
		),
		array(
			'key' => 'url',
			'value' => $this->__constructUrl($Model, $record),
			'type' => 'Text'
		)
	)
 ));

Passing that data in a Model::save() call will in turn execute the following Zend code (more or less – this is a very simplified version of the actual ZendSearchLuceneSource saving code):

$index = Zend_Search_Lucene::open('/path/to/the/index/set/in/dbConfig');
$doc = new Zend_Search_Lucene_Document();
foreach ($data as $field) {
$doc->addField(Zend_Search_Lucene_Field::$field['type']($field['key'], $field['value']));
}
$index->addDocument($doc);

Obviously that’s a basic example; you’ll probably send a whole bunch of dynamic info to the indexer. But that’s the gist of it anyway.

Querying

You can search for records just like you would a regular datasource. Pass the search terms as a “query” condition. If you want the search terms to be highlighted in the returned results, pass ‘highlight’ => true in the array of options. Note that only indexed fields will be highlighted.

You can find all results:

function search($term) {
$results = $this->SearchIndex->find('all', array('highlight' => true, 'conditions' => array('query' => 'best cakephp tutorials')));
}

You can mimic Google’s I’m Feeling Lucky with find(‘first’):

function search($term) {
$topResult = $this->SearchIndex->find('first', array('conditions' => array('query' => 'best cakephp tutorials')));
}

You can even paginate:

function search($term) {
$this->paginate = array(
'limit' => 10,
'conditions' => array('query' => 'best CakePHP tutorials'),
'highlight' => true
);

$results = $this->paginate();
}

Results are returned in the expected CakePHP way, as a multidimensional array – $results[0]['MyModelAlias'] for multiple records, $results['MyModelAlias'] for one (i.e. with find(‘first’)).

There you go – enjoy! As always, comments and suggestions are welcomed.

I used the RSS Feed datasource by Loadsys as a guide to good datasource design. I may have borrowed a function or two.

Neil Crookes’ Searchable plugin also helped.

1. Use a SELECT query with ORDER BY RAND() and LIMIT x (where x is the number of results you want).
2. Get a list of the primary keys of every record in the table, use PHP to select x random entries from that list, and then use a SELECT query using a WHERE primary_key IN (x, y, z) clause.

While option #2 might seem to be slower – two queries and intermediary PHP work! – but ORDER BY RAND() tends to churn to an almost-grinding halt when queries tables with lots of records. So, #2 it is. And, since we’re working with CakePHP, we can abstract it to the Model::find() level with a custom __findXX method that I like to call __findRandom(). Note that usage of this function relies on Matt Curry’s implementation of custom find methods (I seem to link to that bit of code in every post!).

The basic idea is that two queries are executed: first Model::find->(‘list’) generate a list of primary keys, and then either Model::find->(‘first’) or Model::find(‘all’), depending on whether we’re looking for one or more records.

The code is available in my GitHub repository.

Usage is as simple as (using the User model as an example):

$record = $this->User->find('random');

That’ll return one random record from the User model. Like most Model::find functions, you can pass an array as an optional second argument:

$records = $this->User->find('random', array(
    'amount' => 5,
    'list' => array(
        'conditions' => array('User.active' => 1)
    ),
    'find' => array(
        'contain' => array('Group')
    )
));

As you can see, you’re actually working with two nested arrays for your query modifiers, ‘list’ and ‘find’. Use these arrays to modify the the find(‘list’) and find(‘first’)/find(‘all’) queries respectively. Use the ‘amount’ option, which defaults to 1, to specify the maximum records you want returned.

You can also bypass the find(‘list’) query entirely by passing an array of primary keys as the ‘suppliedList’ argument. For example:

$records = $this->User->find('random', array(
    'amount' => 5,
    'suppliedList' => $myIDs,
    'find' => array(
        'contain' => array('Group')
    )
));

As you can see, it’s a fairly simple function. But, it gets the job done! Here’s the source code, which, as mentioned above, you can grab on GitHub as well:

<?php
class AppModel extends Model {

    function find($type, $options = array()) {
        $method = null;
        if (is_string($type)) {
            $method = sprintf('__find%s', Inflector::camelize($type));
        }

        if ($method && method_exists($this, $method)) {
            $results = $this->{$method}($options);
        } else {
            $args = func_get_args();
            $results = call_user_func_array(array('parent', 'find'), $args);
        }

        return $results;
    }

    /**
     * __findRandom()
     *
     * Find a list of records ordered by rank.
     * Instead of executing a __findList() query to get the list of IDs,
     * you can pass an array of IDs via the $options['suppliedList']
     * argument.
     *
     * Two queries are executed, first a find('list') to generate a list of primary
     * keys, and then either a find('all') or find('first') depending on the return
     * amount specified (default 1).
     *
     * Pass find options to each query using the $options['list'] and $options['find']
     * arguments.
     *
     * Specify $options['amount'] as the maximum number of random items that should
     * be returned.
     *
     * If you already have an array of IDs(/primary keys), you can skip the find('list')
     * query by passing the array as $options['suppliedList'].
     *
     * @access  private
     * @param   $options  array of standard and function-specific find options.
     * @return  array
     */
    function __findRandom($options = array()) {
        if (!isset($options['amount'])) {
            $amount = 1;
        } else {
            $amount = $options['amount'];
        }

        $findOptions = array();
        if (isset($options['find'])) {
            $findOptions = array_merge($findOptions, $options['find']);
        }

        if (!isset($options['suppliedList'])) {
            $listOptions = array();
            if (isset($options['list'])) {
                $listOptions = array_merge($listOptions, $options['list']);
            }

            $list = $this->find('list', $listOptions);
        } else {
            $list = $options['suppliedList'];
            $list = array_flip($list);
        }        

        // Just a little failsafe.
        if (count($list) < 1) {
            return $list;
        }

        $originalAmount = null;
        if ($amount > count($list)) {
            $originalAmount = $amount;
            $amount = count($list);
        }

        $id = array_rand($list, $amount);

        if (is_array($id)) {
            shuffle($id);
        }

        if (!isset($findOptions['conditions'])) {
            $findOptions['conditions'] = array();
        }

        $findOptions['conditions'][$this->alias.'.'.$this->primaryKey] = $id;
        if ($amount == 1 && !$originalAmount) {
            return $this->find('first', $findOptions);
        } else {
            return $this->find('all', $findOptions);
        }
    }
}
?>