Always add a “empty” entry to the result

function find($conditions = null, $fields = array(), $order = null, $recursive = null) {
	if (is_array($conditions)) {
		return parent::find($conditions, $fields, $order, $recursive); // old interface
	} else {
		switch ($conditions) {
			case 'list':
				$result = parent::find($conditions, $fields, $order, $recursive);
				$return = $result; // default

				if (!empty($result)) {
					$return = aa('', __("-- please select --", true));
					foreach ($result as $id => $name)
						$return[$id] = $name;
				}

				return $return;
			break;

			default:
				return parent::find($conditions, $fields, $order, $recursive);
			break;
		}
	}
}

Okay, that works and i don’t have to add ‘empty’ everywhere. I modified the method a little further (not actually using it, but maybe someone likes it..) for you to grab. It will still require that you modify all files, but this way you have more control.

Adding “empty” to the find() options array

function find($conditions = null, $fields = array(), $order = null, $recursive = null) {

	if (is_array($conditions)) {
		return parent::find($conditions, $fields, $order, $recursive); // old interface
	} else {
		switch ($conditions) {
			case 'list':
				$result = parent::find($conditions, $fields, $order, $recursive);
				$return = $result; // default

				if (!empty($result) && isset($fields['empty']) && $fields['empty'] != false) {
					$return = aa('', $fields['empty']); // begin with whatever is in 'empty'
					foreach ($result as $id => $name)
						$return[$id] = $name;
				}

				return $return;
			break;

			default:
				return parent::find($conditions, $fields, $order, $recursive);
			break;
		}
	}
}

Everything above goes to app_model.php of course. With the last snippet you are able to move the “empty” option to the controller and go like this:

$categories = $this->Category->find('list', array('empty' => __("-- please select --", true)));

Enjoy & Happy Easter!

$this->User->find('first');
pr ($this->User->record); // has the full record

$this->User->record->username = 'BlaBlubb';
$this->User->record->email = 'bla@blubb.com';
$this->User->save(); // saves full record 

$this->User->find('first');
pr ($this->User->record); // jup, that worked.

Useful? hmm.. maybe. It was fun to explore though. If you are interested in the Behavior, i’ve put it into a gist.

This post is ment as follow up to the one teknoid posted. Instead of doing the array_diff stuff in your controller, you could do it in the model (respectively, all models). So here it goes. I made the $blackList part optional, but feel free to change that.

class AppModel extends Model {

	function save($data = null, $validate = true, $fieldList = array(), $blackList = false) {
		if (!empty($fieldList) && $blackList) {
			$fieldList = array_diff(array_keys($this->schema()), $fieldList);
		}
		return parent::save($data, $validate, $fieldList);
	}
}

In your controller you can then use blacklisting like so:

function some_action() {
	if ($this->Whatever->save($this->data, true, a('user_id'), true)) {
		//...
}

I also had ideas to allow both methods by using blacklist/whitelist as array keys of fieldList, but then again.. lets not overdo this. :)

Sometimes we have more than one model that uses slugs. For example: Tags, Posts, Categories. That’s why i add the following to AppModel which allows me to call it on any model.

function slugify($text) {
	return low(Inflector::slug($text, '-'));
}

But because i am lazy i just use one of the model callbacks to automate the “slugification(tm)”.

function beforeSave() {
	if ($this->hasField('slug') && isset($this->data[$this->alias][$this->displayField])) {
		$this->data[$this->alias]['slug'] = $this->slugify($this->data[$this->alias][$this->displayField]);
	}
}

So on any model that has a “slug” field in the associated table we always slugify the displayField (usually “name”) and keep it fresh. Dead simple.

e(sprintf( __("Please %s or %s to write a comment", true),
    $html->link(__("login", true), array('controller' => 'users', 'action' => 'login')),
    $html->link(__("register", true), array('controller' => 'users', 'action' => 'register'))
));

There are two problems with it:

1. You may have to explain alot when someone translates the app. %s is meaningless.
2. You probably have to reorder the sprintf arguments some day (login,register<>register,login).

String::insert to the rescue!

Let’s rewrite the above:

e(String::insert( __("Please :login or :register to write a comment", true),
array(
    'login' => $html->link(__("login", true), array('controller' => 'users', 'action' => 'login')),
    'register' => $html->link(__("register", true), array('controller' => 'users', 'action' => 'register'))
)));

Now this looks alot nicer, don’t you agree? Anyone translating your app will know what is inserted where, and it even allows to reorder the link replacements within the translation msgstr if needed. And the best part of it: we don’t care!

How to use a model in a component

$model = ClassRegistry::init('ModelName');
$result = $model->find('...');

How to extend a core helper

App::import('Helper', 'Text');
class AppTextHelper extends TextHelper {
  // ... your code
}

How to extend a core component

App::import('Component', 'Auth');
class AppAuthComponent extends AuthComponent {
  // ... your code
}

How to get just the url from a link (href) in a view

$html->url(array('controller' => 'users', 'action' => 'edit'));

How to transform those array formatted urls into a string

Router::url(array('controller' => 'users', 'action' => 'edit'));

How to add a foreign model to a controller

class UsersController extends AppController {
  var $uses = array('User', 'Page');
  function something() {
     $result = $this->Page->find(...);
  }
}

How to load data from a foreign model in any controller

class UsersController extends AppController {
  function something() {
     $result = ClassRegistry::init('Page')->find(...);
  }
}

How to use a helper in a component (or controller)

Don’t …

How to use a model in a helper

Don’t …

After adding it to my app i thought how i could use my setups to change the database with ease. I then remembered reading an bakery article from Joel Moss on how one could use the object constructor in the DATABASE_CONFIG class. Well.. both techniques go well together!

Environment writes the currently loaded environment name to the config, so we just use that info to switch the database config too.

class DATABASE_CONFIG {
	public $default = array(
		'host' 		=> 'localhost',
		'driver' 	=> 'mysql',
		'persistent' 	=> false,
		'login' 	=> 'DEFAULT_USERNAME',
		'password' 	=> 'DEFAULT_PASSWORD',
		'database' 	=> 'DEFAULT_DATABASE',
	);

	public $development = array(
		'login' 	=> 'dev_username',
		'password' 	=> 'dev_password',
		'database' 	=> 'dev_db',
	);

	public $production = array(
		'login' 	=> 'live_username',
		'password' 	=> 'live_password',
		'database' 	=> 'live_db',
	);

    function __construct() { // the magic
    	$environment = Configure::read('Environment.name');
    	if (($environment) && isset($this->{$environment})) {
    		$this->default = array_merge($this->default, $this->{$environment});
    	}
    }
}

Okay.. the above assumes we have setup two environments called “production” and “development”. What an environment does for you is best explained on the original post. I will show you a example setup that’s in the bootstrap.php.

	Environment::configure(
	'development',
		array('server' => 'localhost'),
		array(
			'debug' => 2,
			'security' => 'low'
		)
	);
	Environment::configure(
	'production',
		true,
		array(
			'debug' => 0,
			'security' => 'high'
		)
	);

Now whenever the environment changes the custom database config array by the same name is merged with DATABASE_CONFIG::$default.