Social Engine 4: Model

Following up with my last 2 posts about Widgets and Controllers, the past couple of days I got my hands dirty with Models. Models are created inside the Models directory in a module. A model represents an item, or an object, which is fetched from the database. To describe how things work, I think the simplest way is to use an example.

If you find anything that is inconsistent or does not work, please let me know in a comment or so.

Assume we want to allow the user to categorize his friends (like facebook friends lists). So we’re going to create a table in the database to store this.

From my understanding, the convention of SE (probably zend too) in table names goes like this:

prefix_modulename_tablename

prefix is similar for all tables. It’s actually set somewhere in config files (can’t remember where). modulename is the name of module containing the model for our table. tablename (in plural form) is the actual name of table we’re creating. So, in our example, I’ll assume we’re working inside the “User” module, so we create the table “prefix_user_friendslists“.  We will just give the table a column for primary key  (friendslist_id), creator id (user_id), and category name (list_name).

Note that you must call the primary key column (friendslist_id) as zend automatically infers that from the table name.

Now let’s get started on how to deal with this table from within our application. Inside the Models directory, there is another folder called “DbTable“. DbTable files are most probably the lowest layer files you’ll need to deal with to create models from the database.  A DBTable class is what connects your table to it’s model. So start off by creating a DBTable file (inside DBTable folder) for our table.

Friendslists.php (plural):

class User_Model_DbTable_Friendslists extends Engine_Db_Table

{

protected $_rowClass = ‘User_Model_Friendslist’; Singular

}

$_rowClass chould have class name of our model (that we will create next). This way Social Engine (or zend) would know that results obtained from “User_Friendlists” table, should be assigned to our model. Don’t be confused about singular/plural conventions. Actually if you think about it, DBTable represents the table from database, that’s why it has  plural form like the table name. While a model represent a single object from that table, so it has a singular form in ists class name.

Now in the Models directory create:

Friendslist.php (singular):

class User_Model_Friendslist extends Core_Model_Item_Abstract

{

protected $_owner_type = ‘user’;

}

With $_parent_type and $_owner_type we are getting rid of a manual JOIN operation to get the creator of a category. This way whenever we call $category->getOwner(), its creator”User” object is automatically fetched using the “user_id” column.

Querying the table:

To query our table we first tell the Engine API which table we are going to query against:

$table = Engine_Api::_()->getDbtable(‘friendslists’, ‘user’);

Notice how function paramaters (tablename, modulename)

To select all friendslists a certain user created:

$select = $table->select()  ->where(“user_id = ?”, 1);

$result = $table->fetchAll($select);

foreach($result as $list)

{

echo “{$list->list_name} <br/>” ;

}

A single $category (inside the foreach loop) is an instance of the model we’ve created above. You can use it to access any column by its name.

To create a new category:

Engine_Api::_()->getDbtable(‘friendslists’, ‘user’)

->insert(array(

‘user_id’ => 1,

‘list_name’ => “Shiny new category”

));

Next to come is how to create your own module.