If you want to unit test an action in a controller that checks the request to see if is an XML HTTP Request using the isXmlHttpRequest() method provided by the Zend Framework, then you will definitely run into a problem.

isXmlHttpRequest() pretty much checks to see if the $_SERVER['HTTP_X_REQUESTED_WITH'] is set with ‘XMLHttpRequest’, if not, then returns FALSE. I thought that by setting the server variable with XMLHttpRequest directly will allow me to bypass the check.

function myAjaxTestAction()
{
      $_SERVER['HTTP_X_REQUESTED_WITH'] = 'XMLHttpRequest';

      //then do your ajax tests here
}

This solution seemed like it was going to work, but it turns out that isXmlHttpRequest() makes a call to getHeader() like this:

public function isXmlHttpRequest()
{
        return ($this->getHeader('X_REQUESTED_WITH') == 'XMLHttpRequest');
}

What I didn’t know is that when you are doing unit tests the framework extends the HTTP class and changes the getHeader() to only use headers set using the setHeader or setHeaders methods.
After a couple of minutes tracing over the calls being made. I discovered that the fix was pretty simple, set our headers doing the following in your test case:

function myAjaxTestAction()
{
      $this->request->setHeader('X_REQUESTED_WITH');

      //then do your ajax tests here
}

This will fake an AJAX request and return the expected result.

I hope this article helps many of you since I spent many hours trying to decipher why setting ‘XMLHttpRequest’ to the $_SERVER did not work as I expected.

After reading the reference guide on Zend_Translate I decided that we were going to use “gettext” as our translation adapter. PHP has support for gettext right our of the box, and with the Zend_Translate it’s easy to change adapters, if you decide that you want to use a different adapter.

Assuming that you already have the latest version of Zend Framework (1.10.*) installed in your server, I’m going to explain and guide you guys on how I got it all working.

First you need to get a tool that we will use to parse your project files to create the translation dictionaries. I’m using PoEdit which is free and supports multiple platforms.

Now let’s put some code down in your index.phtml file of you application. This one should be located in /yourapp/application/views/scripts/index/
If it’s not there, then just create one, but make sure you have to corresponding controller and action.
Inside of this file we are going to put the following:

<?php
$t = new Zend_Translate(
	'gettext',  //the adapter
	APPLICATION_PATH.'/translation', //where the lang files will be stored
	'auto',  //set to auto include .mo files
	array('scan' => Zend_Translate::LOCALE_FILENAME) //set to scan lang files
);

echo $t->_("This is my first translation")."<br/>";
?>

Before this piece of code works, we need to generate our translation files, else it will throw an error stating that the application can’t find the corresponding language files.

We need to create a new folder in your application folder. I’m calling it lang, but you can call it anything you want. This folder will be used to store your language files. So you should have something like “/yourapp/application/lang”.

After this, you need to open up PoEdit:

1. Go to File->Catalog Manager

2. Click on the “Create new translations project” icon

3. Give your project a name

4. Select the directory to store your translation files (“/yourapp/application/lang”) and hit OK

With a newly crated project, we can now generate our language file.
To do this,  close the Catalog Manager window

1. Go to File->New Catalog

2. Give it a project Name and/or version and be sure to feel in the appropriate information. Be sure to select Charset  ”utf-8″

3. Now, click on the paths tab. Here you will have to add all the dir paths that point to the files that you want to parse for translation. (/yourapp/application/views/scripts/index/index.phtml)

4. Finally, click on the Keywords tab, and make sure you include the keyword the parser will use to identify the text that needs translation. In our example we will put an underscore “_”  since in our code we have echo $t->_(“This is my first translation”);

5. Hit OK and make sure that you save the file with a name such as mylang_en.po. The _en is crucial, since Zend_Translate will scan the appropriate language file and use this naming convention to load the appropriate file

Since by default the PoEdit PHP parser handles files with .php extension. We need to modify the preferences so that it allows other types, such as .phtml files.
To do this, go to Edit->Preferences->Parsers  When you get to parsers select PHP and then click on the EDIT button. In the parser setup window we need to add *.phtml extension to the “List of extensions” field in the Language section, separated by semicolons. The field should be something like this: *.php;*.phtml
Then, in the Invocation section, you need to add  -L php to the parser command. This should look like this  xgettext --force-po -o %o %C %K %F -L php

Once you have completed this, a pop up screen will show the progress of the catalog update and then list you all the parsed strings. Hit OK and then you will be in the translation view. Just select the string you would like to translate save and you are good to go.

Once you’ve completed the following steps just copy the .po file and create additional one’s for the languages you want to do translation. Remember the naming convention discussed on the steps above.

In your code to switch languages, you need to put the following line $t->setLocale('es'); This for example will switch the locale to Spanish and will try to load a file with “_es”

<?php
$t = new Zend_Translate('gettext', APPLICATION_PATH.'/translation', 'auto', array('scan' => Zend_Translate::LOCALE_FILENAME));

echo $t->_("This is my first translation")."<br/>";

//change locale to spanish
$t->setLocale('es');

echo $t->_("This is my Second translation")."<br/>";
?>

This week I had the chance to play around with Google’s charts API, and let me tell you that I’m loving it. In the past couple of years I’ve had to integrate charts into the different projects. I have used everything from Fusion Charts, to PHP/SWF Charts, and DOJO’s charting engine. But, since I learned that Google provided developers with an API to create charts on the fly, I wanted to give it a try.

To create static bart chart is as simple as:

<img src="http://chart.apis.google.com/chart?
cht=bvs
&chs=200x125
&chd=t:10,50,60,80,40|50,60,100,40,20
&chco=4d89f9,c6d9fd
&chbh=20&chds=0,160"/>

Let me break out the parameters for you into:
// this is the chart type
cht=bvs
//this is the bar colors
chco=4D89F9,C6D9FD
//this is the chart values
chd=t:10,50,60,80,40|50,60,100,40,20
//chart dimensions
chds=0,160

In the Google Charts API website you can find more info regarding this simple but useful chart api. But, that’s not all. They also have the Google Visualization API where they actually give you more advanced and dynamic set of visualization tools. They pretty much opened their entire library of data visualization helpers to allow developers like yourself create user interfaces that contain elements that some of your users will be used to seeing, since graphs, charts and other elements you will find in this API is already being implemented in google products.

I encourage you to check both, the more simple and straight forward Charts API, or the more advanced and dynamic Visualtization API.

Feel free to let me and the readers know on the exiting ways you are utilizing those API’s

When developing an application there are some important factors that you have to pay close attention to avoid problems in the future. I think one of the most important is logging information on how your application is working and when it fails.

Must of us like to log only big exceptions and fatal errors, but the truth is, that when you are in the development process it’s very important to keep track of not just errors, but important information of when something gets executed. As a web developer one of the most important tools to have is FireBug. If you didn’t know, FireBug has an API that you can use to send console messages for logging purposes, when debugging JavaScript. But, did you know you can use FireBug to debug your php applications?

Through Wildfire, a project that was created to help developers have a standard way for sending messages between different programming languages and scripts. The Zend Framework is now able to communicate to the Firebug console in order to display logging messages injected by PHP.

Using this component is pretty straight forward if you are using Zend_Controller_Front (MVC) with zend Framework.

Place this in your bootstrap file before dispatching your front controller

$writer = new Zend_Log_Writer_Firebug();
$logger = new Zend_Log($writer);

Then whenever you want to log something to Firebug just use it in your model, view, or controller like this.

$logger->log('This is an INFORMATIONAL log message!', Zend_Log::INFO);
$logger->log('This is a WARNING log message!', Zend_Log::WARN);
$logger->log('This is an ERROR log message!', Zend_Log::ERROR);

If you notice in the example above, you can specify the type of message you want to log (INFO, WARN, etc..). This is helpful when you want to clearly identify what type of message you are viewing since it will apply a special formatting and in some instances provide more information.

If you want to use the Zend_Log_Writer_Firebug as a stand alone here is the sample code you can use:

//Instantiate the Firebug Writer
$writer = new Zend_Log_Writer_Firebug();
$logger = new Zend_Log($writer);

//start the wildfire component
$request = new Zend_Controller_Request_Http();
$response = new Zend_Controller_Response_Http();
$channel = Zend_Wildfire_Channel_HttpHeaders::getInstance();
$channel->setRequest($request);
$channel->setResponse($response);

// Start output buffering
ob_start();

// Now you can make calls to the logger

$logger->log('This is a log message!', Zend_Log::INFO);

// Flush log data to browser
$channel->flush();
$response->sendHeaders();

If you don’t use ZendFramework there is another alternative to php developers. FirePhp, will also enable you to send log messages to Firebug by using php method calls. Be sure to check FirePhp website to get more information.

So remember that this is just one easy and great way to debug your projects, there are many other tools and methods you can incorporate into your projects. If you want to share other ways or simply just want to ask a question regarding this post, feel free to leave a comment.

$rssFeedLink = 'http://www.smooka.com/blog/';
$cacheId = 'rss_feed';

$frontendOptions = array(
		   	'lifetime' => 1800, // cache lifetime of 30 mins
		   	'automatic_serialization' => true);

$backendOptions = array(
		    	// Directory where to put the cache files
		    	'cache_dir' => '/cache/'
			);

// getting a Zend_Cache_Core object
$cache = Zend_Cache::factory('Core','File', $frontendOptions, $backendOptions);

if (!$rss = $cache->load($cacheId)) {
	try {
		$rss = Zend_Feed::import($rssFeedLink);
	} catch (Exception $e) {
		$feedError = true;
	}

	//check to see if it did not fail
	if (!$feedError && is_object($rss))
	{
		$cache->save($rss, $cacheId);
	}
}

//assuming that everything went right while fetching the feed
foreach ($rss as $item) {
	$channel['items'][] = array(
		'title'       => $item->title(),
		'link'        => $item->link(),
		'description' => $item->description()
	);
}

While iterating through the feed, the script would output the following message “Warning: Invalid argument supplied for foreach()”, under, “Zend/Feed/Element.php on line 322″ on an empty cache.

It appears that Zend_Feed and Zend_Cache do not get along, I’m pretty sure it’s a bug since it looks like Zend_Feed_Rss is sent to sleep by the $cache->save() call and it’s not waking up automatically. The solution that I found it’s pretty straight forward. Just modify the following piece of code.

if (!$feedError && is_object($rss))
{
	$cache->save($rss, $cacheId);
	//ADD a wakeup call to the RSS object
	$rss->__wakeup();
}

That should do the trick!

After I fixed the issue, I went back to the drawing board and decided that it was more efficient to cache the actual HTML output, instead of the returned object by Zend_Feed. That seems to work just fine, since the call to $cache->save() is done after the iteration of the feed items. That fixes the issue and at the same time you are eliminating the need to iterate and re-build the HTML every time the page is loaded.

Hope this information helps you, and if you have any questions or comments be sure to post them here.

• isXmlHttpRequest()
• JSON action helper
• AutoComplete
• ContextSwitch
• AjaxContext

isXmlHttpRequest()

This handy little method can eliminate the need to send extra parameters such as /ajax/true/ to let the controller know it’s an Ajax request. Most standard JavaScript frameworks (jQuery, YUI, Prototype) pass the X-Requested-With HTTP header with the value ‘XMLHttpRequest’ when doing an Ajax request. isXmlHttpRequest() basically just checks to see if that header is set and if it is, then execute the code that needs to be executed if it’s an Ajax call.

/**
* myAction from myController
*/
function myAction()
{
if  ($this->getRequest()->isXmlHttpRequest()) {
// do the handling of your ajax request
}
else {
// if it's not an ajax request then do regular handling here
}
}

JSON action helper

I was surprised when I found this action helper in the framework. The JSON helper is pretty slick. It does 5 things that usually I had to do myself.

• It Disables layouts if currently enabled.
• Disables the ViewRenderer if currently enabled.
• Sets the ‘Content-Type’ response header to ‘application/json’.
• Immediately returns the response, without waiting for the action to finish execution.
• Array passed as argument will be returned as a json formatted response.

So if you use this helper along with the isXmlHttpRequest() method you can easily handle any Ajax request and return a response with minimum amount of programming.

/**
* myAction from myController
*/
function myAction()
{
if ($this->getRequest()->isXmlHttpRequest()) {
// do the handling of your ajax request

$myArrayofData = array('a','b','c');

//encode your data into JSON and send the response
$this->_helper->json($myArrayofData);
//nothing else will get executed after the line above

}
else {
// if it's not an ajax request then do regular handling here
}
}

AutoComplete

This helper is currently supported only by Dojo and Scriptaculous AJAX libraries, so if you are working with any of those libraries, Zend’s AutoComplete will make your life a little bit easier. AutoComplete will do the same actions as the JSON helper (disable layout, sent appropriate content type, etc…) but will do the extra step to make sure your data is formatted correctly to use with the auto complete feature of the previously mentioned libraries. Definitely check this helper out if you are working with auto complete functionality.
To read more and see examples click here.

ContextSwitch and AjaxContext

These last two are very similar, If I’m not mistaken AjaxContext extends ContextSwitch to contain all the functionality of ContextSwitch, but, there are a couple of key differences that you must know! ContextSwitch is a great way to direct a request to it’s appropiate response. Let’s say you have a page that is meant to list information. With ContextSwitch you can make the action output a regular page for it’s regular call, but, if the user switched the request to ?request=xml. The user will now get the xml version! You only need to create a view script like this: myaction.xml.phtml, and handle the display there.
AjaxContext it’s essentially a wrapper to ContextSwitch that it’s only triggered if an XmlHttpRequest is sent in the headers. I suggest you head over to the ZendFramework’s Official documentation to read in depth on how ContextSwitch & AjaxContext work since there is a a lot to cover, and there is really no point in repeating was is already in the FrameWork docs.

I hope this post helps you, and if you have any more interesting or helpful Zend Framework tips, you are invited to post them in the comments.