Adding Functionality

This section outlines a few of the ways you can extend model functionality as you build your application. As you think about different pieces of functionality to add, please keep in mind that there are two main ways to add functionality to your models:

  1. Static methods that apply to the Model
  2. Instance methods that apply to each Entity (Document or Record)

Static vs Instance Methods

As a rule of thumb, all static methods work with a collection of objects on the database, while non-static methods are tied to one single document/record. Consider the following example:

  1. $post = Posts::first(['conditions' => ['author' => 'foo']]);
  2. $post->title = 'Hello World';
  3. $post->save();

The first() method is static because it iterates over a bunch of entities in your database and returns the first entry where the author equals foobar. The result you get is an instance of a Post so all subsequent methods on it are non-static. The second line in the example sets the title and the third line saves it back to the database. This concept feels natural and also has the benefit of instantly knowing on what kind of dataset you’re operating.

If you remember this simple rule, you’ll understand how the framework reacts to new functions placed in models—and you’ll be able to use them more effectively.

Static Data Access

One simple example is if you have a bit of data that is specific to a model’s domain, and you want to make that data available to controllers using those models.

  1. namespace app\models;
  3. class Users extends \lithium\data\Model {
  5.     protected static $_roles = ['admin', 'friend', 'stranger'];
  7.     public static function roles() {
  8.         return static::$_roles;
  9.     }
  10. }

Because this method is accessed statically, it behaves as you’d expect:

  1. if (!in_array('admin', Users::roles())) {
  2.     return false;
  3. }

Model Instance Methods

It’s often useful to add a method to a model so that you can easily transform data once you’ve got a model instance (of type Entity, either Document or Record) in your controllers and views. In this case, you’ll need to create a method that accepts the entity itself as the first argument, then any addition parameters (if any). Here’s a simple use case of creating a method on a Users model that formats a full name based on first and last names:

  1. namespace app\models;
  3. class Users extends \lithium\data\Model {
  5.     public function fullName($entity) {
  6.         return $entity->firstName . ' ' . $entity->middleInitial . '. ' . $entity->lastName;
  7.     }
  8. }

If you want to add additional parameters, do so after you’ve specified the entity as the first:

  1. namespace app\models;
  3. class Users extends \lithium\data\Model {
  5.     public function fullName($entity, $suffix = false) {
  6.         $name = $entity->firstName . ' ' . $entity->middleInitial . '. ' . $entity->lastName;
  8.         if ($suffix) {
  9.             $name .= ' ' . $entity->suffix;
  10.         }
  11.         return $name;
  12.     }
  13. }

Once this is done, use it wherever you’ve got access to a Users model instance:

  1. $firstUser = Users::first();
  3. $firstUser->fullName();  // "Bill S. Preston"
  4. $firstUser->fullName(true);  // "Bill S. Preston Esq."