So we’ll have to make one and it’s very simple.

First you need to have the Symfony2 Console component setup in your Silex project.

The following console file is based on the example in this blog post and the Swiftmailer bundle console.

Make that file executable, or remove the first line and call it through the php cli.

You will also have to do a little change to your current Silex bootstrap file:

That should be it. This means you can now have a cron running to send emails and to the user they don’t have the wait while the SMTP server responds.

Here is a quick code sample which shows how to test emails that are sent using Silex and Swiftmailer.

I would recommend using this example app to get Silex and Swiftmailer setup if you haven’t got a working setup.

The aim in the code is to stop sending of real email in the test environment and log the messages so we can test them.

Here is a quick gist of the Test class, testing for number of emails sent and the first emails subject.

I have copied out the Symfony2 MessageLogger.php class from the SwiftmailerBundle, which I’ve included in the gist for your convenience.

(crossposted from Sebastian’s personal blog)

One of our clients needs to send emails with UTF-8 subject lines. Swift Mailer, which Symfony uses, makes this easy to do, but writing functional tests for it is another story. The problem is that, if non-ASCII characters are present in the subject line, Swift Mailer encodes them as required by RFC 2047 – for example, a string like “Transformación” turns into “=?utf-8?Q?Transformaci=C3=B3n?=”. How do we know that this is the right subject line?

There’s no immediately-available “convert this into a RFC 2047-compliant subject line” function, but we can get around this by making use of Swift_Message->toString and some choice preg functions.

First, create a dummy message containing the appropriate header. Swift_Message->toString() will contain our encoded header:

Next, we have to extract our encoded header – I’ve used preg_match() and a fairly simple regex.

Finally, now that the encoded header has been extracted, we need only wrap it in preg_quote() (because checkHeader() uses regex syntax) and test away.

Voila – now we can be confident that our test script can deal with Unicode email subjects.

First of all, my stored functions are in separate .sql files in my plugin’s data/sql/ directory in the interests of following convention within the project’s directory structure.

Secondly, in myPlugin/config/MyPluginConfiguration.class.php file, I have the following for the initialize() method.:

public function initialize()
{
  sfConfig::set("zz_myplugin_dir", $this->getRootDir());
  $this->dispatcher->connect("command.post_command", array($this, 'initializeStoredFuncs'));
}

We listen for the command.post_command event which we can then check to see if it’s a Doctrine insert-sql task being run. We also check to see if the function already exists before attempting to create it – if not, then carry on.

public static function initializeStoredFuncs(sfEvent $event)
{
  static $doneConfig = false;
 
  if ($doneConfig)
  {
    // Already done it.
    return;
  }
 
  if (!($event->getSubject() instanceof sfDoctrineInsertSqlTask))
  {
    // Not inserting any SQL. No point continuing
    return;
  }
 
  // Get database connection
  $con = Doctrine_Manager::connection();
 
  // Configure function 1
  self::addStoredRoutine($con, "myFuncName1", "myFuncName1.sql");
 
  // Configure function 2
  self::addStoredRoutine($con, "someOtherFunc", "someOtherFunc.sql");
 
  // Set config completed flag for later
  $doneConfig = true;
}
 
/**
* Adds a stored procedure into the database
*
* @param string $con Connection to use
* @param string $routineName Routine name
* @param string $routineFile Filename inside our [plugin dir]/data/sql/
*/
protected static function addStoredRoutine($con, $routineName, $routineFile)
{
  $options = $con->getOptions();
  $dsn = $options["dsn"];
  preg_match("/dbname=([^;]+)[;]?/", $dsn, $matches);
  $dbname = $matches[1];
 
  $sql = "SELECT COUNT(*) AS c FROM information_schema.routines WHERE routine_name = '{$routineName}' AND routine_schema = '{$dbname}'";
  try
  {
    $dbh = $con->getDbh();
  }
  catch (Exception $e)
  {
    // No database available - can't carry on
    return;
  }
 
  $resultSet = $dbh->query($sql);
  $results = $resultSet->fetch();
  if ($results["c"] == 0)
  {
    // Create the function
    $sqlRoutine = file_get_contents(sfConfig::get("zz_myplugin_dir") . "/data/sql/" . $routineFile);
    $con->getDbh()->prepare($sqlRoutine)->execute();
  }
}

I’m not a massive fan of the way the database name has been retrieved but it works for now :-) I’m pretty sure there’s a neater way of accomplishing the above too, but this is working consistently and allows the stored functions to become part of a plugin, so that if the plugin is removed at a later date, then any subsequent database builds will not have unnecessary routines hanging around.

id: 1
name: Joe Bloggs
profile_picture: ffba81d3ac4ef1dcba70.txt

Great, if you’re not concerned about the appearance of the filename after uploading. If however, you want to preserve the filename, then you can create a generateFilename() method in your form object and Symfony will use that. But, what if you want to store more than the filename in your database, for example part of a path including multiple levels deep in directories? Or you want to do this each time, but don’t want to have to recreate/copy the same method multiple times? Or both?! Enter the use of sfValidatedFile.

In my experimentation, I wanted a custom file upload path, something like this:

• /home/rich/myproject/web/uploads/entries/4cad77fd2da01/1/filename.txt
• /home/rich/myproject/web/uploads/entries/4cad77fd2da01/2/otherfile.jpg

but I wanted to be able to store everything from 4cad… onwards as the filename, as everything up to ‘entries’ was a Symfony configuration value.

So, in your form configure() method, do something like the following:

// Generate your unique path here
$path = sfConfig::get("sf_my_upload_path") . DIRECTORY_SEPARATOR . uniqid();

$this->validatorSchema["myFileUpload"] = new sfValidatorFile(array("path" => $thisPath, "validated_file_class" => "myValidatedFile");


This tells Symfony to use a custom path to save, but also to use the myValidatedFile class to handle the processing of the uploaded file – move it to the correct place and so on. The myValidatedFile class is what we’re going to use to accomplish the above challenges.

Next, create the file lib/vendor/myValidatedFile.class.php:


class myValidatedFile extends sfValidatedFile
{
  public function generateFilename()
  {
    return $this->path . DIRECTORY_SEPARATOR . $this->getOriginalName();
  }

  public function save($file = null, $fileMode = 0666, $create = true, $dirMode = 0777)
  {
    $result = parent::save($file, $fileMode, $create, $dirMode);

    // Alter the savedName to reflect what we're after
    $this->savedName = str_replace(sfConfig::get("sf_my_upload_path") . DIRECTORY_SEPARATOR, "", $this->savedName);

    return null === $this->path ? $this->savedName : str_replace($this->path.DIRECTORY_SEPARATOR, '', $this->savedName);
  }
}


Simples. Let’s take each method in turn.

The first method simply returns the full path and original filename. Symfony will use the directory of this when deciding where to save the file, and it will use the leaf part to determine the file’s name. Part 1 accomplished!

The second method calls the original sfValidatedFile save() method. We’re not concerned with the mechanics of saving the file, so we’ll just do as normal (we’ve already set the path above). What we are concerned with is creating the correct value to be saved into the database or whatever you do with the field value eventually.

The key parts are the final 2 lines. Essentially here, we remove the part of the file’s path and filename that we have stored in the configuration value. This means that what is left will be (in the example above), our uniqid() value and the filename. This return value is what is saved/used elsewhere.

And then, your database entry will look like this:

id: 1
name: Joe Bloggs
profile_picture: 4cad77fd2da01/2/joes_picture.jpg


All you need to do now is set the “validated_file_class” option value on your file upload widget to myValidatedFile whenever you need this functionality, and job done!

As we find it a good resource we try and answer questions on things we know about, in turn for answers you get points and sometimes badges.  The badges/points side of things is a little childish but very addictive and a more productive use of time than Youtube.

Recently Stack Overflow released an API and I thought that joining Stack Overflow and Twitter together sounded like a fun reason to play with both websites’ APIs.

So Stack of Twits was born and unleashed to the world last night. Simply it sends you a message on Twitter when a question matches your set of keywords.

I built the site using our framework of choice symfony very quickly. It only took me a few hours over the course of a week or so to get it together. While building it I have made a PHP wrapper for the Stack Overflow API and the plan is to open source this work. Any interest in it pre release please comment below.

As part of one of our current Symfony projects in work, a colleague and I decided that rather than reinventing the wheel everytime we used a new admin-generated module in the application with regards to overriding partials and actions in pretty much the same way each time, it would be productive and easier in the long run to create an admin generator theme. The documentation on the Symfony site for this is sparse to say the least, and when I get some time, I’ll look at contributing back to the Symfony docs a condensed version of this blog post so that it’s a bit more straightforward for the next person. You have the ability to customise pretty much every part of the admin generator including batch actions, form actions, filters, table headers and so on, so it’s worth the work in the long run if you’re looking for quick admin-generated module deployments in line with your site’s template.

OK, so before I start, be warned this is nice and long (and hopefully explanatory)…! I’ll also say that clearing your cache upon making changes to partials is vital. I repeat, VITAL! :-)

Getting started

The first step I carried out, which is mentioned on the Symfony site, was to copy all the files from the default theme into your project. In our case, we’re using Doctrine as the ORM, so the files were found in lib/vendor/symfony/plugins/sfDoctrinePlugin/data/generator/sfDoctrineModule/admin, and they were copied to data/generator/sfDoctrineModule/ourTheme. This directory contains 3 subdirectories – we’ll need all 3. The names should be self-explanatory – “parts” consists of all the parts needed to dynamically generate the code, “skeleton” consists of skeleton files that form the basis of the final module (generator.yml etc), and “template” consists of the template files that use the files in “parts“. Simple!

That’s the basic step out of the way. If you want to check that everything is being correctly read here, simply alter an existing generator.yml file as follows:

theme: ourTheme

Clear your cache, and reload your page. You shouldn’t see any change – this is because the files are exactly the same as the default theme. Now comes the fun part!

For the following paths, I’ll assume the prefix of data/generator/sfDoctrineModule/ourTheme/ to avoid typing it out each time.

Adding configuration options

The first change I wanted to carry out was to add some extra configuration options via the generator.yml file. One major gripe I have with the Symfony admin generator is that once you’ve added a new object, or edited one, the default destination is the edit page, rather than the list page. Personally I see returning to the list as expected behaviour, and every project I use the admin generator in, I end up overriding the processForm() action and making this change. I wanted to be able to specify this destination via a configuration option on the ‘new’ and ‘edit’ contexts, with a ‘return_to’ option. Carrying out this change involves overriding some other classes in Symfony, most notably the sfModelGeneratorConfiguration class. I copied this class from the Symfony core to lib/generator/myModelGeneratorConfiguration.class.php.

Once you’ve done this, alter parts/configuration.php so that the generated class extends from myModelGeneratorConfiguration instead of sfModelGeneratorConfiguration.

Open up this class, and you’ll see a lot of abstract methods defined near the top. These methods are created during the generation process, and are located in the parts/fieldsConfiguration.php file. You’ll see that it consists of what looks like PHP within PHP – this is a common theme throughout the development of an admin generator theme, and can get a tad confusing if you forget what context you’re in when you’re writing code! You can use the example methods to build your own. In my case, I added the following:

public function getNewReturnTo()
{
return '<?php echo $this->escapeString(isset($this->config['new']['return_to']) ? $this->config['new']['return_to'] : 'edit') ?>';
<?php unset($this->config['new']['return_to']) ?>
}

public function getEditReturnTo()
{
return '<?php echo $this->escapeString(isset($this->config['edit']['return_to']) ? $this->config['edit']['return_to'] : 'edit') ?>';
<php unset($this-&gtconfig['edit']['return_to']) ?>
}

These methods both return a configuration value if it exists in the YAML file, or the defaults of ‘new’ and ‘edit’ respectively if no configuration value is specified.

In order to make this option available in the configuration, the myModelGeneratorConfiguration->compile() method should be altered to allow this option:

// ...
'new' => array(
'fields' => array(),
'title' => $this->getNewTitle(),
'actions' => $this->getNewActions() ? $this->getNewActions() : $this->getFormActions(),
'return_to' => $this->getNewReturnTo()
),
// …


and the same for the edit option. The final change is to actually action this change in the processForm() method, conveniently found in parts/processFormAction.php. This file (along with all the other *Action.php files) are included in the generated sfActions class specific to the module you’re creating. I removed the final redirect line which redirected back to the ‘edit’ URL, and replaced it with the following changes:

// ...
if ($form->isValid())
{
$thisContext = $form->getObject()->isNew() ? 'new' : 'edit';
$notice = $form->getObject()->isNew() ? 'The item was created successfully.' : 'The item was updated successfully.';

// ...
$this->redirect('@<?php echo $this->getUrlForAction('new') ?>');
}
else
{
$route = '<?php echo $this->getSingularName(); ?>';
$returnTo = strtolower($this->configuration->getValue($thisContext . '.return_to'));
if ($returnTo != 'list')
{
$route .= '_' . $returnTo;
}

$returnArray = array('sf_route' => $route);
if ($returnTo != 'list')
{
$returnArray['sf_subject'] = $<?php echo $this->getSingularName(); ?>;
}
$this->redirect($returnArray);


That’s it! Add the configuration option into your generator.yml as follows:
new:
return_to: list


Clear your cache, reload the page and test it out. After creating a new object, you should be returned to the list. This is restricted to eg my_model_ACTION-type routes, but you can easily enhance the above code to redirect to any other route, check for an “@” symbol if needs be and so on.

New “contexts”

I wanted to implement an Ajax edit form on a “view” page for my model, so that the user wasn’t taken away. The templates I was working from had this as a pop-over box, but instead of redirecting the user afterwards, I wanted the edit and update to be seamless. In terms of the form, the ajax form was similar (but slightly different) to the normal admin-generated edit form, so I wanted the ability to be able to configure the form separately from the edit page.

I experimented with configuring it as part of my ‘view’ context but ran into problems with nested array configurations, so I decided to abstract it out and create a new “context” with which I could configure items in the same way as a normal context (‘new’, ‘edit’, ‘list’ and so on). I termed this ‘ajaxedit’; NB I’m calling them ‘contexts’ here as I’m sure I read that’s what they were called somewhere! Correct me if not ;-)

The creation of this is very similar to the above changes for adding a configuration value. In myModelGeneratorConfiguration.class.php, add the following in to the configuration array in compile():

'ajaxedit' => array(
'title' => $this->getAjaxeditTitle(),
'actions' => $this->getAjaxeditActions() ? $this->getAjaxeditActions() : $this->getFormActions(),
'fields' => array()


I added this after the ‘edit’ one currently there. If you proceed down through this method, I also duplicated the ‘edit’ line in the first foreach() loop, where the fields are configured using sfModelGeneratorConfigurationField, and altered ‘edit’ to ‘ajaxedit’ where appropriate. Same in the ‘virtual fields’ configuration, the form actions, the field configuration (duplicated from ‘list field configuration’), and the $this->parseVariables() lines.

You should also add ‘ajaxedit’ to the credentials array near the end of the compile() method, so that you can control access to the popup/context with credentials, and again into the getConfig() method at the end of the class.

You then need to create the relevant abstract methods as before, so that the context can be correctly configured. Again, I used the ‘edit’ context as an example to base my changes and additions on.

The next step is to configure the templates and partials so that they recognise this. I used the default _form.php partial so that I could re-use code where possible, but added a ‘context’ variable to the partial when calling it, eg. in my view page:


[?php include_partial('<?php echo $this->getModuleName() ?>/form', array('<?php echo $this->getSingularName() ?>' => $<?php echo $this->getSingularName() ?>, 'form' => $form, 'configuration' => $configuration, 'helper' => $helper, 'context' => 'ajaxedit')) ?]


In my form partial, I then altered the getFormFields() call to the following:


[?php foreach ($configuration->getFormFields($form, $form->isNew() ? 'new' : 'edit') as $fieldset => $fields): ?]


so that I was using the correct set of fields for the form display. Don’t forget to clear your cache after making these changes.

You can handle the ajax post however you like; I used jQuery and a callback handler to adjust details and display new values etc where required. The handling of the form data was done in the same way as a normal Symfony action; details of this (and Ajax-specific stuff) are in the main Symfony documentation.

Here’s the result:

Conclusion

The one major thing to remember is that clearing your cache is VITAL to a speedy admin generator theme development. If you’re running in dev mode via your front controller, then Symfony will only regenerate partials that are directly related to your generator.yml on the fly. It won’t recreate action templates if there is no need to from generator.yml changes. This means that you will need to manually call “./symfony cc” from the command line whenever you make changes to partials. I lost count of how many times I ran that task during my theme development :-)

I’d imagine there are nicer ways to do some of the above – I’m not particularly a fan of the overriding of classes and having them separate from the theme, although I know that Symfony’s autoloading can be pretty clever sometimes, so it would probably find the classes with a bit of tweaking, if I put them as part of the theme. It’s also a bit tricky to get your head around the whole PHP-creating-PHP idea, and remembering whereabouts you are, and what variables you have available to you. I lost a good few hours trying to use variables that were in the top-level PHP, in my generated partials, and wondering why they weren’t working.

However, the end result is definitely worth it and saves a lot of time in the long run if you’re looking to re-use templates and code across a number of admin-generated modules!

So we decided it was time to perhaps investigate alternatives.  The obvious choice for Symfony would be to use Sismo, but sadly it hasn’t been released yet… Fabien, any clues as to a release date? ;-) It looks at the moment as if we’re stuck with a Java-based solution, so we decided to look at Hudson as an alternative.

Setting up Hudson was straightforward using Nicolas Perriault’s blog post on exactly what we were trying to achieve, linking in with our Subversion repository.  The configuration of the projects took a bit of faffing – for some reason, Hudson liked to check out the whole repository rather than just eg the trunk folder  as specified, so this screwed up some of the paths.  A bit of trial and error later and we were up and running with a build every 30mins if there are new commits, as this pretty graph shows… (using the jUnit XML output available in Symfony 1.4).  Total number of tests in blue, failures in red.

One thing to bear in mind if you’re getting test failures randomly, or perhaps always after a certain developer checks in (and it’s not a result of broken code) is to ensure that the permissions are correct for Symfony, as SVN likes to store permissions where it can.  The fix for this, apart from committing new permissions, is to add a build step in Hudson that carries out ./symfony project:permissions (Symfony 1.3+) shortly before the build.  This seems to solve it nicely, and explained the small red peaks in the graph above.

The problem I discovered was that obviously Doctrine didn’t know what the conditional relationships were, since it was dependant on the type column. I researched some different approaches:

1. Doctrine’s RawSql

   This approach worked for generating the correct SQL query without a problem, but the issue then arose of how Doctrine could hydrate the result set. Answer was – it couldn’t :-) Well, I lie – I could use Doctrine::HYDRATE_SCALAR but I had issues with other related models, where I was joining to a table twice but under different aliases, which failed, since the scalar hydration would override earlier joins on the same table.

2. Column aggregation

   Column aggregation looked great initially – I could have a “TypeAEntry” and a “TypeBEntry”, and Doctrine would have handled the typing of the Entry automatically. I couldn’t however see a way to query “in reverse” – get all Entries and their associated models.

3. Write a raw SQL query, and use Doctrine’s PDO instance to retrieve the data.

Option 3) was the one I settled for in the end. It meant of course that I had to specify column names, and perform all the joins myself, but it did mean I could specify precisely what data I wanted back. This came back in the form of a normal array.  I’d tried to stay away from this option intially, but after spending too long researching the other 2 and hitting brick walls, I bit the bullet and dropped down to the raw stuff.  And hey presto!

Note – this approach will only work if you want the data to be read-only. If you want to then use Doctrine’s model goodness, you’ll need to work out how to transform that *back* into a model.

I know Dan, for example, doesn’t see the point of using Criteria because what is wrong with SQL?

I have sat and scratched my head a few times trying to figure out how to query using Criteria, I know how I would do it in SQL but I can sit for ages trying to bend Criteria to my will.

I really should have RTFM…

We do still recommend that you use SQL when it proves to be simpler, though.

Criteria is great when it fits your needs, but when it doesn’t or becomes very complex..stop step back and use SQL.

Using Propel 1.3 you get to use PDO and that is not something that is framework specific it’s an inbuilt PHP database abstraction layer. So the skills you learn using PDO are transferable to another project that doesn’t use a framework but uses a database.

So we have a custom query that we want to run and get back a bunch of user objects and we really don’t want to use Criteria…easy:

$name = “Wards”;
$bunchofusers = array();
//Our highly complex query….
//Fancy prepared stuff you get from PDO…think sprintf
$stmt = $con->prepare(“SELECT * FROM user WHERE last_name = ?”);
$stmt->bindValue(1, $name);
//erm execute…
$stmt->execute();
//Loop on our rows…and lets make some User objects..
while($row = $stmt->fetch()) {
$oUser = new User();
$oUser->hydrate($row);
$bunchofusers[]=$oUser;
}

Nothing really new to learn in the above code, it’s more like remembering that we can code how we choose too and we don’t have to be shackled to a certain way or slowed down by a framework when things don’t exactly fit.

** “What is Criteria?” I hear you say…well it comes with the Propel ORM, and it is for building up queries using objects rather than SQL. We use Propel within the symfony framework as our current ORM of choice.