It is sometimes desirable to store additional data with a many to many association. Consider the following

Student hasAndBelongsToMany Course
Course hasAndBelongsToMany Student

In other words, a Student can take many Courses and a Course can be taken my many Students. This is a simple many to many association demanding a table such as this

id | student_id | course_id

Now what if we want to store the number of days that were attended by the student on the course and their final grade? The table we’d want would be

id | student_id | course_id | days_attended | grade

The trouble is, hasAndBelongsToMany will not support this type of scenario because when hasAndBelongsToMany associations are saved, the association is deleted first. You would lose the extra data in the columns as it is not replaced in the new insert.

The way to implement our requirement is to use a join model, otherwise known (in Rails) as a hasMany through association. That is, the association is a model itself. So, we can create a new model CourseMembership. Take a look at the following models.

		student.php

		class Student extends AppModel
		{
			public $hasMany = array(
				'CourseMembership'
			);

			public $validate = array(
				'first_name' => array(
					'rule' => 'notEmpty',
					'message' => 'A first name is required'
				),
				'last_name' => array(
					'rule' => 'notEmpty',
					'message' => 'A last name is required'
				)
			);
		}      

		course.php

		class Course extends AppModel
		{
			public $hasMany = array(
				'CourseMembership'
			);

			public $validate = array(
				'name' => array(
					'rule' => 'notEmpty',
					'message' => 'A course name is required'
				)
			);
		}

		course_membership.php

		class CourseMembership extends AppModel
		{
			public $belongsTo = array(
				'Student', 'Course'
			);

			public $validate = array(
				'days_attended' => array(
					'rule' => 'numeric',
					'message' => 'Enter the number of days the student attended'
				),
				'grade' => array(
					'rule' => 'notEmpty',
					'message' => 'Select the grade the student received'
				)
			);
		}

The CourseMembership join model uniquely identifies a given Student’s participation on a Course in addition to extra meta-information.

Working with join model data

Now that the models have been defined, let’s see how we can save all of this. Let’s say the Head of Cake School has asked us the developer to write an application that allows him to log a student’s attendance on a course with days attended and grade. Take a look at the following code.

	controllers/course_membership_controller.php

	class CourseMembershipsController extends AppController
	{
		public $uses = array('CourseMembership');

		public function index() {
			$this->set('course_memberships_list', $this->CourseMembership->find('all'));
		}

		public function add() {

			if (! empty($this->data)) {

				if ($this->CourseMembership->saveAll(
					$this->data, array('validate' => 'first'))) {

					$this->redirect(array('action' => 'index'));
				}
			}
		}
	}

	views/course_memberships/add.ctp

		echo $form->create('CourseMembership');
		echo $form->input('Student.first_name');
		echo $form->input('Student.last_name');
		echo $form->input('Course.name');
		echo $form->input('CourseMembership.days_attended');
		echo $form->input('CourseMembership.grade');
		echo 'Save';
		echo $form->end();

You can see that the form uses the form helper’s dot notation to build up the data array for the controller’s save which looks a bit like this when submitted.

	Array
	(
	    [Student] => Array
	        (
	            [first_name] => Joe
	            [last_name] => Bloggs
	        )

	    [Course] => Array
	        (
	            [name] => Cake
	        )

	    [CourseMembership] => Array
	        (
	            [days_attended] => 5
	            [grade] => A
	        )

	)

Cake will happily be able to save the lot together and assigning the foreign keys of the Student and Course into CourseMembership with a saveAll call with this data structure. If we run the index action of our CourseMembershipsController the data structure received now from a find(‘all’) is:

	Array
	(
	    [0] => Array
	        (
	            [CourseMembership] => Array
	                (
	                    [id] => 1
	                    [student_id] => 1
	                    [course_id] => 1
	                    [days_attended] => 5
	                    [grade] => A
	                )

	            [Student] => Array
	                (
	                    [id] => 1
	                    [first_name] => Joe
	                    [last_name] => Bloggs
	                )

	            [Course] => Array
	                (
	                    [id] => 1
	                    [name] => Cake
	                )

	        )

	)

There are of course many ways to work with a join model. The version above assumes you want to save everything at-once. There will be cases where you want to create the Student and Course independently and at a later point associate the two together with a CourseMembership. So you might have a form that allows selection of existing students and courses from picklists or ID entry and then the two meta-fields for the CourseMembership, e.g.

	views/course_memberships/add.ctp

	echo $form->create('CourseMembership');
	echo $form->input('Student.id', array('type' => 'text', 'label' => 'Student ID', 'default' => 1));
	echo $form->input('Course.id', array('type' => 'text', 'label' => 'Course ID', 'default' => 1));
	echo $form->input('CourseMembership.days_attended');
	echo $form->input('CourseMembership.grade');
	echo 'Save';
	echo $form->end();

	$this->data when POSTed

	Array
	(
	    [Student] => Array
	        (
	            [id] => 1
	        )

	    [Course] => Array
	        (
	            [id] => 1
	        )

	    [CourseMembership] => Array
	        (
	            [days_attended] => 10
	            [grade] => 5
	        )

	)

Again Cake is good to us and pulls the Student id and Course id into the CourseMembership with the saveAll.

Join models are pretty useful things to be able to use and Cake makes it easy to do so with its built-in hasMany and belongsTo associations and saveAll feature.

There are 2 examples of wrapping here. Firstly the client address is wrapped, and secondly the first row of the line item data has a wrapped description.

View the PDF here

In both cases the MultiCell in-built function is used. Before I had this solution working I was using the Cell function. In that case, long text simply continued through to the next cell ‘Quantity’. In the case of Cell, you can simply output a series of calls to the function with a cell width and so fourth and the cells will line up against each other on the same line.

When I switched to MultiCell for the first cell of each row only, I found that it would cause all subsequent cells in the same row to wrap to the next line. Therefore my solution was to use the SetXY function to reposition the ‘cursor’ back to where the 2nd cell of the current row would normally be, and then proceed to use Cell calls.

In order to do that it’s a case of marking the current X and Y coordinates of the cursor prior to entering the line item loop and calling SetXY just after the 1st cell MultiCell function call. That solved the line wrapping issue and my text wrapped inside the first cell – great.

The second issue however is that the MultiCell is arbitrarily high depending on the amount of text wrapping going on. I had been provided a static height to my Cell calls as as such they were now out of line with the first column, that is, the text and border lines were all out of sync with the 1st column.

To solve that problem it was a case of grabbing the Y coordinate of the cursor before and immediately after the MultiCell call, finding the difference to ascertain the height of the cell, and then using this to size the height of the remaining Cell calls on the row.

Source Code

Please feel free to download the source code for this article which builds the invoice PDF as described.

The source code is provided as a ZIP file with index.php and InvoicePDF.class.php. You will need to obtain the FPDF library yourself and modify the index.php include file locations.

Best of luck!

Moo is an online printing company that produce a small set of quality eco-friendly products such as minicards, stickerbooks and notecards, and for a great price and fast global delivery.

The great thing about Moo is that you can upload your photos or (the bit that I like) brilliantly get it to import photos out of your favourite image-related accounts that you may have around the web such as Flickr, Bebo, VOX and more. Or, if you don’t have any images, they have some stuff for you to choose from. They don’t yet do full photo albums but I really hope they do in future.

We decided at roxxor to use Moo Minicards for our business cards. A business card says a lot about the person or company giving it and we felt we wanted to (as Ben likes to say) “eat our own dog food” and demonstrate our awareness and support of excellent web businesses.

Moo provides an online editor for entering the information for your card and placing imagery if you are customising it yourself. We chose to download the Photoshop templates for ours but you need not. When you’re happy, you submit your design, pay a good price and just 3 days later you get an exciting little box packed full of cards. Simplicity.

The first thing you’ll notice is their size. This size was typical of “calling cards” back in the day, and are 1/2 the size of a normal business card. Most of the time normal business cards do not use that space and if they do look over-crowded and ugly. The material is best described as a satin finish – that is, not glossy and not matte but just a slight sheen. The thickness is pleasingly thick and together with their size makes bending only possible in one direction.

We chose to make an impact with our brand on the front side of the card, whilst adding limited contact information to the rear. And yet even with this smaller card, it looks fresh and spacious whilst still providing clear brand and enough information.

We highly recommend Moo – it’s one of the more useful companies out there on the web doing a fantastic job of a simple idea – just as business should be.

We encountered a problem recently with a site not rendering correctly in IE6.0 – of course our dev guys fixed this right up but this inspired me to get some stats on just what browsers folks were using on our clients web sites. I took a peak at the analytics for this across a range of our clients that have significant traffic volumes (in excess of 1M visit per month) and a varied demographic user base across a range of industry sectors (Fashion, Retail and Transport) to make these stats work as ‘real’ averages.

It made interesting reading and I thought you might like to see the results.

Based on this data we have decided to rule out IE5.5 from any design/dev decisions going forwards. Sorry to any of you still using this, but there just aren’t enough of you out there to warrant the additional tests.

Here it is;

class MyObject {
  function __construct($data = NULL) {
    if ($data) {
      foreach ($data as $ak => $av) {
        eval("\$this->" . $this->db2Camel($ak) . " = '{$av}';");
      }
    }
  }

  function db2Camel($str) {
    $str = strtolower($str);
    $parts = explode('_', $str);
    for ($i = 0; $i < count($parts); $i++) {
      if ($i == 0) {
        $parts[$i] = strtolower($parts[$i]);
      } else {
        $parts[$i] = ucfirst($parts[$i]);
      }
    }
    return implode('', $parts);
  }
}

This code relies on a number of assumptions. These are, but are probably not limited to;

1. The data parameter to the constructor is an associative array, depicting a row from the database.
2. That the database column names are lowercase, and separated by underscores, e.g. the_column_name
3. Your attributes will be in camel casing as governed by the db2Camel function
4. Your attributes will be public as they do not benefit from an explicit declaration of access scope such as private or protected.
5. You will access the attributes direct on the object, not through get accessors, e.g. $obj->theAttribute
6. A programmer would not know the attributes that an object contained from reading the code, they would need to understand the constructor's function and consult the database column names to infer the attribute names.

If you are happy with all those assumptions, then this code might just prove quite handy in expediating the process of population of PHP object attributes dynamically from a database.

Reading around, I saw developers saying all sorts, such as making copies of the XAMPP folder to ensure Vista had the right permissions, or turning Vista’s User Access Control mechanism off, or installing services from the command line and so on and fourth.

But amongst all these suggestions, only 2 things need to be done to get XAMPP (1.6.2 anyway) working on Vista.

First, don’t forget to run setup_xampp.bat in the XAMPP installation folder.

And secondly, you need a file called msvcp71.dll to reside in the root XAMPP folder. I copied this from my old XP Windows/system32 folder, but you might need to get it elsewhere.

If you do these 2 things, XAMPP should fire up no problem.

The entities originated from an XML input stream fed into the Flash movie.

Quite a few folk out there seem to have developed string search and replace functions, but these are limited by the anticipated characters.

I found a much simpler method was just to set the dynamic text field instance’s .html attribute to true, and then inject the text into the .htmlText rather than the .text attribute. Flash apparantly then displays the characters properly.

And I should add that the dynamic text field in question still has anti-aliasing applied in case any of you are worried that using the html attributes do not support it.

Happy days.