jQuery.validator.addMethod("elfproef", function(value, element) {
var sum=0;
for (i=1; i<10; i++) {
amount=value.charAt(i-1);
sum+=amount*(10-i);
}

if (sum % 11==0 && value.length==9) {
return true
} else {
return false
}
}, "Vul hier een geldige bankrekeningnummer in.");


With Symfony I have worked with Doctrine regularly and in this blog I’ll show you how to use Doctrine for your own component in Joomla. Doctrine is an Object Relational  Mapping framework and offers you a persistence library. This not the holy grail and you should determine  if you need the extra overhead and if you are comfortable with it.

The first step

I’ll start with an clean Joomla 1.6 install from the Joomla website. Also I installed Doctrine ORM from the Doctrine website. I unpacked the archive in  a new folder in the Joomla folder libraries.The structure in this new folder would be the same as the archive, so you get a Doctrine folder and a bin folder in the libraries/doctrine folder.

By the way, we live in 2011 and the current release of PHP is 5.3.5. Doctrine and the implementation I show you here assumes you use PHP 5.3. If you still use PHP 5.2 you seriously need to work on the upgrade of that projects.

The example

I’m going to provide you a very simple example. The most important thing I want to show you is how to implement Doctrine in your Joomla project, not how to use Doctrine. The documentation on the Doctrine website is of high quality and should give you enough information to get going.

We are writing a new component called Bugs end hold one entity called ‘Bug’. It has five attributes. ID, title, description, notificationDate and solvedDate. In the controller I’ll show you some examples how to use it.

Setting up the defaults

It is possible that you want to use Doctrine on multiple components you are going to write. This is the reason why I choose to add Doctrine to the libraries folder. In this folder we are going to add two files. One is an interface to provide a generic interface, the other is a bootstrapper to get Doctrine going. First the easy stuff, the interface.

The interface looks like this:

<?php

interface JoomlaDoctrineController {
public function setEntityManager(Doctrine\ORM\EntityManager $entityManager);
}

?>

Nothing spectacular  here, lets move on.

Doctrine needs to have some basic configuration to get going. We need to tell Doctrine where it can find the entities and where it needs to place the generated proxies. Here is the implementation of JoomlaDoctrineBootstrapper:

<?php
/**
 * Configuration class to integrate Doctrine into Joomla.
 *
 * @author pderaaij <paul@paulderaaij.nl>
 */

use Doctrine\Common\ClassLoader,
    Doctrine\ORM\EntityManager,
    Doctrine\ORM\Configuration,
   Doctrine\Common\Cache\ArrayCache;

if( !class_exists('\Doctrine\Common\Classloader')) {
    require_once dirname(__FILE__) . '/../doctrine/Doctrine/Common/ClassLoader.php';
}

class JoomlaDoctrineBootstrapper {

    const APP_MODE_DEVELOPMENT = 1;
    const APP_MODE_PRODUCTION  = 2;

    private $applicationMode;
    private $cache;
    private $entityLibrary;
    private $proxyLibrary;
    private $proxyNamespace;
    private $entityManager;
    private $connectionOptions;

    public function __construct($applicationMode) {
        $this->applicationMode = $applicationMode;
    }

    public function getConnectionOptions() {
        return $this->connectionOptions;
    }

    public function setConnectionOptions($connectionOptions) {
        $this->connectionOptions = $connectionOptions;
    }

    public function getProxyLibrary() {
        return $this->proxyLibrary;
    }

    public function setProxyLibrary($proxyLibrary) {
        $this->proxyLibrary = $proxyLibrary;
    }

    public function getProxyNamespace() {
        return $this->proxyNamespace;
    }

    public function setProxyNamespace($proxyNamespace) {
        $this->proxyNamespace = $proxyNamespace;
    }

    public function getCache() {
        return $this->cache;
    }

    public function setCache($cache) {
        $this->cache = $cache;
    }

    public function getEntityLibrary() {
        return $this->entityLibrary;
    }

    public function setEntityLibrary($entityLibrary) {
        $this->entityLibrary = $entityLibrary;
    }

    public function getApplicationMode() {
        return $this->applicationMode;
    }

    public function setApplicationMode($applicationMode) {
        $this->applicationMode = $applicationMode;
    }

    public function getEntityManager() {
        return $this->entityManager;
    }

    public function setEntityManager($entityManager) {
        $this->entityManager = $entityManager;
    }

    /**
     * Bootstrap Doctrine, setting the libraries and namespaces and creating
     * the entitymanager
     */
    public function bootstrap() {
        $this->registerClassLoader();

        // Load cache
        if ($this->getApplicationMode() == self::APP_MODE_DEVELOPMENT) {
            $this->cache = new ArrayCache;
        } else {
            $this->cache = new ApcCache;
        }

        /** @var $config Doctrine\ORM\Configuration */
        $config = new Configuration;
        $config->setMetadataCacheImpl($this->cache);
        $driverImpl = $config->newDefaultAnnotationDriver($this->getEntityLibrary());

        $config->setMetadataDriverImpl($driverImpl);
        $config->setQueryCacheImpl($this->cache);
        $config->setProxyDir($this->getProxyLibrary());
        $config->setProxyNamespace($this->getProxyNamespace());

        if ($this->applicationMode == self::APP_MODE_DEVELOPMENT) {
            $config->setAutoGenerateProxyClasses(true);
        } else {
            $config->setAutoGenerateProxyClasses(false);
        }

        $this->entityManager = EntityManager::create($this->getConnectionOptions(), $config);
    }

    /**
     * Register the different classloaders for each type.
     */
    private function registerClassLoader() {
        // Autoloader for all the Doctrine library files
        $classLoader = new ClassLoader('Doctrine', dirname(__FILE__) . '/');
        $classLoader->register();

        // Autoloader for all Entities
        $modelLoader = new ClassLoader('Entities', $this->getEntityLibrary());
        $modelLoader->register();

        // Autoloader for all Proxies
        $proxiesClassLoader = new ClassLoader('Proxies', $this->getProxyLibrary());
        $proxiesClassLoader->register();
    }

}
?>

Creating the component

Now we can start with setting up our component. Create a com_bugs folder in components with a models folder in it. In the models folder you should create an Entities folder (mind the capital, it’s important!).

Create the ‘Bug’ entity next. Copy the text below and place it in Bug.php in the models/Entities folder. Do not forget to set the namespace it is essential. If you forget it the entity can’t be found by the classloader. This is also the reason why the capitalization is so important.

<?php

namespace Entities;

/**

* @Entity @Table(name="bugs")

*/

class Bug {

/** @Id @Column(type="integer") @GeneratedValue */

private $id;

/** @Column(type="string") */

private $title;

/** @Column(type="string") */

private $description;

/** @Column(type="datetime") */

private $notificationDate;

/** @Column(type="datetime") */

private $solvedDate;

public function getId() {

return $this->id;

}

public function setId($id) {

$this->id = $id;

}

public function getTitle() {

return $this->title;

}

public function setTitle($title) {

$this->title = $title;

}

public function getDescription() {

return $this->description;

}

public function setDescription($description) {

$this->description = $description;

}

public function getNotificationDate() {

return $this->notificationDate;

}

public function setNotificationDate($notificationDate) {

$this->notificationDate = $notificationDate;

}

public function getSolvedDate() {

return $this->solvedDate;

}

public function setSolvedDate($solvedDate) {

$this->solvedDate = $solvedDate;

}

}

?>

There is our entity! Now we need a way to get that entity definition in our database. Doctrine has command-line tools for us to do that, but they need the same configuration as we give to our controller in the front-end. So, lets set-up that configuration and use it on the command line.

The configuration

In order to use Doctrine within our controllers we have to create the configuration and use our created bootstrapper to get Doctrine going. At the moment I chose the component initialization file for our initialization work on Doctrine. I’m looking for a way to extract this initialization in to a nicer place, but the options I’ve tried didn’t made me happy at all.

What do we need to do? Well, we need to tell where our entities are stored on the file system and where we want to store our proxy files. also we need to pass our database parameters to Doctrine so it has authorization to the database. Here is my init file (bugs.php) of the component:

<?php
// no direct access
defined('_JEXEC') or die;

// Include dependancies
jimport('joomla.application.component.controller');

require_once(JPATH_LIBRARIES . '/doctrine/bootstrap.php');

$controller = JController::getInstance('Bugs');
// configure Doctrine thru the bootstrapper
$controller->setEntityManager(bootstrapDoctrine());
$controller->execute(JRequest::getCmd('task', 'index'));
$controller->redirect();

/**
 * Initialize doctrine by setting the entities and proxies locaties. Also define
 * a default namespace for the proxies.
 */
function bootstrapDoctrine() {
    $doctrineProxy = new JoomlaDoctrineBootstrapper( JoomlaDoctrineBootstrapper::APP_MODE_DEVELOPMENT );
    $doctrineProxy->setEntityLibrary(dirname(__FILE__) . '/models');
    $doctrineProxy->setProxyLibrary(dirname(__FILE__) . '/proxies');
    $doctrineProxy->setProxyNamespace('Joomla\Proxies');
    $doctrineProxy->setConnectionOptions(getConfigurationOptions());
    $doctrineProxy->bootstrap();

    return $doctrineProxy->getEntityManager();
}

function getConfigurationOptions() {
     // Define database configuration options
    $joomlaConfig = JFactory::getConfig();
    return array(
        'driver' => 'pdo_mysql',
        'path' => 'database.mysql',
        'dbname' => $joomlaConfig->get('db'),
        'user' =>  $joomlaConfig->get('user'),
        'password' =>  $joomlaConfig->get('password')
    );
}

What do we do here. We retrieve an instance of our controller and our going to inject an EntityManager to this controller. In order to this we are going to call the JoomlaDoctrineBootstrapper, set the configuration parameters and it will return us the EntityManager. To make the configuration and use a little easier we are using the database credentials from the Joomla configuration.

That’s nice for the front-end, but how about that command line tool? Well Doctrine will search for a file called ‘cli-config.php’ on the location you call the doctrine command line tool. The file ‘cli-config.php’ will return an EntityManager using the configuration we set from our bootstrap file.

Before we start sorting out this file, a little notice. This file is somewhat strange. We have to perform a number of tricks so we can make use of the Joomla framework on the command line. The way we do use led to the fact we need a separate configuration file containing the database credentials and other configuration options. I’m sure that a number of trick I use here aren’t necessary, but I just can’t find a better way to do this. If you know the trick, please let me know. I, for sure, don’t like the way this file has been built up and would love to improve it.

Now with that out, I’ll show you the file.

<?php
// We are a valid Joomla entry point.
define('_JEXEC', 1);

// Setup the path related constants.
define('DS', DIRECTORY_SEPARATOR);
define('JPATH_BASE', __DIR__ . '/../../');
define('JPATH_ROOT', JPATH_BASE);
define('JPATH_CONFIGURATION', JPATH_BASE);
define('JPATH_LIBRARIES', JPATH_BASE.DS.'libraries');
define('JPATH_METHODS', JPATH_ROOT.DS.'methods');

// Load the library importer.
require_once (JPATH_LIBRARIES.'/joomla/import.php');
require_once (JPATH_CONFIGURATION.'/configuration.php');

// Import library dependencies.
jimport('joomla.application.application');
jimport('joomla.utilities.utility');
jimport('joomla.language.language');
jimport('joomla.utilities.string');
jimport('joomla.factory');

require_once __DIR__ . '/../../libraries/doctrine/bootstrap.php';

/**
 * Initialize doctrine by setting the entities and proxies locaties. Also define
 * a default namespace for the proxies.
 */
function bootstrapDoctrine() {
    $doctrineProxy = new JoomlaDoctrineBootstrapper( JoomlaDoctrineBootstrapper::APP_MODE_DEVELOPMENT );
    $doctrineProxy->setEntityLibrary(dirname(__FILE__) . '/models');
    $doctrineProxy->setProxyLibrary(dirname(__FILE__) . '/proxies');
    $doctrineProxy->setProxyNamespace('Joomla\Proxies');
    $doctrineProxy->setConnectionOptions(getConfigurationOptions());
    $doctrineProxy->bootstrap();

    return $doctrineProxy->getEntityManager();
}

function getConfigurationOptions() {
     // Define database configuration options
    $joomlaConfig = JFactory::getConfig(JPATH_BASE . '/cli-configuration.php');
    return array(
        'driver' => 'pdo_mysql',
        'path' => 'database.mysql',
        'dbname' => $joomlaConfig->get('db'),
        'user' =>  $joomlaConfig->get('user'),
        'password' =>  $joomlaConfig->get('password')
    );
}

$helperSet = new \Symfony\Component\Console\Helper\HelperSet(array(
    'em' => new \Doctrine\ORM\Tools\Console\Helper\EntityManagerHelper(bootstrapDoctrine())
));

The first part of the file is just bootstrapping of the Joomla framework. We determine the location of some core folders, we import core classes and all that will bootstrap the Joomla Framework. Then two function follow that we have seen before. The only difference is that we can’t use the default configuration, which will give us an blank configuration class, but an alternative file. Why not the default file? Well the default file is of the type JConfig and the factory expects an JFrameworkConfig to import.

The bottom three lines are the default code of Doctrine to get the command line tools going. You see, the only thing we do here is setting the EntityManager. More information about this file can be found on the Doctrine website.

The last mile

It has been a long way already, but we are getting there.The last thing I’m going to show you is how to make use of the Doctrine. If you remember we have created an interface earlier in this blog. Just implement this on your controller and implement the setEntityManager() method as required by the interface.

If you look back in the init file of the component we are using this method to set the EntityManager on the controller. We use the interface to make sure we use an generic method on all the controllers. In the example below you see how I created a simple example which makes use of Doctrine and outputs some basic information.

<?php

// No direct access
defined('_JEXEC') or die;

jimport('joomla.application.component.controller');
require_once(JPATH_LIBRARIES . '/doctrine/JoomlaDoctrineController.php');

/**
 * Description of BugsController
 *
 * @author pderaaij
 */
class BugsController extends JController implements JoomlaDoctrineController {

    /**
     *
     * @var Doctrine\ORM\EntityManager
     */
    private $em;

    public function setEntityManager(Doctrine\ORM\EntityManager $entityManager) {
        $this->em = $entityManager;
    }

    public function index() {
        // add a default bug every refresh
        $newBug = new Entities\Bug();
        $newBug->setTitle('Doctrine Test');
        $newBug->setDescription('test');
        $newBug->setNotificationDate(new DateTime());
        $newBug->setSolvedDate(new DateTime());
        $this->em->persist($newBug);
        $this->em->flush();

        $dql = "SELECT b FROM Entities\Bug b";
        $query = $this->em->createQuery($dql);
        $query->setMaxResults(30);
        $bugs = $query->getResult();

        echo '<h1>Bug overview</h1>';
        echo '<table width="100%">';
        echo '<tr>';
            echo '<th>#</th>';
            echo '<th>Title</th>';
            echo '<th>Notification date</th>';
            echo '<th>Date solved</th>';
        echo '</tr>';

        foreach( $bugs as $bug ) {
            /* @var $bug Bug */
            echo '<tr>';
                echo '<td>' . $bug->getId() . '</td>';
                echo '<td>' . $bug->getTitle() . '</td>';
                echo '<td>' . $bug->getNotificationDate()->format("Y-m-d H:i:s") . '</td>';
                echo '<td>' . $bug->getSolvedDate()->format("Y-m-d H:i:s") . '</td>';
            echo '</tr>';
        }

        echo '</table>';

        echo '<h1>Bug #1</h1>';
        $bug = $this->em->find("Entities\Bug", 1);
        echo '<pre>';
            var_dump($bug);
        echo '</pre>';
    }

}
?>

It’s a wrap

That’s it, now you can make use of Doctrine within your component. It was a long blog post, but I hope I’ve shown you an easy way to get going with Doctrine within Joomla.

I hope you liked this article. You can leave your feedback behind on this blog, since I’m always interested in new insights which I can use to learn and grow as an developer.

While getting my way around the Joomla! framework I have a big problem getting the checked in unit tests to run. If you do a checkout of the unit tests from the svn you’ll see there are about 960 tests and about 600 fails straight out of the box. Pretty annoying and unusable to write your own tests against.

So I’ve been working on a test runner of my own. The test runner tries to use the most of the Joomla! framework, but some things it just have to do itself. It consists of 2 files. One file is the testloader which is setup as an autoloader using the JLoad class. The second class sets some configuration files and kickstarts the Joomla! framework.

Here’s the code for the testloader

<?php

/**

* Testloader class

*

* This class strips the requested class and passes it thru

* to the Joomla autoload function

*

* @author Paul de Raaij <paul@paulderaaij.nl>

*/

// Preload the model so we can add paths to the inlude path of JLoader

jimport( 'joomla.application.component.model' );

class TestLoader {

/**

* Strip the given class and pass it to the

* Joomla autoloader.

*

* If it's a component add the path to the

* include path of the loader

*

* @param String $classname

* @return bool Has the inclusion succeeded

*/

static public function load( $classname ) {

$explodedPath = self::explodeClassname( $classname );

if( $explodedPath == null ) {

return self::loadJoomlaClass( $classname );

}

// Add the folder to the loader include path

JModel::addIncludePath('../components/com_' . $explodedPath['component'] . '/' . $explodedPath['type'] . 's');

return self::loadJoomlaClass( $classname );

}

/**

* Explode the classname and strip component name,

* type and type name

*

* @param string $classname

* @return mixed Returns null when it's a core file. Returns an array with data if it's a component data

*/

static protected function explodeClassname( $classname ) {

$types = array('model', 'controller', 'helper', 'view');

$classname = strtolower($classname);

if( $classname == 'jmodel' ) {

return null;

}

$fileInfo = array();

foreach( $types as $type ) {

if( false !== strpos($classname, $type) ) {

$fileInfo['type']       = $type;

}

}

if( isset( $fileInfo['type'] ) ) {

$fileInfo['component']  = substr($classname, 0, strpos($classname, $fileInfo['type'] ) );

$fileInfo['name']       = substr($classname, ( strpos($classname, $fileInfo['type'] ) + strlen($fileInfo['type']) ) );

return $fileInfo;

}

return null;

}

/**

* Simple pass thru function to the Joomla autoloader

*

* @param string $class

* @return bool Has inclusion succeeded?

*/

static public function loadJoomlaClass( $class ) {

return JLoader::load( $class );

}

}

?>

And this is the TestCase class which is required by each unit test file:

<?php

require_once 'PHPUnit/Framework.php';

// We are a valid Joomla entry point.

define('_JEXEC', 1);

// Setup the path related constants.

define('DS', DIRECTORY_SEPARATOR);

define('JPATH_BASE', dirname( __FILE__ ) . '\..');

define('JPATH_ROOT', JPATH_BASE);

define('JPATH_CONFIGURATION', JPATH_BASE);

define('JPATH_LIBRARIES', JPATH_BASE.DS.'libraries');

define('JPATH_METHODS', JPATH_ROOT.DS.'methods');

// Load the library importer, datbase class and configuration

require_once (JPATH_LIBRARIES.'/joomla/import.php');

require_once (JPATH_LIBRARIES.'/joomla/database/database.php');

// Load the TestLoader

require_once dirname(__FILE__) . '\lib\TestLoader.php';

// register specific test autloader

if( !defined('LOADED_AUTOLOADER') ) {

spl_autoload_register( array('TestLoader', 'load') );

define('LOADED_AUTOLOADER', true);

}

// Define configuration

jimport( 'joomla.registry.registry' );

require_once( JPATH_CONFIGURATION.'/configuration.php' );

// Create the JConfig object

$config = new JConfig();

// Get the global configuration object

$registry =& JFactory::getConfig();

// Load the configuration values into the registry

$registry->loadObject($config);

$options = array ('driver' => $config->driver,

'host' => $config->host,

'user' => $config->user,

'password' => $config->password,

'database' => $config->database,

'prefix' => $config->prefix );

// Preload database with configuration

$db = JDatabase::getInstance( $options );

?>

An example unit test looks like this:

<?php

require_once dirname(__FILE__) . '\..\..\..\TestCase.php';

class Model_Test_Base extends PHPUnit_Framework_TestCase {

protected $model = null;

public function setUp() {

$this->model = JModel::getInstance('<modelname>', '<componentname>Model');

}

public function testSimpleAssertion() {

$this->assertTrue( $this->model->test() );

}

}

?>

Perhaps this isn’t the best way to use unit testing in Joomla! But at the moment this is the only thing I got working. If you’ve got some suggestions your glad to leave it behind as a reaction!

Account:
columns:
id:             { type: integer, primary: true, autoincrement: true, notnull: true }
accountNumber:  { type: integer, notnull: true }
accountName:    { type: string(255), notnull: true }

Order:
columns:
id:             { type: integer, primary: true, autoincrement: true, notnull: true }
internID:       { type: string(20) }
accountID:      { type: integer, notnull: true }
locationID:    { type: integer }
orderDate:      { type: timestamp }
orderedBy:      { type: integer, notnull: true }
remarks:        { type: string(3000) }
orderDelivered: { type: boolean }
placedOrder:    { type: boolean }
relations:
Account:        { onDelete: CASCADE, local: accountID, foreign: id, foreignAlias: accountOrders }

Article:

columns:

id:            { type: integer, primary: true, autoincrement: true, notnull: true }
accountID:     { type: integer, notnull: true }

articleNumber: { type: string(15) }

description:   { type: string(255) }

currentStock:  { type: integer }

minimumStock:  { type: integer }

packageAmount: { type: integer }

previewFile:   { type: string( 255 ) }

remarks:       { type: string( 3000 ) }

internRemarks: { type: string( 5000 ) }

image:         { type: string( 255 ) }

relations:

Account:       { onDelete: CASCADE, local: accountID, foreign: id, foreignAlias: articleAccount }

In short. We have an account and each account has it own articles. The can order these articles and this is stored in the Order model ( and a bunch of others, which aren’t relevant for this post).

What we want to achieve is that we can filter the client list based on a article number or order id.

To do this I extended the generator.yml to add the two new fields.

config:

fields:
articleNumber:     {label: Artikel nummer, type: string }
orderNumber:     {label: Order nummer, type: string }

Next thing to do is to modify the filter form of the account model. Here we’re going to add the two new fields to the filter form and give them a simple validator.

public function configure()

{

parent::configure();

$this->widgetSchema['articleNumber'] = new sfWidgetFormInputText();

$this->validatorSchema['articleNumber'] = new sfValidatorPass(array('required'=>'false'));

$this->widgetSchema['orderNumber'] = new sfWidgetFormInputText();

$this->validatorSchema['orderNumber'] = new sfValidatorPass(array('required'=>'false'));

}

Now we want to add the filter values to the query so that the list actually gets filtered by the given values. Therefore were going to add a function for each of the filter fields. The function has one purpose and that is to add a where to the doctrine query.

protected function addArticleNumberColumnQuery( Doctrine_Query $query, $field, $values) {

$rootAlias = $query->getRootAlias();

$fieldName = 'articleNumber';

$query->addWhere( sprintf('%s.articleAccount.%s = ?', $rootAlias, $fieldName), $values );

}

protected function addOrderNumberColumnQuery( Doctrine_Query $query, $field, $values) {

$rootAlias = $query->getRootAlias();

$fieldName = 'id';

$query->addWhere( sprintf('%s.accountOrders.%s = ?', $rootAlias, $fieldName), $values );

}

The name of the function is specific and has to match the format add%fieldname%ColumnQuery. The code in the functions are pretty self-explanatory. Somethings are hard coded and could be a  nicer. For example you could name the field accountOrders instead of orderNumber so that you can use the value of $field.

This is the simplest solution I could find for filtering a model based on its relations. If someone knows a better way I’d love to hear about it.

At the moment I’m working on my first Symfony application what will be a toto for the upcoming World Championship soccer. A quite challenging application but fun and instructive.

The design presented me with a great challenge. As you can see in the picture above (which is in Dutch, sorry), we want multiple rows containing the matches of that group per row,  where you can fill in your prediction of the result of that match.

The schema I’ve figured out is this one (just the relevant part) :

Groups:

columns:

id: { type: integer, primary: true, autoincrement: true }

name: { type: string(100) }

Team:

columns:

id: { type: integer, primary: true, autoincrement: true }

group_id: { type: integer, notnull: true }

name: { type: string(255) }

flag: { type: string(255) }

desription: { type: string(4000) }

biography: { type: string(4000) }

points: { type: integer(2) }

relations:

Groups: { local: group_id, foreign: id }

Games:

columns:

id: { type: integer, primary: true, autoincrement: true }

home_team_id: { type: integer, notnull: true }

away_team_id: { type: integer, notnull: true }

stadium_id: { type: integer }

playing_time: { type: timestamp }

desription: { type: string(3000) }

relations:

Stadium: { local: stadium_id, foreign: id, foreignAlias: Stadium }

HomeTeam: { class: Team, local: home_team_id, foreign: id, foreignAlias: homeTeam }

AwayTeam: { class: Team, local: away_team_id, foreign: id, foreignAlias: awayTeam }

Predictions:

actAs: [Timestampable]

columns:

id: { type: integer, primary: true, autoincrement: true }

user_id: { type: integer(4) }

game_id: { type: integer }

home_score: { type: integer(2) }

away_score: { type: integer(2) }

real_home_score: { type: integer(2) }

real_away_score: { type: integer(2) }

relations:

Profile: { local: user_id, foreign: user_id, foreignAlias: User }

Games: { local: game_id, foreign: id, foreignAlias: Game }

Okay, now I’ve shown you the design we wanted and the schema I’ve used. Let me show the implementation I’ve used and the steps how I got to the result.

We want the user to predict the matches that are in the system so I want to show all the games with an embedded form of Prediction. But the problem here is that the 1:n relation is sorted out via the Predictions model, which to me is logical as you have one match with multiple predictions. Here the difficulty came. How do you couple a game to a prediction when there isn’t a relation yet, which is the case in a first prediction.

This is my solution:

I’ve created a new action in the Games controller called executePredict:

public function executePredict( sfWebRequest $request ) {
$this->form = new GamesCollectionForm( );
}

Here we call GamesCollectionForm which collects all games in the system and creates a form for them.

class GamesCollectionForm extends BaseGamesForm

{

public function configure()

{

$this->useFields(array());

$q = Doctrine_Query::create()->from('Games');

$aGames = $q->execute();

$wrapperForm = new sfForm();

foreach( $aGames as $index => $game ) {

$gameForm = new GamesPredictionForm( $game );

$gameForm->widgetSchema->setNameFormat('games[predictions][game_' . $index . '][%s]');

$wrapperForm->embedForm('game_' . $index, $gameForm);

}

$this->embedForm('predictions', $wrapperForm);

}

}

Okay, here I ran into multiple problems. The first one being that the collection form is an child of BaseGamesForm and therefore contains form widgets for adding a game, something I don’t want. So clean them all out by stating that we aren’t going to use any fields.

Next we collect all the games in the system and create an empty sfForm as wrapperform. In this wrapperform we’re going to embed instances of the GamePredictionForm. So for every game we create a GamesPredictionForm and set the right name format. This name format we need for the rendering and saving the forms.

Each form is embedded to the wrapper by setting its index prefixed with “game_”. Eventually the wrapperform gets embedded to the collection form.

The GamesPredictionForm looks like this:

class GamesPredictionForm extends BaseGamesForm

{

public function configure( )

{

$q = Doctrine_Query::create()->from('Predictions')->where('user_id = ? ', sfContext::getInstance()->getUser()->getProfile()->getUserID())->andWhere('game_id = ?', $this->getObject()->getID());

$oPred = $q->fetchOne();

if(! $oPred instanceof Predictions ) {

$oPred = new Predictions();

$this->getObject()->Game[] = $oPred;

}

$this->embedRelation('Game', 'PredictionsForm', array('user_id' => sfContext::getInstance()->getUser()->getProfile()->getUserID()));

$this->widgetSchema['home_team_id'] = new sfWidgetFormInputHidden();

$this->widgetSchema['away_team_id'] = new sfWidgetFormInputHidden();

}

}

What this class does is checking if there is a prediction of the user for this game. If this isn’t the case we create an empty Predictions object so the form renders a Prediction form. The Predictions model gets embedded with the game form and the id widgets are set hidden. This configuration of hidden inputs is needed for the customized rendering as I going to show later.

If we now render our form we got the result like below.

Nice, but not quite what we wanted. Besides that, any user now can edit the stadium, playing time or description. That’s not want we’d like to see, so lets start change the rendering of this form.

Before we change the rendering of the form I’d like to mention that at this moment it isn’t possible to save the form. If you’ll try to save now a database error is thrown stating that you try to enter null values in the games table. Which is correct, we’ve said that we don’t want to use any fields in the GamesCollectionForm. That works for the widgets, not for the save function. We need to modify that. My solution to this problem took me ages to find and I doubt that this is the best way to handle this.

What I’ve done is to override the doSave function of the GamesCollectionForm and checked if there’s any home_team_id been set. If not, the form is used for prediction by a user and we only want to save the embedded forms. In code it looks like this:

public function doSave( $con = null ) {

if( $this->getObject()->getHomeTeamId() != null ) {

} else {

$this->updateObjectEmbeddedForms($this->taintedValues);

$this->saveEmbeddedForms($con);

return;

}

}

What took me so long to figure out is the updateObjectEmbeddedForms. It seems this just don’t happens with the bind function of the form which is called in the action. By that it mean, if the parent values are all null, the embedded forms doesn’t get bound to the form values. I did not tested this so it’s an assumption and not a fact.

public function executePredict( sfWebRequest $request ) {

if($request->isMethod(sfRequest::POST) || $request->isMethod(sfRequest::PUT)) {

$games = Doctrine::getTable('Games')->find(array($request->getParameter('id')));

$this->form = new GamesCollectionForm($games);

$this->processForm($request, $this->form);

} else {

$this->form = new GamesCollectionForm( );

}

}

protected function processForm(sfWebRequest $request, sfForm $form)

{

$form->bind($request->getParameter($form->getName()), $request->getFiles($form->getName()));

if ($form->isValid())

{

$form->save();

$this->redirect('games/predict');

}

}

Well, now we can save our form whether its new or just an update, it works and that’s a victory on its own.

Now the rendering of the form. Our goal is to get the rendering as suggested by the designers. Well I can tell a lot about this, but lets just start by showing the code and the end result of that code. This is the code of the template rendering:

<?php use_helper('Date'); ?>

<h1>Voorspel de wedstrijden</h1>

<form action="<?php echo url_for('games/predict') ?>" method="POST">

<table width="100%">

<?php echo $form['id'];?>

<?php echo $form[$form->getCSRFFieldName() ]->render(); ?>

<?php foreach( $form->getEmbeddedForm('predictions')->getEmbeddedForms() as $pred): ?>

<tr>

<td><?php echo format_datetime($pred->getObject()->getPlayingTime(), 'dd-MM-yyyy HH:mm'); ?></td>

<td><?php echo "<img src='/uploads/flags/" . $pred->getObject()->getHomeTeam()->getFlag() . "' width=15 height=10/>";

echo $pred->getObject()->getHomeTeam(); ?></td>

<td> - </td>

<td><?php echo "<img src='/uploads/flags/" . $pred->getObject()->getAwayTeam()->getFlag() . "' width=15 height=10/>";

echo $pred->getObject()->getAwayTeam(); ?></td>

<td><?php echo $pred->getObject()->getStadium()->getName(); ?></td>

<td><?php echo $pred->getObject()->getStadium()->getCity(); ?></td>

<td><?php echo $pred['Game'][0]['home_score']; ?></td>

<td> - </td>

<td><?php echo $pred['Game'][0]['away_score']; ?></td>

<?php echo $pred['Game'][0]['id']; ?>

<?php echo $pred['Game'][0]['user_id']; ?>

<?php echo $pred['Game'][0]['game_id']; ?>

<?php echo $pred['home_team_id']; ?>

<?php echo $pred['away_team_id']; ?>

</tr>

<?php endforeach; ?>

<tr>

<td colspan="2">

<input type="submit" />

</td>

</tr>

</table>

</form>

Which leads us to…

Hey! It looks like we’ve got it right. In essence this is just like the designers wishes. Well, what’s up with this form rendering…

First of all I start with rendering the hidden form ID tag and the hidden CSFR field. We need this for the binding and security of the form (I’m not sure of the binding part).

Then I want the embedded Predictions form which is the wrapperform containing all forms per match as an embedded form. Hence, the double getEmbeddedForms call. The $pred variable now holds an instance of the GamesPredictionForm class.

Per row we first render all the static match information by retrieving the object and outputting them. After that we render the prediction form elements which are stored in the Game property of the GamesPredictionForm. The game[0] holds the Predictions form which needs to be editable for the user.

That are all the visible fields, they are followed by a bunch of hidden fields so that the objects can be stored right. This information is processed by the bind and updateObject function and are mandatory.

This rendering will be done for every Game stored in the system. And the best thing is that it works!

But there’s a catch. It works and I’m glad with that, but I’m not happy with this solution. I can’t figure out if the model design is incorrect, if I use Symfony wrong or just do something other totally the wrong way around. Therefore I need you! If you got to here you probably have the same problem or a huge interest in Symfony ( or just me, but I’ll let that idea go by ).

Perhaps you can tell me what I can do better to prevent these kind of ‘hacks’ and adjustments. Help me to grow as developer and give your feedback. I appreciate it big time!

Thanks for your time so far!

De oplossing is echter simpel. Controleer of alle plugins die je in de configuratie opgeeft wel bestaan en geladen kunnen worden. Dus deze regel:

plugins : ‘table,advimage,archvr,paste’,

Moet wel over plugins beschikken die bestaan en bereikbaar zijn.

Toch wil ik in dit blog vertellen wat ik dit jaar wil gaan doen op het gebied software engineering, ondernemen en persoonlijk ondernemen. Door het op te schrijven in dit blog kan ik wat feedback van lezers krijgen op de dingen die ik wil gaan doen en ik kan mezelf er ook wat beter aan houden

Algemene software ontwikkeling

Dit ga ik voornamelijk behalen via het werk wat ik voor school moet doen. Door nu niet alleen maar te lezen over ontwikkelmethodes en software concepten, maar ook verplicht en gestimuleerd te worden door ze te gebruiken hoop ik dat ik dat vrij goed onder de knie krijg.

PHP

Aan het eind van vorig jaar al lichtelijk verdiept in het Symfony framework en dat wil ik zeker nog verder uitbreiden. Symfony biedt interessante mogelijkheden en zorgt voor een stukje zekerheid tijdens het ontwikkelen. Daarnaast helpt het mijn ontwikkeling als programmeur ontzettend. Voornamelijk omdat je gedwongen word op de ´juiste manier´ te programmeren zodat je van alle voordeeltjes gebruik kan maken.

Overigens wil ik niet alleen met symfony werken. Op den duur wil ik ook kennis hebben van andere frameworks zodat je leert te kiezen welk framework je kan gebruiken voor een probleem.

Project methode

Met mijn bedrijf werken voornamelijk aan kleine projectjes van 3 weken. Ik wil op zoek naar een project/ontwikkelingsmethode die ons echt kan helpen om gestructureerd te werken zonder te verzanden in bergen extra werk. Als iemand tips heeft dan lees ik ze graag!

Regular expressions & wiskunde

Dit jaar wil ik erg graag mijn kennis van regexs en wiskunde in zijn algemeenheid verbeteren. Ik merk dat mijn kennis over deze onderwerpen niet optimaal is. Vooral door regex beter onder de knie te krijgen hoop ik wat smerige hacks achterwege te kunnen laten in de toekomst.

Wat betreft Wiskunde heb ik al een boek van Head First gekocht. Dit is voornamelijk bedoeld om te leren sommen te optimaliseren. Soms denk ik gewoon veels te moeilijk.

En verder…

Meer conferenties bezoeken is een belangrijk doel dit jaar en we beginnen goed. Eind januari ga ik naar de conference van PHP Benelux, in april help ik tijdens het pfcongres en de dutch php conference staat ook op het wensenlijstje.

Alhoewel ik niet veel tijd heb lijkt het me erg leuk en zinvol om dit jaar betrokken te raken bij een open source project wat mij aanspreekt. Door met meerdere developers aan een project te werken kan ik een heleboel leren en terug te geven aan de open source community. Dus als iemand een leuk project voor ogen heeft

In ieder geval wil ik nog een heleboel, pas aan het eind van het jaar gaan we zien of het allemaal gelukt is. Heb je nog tips of tricks? Ik hoor ze graag!

Na wat onderzoek waarom niet, blijkt dat men dit doet om de leercurve van PHP zo laag mogelijk te houden. Wat mij betreft een wat vreemde uitleg, want volgens mij kan de dynamiek van de taal er juist groter van worden. Is het niet zo dat de verantwoordelijkheid van het gebruik van een functionaliteit bij een gebruiker ligt? Tot hoever moet je als ontwikkelaar van een programmeertaal je gebruikers beschermen tegen fout gebruik van het één en ander. OOP word nu ook genoeg vallen misbruikt, maar dat gaat toch ook niet dicht gezet worden?

Nu ben ik wel benieuwd wat de meningen van anderen hierover zijn.

Allereerst voor mijn installatie heb ik het volgende artikel van techPortal gevolgd: http://techportal.ibuildings.com/2009/03/03/getting-started-with-phpundercontrol/

Waar je op moet letten

• De cli commando’s phpdoc, phpcs en phpunit moet je voorzien van .bat anders kan Ant de programma’s niet vinden
• Alle bestanden omringen door quotes zodat het pad goed gaat
• Ik heb al mijn svn tags voorzien van –username en -password omdat Ant bij mij wat problemen gaf met het inloggen op de SVN server

Dit zijn mijn aandachtspunten voor het opzetten van phpUnderControl op een Windows bak. Met bovenstaande in gdachten draait het bij mij als een zonnetje inmiddels! Marc Veldman bedankt voor het artikel met heldere uitleg!

Vandaag toch maar eens tijd gemaakt om op zoek te gaan naar een goede plugin hiervoor en inmiddels ook gevonden! Paste2 is de verlossende redder en verwijdert ook echt alles zonder de semantiek te verliezen! Kudo’s voor de makers van dit project! Nu weer tijd voor eigen ontwikkelingen…