$form->getWidgetSchema()->setFormFormatterName('list');

The question is, “where do you put this to alter sfGuard’s login form?”

In the case of sfGuard you just need to create a new folder under apps/frontend/modules/ (replace frontend with your app name) called sfGuardAuth, in this you create a folder called actions, and within this again a file called actions.class.php.

apps/
-frontend/
--modules/
---sfGuardAuth/
----actions/
-----actions.class.php

Inside the actions.class.php file you put this:

<?php
    require_once sfConfig::get('sf_plugins_dir').
    '/sfGuardDoctrinePlugin/modules/sfGuardAuth/lib/BasesfGuardAuthActions.class.php';

/**
* Extend to use list schema formatter
*/
class sfGuardAuthActions extends BasesfGuardAuthActions
{
    public function executeSignin($request)
    {
        parent::executeSignin($request);
        $this->form->getWidgetSchema()->setFormFormatterName('List');
    }
}
?>

We manually include BasesfGuardAuthActions.class.php because symfony’s black magic autoloader doesn’t pick this up. Voila. Nice and easy!

If you wanna make your completely own sfWidgetFormSchemaFormatter you can read about it over at notjosh’s blog.

For anyone who has played with Ruby on Rails, symfony will be very familiar. You got a nice command line interface to do your scaffolding, migrations and application building, and of course the well-known and diffuse MVC coding paradigm to seperate business logic from presentation.

Symfony is very well documented in english, something I didn’t expect as the author company, Sensio labs is a french web development company. It totally blew me away.

You do your configuration in XML or YAML whereas the latter is recommended because it’s alot easier on the eye.

So far I’ve only scratched the surface of symfony, but as I’m doing a full-scale application in symfony these days, I expect to get more familiar and have more to present later.

Why two formats?

At first glance, the two formats look very similar in their purpose and capabilities, and they are. The main difference is that Exif is a write-once-read-only-format, IPTC is a read-and-write-format. By this it’s meant that Exif is only supposed to be written once, and that’s when the camera takes the picture. After that you’re only supposed to read the data and never modify it.

IPTC on the other hand is an exchange format that removes the need for sending an additional file with meta data. If you look at the IPTC IIM specification you’ll see that you can embed almost any imaginable meta data. In this post I’ll only focus on chapter 6, section 1.4 of the IPTC headers: “Application record No. 2″, which is where you specify most of the “personal stuff”.

This also somewhat implies that Exif headers contain more technical details, while IPTC headers contain more personal/human details.

Exif

Exif is pretty straight forward to work with in PHP. As of PHP >= 4.2.0 you are presented with exif_read_data(), where you specify the path to the file you want to read the meta data from.

print_r(exif_read_data('05042008042.jpg'));
Array
(
    [FileName] => 05042008042.jpg
    [FileDateTime] => 1207409868
    [FileSize] => 791791
    [FileType] => 2
    [MimeType] => image/jpeg
    [SectionsFound] => ANY_TAG, IFD0, THUMBNAIL, EXIF, GPS
    [COMPUTED] => Array
        (
            [html] => width="2592" height="1944"
            [Height] => 1944
            [Width] => 2592
            [IsColor] => 1
            [ByteOrderMotorola] => 0
            [ApertureFNumber] => f/2.8
            [Thumbnail.FileType] => 2
            [Thumbnail.MimeType] => image/jpeg
        )

    [Make] => Nokia
    [Model] => N95
    [Orientation] => 1
    [XResolution] => 300/1
    [YResolution] => 300/1
    [ResolutionUnit] => 2
    [YCbCrPositioning] => 1
    [Exif_IFD_Pointer] => 144
    [GPS_IFD_Pointer] => 2994
    [THUMBNAIL] => Array
        (
            [Compression] => 6
            [XResolution] => 72/1
            [YResolution] => 72/1
            [ResolutionUnit] => 2
            [JPEGInterchangeFormat] => 3294
            [JPEGInterchangeFormatLength] => 18626
        )

    [ExposureTime] => 29000/1000000
    [FNumber] => 28/10
    [ISOSpeedRatings] => 400
    [ExifVersion] => 0220
    [DateTimeOriginal] => 2008:04:05 17:36:05
    [DateTimeDigitized] => 2008:04:05 17:36:05
    [ComponentsConfiguration] => 
    [ShutterSpeedValue] => 5107/1000
    [ApertureValue] => 297/100
    [LightSource] => 4
    [Flash] => 25
    [FocalLength] => 56/10
    [FlashPixVersion] => 0100
    [ColorSpace] => 1
    [ExifImageWidth] => 2592
    [ExifImageLength] => 1944
    [CustomRendered] => 0
    [ExposureMode] => 0
    [WhiteBalance] => 0
    [DigitalZoomRatio] => 100/100
    [SceneCaptureType] => 0
    [GainControl] => 2
    [GPSVersion] => 
    [GPSLatitudeRef] => N
    [GPSLatitude] => Array
        (
            [0] => 59/1
            [1] => 55/1
            [2] => 2883/100
        )

    [GPSLongitudeRef] => E
    [GPSLongitude] => Array
        (
            [0] => 10/1
            [1] => 29/1
            [2] => 3939/100
        )

    [GPSAltitudeRef] => 
    [GPSAltitude] => 14750/100
    [GPSTimeStamp] => Array
        (
            [0] => 0/1
            [1] => 0/1
            [2] => 0/1
        )
    [GPSDateStamp] => 0000:01:01
)

That’s a lot of data, and unless you’re a photographer probably only understand parts of it. Anyway. This was shot with my Nokia N95 with LocationTagger enabled, so I get the extra GPS data embedded as well. Now, to pick any of this data you just go to the index in your associative array. For instance if I want read the date and time my picture was shot, I get it like this:

$info = exif_read_data('05042008042.jpg');
echo 'Image was taken at: '.$info['DateTimeOriginal'];

Straight forward and easy, time to have a look at IPTC headers on the next page.

In the old days I would implements the “plotter” in GD2, using PHPs excellent api, but since then Google have released their charts api which basically means you send a GET request to Google’s servers, and get an image/plot back.

This is all fine and dandy, but it gets tedious to build the GET parameters every time. So then I decided to go look for a nice PHP wrapper for this api. While I did find some interesting ones, I decided to start my own. This because I found the other frameworks lacking, either because they serve a different purpose(like being very easy to use(1file)), or because they used an approach I didn’t feel comfortable with.

Anyway. Feel free to contribute with code or comment comments. I do plan on eventually to support the whole api, but it will come in bits and pieces as I need them. First out is barchart which is nearly done already!

So what exactly is a callback function?

A callback-function has the exact same signature as any other function; because it is a normal function. It may take some parameters to work with, and it may return a value, but neither are required. This implies that “normal” functions may also be used as callback functions. In reality though, most callback functions will take one or more parameters, work with this and return a value.

The biggest difference between a normal function and a callback function is that the calling/parent function may not know the name or signature of the callback function at compile time, but rather at run time. In PHP, these times are normally the same, as most people run PHP as an interpreted language.

Now this can be a tough concept to grasp, hence we proceed with an example.

// In order to keep the code small and clean, there is no input checking being done.
// SETUP
// This is our function that will be used as a callback function
function sqr( $var )
{
  return $var*$var;
}

$int_arr = array( 1, 2, 3 );
// END SETUP

// Call like normal function
echo 'Normal call: '.sqr( 5 );

// call within another function
function var_sqr( $i )
{
  echo 'Within another function: '.sqr( $i );
}

var_sqr(5);

// Call as a callback function

function sqr_arr( $arr, $callback )
{
  foreach( $arr as $i )
  {
    echo 'Callback-call: '.call_user_func( $callback, $i );
  }
}

sqr_arr( $int_arr, 'sqr' );

The result should print something like this (with newlines added)

Normal call: 25
Within another function: 25
Callback-call: 1
Callback-call: 4
Callback-call: 9

The two first you should be able to predict on your own. The third one on the other hand, is what this article is really about. As you can see we call the arr_sqr function like this

arr_sqr( $int_arr, 'sqr' );

The first parameter is just a normal array with three integers. No magic going on there. The second parameter on the other hand, is somewhat fishy. Here we provide the name of the function. We don’t provide any parameters or any magic to this second function, just the name.

The foreach loop in the var_sqr function shouldn’t be unfamiliar either. It just iterates over the array, and for each value in the array runs the loop body.

The call_user_func() call on the other hand, is somewhat frightning and scary.

call_user_func() is what we may call the “function executer”, it takes care of calling our callback function and providing it with parameters. call_user_func() takes an infinite number of parameters, but the first one has to be the name of function. The trailing parameters to call_user_func() are the same parameters that will be sent to the callback function, in the same order they are listed in call_user_func().

Example:

call_user_func( 'myfunc', $1, $2, $3 );

Here we are calling a function called myfunc() which takes at least three parameters. It will be called as follow:

myfunc( $1, $2, $3 )

So why use callback functions?

Callback functions are excellent for writing modular code. For instance we have this code:

/*
List the directory $dir, and apply the $filter_func function to all the elements to filter out the unwanted elements.
return the array of wanted elements from $dir
$filter_func should take one parameter (a name of a file or directory) and return true or false
*/

function listDir($dir, $filter_func) {

$ret = array();

if(function_exists($filter_func) && is_callable($filter_func)) {
 if(is_dir($dir)) {
  if(is_readable($dir)) {
   $curr_dir = getcwd();
   // undocumented notice on error?
   if(@chdir($dir)) {
    if($fp = opendir('.')) {
     while(false !== ($file = readdir($fp))) {
      if($file != '.' && $file != '..') {
       if(call_user_func($filter_func, $file))
        $ret[] = $file;
      }
     }
     closedir($fp);
    }
    chdir($curr_dir);
   }
  }
 }
}
return $ret;
}

This function takes two parameters, a directory/path and a callback function. As the name implies, this function will list the files in the path given by the $dir parameter. What might not be so obvious is the second parameter, $filter_func. As mentioned this argument is the name of the callback function, and it should take exactly one parameter and return true or false.

The listDir() function will then use the callback function to determine whether or not to add the file in question to the list(returned array) or not.

For instance: Say we have a function is_image() which takes one parameter, and determines if the file or directory given in the parameter is an image or not. Then we could list all images in a directory like this.

$images = listDir( 'somedir/', 'is_image' );
print_r( $images );

Or say we only wanted to list subdirectories of $dir, we could do this (note that we are using the in-built function is_dir())

$dirs = listDir( 'somedir/', 'is_dir' );
print_r( $dirs );

One could even make an advanced version of is_dir() which prints the name of the “file” if it is a directory, and called listDir() on this before it returned true and that way print all directories recursively. Note that I write “print all directories”. This is because listDir() wouldn’t save the value from is_dir() if it returned an array of directories anyway, as it expects is_dir() to return true or false. But if is_dir() PRINTS the directory it will make a recursive list. (This is left as an excercise to the reader phew)

I hope this can work as a primer for using callback functions to modularize your code. By doing this will avoid having to re-invent the wheel only to change the rims.

In this post I aim to nail the first problem mentioned by Harry Fuecks in his blog, shared web server. One of his suggested solutions is to use a database to store the sessions instead of normal files, and that’s exactly what we’re going to do.

First of all, you have to create the database table for our code to use. This is done by executing the following code either directly in PHP with mysql_query, or by using phpmyadmin or a similar tool:

CREATE TABLE IF NOT EXISTS sessions
(
    session_id VARCHAR(255) NOT NULL,
    session_expires CHAR(10) NOT NULL,
    session_data TEXT,
    PRIMARY KEY (session_id)
) ENGINE=INNODB;

This should create a table called “sessions”. The storage engine used here is InnoDb, but you can change this to HEAP to use an in-memory engine, or MyISAM which is the default MySQL table type or any other type supported by MySQL.

Now it’s time to configure a few settings to allow our script to access the database, these settings are located at the top of our script and should be self-explanatory:

// Mysql user
define( 'DB_USERNAME', '' );

// Mysql password
define( 'DB_PASSWORD', '' );

// Mysql database name
define( 'DB_NAME', '' );

// Mysql host
define( 'DB_HOST', null );

// Mysql host port
define( 'DB_PORT', null );

// Name of the session table
define( 'DB_SESSION_TABLE', 'sessions' );

That’s it! You’re done! You don’t have to call any special methods or functions to use this script. While the example below looks like its using sessions in the normal way the actual data is being stored in the database table. This is far more secure than using sessions in a shared web server environment. Don’t forget to call session_start():

require_once( 'mysql_session_manager.php' );
session_start();

// add a session
$_SESSION['this_is_a_session'] = 'omg, this is easy!';

// use it
if( isset( $_SESSION['this_is_a_session'] ) )
{
    // This will output "omg, this is easy!"
    echo $_SESSION['this_is_a_sesion'];
}

// delete session
unset( $_SESSION['this_is_a_session'] );

The script is written in OOP and PHP5. It requires a mysql database, version 4.1 or newer.

The code is released under the Creative Commons Attribution 2.5 License

Use 7-zip or similar to un-pack on a windows machine, or the unzip command or similar on linux.

Download: MySQL session manager