Palivoda IT Solutions

CakePHP format user input before validation

Rostislav Palivoda — Thu, 26 Nov 2009 09:37:50 +0000

While struggling with incorrect user validation rules I’ve decided to solve the issue from the opposite side - automatically format user input. Format includes: capitalize first letters of the words, capitalize first letters of the sentences, ad spaces after punctuation marks, etc. In fact there could be added other rules later.
So I ‘ve started to work on FormatBehaviour class that will do the job, here is the code:

 
/**
 * CakePHP behaviour to format text entered by user.
 * Can be used to convert letters case, trim, etc.
 *
 * @filesource
 * @author Rostislav Palivoda
 * @link http://www.palivoda.eu
 * @version	$Revision$
 * @license	http://www.opensource.org/licenses/mit-license.php The MIT License
 * @package app
 * @subpackage app.models.behaviors
 */
class FormatBehavior extends ModelBehavior {
 
    var $settings = array(
    );
 
    function setup(&$model, &$config = array()) {
		$this->settings[$model->alias] = array_merge( $this->settings, $config );
    }
 
	function beforeValidate(&$model) {
 
		foreach (array('caseUpper', 'caseLower', 'caseTitle', 'caseSentence', 'noSpaces',
					'caseSentences', 'trim', 'html2text', 'normalSpacing', 'prefixUrl') as $section) {
			if (isset($this->settings[$model->alias][$section])) {
				foreach ($this->settings[$model->alias][$section] as $field) {
					if (isset($model->data[$model->alias][$field])) {
						$model->data[$model->alias][$field] = 
							$this->mb_format($model->data[$model->alias][$field], $section);
					}
				}
			}
		}
 
		return true;
	}
 
	function mb_format($string, $mode, $encoding = 'UTF-8') {
 
		if (in_array($mode, array('caseUpper', 'caseLower', 'caseTitle'))) {
			if ($mode == 'caseUpper') $mode = MB_CASE_UPPER;
			else if ($mode == 'caseLower') $mode = MB_CASE_LOWER;
			else if ($mode == 'caseTitle') $mode = MB_CASE_TITLE;
 
			return $this->mb_trimspaces(mb_convert_case($string, $mode, $encoding));
		}
		else if ($mode == 'caseSentence'){
			return $this->mb_ucfirst($string, $encoding);
		}
		else if ($mode == 'caseSentences') {
			return $this->sentence_case($string,  $encoding);
		}
		else if ($mode == 'html2text') {
			return $this->html2txt($string,  $encoding);
		}
		else if ($mode == 'trim') {
			return $this->mb_trimspaces($string);
		}
		else if ($mode == 'noSpaces') {
			return  preg_replace('/\s+/ui', '', $string);
		}
		else if ($mode == 'normalSpacing') {
			return $this->mb_normal_spacing($string,  $encoding);
		}
		else if ($mode == 'prefixUrl') {
			return $this->mb_prefix($string, array('www.', 'http://'), $encoding);
		}
		else return $string;
	}
 
	//Add prefix to string, if no prefix.
	function mb_prefix($string, $prefixes, $encoding) {
		foreach ($prefixes as $prefix) {
			if (mb_strpos($string, $prefix, 0, $encoding) === false) {
				$string = $prefix.$string;
			}
		}
		return $this->mb_trimspaces($string);
	}
 
    function mb_ucfirst($string, $encoding) {
		return $this->mb_trimspaces(mb_strtoupper(mb_substr($string, 0, 1, $encoding), $encoding).
			mb_substr($string, 1, mb_strlen($string), $encoding));
    }	
 
	function sentence_case($string, $encoding) {
		$sentences = preg_split('/([\.?!\n]+)/ui', $string, -1, PREG_SPLIT_NO_EMPTY|PREG_SPLIT_DELIM_CAPTURE);
		$new_string = '';
		foreach ($sentences as $key => $sentence) {
			$new_string .= ($key & 1) == 0?
				$this->mb_ucfirst(trim($sentence), $encoding) :
				$sentence.' '; 
		}
		return $this->mb_trimspaces($new_string);
	}
 
	//Remove spaces from start and end of the string and remove double spaces.
	//Transform "   aaa   bbb   " to "aaa bbb".
	function mb_trimspaces($string) {
		$retVal = $string;
		//debug('Before:
"'.htmlspecialchars($string).'"');
		foreach(array('/\r|\n|\r\n/ui' => '', '/\s\s+/ui' => ' ', 
			'/^\s+|\s+$/ui' => '', '//ui' => "\n", '/\n\s/' => "\n") as $pattern => $value) {
			$retVal = preg_replace($pattern, $value, $retVal);
		}
		//debug('After:
"'.htmlspecialchars($retVal).'"');
		return trim($retVal);
	}
 
	//Remove HTML tags.
	function html2txt($string){
		$search = array('@]*?>.*?@si',  // Strip out javascript
		               '@]*?>.*?@siU',    // Strip style tags properly
		               '@<[\/\!]*?[^<>]*?>@si',            // Strip out HTML tags
		               '@\s\S]*?--[ \t\n\r]*>@'         // Strip multi-line comments including CDATA
		);
		$new_string = preg_replace($search, '', $string);
		return $this->mb_trimspaces($new_string);
	}
 
	//Transform "(aaa),bbb,(ccc)ddd,(eee)" to "(aaa), bbb, (ccc) ddd, (eee)".
	function mb_normal_spacing($string, $encoding) {
		//debug('"'.htmlspecialchars($string).'"');
 
		//put spaces after special characters, except last character
		$tokens = preg_split('/([\.?!,;:\)]){1}/u', mb_substr($string, 0, -1), -1, PREG_SPLIT_NO_EMPTY|PREG_SPLIT_DELIM_CAPTURE);
		$new_string = '';
		foreach ($tokens as $key => $token) {
			//debug('"'.mb_substr($new_string, -1, 1).'" - '.mb_strlen($token).' - "'.$token.'"');
			if (mb_strlen($token) == 1 && mb_substr($new_string, -1, 1) == " ") 
				$new_string = trim($new_string);
			$new_string .= mb_strlen($token) == 1 ? $token.' ' : $token; 
			//debug('"'.$new_string.'"');
		}
		$new_string .= mb_substr($string, -1, 1);
 
		//spaces before specila characters, except first character
		$tokens = preg_split('/([\(]){1}/u', mb_substr($new_string, 1), -1, PREG_SPLIT_NO_EMPTY|PREG_SPLIT_DELIM_CAPTURE);
		$new_string = mb_substr($new_string, 0, 1);
		foreach ($tokens as $key => $token) {
			//debug('"'.mb_substr($new_string, -1, 1).'" - '.mb_strlen($token).' - "'.$token.'"');
			if (mb_strlen($token) == 1 && mb_substr($new_string, -1, 1) == " ") 
				$new_string = trim($new_string);
			$new_string .= mb_strlen($token) == 1 ? ' '.$token : $token; 
			//debug('"'.$new_string.'"');
		}
 
		//debug('"'.htmlspecialchars($new_string).'"');
		return $this->mb_trimspaces($new_string);
	}
 
}
?>

And finally to attach it to the model just ad it to the actAs list and provide format rules as parameters:

var $actsAs   = array('format' => array(
    'html2text' => array('firstname', 'lastname', 'nationality', 'address', 'city', 'postal_code', 'telephone', 'mobile' ,'fax', 'email'),
    'caseTitle' => array('firstname','lastname','nationality','city', 'address'),
    'caseUpper' => array('postal_code'),
    'trim' => array('telephone', 'mobile' ,'fax', 'email')),
);

Now before model is validated, the fields are formatted. Note, if you use model validation separately with {Model}->validates() then formatted data will stay in the $this->{Model}->data, so dont forget to get changed data from there after validation. Hope this helps.

CakePHP how to use Model in Component

Rostislav Palivoda — Fri, 31 Jul 2009 10:03:13 +0000

I know it’s against the main design stream of CakePHP applications to use models in the components and I was restricting myself from doing that… but finally I decide to make a try and see will that simplify my CakePHP applications development.
Let me explain a bit my motivation to use model in component. I want to add some controller output independent blocks to various screens of my application, e.g. to show list of last posts on screen 1,2 and 3. Currently I pass data from controller to layout component, so each controller method has almost the same part of code to load data from model, process data an put in to the session, so later the view element can render it. On the other hand if the data load, processing and session manipulation will be in the component then the only thing left for controller method is to add component in to the used components list.
So, here is the solution. The core controller loads models with Controller::loadModel() method. And here is how we can reuse that functionality in the component:

 
class BaseModelComponent extends Object {
 
	var $uses = false;
 
	function initialize(&$controller) {
 
		//load required for component models
		if ($this->uses !== false) {
			foreach($this->uses as $modelClass) {
				$controller->loadModel($modelClass);
				$this->$modelClass = $controller->$modelClass;
			}
		}
 
	}
 
}
?>

As you can see from its name this is a base class. So if you would like to use a model in your component just inherit it from the BaseModelComponent, like this:

 
App::import('Component', 'BaseModel'); 
class MyFooComponent extends BaseModelComponent {
 
	var $uses = array('Foo'); //models to load
 
	function initialize(&$controller) {
		return parent::initialize($controller); //important to initialize base component
	}
 
	function doFoo() {
		debug($this->Foo->findAll()); //sample output to test it works
	}
}
?>

After your base class changed, the Foo component can define in the $uses variable list of the models to use. Now you can access the model the same way as you’ve done that in the controller. Controller code can be moved to the component without any change.

Hope this helps. Have a nice day.

CakePHP conference in Berlin 2009

Rostislav Palivoda — Thu, 02 Apr 2009 17:25:33 +0000

To register your proposal: http://cakefest.org/talks/add
To participate: http://cakefest.org/pages/badges

CakePHP Exception Handler

Rostislav Palivoda — Mon, 30 Mar 2009 18:34:47 +0000

While searching for ready exception handler I did not found any that could match following requirements:
1) Handle Exception and any other (AppException, MyAppException etc) exception that are Exception super class;
2) Send email notification about exception;
3) Dump exception to log;
4) Show nice page to the user:
a) A custom landing page can be defined for exception;
b) For all other exceptions a default landing page should be used;
5) Landing page text should be localizable;
As a good start I’ve used existing AppException implementation [1]. It matches requirements: 4 and 5, but can not handle Exceptions, only AppException. So, here my evolved version of the code:


/**
  * Aplication wide exception handler class.
  *
  * Installation: 
  * 1) Copy file in to the app directory;
  * 2) Add to bootstrap.ctp folowing lines:
  * require_once(APP.'app_exception.php');
  * set_exception_handler(array('AppExceptionHandler', 'handleException'));
  * 3) Add default view to render exceptions in /exceptions/unknown.ctp, 
  * view has access to $info variable
  *
  * References:
  * http://www.mt-soft.com.ar/2007/12/21/handling-exceptions-in-cakephp-12/
  */
class AppExceptionHandler extends Object {  
 
	static function handleException($exception) {
		$parsed = new AppExceptionParser($exception);
		$instance = new AppExceptionHandler();
		$instance->renderException($parsed->getInfo());
		$instance->logException($parsed->getInfo());
		$instance->emailException($parsed);
		exit;
	}
 
	function renderException($info = array()) {
		$Controller = new Controller();
		$Controller->viewPath = 'exceptions';
		$Controller->layout = 'exception';
		$Dispatcher = new Dispatcher();
		$Controller->base = $Dispatcher->baseUrl();
		$Controller->webroot = $Dispatcher->webroot;
		$Controller->set(compact('info'));
		$View = new View($Controller);
		$view = @$info['type'];
		if (!file_exists(VIEWS.'exceptions'.DS.$view.'.ctp')) {
			$view = 'unknown';
		}
		//header('HTTP/1.0 500 Internal Server Error');
		$out = $View->render($view);
		$Controller->afterFilter();  
		echo $out;
	}
 
	function logException($info) {
		$this->log(serialize($info), LOG_ERROR);
	}
 
	function emailException($message) {
		App::import('Core', 'Email');  
		$email = new EmailComponent;  
		$email->from = 'noreply@example.com';  
		$email->to = 'dev@example.com';  
		$email->sendAs = 'text';  
		$email->subject = 'Exception notification';  
		$email->send($message);  
	}
}
 
/**
  * Application exception info synthetic class.
  */
class AppExceptionParser extends Object {
 
	var $exception = null;
 
	function __construct($exception) {
		$this->exception = $exception;
	}
 
    public function __toString() {
		return print_r($this->getInfo(), true);
    }	
 
	function getInfo() {
		return array_merge(
			array(
				'type' => $this->getType(),
				'message' => $this->getMessage()
			),
			$this->where(), 
			$this->context()
		);
	}
 
	function getType() {
		if (get_class($this->exception) == 'AppException' || is_subclass_of($this->exception, 'AppException')) {
			return $this->exception->getType();
		}
		else return 'unknown';
	}
 
	function getMessage() {
		return $this->exception->getMessage();
	}
 
	function where() {
		return array(
			'function' => $this->getClass().'::'.$this->getFunction(),
			'file' => $this->exception->getFile(),
			'line' => $this->exception->getLine(),
			'url' => $this->getUrl()
			);
	}
 
	function getUrl($full = true) {
		return Router::url(array('full_base' => $full));
	}
 
	function getClass() {
		$trace = $this->exception->getTrace();
		return $trace[0]['class'];
	}
 
	function getFunction() {
		$trace = $this->exception->getTrace();
		return $trace[0]['function'];
	}
 
	function context() {
		return array(
			'remoteAddr' => $this->getRemoteAddr(),
			'requestMethod' => $this->getRequestMethod(),
			'httpUserAgent' => $this->getHttpUserAgent(),
			'httpAcceptLangage' => $this->getHttpAcceptLanguage(),
			'httpReferer' => $this->getHttpReferer(),
			'sessionAuth' => $this->getSessionAuth()
			);
	}
 
	function getRemoteAddr() {
		return $_SERVER['REMOTE_ADDR'];
	}
 
	function getRequestMethod() {
		return $_SERVER['REQUEST_METHOD'];
	}
 
	function getHttpUserAgent() {
		return $_SERVER['HTTP_USER_AGENT'];
	}
 
	function getHttpAcceptLanguage() {
		return $_SERVER['HTTP_ACCEPT_LANGUAGE'];
	}
 
	function getHttpReferer() {
		return isset($_SERVER['HTTP_REFERER']) ? $_SERVER['HTTP_REFERER'] : 'None';
	}
 
	function getSessionAuth() {
		return isset($_SESSION['Auth']) ? print_r($_SESSION['Auth'], true) : 'Anonymous';
	}
 
}
 
/**
  * Application base exception class. The $info['type'] stores name of the view file in /views/exceptions/, without .ctp.
  * Default view is /views/exceptions/unknon.ctp
  */
class AppException extends Exception {
 
	var $type = null;
 
	function __construct($message, $type = 'unknown') {
		parent::__construct($message);
		$this->type = $type;
	}
 
	function getType() {
		return $this->type;
	}
 
}
?>

To attach AppExceptionHandler to yours the CakePHP application add to the bootstrap.php following lines:

require_once(APP.'app_exception.php');
if (configure::read() <= 1) {
	set_exception_handler(array('AppExceptionHandler', 'handleException'));
}

The last step is to create /views/exceptions/unknown.ctp, here is my example:


	"/img/logo.png"/>
	('-views-exceptions-unknown-header') ?>
	('-views-exceptions-unknown-text-short_term'); ?>
	('-views-exceptions-unknown-text-long_term'); ?>
 
	"debug" class="cake-exception-log">
	if(Configure::read() >= 1){foreach($infoas$name => $value){echo'';
			}}
	?>  
			    
				 '.$name.': $name.'">'.$value.'

'.$name.':	$name.'">'.$value.'

That’s it. Hope this helps.

References:
[1] http://www.mt-soft.com.ar/2007/12/21/handling-exceptions-in-cakephp-12/

SQL to order Null values on top with CakePHP

Rostislav Palivoda — Sat, 22 Nov 2008 11:11:09 +0000

It’s clear - to make null values on top can be used that SQL:

ORDER BY date_end IS NULL DESC, date_end DESC

and here is how to pas that SQL order in CakePHP:

array('date_end' => 'IS NULL DESC', 'Model.date_end' => 'DESC')

Here is few things you should keep in mind:
1) if you just write date_end IS NULL as string, CakePHP will fail with error ‘date_end IS NULL’ column not found, thats why we have that array to pass order fields;
2) the second parameter is Model.date_end, because is you make it just date_end CakePHP will ignore it because date_end is already in array of sorted fields.

That’s all, happy coding.

Image submit button with changable text

Rostislav Palivoda — Tue, 07 Oct 2008 07:18:21 +0000

After several try to make a graphical submit form button with localizable text in it i found it’s not so simple. Furthermore there are no cases I found in the Internet. This mean weather I hav to create an image button for each language or… here is the story how I made this.

Problem definition

As input we have a button background layout and a text string to draw on the button background.

As output we should have an URL wich produces button with text.

Right now caching of result images is not important, but we can add it later for high performance aplications.

The solution

We use php GD library to load image, and draw a text on it. After the image is ready it’s writen to the webserver response stream.

To draw a text we need a font, the arial.ttf will fit, so we place it in to the /app/vendors/imagetext/arial.ttf to use it later in our controller.

To output image we create controller and remove any model associations from it (we do not need model for that functionality, the image name and text to draw we need we will get from parameters).

Here is the controller code:


/**
 * Controller provides functionality to render imges with specified text over it
 */
 
class ImagesController extends Controller {
 
	var $uses = array(); 
 
	/**
	* Diaplays image with text over it
	*/
	function textover($caption, $image) {
 
		// Some basic setup
		$textFont = realpath(VENDORS.'imagetext').'/'.'arial'.'.ttf';
		$textSize = 15;
		$textString = $caption;
		$imageFile = IMAGES_URL.DS.$image;
 
		// Load background image
		$image = imagecreatefrompng($imageFile);
		$textColor = imagecolorallocate($image, 0, 0, 0);
 
		//Get image dimensions
		list($imageWidth, $imageHeight) = getimagesize($imageFile);
 
		// Get box info
		$box = imagettfbbox($textSize, 0, $textFont, $textString);
 
		//Find out the width and height of the text box
		$textW = $box[2] - $box[0];
		$textH = $box[5] - $box[3];
 
		// Calculate the positions
		$positionLeft = ($imageWidth - $textW)/2;
		$positionTop = (($imageHeight - $textH)/2);
 
		// Add some text
		imagettftext($image, $textSize, 0, $positionLeft, $positionTop, $textColor, $textFont, $textString);
 
		header('Pragma: public');
		header('Content-type: image/png');
		imagepng($image);
 
		// Destroy the image
		imagedestroy($image); 
 
        $this->autoRender=false;
	}
 
}
?>

That’s it. Now we are ready to get our image from the url /images/textover/[caption]/[background].png

where the caption is the text to draw on the image and the bacground.png is a filename in the /app/webroot/img directory. Try to get image by that url, if it works ok then you can use it as a source of input.

Bridgecamp Riga

Rostislav Palivoda — Fri, 25 Apr 2008 20:10:34 +0000

Dynamic CSS file linking to CakePHP layout

Rostislav Palivoda — Fri, 18 Apr 2008 07:21:09 +0000

Here is peace of code that can allow you to link CSS per controller action, just place the code in to the layout head section /app/views/layouts/default.ctp:

// view specific CSS - css//.css or /css/pahes/.css linking, if CSS file exists
$action = $this->params["controller"] != 'pages' ? $this->params["action"] : $this->params["pass"]['0'];
if (is_file(APP.WEBROOT_DIR.DS."css".DS.$this->params["controller"].DS.$action.".css")) {
	   echo $html->css($this->params["controller"]."/".$action);
}

i18n in CakePHP 1.2 - database content translation, Part 2

Rostislav Palivoda — Tue, 15 Apr 2008 15:49:51 +0000

In my own opinion database content translation with core CakePHP ‘translate’ behavior is a kind of pain when the matter comes to HABTM relations and any bulk records manipulations. It’s not a secret that it is also pain for java ORM engines, like Hibernate.
So the situation needs simple solution that just works.

User wants to add, delete and amend some classifiers in all languages the application is available. This means default.so file is not our friend any more and the magic __() function also. Of course it’s possible to modify the SO files but why we need it if there is a database to store this kind of data.
Database content localization should not complicate bulk records manipulations with sub queries.
Localization of single record CRUD should be simple for developer. Perfect solution – change nothing.
There is legacy database fields that should remain unchanged to keep current functionality up and running after the localization functionality deployed. Also this field values should be used as default values if there is no translation.
Development contract defines how many languages should support application, so we know from the beginning what languages should the application support. If user locale does not match supported locales then application should fallback to default locale.

In a couple of minutes I found at least three following approaches how to store the data.

Solution	Bulk manipulations	Single CRUD
1. Store localized data in separate table, like it does CakePHP translation behavior (i18n table).	Bulk manipulations with this approach can be done at programming language level with loops. Direct SQL queries will include additional relation to the table with localized data. Localized data field type is a memo for all types of data.	Here is possible to use model object interceptors to amend sql to read data from external table before CRUD request and manipulate data after CRUD request to set localized values. In CakePHP implementation I found that if there is no translated content in i18n table then no record selected at all.
2. Just store all data in one field in a kind of xml or symbol separated format, e.g. English String; Russian String.	Because all data in one field it’s hard to manipulate with localized values with SQL. There is overhead with unnecessary data load that hard to fix. For example you have 28 languages and user want to see data in selected locale. The rest 27 localized values just wasting computer memory.	On read we have to get whole field value and select value for current locale in code. On save we should done reverse process.
3. Store localized data In the same table - for each localizable field create fields for default value and localized values, e.g. crate fields with _eng and _rus suffix and map _eng as default.	Bulk manipulations with localized data are simple because you can access localized value with sql column name without external table linkage and sql queries are easy to localize with text parser.	Method requires to intercept request before a) read operation to select only localized values and localize sql field names; b) save operation to write content to the current locale field. If you need to read values for more then one language then: a) you can select multiple columns - pass array of locales to read and locale to use as default; b) you can read same model object multiple times - one time per selected locale.

I’ve selected approach 3 because second looks bad to me, and I already had experience with the first one. Maybe there are some other solutions, but I fill comfortable with the third one - it looks simple to me can match all requirements. Lets go deeper in the third approach implementation for CakePHP…

The i18n model behavior

A weekend is passed. Finally I’ve done with i18n behavior prototype. Here is the code:


/* SVN FILE: $Id: $ */
/**
 * Requires:
 * CakePHP 1.2.1.8004
 *
 * I18n behavior for database content internationalization using locale dependent table field names.  
 *
 * I18n behavior integration steps:
 * 1. Identify which languages you are going to use 
 *	(e.g. English and Russian)
 * 2. Identify your default language 
 *	(e.g. English);
 * 3. Identify fields of your models to be internationalized (
 *	(e.g. model Country field 'name' should be i18n compatible);
 * 4. Update your database tables for each model field to be i18n compatible 
 *	(e.g. rename 'name' field to .'_'.DEFAULT_LANGUAGE - default, and create field 'name_rus' that will be russian content); 
 * 5. Add to your model this behavior;
 *	(e.g. $artAs = array('i18n' => array('fields' => array('name'), 'display' => 'name');) 
 * 6. Add to all models that are associated with i18n compatible models this behavior;
 *	(e.g. $actAs = array('i18n'); //you can simply add this to each model )
 *	Its necessary because beforeFind and afterFind invoked for the behavior of the model that calls find method. 
 *	During beforeFind and afterFind the behavior will look for any i18n behaviors, see _localizeScheme and _unlocalizeResults.
 * 7. In your model you can set $displayField as usual. The i18n behavior will unlocalize result field names in afterFind. Default $displayField is 'name'.
 * 8. In your model you can set $order as usual. The i18n behavior will localize your order field name in beforeFind.
 * 9. In your relations you can set order attribute for one field and it will be localized.
 * 10. To save multiple locales pass data with database field names.
 *  (e.g. 'name_rus', 'name_eng');
 * 11. To save data in to current locale pass data without locale profex.
 *  (e.g. 'name' will be saved to 'name_eng' if current locale is 'eng');
 * 12. To load values for all locales detach the i18n behavior before calling model read.
 * (e.g. $this->MyModel->Behaviors->detach('i18n'); $this->MyModel->read();)
 * 13. i18n can be used with Containable behaviour, but becuase it relies on recursion while searching for localizable 
 * fields througth relations, check you have enougth recursion level (default recursion=1);
 *
 * PHP versions 4 and 5
 *
 * Copyright 2008, Palivoda IT Solutions, Inc.
 *
 * Licensed under The MIT License
 * Redistributions of files must retain the above copyright notice.
 *
 * @filesource
 * @copyright		Copyright 2008, Palivoda IT Solutions, Inc.
 * @link			http://www.palivoda.eu
 * @package		app
 * @subpackage		app.models.behaviors
 * @since			CakePHP(tm) v 1.2
 * @version			$Revision:  $
 * @modifiedby		$LastChangedBy:  $
 * @lastmodified		$Date: $
 * @license			http://www.opensource.org/licenses/mit-license.php The MIT License
 */
class I18nBehavior extends ModelBehavior {
 
	//for each model stores lozalizable field names and their aliases to current locale
	var $fields = array();
 
	/** 
	 * Reads configuration of behavior.
	 * Allowed values:
	 * fields - array of i18n compatible field names;
	 */
	function setup(&$model, $config = array()) {
		if (!defined('DEFAULT_LANGUAGE')) {
			trigger_error("Add to bootstrap.php line: define('DEFAULT_LANGUAGE', 'eng');");
		}
		if (!empty($config['fields'])) {
			$this->fields[$model->alias] = array_fill_keys($config['fields'], null);
		}
	}
 
	function cleanup(&$model) {
		$this->_refreshSchema($model);
		//debug('I18n behaviour detached from '.$model->alias.' model.');
	}
 
	function beforeFind(&$model, &$query) {
 
		$locale = $this->_getLocale($model);
		//debug('i18n-'.$model->alias.'-beforeFind-'.$locale);
		//debug($query);
 
		//reset shema if model locale set and was changed since last query
		if (isset($model->locale) && $locale != $model->locale) $this->_refreshSchema($model);
 
		$recursive = empty($query['recursive']) ? 
			(empty($model->recursive) ? 0 : $model->recursive) 
				: $query['recursive']; //during 'delete' there are queries with empty recursive
 
		$this->_localizeScheme($model, $locale, $recursive);
		$this->_localizeQuery($model, $query, $recursive, true);
 
		//debug($query);
		return $query;
	}
 
	//Recursively replaces $localField values to $localAlias in $section array (or string)
	function __localizeArrayInQuery(&$model, &$section, $localField, $localAlias, $isPrimary, &$level) {
 
		if ($level <= 0) return; //rectrict recursion level
 
		//multiple filed as array
		if (is_array($section)) {
 
			//localize array values 
			foreach($section as $queryAlias => &$queryField) {
				if (is_array($queryField)) {
					//for containable [model] => array('fields'=>array(...)), all sub calls will localize by short name too
					if ($queryAlias == $model->alias) $isPrimary = true;
					//localize array values in sub section (like contain, order)
					$this->__localizeArrayInQuery($model, $queryField, $localField, $localAlias, $isPrimary, $level);
				}
				else {
					//full name
					if (preg_match('/(^|,| )('.$model->alias.'.'.$localField.')(,| |$)/i', $queryField))
						$queryField = preg_replace('/(^|,| )('.$model->alias.'.'.$localField.')(,| |$)/i', 
							'$1'.$model->alias.'.'.$localAlias.'$3', $queryField);
					//short name
					else if ($isPrimary && preg_match('/(^|,| )('.$localField.')(,| |$)/i', $queryField))
						$queryField = preg_replace('/(^|,| )('.$localField.')(,| |$)/i', 
							'$1'.$localAlias.'$3', $queryField);
				}
			}
 
			//localize array keys
			$oldKeys = array();
			foreach($section as $queryAlias => &$queryField) {
				//full name
				if (preg_match('/(^|,| )('.$model->alias.'.'.$localField.')(,| |$)/i', $queryAlias)) {
					$newKey = preg_replace('/(^|,| )('.$model->alias.'.'.$localField.')(,| |$)/i', 
							'$1'.$model->alias.'.'.$localAlias.'$3', $queryAlias);
					$section[$newKey] = $queryField;
					$oldKeys[] = $queryAlias;
					debug($queryAlias.''.$newKey);
				}
				//short name
				else if ($isPrimary && preg_match('/(^|,| )('.$localField.')(,| |$)/i', $queryAlias)) {
					$newKey = preg_replace('/(^|,| )('.$localField.')(,| |$)/i', 
						'$1'.$localAlias.'$3', $queryAlias);
					$section[$newKey] = $queryField;
					$oldKeys[] = $queryAlias;
					debug($queryAlias.''.$newKey);
				}
			}
			foreach($oldKeys as $removeKey) {
				unset($section[$removeKey]);
			}
 
			unset($queryAlias); unset($queryField); unset($section);
		}
		//multiple fileds in one string, comma separated
		else {
			//full name
			if (strstr($section, $model->alias.'.'.$localField) != false)
				$section = str_replace($model->alias.'.'.$localField, $model->alias.'.'.$localAlias, $section);
			//short name
			else if ($isPrimary && strstr($section, $localField) != false)
				$section = str_replace($localField, $localAlias, $section);
		}
 
	}
 
	/**
	* Modifies query fielelds to load localized content for current locale.
	* isPrimary should be true only when localizing model that has afterFind event
	*/
	function _localizeQuery(&$model, &$query, $recursive, $isPrimary) {
 
		if (isset($model->Behaviors->i18n) && isset($model->Behaviors->i18n->fields[$model->alias])) {
			foreach($model->Behaviors->i18n->fields[$model->alias] as $localField => $localAlias) { //$localAlias set by _localizeScheme
 
				//localize field names in query sections:
				//1. fields - localize full and short array values
				//2. contain - localize full array values
				//3. conditions - localize array keys, localize array values
				//4. order - localize array values as comma separated string
				foreach(array('fields', 'contain', 'conditions', 'order') as $section) {
					if (isset($query[$section])) {
						$level = 3; //recursion level for __localizeArrayInQuery only
						$this->__localizeArrayInQuery($model, $query[$section], $localField, $localAlias, $isPrimary, $level);
					}
				}
 
				//on primary model append default display name to query if not exists
				if ($isPrimary && 
					is_array($query['fields']) &&
					$model->displayField == $localField &&
					!in_array($model->alias.'.'.$localAlias,  $query['fields']) &&
					!in_array($localAlias,  $query['fields']) ) {
						//keep only one Id column in query
						$query['fields'] = array_values(array_unique($query['fields']));
						$query['fields'][] = $model->alias.'.'.$localAlias;
						//set displayFieled fof list type of query
						$query['list']['valuePath'] = '{n}.'.$model->alias.'.'.$localField; 
 
				}
			}
		}
 
		//if no recursive set then localize fields of related models
		if (empty($recursive)) $recursive = 0;
 
		if ($recursive < 0) return;
 
 		//go throught related models and if thay has i18n behaviour then localize theme
		//Note: models A-B-C, if B is not i18n then C will not be localized, even if it has i18n behaviour
 
		foreach(array('belongsTo','hasOne','hasMany','hasAndBelongsToMany') as $relationGroup) {
			if (isset($model->$relationGroup)) {
				foreach ($model->$relationGroup as $name => &$relation) {
					if (isset($model->Behaviors->i18n)) {
						$model->Behaviors->i18n->_localizeQuery($model->$name, $query, $recursive-1, false);
					}
				}
			}
		}
 
	}
 
	/**
	* Modifies theme to load localized content only for default and current locale.
	*/
	function _localizeScheme(&$model, $locale, $recursive, &$relation = null) {
 
		$model->locale = $locale;
 
		if (isset($model->Behaviors->i18n) && isset($model->Behaviors->i18n->fields[$model->alias])) {
			foreach($model->Behaviors->i18n->fields[$model->alias] as $configName => &$configAlias) {
 
				//ammend schema and store in config localized field name _ or _def
				$foundSpecific = false;
				foreach($model->_schema as $shemaName => $v) {
					if (strpos('_'.$shemaName, $configName) == 1) { //is one of i18n fields
						if ($configName.'_'.DEFAULT_LANGUAGE != $shemaName) { //not for default locale
							if ($configName.'_'.$locale != $shemaName) { //not for current locale
								unset($model->_schema[$shemaName]);
							}
							else {
								$foundSpecific = true;
								$configAlias = $configName.'_'.$locale;
							}
						}
					}
				}
				unset($shemaName); unset($v);
				if ($foundSpecific) { //found locale specific content, no need in default content
					unset($model->_schema[$configName.'_'.DEFAULT_LANGUAGE]);
				}
				else {
					$configAlias = $configName.'_'.DEFAULT_LANGUAGE;
				}
 
				//set defailt display field to i18n name or title
				if (empty($model->displayField) || $model->displayField == 'id') {
					if (isset($this->fields[$model->alias]['name'])) {
						$model->displayField = 'name';
					}
					if (isset($this->fields[$model->alias]['title'])) {
						$model->displayField = 'title';
					}
				}
 
				//localize relations
				if (isset($relation)) {
 
					// localize other relation attributes: 'conditions', 'fields', 'order', //TODO: 'finderQuery', 'deleteQuery', 'insertQuery'.
					$sections = array(&$relation['fields'], &$relation['order'], &$relation['conditions']);
					foreach ($sections as &$section) {
						//do not localize more than once
						if (isset($section)) {
							if (is_array($section)) {
								foreach ($section as &$subSection) {
									if (substr_count($subSection, $configAlias) == 0)
										$subSection = str_replace($configName, $configAlias, $subSection);
								}
							} 
							else { 
								if (strlen($section) > 0 && substr_count($section, $configAlias) == 0)
									$section = str_replace($configName, $configAlias, $section);
							}
						}
					}
 
				}
 
 
			}
		}
 
 
		//if no recursive set then update schema of related models
		if (empty($recursive)) $recursive = 0;
 
		if ($recursive < 0) return;
 
		//go throught related models and if thay has i18n behaviour then localize theme
		//Note: models A-B-C, if B is not i18n then C will not be localized, even if it has i18n behaviour
 
		foreach(array('belongsTo','hasOne','hasMany','hasAndBelongsToMany') as $relationGroup) {
			if (isset($model->$relationGroup)) {
				foreach ($model->$relationGroup as $name => &$relation) {
					if (isset($model->Behaviors->i18n)) {
						$model->Behaviors->i18n->_localizeScheme($model->$name, $locale, $recursive-1, $relation);
					}
				}
			}
		}
 
	}
 
	function afterFind(&$model, &$results, &$primary) {
		//debug('i18n-'.$model->alias.'-afterFind');
		if (is_array($results)) {
			foreach ($results as &$result) {
				$this->_unlocalizeResults($model, $result, $this->_getLocale($model));
			}
		}
		return $results;
	}
 
	/**
	* Narrows fields of loaded data to locale independant names, e.g. fields _def and _eng will became just .
	* It recurse as far as resulsts are exists. If you made find with recursive 2 then it will recurse till second level of results.
	* TODO: The reverse process should be made before model saved.
	*/
	function _unlocalizeResults(&$model, &$result, &$locale) {
 
		if (isset($model->Behaviors->i18n) && isset($model->Behaviors->i18n->fields[$model->alias])) {
 
			//collection of models
			if (!empty($result[$model->alias])) {
				$data = &$result[$model->alias];
			}
			//single model
			else {
				$data = &$result;
			}
 
			foreach($model->Behaviors->i18n->fields[$model->alias] as $name => $alias) { //alias set in _localizeScheme
				//unlocalize field name
				if (is_array($data) && array_key_exists($alias, $data)) {
					$data[$name] = $data[$alias];
					unset($data[$alias]);
				}
			}
 
			unset($data);
		}
 
		if (isset($model->belongsTo)) {
			foreach ($model->belongsTo as $name => $relation) {
				$behaviors = $model->$name->Behaviors;
				if (isset($result[$name]) && isset($model->Behaviors->i18n)) {
					$model->Behaviors->i18n->_unlocalizeResults($model->$name, $result[$name], $locale);
				}
			}
		}
 
		if (isset($model->hasOne)) {
			foreach ($model->hasOne as $name => $relation) {
				$behaviors = $model->$name->Behaviors;
				if (isset($result[$name]) && isset($model->Behaviors->i18n)) {
					$model->Behaviors->i18n->_unlocalizeResults($model->$name, $result[$name], $locale);
				}
			}
		}
 
		if (isset($model->hasMany)) {
			foreach ($model->hasMany as $name => $relation) {
				$behaviors = $model->$name->Behaviors;
				if (isset($result[$name]) && isset($model->Behaviors->i18n)) {
					foreach ($result[$name] as &$record) {
						$model->Behaviors->i18n->_unlocalizeResults($model->$name, $record, $locale);
					}
				}
			}
		}
 
		if (isset($model->hasAndBelongsToMany)) {
			foreach ($model->hasAndBelongsToMany as $name => $relation) {
				$behaviors = $model->$name->Behaviors;
				if (isset($result[$name]) && isset($model->Behaviors->i18n)) {
					foreach ($result[$name] as &$record) {
						$model->Behaviors->i18n->_unlocalizeResults($model->$name, $record, $locale);
					}
				}
			}
		}
 
	}
 
	function beforeSave(&$model) {
 
		//get current locale
		$locale = $this->_getLocale($model);
 
		//if user is saving unlocalized values then reset shema and do not localize any value
		foreach($this->fields as $modelAlias => $modelFields){
			foreach($modelFields as $fieldName => $fieldAlias){
				if(isset($model->data[$modelAlias][$fieldAlias])) {
					$this->_refreshSchema($model);
					return true; //exit
				}
			}
		}
 
		//save localized value to alias database field
		foreach($this->fields as $modelAlias => $modelFields){
			foreach($modelFields as $fieldName => $fieldAlias){
				if(!empty($model->data[$modelAlias][$fieldName])){				
					$model->data[$modelAlias][$fieldAlias] = $model->data[$modelAlias][$fieldName];
					unset($model->data[$modelAlias][$fieldName]);
				}
			}
		}
		//debug($model->data);
 
		return true;
	}	
 
	public static $_i18n = null;
 
	function _getLocale(&$model) {
 
		//instanciate current locale storage class
		if (self::$_i18n == null) {
			if (!class_exists('I18n')) {
				uses('i18n');
			}
			self::$_i18n =& I18n::getInstance();
		}
 
		//retreive current locale
		$locale = self::$_i18n->l10n->locale;
		//debug($model->alias.' get locale '.$locale);
 
		return $locale;
	}
 
	function _refreshSchema(&$model) {
		$model->_schema = null;
		$model->schema();
		//debug($model->alias.' schema renewed');
	}
 
}
 
?>

Localized find operation

Lets imagine we have following table in the database with fields for localized content for English and Russian languages:

CREATE TABLE IF NOT EXISTS `countries` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name_eng` varchar(64) character SET utf8 collate utf8_unicode_ci NOT NULL,
  `name_rus` varchar(64) character SET utf8 collate utf8_unicode_ci NOT NULL,
  PRIMARY KEY  (`id`)
);
 
--- and here is sample records
INSERT INTO `countries` (`id`, `name_eng`, `name_rus`) VALUES
(1, 'Australia', 'Австралия'),
(2, 'Austria', 'Австрия');

Next we have the model class /app/models/country.php:


class Country extends AppModel {
	var $name = 'Country';
	var $useTable = 'countries';
	var $actsAs   = array('i18n' => array('fields'=>array('name')) ); 
	var $displayField = 'name';
	var $order = 'name';
}
?>

Note, we have i18n in the behaviors list ($actAs) and name of the field we want to localize - “name”. Here in our example we have only one filed, but you can add as many fileld to the array as you wish, like

var $actsAs   = array('i18n' => array('fields'=>array('name', 'shortname', 'firstname', 'mydrandmaname')) );

CakePHP uses “name” or “title” as default display name and i18n behavior do the same, therefore we can skip definition of $displayField variable but I will leave it for example.
As far as we have our model we can drop the i18n behavior in to the /app/models/behaviors/i18n.php (full source code of i18n is at the top of the page).
Next we have to define that English is our default language in /app/config/bootstrap.php

define('DEFAULT_LANGUAGE', 'eng');

Fallback to default language happens when the database field for the specific locale not found. e.g. user wants Lithuanian locale, but in the database there are fields name_eng and name_rus, but no field name_lit, then values from name_eng field will be selected.
Now we are ready to read our localized model from database, and here is how we do that:

//output localized list or countries
debug($this->Country->find('list'));
//output all countries with all fields with localized names
debug($this->Country->findAll());

That’s all about find operation localization.

I tried making one of the fields empty, but it does not falls back to the default locale language. I want to select default value if column exists but value is empty. Like user has Russian locale and there is name_rus but values are NULL in the database. Then app should select values from name_eng.

This will increase the amount of selected data (we need to select default and locale specific) fields from the database and in afterfind event of the behavior we should parse all results to check for empty locale specific value. It’s really bad from performance point of view. My idea is to write default value to the empty locale specific value during save operation. E.g. we have name_eng, name_rus, user has Russian locale and saves model, if value is empty then value of nam_eng will be written to the name_rus. Note, this functionality not implemented yet.

I have a one to many relationship table - a category table which has many product relationship. Product model has id field, i18n ‘name’ field (name_eng and name_zh_tw), and this table belongs to category by category_id field. When I retrieve the category table with recursive of two, I wanted to retrieve the name of the product depending on the locale.

What you should keep in mind it is the i18n behavior should be both:
a) in the model that has the localizable fields;
b) in the model that does find operation.
In your case you have: category (no i18n fields) 1 - M product (i18n fileds: name_eng, name_zh_tw).
For this case you should put the i18n behavior:
a) in to the product model the i18n behavior to mark fields that you are going to localize;

var $actsAs   = array('i18n' => array('fields'=>array('name')) );

b) in to the category model to allow the i18n behavior to intercept the beforeFind and afterFind calls:

var $actsAs   = array('i18n');

What’s next?

As you can see in comments the save interception is not implemented yet. And if you will try to save localized model you will got error message that field not found.
I will keep up to date the post and commit updates to the code as I will progress in the area. Right now this functionality is enough for me and it works great.
Do not hesitate to post comments and code improvements.
As soon as the code became more or less functional and stable enough it will be introduced to CakePHP community.
That’s all for now, happy coding.

i18n in CakePHP 1.2 - database content translation.

Rostislav Palivoda — Thu, 10 Apr 2008 07:47:53 +0000

Use case: Show translation of database content.

To start with translation of database content in CakePHP 1.2 we have to create a table to store all translated data, by default it’s name is i18n. We can use ‘cake i18n’ command to create the table. Here is the SQL of the table I’ve got:

CREATE TABLE `i18n` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `locale` varchar(6) collate utf8_unicode_ci NOT NULL,
  `model` varchar(255) collate utf8_unicode_ci NOT NULL,
  `foreign_key` int(11) NOT NULL,
  `field` varchar(255) collate utf8_unicode_ci NOT NULL,
  `content` text collate utf8_unicode_ci,
  PRIMARY KEY  (`id`),
  KEY `locale` (`locale`),
  KEY `model` (`model`),
  KEY `foreign_key` (`foreign_key`),
  KEY `field` (`field`)
)

I will localize Country names, so here is sql for counries table:

CREATE TABLE `countries` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(255) collate utf8_unicode_ci NOT NULL,
  PRIMARY KEY  (`id`)
)

Just a few words about the table: the idea of translation is to intercept calls to the model data and to lookup for translated content in the i18n table. Translation content identified by model name, current locale, model identifier (id) and field name to be translated.
So setup fields to be translated we have to add behavior in to the model and supply model field names:

var $actsAs   = array('Translate' => array('name'));

My model name is ‘Country’. After adding behavior to the model in the sql trace I can see additional query to the database:

SELECT `Country`.`id`, `I18n__name`.`content` FROM `countries` AS `Country` LEFT JOIN `i18n` AS `I18n__name` ON (`Country`.`id` = `I18n__name`.`foreign_key` AND `I18n__name`.`model` = 'Country' AND `I18n__name`.`field` = 'name') WHERE `I18n__name`.`locale` = 'eng'

It’s TranslateBehavior is looking for translated content. I have about 200 records in countries table but after adding the behavior the results are empty. It looks like only translated content records appear in the results.

Found a problems

1) Find as list does not load translated content. (problem 4456). Following code will return identifiers but translated values always will be set to null.

$countries = $this->Somemodel->Country->find('list'); //returns array with null values

2) If there are multiple model associations has-one to the same model then i18n content searches by model.name, not by model.alias (problem 4461).

That’s all. Happy baking.

P.S.:

Why I need Country.name column in the database table if contents for the name column is stored in the i18n table? I’ve renamed the column to ‘name_old’ and it still works, buy in lists only identifier are displayed. After following line was added translated values appeared again in the lists.

var $displayField = 'name';

So there is no column in the databse but in model it’s created from translation behavior. Now countries table has following structure:

CREATE TABLE `countries` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  PRIMARY KEY  (`id`)
)

P.S.:

To sort by localized values use ‘I18n__.content’. For example to sort countries list by localized name I use:

var $order = 'I18n__name.content';

Open questions

1. Why contents not localized for related models one-to-many, many-to-one, many-to-many (HABT)?
2. Why order column should be ‘I18n__name.contents’?

What next?

Take a look at the alternative solution in the next post.