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.