]]> Seems like URL shorteners have gain extreme popularity with web services like Twitter. Not to mention the fact that long URLs are somewhat hard to pass along. They are also harder to verbalize in a conversation, and above all in some cases they are almost impossible to remember.

There are quite a large number of URL shorteners out there these days, mostly free. One of the freshest is Google’s URL shortener. This article is not about outlining the features that make this shortener better then the other ones (as I am sure some offer more features at the moment). This article is merely for the purpose of showing you how easy it is to use the Google URL Shortener service via your ZendFramework libraries.

Basically all we need is the instance of Zend_Http_Client class and preferably the API key for Google URL Shortener. For API key, just follow the instructions outlined here.

Here are the few actions you can with the Google URL Shortener at the moment:

• Shorten a long URL
• Expand a short URL
• Look up a short URL’s analytics
• Look up a user’s history

Example #1 – Shorten a long URL

$client = new Zend_Http_Client();

$client->setUri('https://www.googleapis.com/urlshortener/v1/url');
$client->setHeaders(Zend_Http_Client::CONTENT_TYPE, 'application/json');
$client->setMethod(Zend_Http_Client::POST);

$payload = json_encode(array(
    'longUrl' => 'http://activecodeline.net/',
    'key' => '___YOUR_API_KEY_HERE___'
));

$client->setRawData($payload);

$response = $client->request();

Below you can see the example of response for the above request.

Zend_Debug::dump($response, '$response');

/**
$response object(Zend_Http_Response)#225 (5) {
  ["version":protected] => string(3) "1.1"
  ["code":protected] => int(200)
  ["message":protected] => string(2) "OK"
  ["headers":protected] => array(11) {
    ["Cache-control"] => string(46) "no-cache, no-store, max-age=0, must-revalidate"
    ["Pragma"] => string(8) "no-cache"
    ["Expires"] => string(29) "Fri, 01 Jan 1990 00:00:00 GMT"
    ["Date"] => string(29) "Sat, 26 Feb 2011 08:06:45 GMT"
    ["Content-type"] => string(31) "application/json; charset=UTF-8"
    ["X-content-type-options"] => string(7) "nosniff"
    ["X-frame-options"] => string(10) "SAMEORIGIN"
    ["X-xss-protection"] => string(13) "1; mode=block"
    ["Server"] => string(3) "GSE"
    ["Connection"] => string(5) "close"
  }
  ["body":protected] => string(104) "{
 "kind": "urlshortener#url",
 "id": "http://goo.gl/7rDDa",
 "longUrl": "http://activecodeline.net/"
}
"
}

*/

Example #2 – Expand a short URL

$client = new Zend_Http_Client();

$client->setUri('https://www.googleapis.com/urlshortener/v1/url');
$client->setMethod(Zend_Http_Client::GET);
$client->setParameterGet('shortUrl', 'http://goo.gl/7rDDa');
$client->setParameterGet('key', '___YOUR_API_KEY_HERE___');

$client->setRawData($payload);

$response = $client->request();

Below you can see the example of response for the above request.

Zend_Debug::dump($response, '$response');

/**

$response object(Zend_Http_Response)#225 (5) {
  ["version":protected] => string(3) "1.1"
  ["code":protected] => int(200)
  ["message":protected] => string(2) "OK"
  ["headers":protected] => array(11) {
    ["Expires"] => string(29) "Sat, 26 Feb 2011 08:37:13 GMT"
    ["Date"] => string(29) "Sat, 26 Feb 2011 08:32:13 GMT"
    ["Content-type"] => string(31) "application/json; charset=UTF-8"
    ["X-content-type-options"] => string(7) "nosniff"
    ["X-frame-options"] => string(10) "SAMEORIGIN"
    ["X-xss-protection"] => string(13) "1; mode=block"
    ["Server"] => string(3) "GSE"
    ["Cache-control"] => string(50) "public, max-age=300, must-revalidate, no-transform"
    ["Age"] => string(2) "48"
    ["Connection"] => string(5) "close"
  }
  ["body":protected] => string(121) "{
 "kind": "urlshortener#url",
 "id": "http://goo.gl/7rDDa",
 "longUrl": "http://activecodeline.net/",
 "status": "OK"
}
"
}

*/

Example #3 – Look up a short URL’s analytics

$client = new Zend_Http_Client();

$client->setUri('https://www.googleapis.com/urlshortener/v1/url');
$client->setMethod(Zend_Http_Client::GET);
$client->setParameterGet('shortUrl', 'http://goo.gl/7rDDa');
$client->setParameterGet('projection', 'FULL');
$client->setParameterGet('key', '___YOUR_API_KEY_HERE___');

$client->setRawData($payload);

$response = $client->request();

Below you can see the example of response for the above request.

Zend_Debug::dump($response, '$response');

/**

$response object(Zend_Http_Response)#225 (5) {
  ["version":protected] => string(3) "1.1"
  ["code":protected] => int(200)
  ["message":protected] => string(2) "OK"
  ["headers":protected] => array(10) {
    ["Expires"] => string(29) "Sat, 26 Feb 2011 08:36:40 GMT"
    ["Date"] => string(29) "Sat, 26 Feb 2011 08:36:40 GMT"
    ["Cache-control"] => string(48) "public, max-age=0, must-revalidate, no-transform"
    ["Content-type"] => string(31) "application/json; charset=UTF-8"
    ["X-content-type-options"] => string(7) "nosniff"
    ["X-frame-options"] => string(10) "SAMEORIGIN"
    ["X-xss-protection"] => string(13) "1; mode=block"
    ["Server"] => string(3) "GSE"
    ["Connection"] => string(5) "close"
  }
  ["body":protected] => string(2042) "{
 "kind": "urlshortener#url",
 "id": "http://goo.gl/7rDDa",
 "longUrl": "http://activecodeline.net/",
 "status": "OK",
 "created": "2011-02-26T08:06:45.845+00:00",
 "analytics": {
  "allTime": {
   "shortUrlClicks": "1",
   "longUrlClicks": "1",
   "referrers": [
    {
     "count": "1",
     "id": "Unknown/empty"
    }
   ],
   "countries": [
    {
     "count": "1",
     "id": "HR"
    }
   ],
   "browsers": [
    {
     "count": "1",
     "id": "Chrome"
    }
   ],
   "platforms": [
    {
     "count": "1",
     "id": "Windows"
    }
   ]
  },
  "month": {
   "shortUrlClicks": "1",
   "longUrlClicks": "1",
   "referrers": [
    {
     "count": "1",
     "id": "Unknown/empty"
    }
   ],
   "countries": [
    {
     "count": "1",
     "id": "HR"
    }
   ],
   "browsers": [
    {
     "count": "1",
     "id": "Chrome"
    }
   ],
   "platforms": [
    {
     "count": "1",
     "id": "Windows"
    }
   ]
  },
  "week": {
   "shortUrlClicks": "1",
   "longUrlClicks": "1",
   "referrers": [
    {
     "count": "1",
     "id": "Unknown/empty"
    }
   ],
   "countries": [
    {
     "count": "1",
     "id": "HR"
    }
   ],
   "browsers": [
    {
     "count": "1",
     "id": "Chrome"
    }
   ],
   "platforms": [
    {
     "count": "1",
     "id": "Windows"
    }
   ]
  },
  "day": {
   "shortUrlClicks": "1",
   "longUrlClicks": "1",
   "referrers": [
    {
     "count": "1",
     "id": "Unknown/empty"
    }
   ],
   "countries": [
    {
     "count": "1",
     "id": "HR"
    }
   ],
   "browsers": [
    {
     "count": "1",
     "id": "Chrome"
    }
   ],
   "platforms": [
    {
     "count": "1",
     "id": "Windows"
    }
   ]
  },
  "twoHours": {
   "shortUrlClicks": "1",
   "longUrlClicks": "1",
   "referrers": [
    {
     "count": "1",
     "id": "Unknown/empty"
    }
   ],
   "countries": [
    {
     "count": "1",
     "id": "HR"
    }
   ],
   "browsers": [
    {
     "count": "1",
     "id": "Chrome"
    }
   ],
   "platforms": [
    {
     "count": "1",
     "id": "Windows"
    }
   ]
  }
 }
}
"
}

*/

The above 3 examples are pretty easy, and straight forward. Last example, “Look up a user’s history”, requires a bit more finesse as it requires your/user authentication in order to get the proper response. There are several ways you can authenticate (OAuth, ClientLogin). OAuth is the preferred mechanism for logging in and performing actions on behalf of a Google user.

If Oauth is not feasible, you can use ClientLogin. With this mechanism, you give google.com an email and password in exchange for an access token.

In this last example “Look up a user’s history” I will show you how to do it with ClientLogin approach as it is somewhat simpler. However, this does not mean that ClientLogin approach will suite your needs, in which case you should really study the Oauth implementation.

Example #4 – Look up a user’s history

$clientLogin = new Zend_Http_Client();

$clientLogin->setUri('https://www.google.com/accounts/ClientLogin');
$clientLogin->setMethod(Zend_Http_Client::POST);
$clientLogin->setHeaders(Zend_Http_Client::CONTENT_TYPE, 'application/x-www-form-urlencoded');
$clientLogin->setParameterPost('accountType', 'HOSTED_OR_GOOGLE');
$clientLogin->setParameterPost('Email', '_YOUR_GOOGLE_EMAIL_HERE_');
$clientLogin->setParameterPost('Passwd', '_YOUR_GOOGLE_PASS_HERE_');
$clientLogin->setParameterPost('service', 'urlshortener');
$clientLogin->setParameterPost('source', 'myname-testapp-1.0.1');

$responseLogin = $clientLogin->request();
$responseLoginBody = $responseLogin->getBody();

$loginTokens = explode("\n", $responseLoginBody);
$authToken = '';

foreach ($loginTokens as $r) {
    $_r = explode("=", $r);
    if (count($_r) > 1) {
        if ($_r[0] == 'Auth') {
            $authToken = $_r[1];
        }
    }
}

if (!empty($authToken)) {
    $clientHistory = new Zend_Http_Client();

    $clientHistory->setUri('https://www.googleapis.com/urlshortener/v1/url/history');
    $clientHistory->setMethod(Zend_Http_Client::GET);
    $clientHistory->setHeaders(Zend_Http_Client::CONTENT_TYPE, 'application/json');
    $clientHistory->setHeaders('Authorization', 'GoogleLogin auth='.$authToken);
    $clientHistory->setParameterGet('key', '___YOUR_API_KEY_HERE___');

    $responseHistory = $clientHistory->request();
    $responseHistoryBody = $responseHistory->getBody();
    //Zend_Debug::dump($responseHistoryBody, '$responseHistoryBody');
    //Zend_Debug::dump($responseHistory, '$responseHistory');
}

Below you can see the example of response for the above request.

Zend_Debug::dump($responseHistory, '$responseHistory');

/**

$responseHistory object(Zend_Http_Response)#237 (5) {
  ["version":protected] => string(3) "1.1"
  ["code":protected] => int(200)
  ["message":protected] => string(2) "OK"
  ["headers":protected] => array(10) {
    ["Expires"] => string(29) "Sat, 26 Feb 2011 10:20:34 GMT"
    ["Date"] => string(29) "Sat, 26 Feb 2011 10:20:34 GMT"
    ["Cache-control"] => string(49) "private, max-age=0, must-revalidate, no-transform"
    ["Content-type"] => string(31) "application/json; charset=UTF-8"
    ["X-content-type-options"] => string(7) "nosniff"
    ["X-frame-options"] => string(10) "SAMEORIGIN"
    ["X-xss-protection"] => string(13) "1; mode=block"
    ["Server"] => string(3) "GSE"
    ["Connection"] => string(5) "close"
  }
  ["body":protected] => string(2943) "{
 "kind": "urlshortener#urlHistory",
 "totalItems": 13,
 "itemsPerPage": 30,
 "items": [
  {
   "kind": "urlshortener#url",
   "id": "http://goo.gl/IkFNS",
   "longUrl": "http://www.jetbrains.com/phpstorm/whatsnew/index.html",
   "status": "OK",
   "created": "2011-02-25T09:29:03.995+00:00"
  },
  {
   "kind": "urlshortener#url",
   "id": "http://goo.gl/NpdS9",
   "longUrl": "http://www.eclipse.org/egit/?gclid\u003dCPfd-5L_oqcCFZMK3wodkC6_BA",
   "status": "OK",
   "created": "2011-02-25T09:28:28.545+00:00"
  },
  {
   "kind": "urlshortener#url",
   "id": "http://goo.gl/RiVJH",
   "longUrl": "http://www.flickr.com/photos/ajzele/sets/72157626133406912/detail/",
   "status": "OK",
   "created": "2011-02-25T08:46:47.203+00:00"
  },

*/

That’s it. Examples above cover the most of what you can do with the Google URL Shortener API at the moment. Hope you find the article useful.

]]> Hi, first of all, I’d like to explain the title of this post. I won’t go into depths of complicated examples, but rather explain the logic of it.

PHP first implemented OOP (Object Orientated Programming) the right way in version 5. OOP is powerful tool in any programming language. But the next logic step was to create framework as an “abstract layer” that will help developers in both speed and quality of their work. To conclude this brief introduction, I’ll say that there are many frameworks written in PHP for PHP.

Now to the fun part. For example I’ll use Magentos framework, that is written over Zend framework. To make stuff just a little bit more complicated. Zend framework is written on top of PHP’s built in functions.

Now, if you are a Magento developer (like we are ), you need to work by rules, or there will be problems with your Magento modules, extensions, etc. I promise. The problem is if you, lets say, use Zend framework directly in Magento module, which you can (Magento is its “extenstion”, which allows you to call parent methods). Why, you ask me? Well, to answer that, I will ask you a question. What will happen if you upgrade Magento to latest version which excluded some Zend framework functionality from its libraries?

It will collapse your module, and you will have to rewrite it in whole new way. But if you used only Magento functionalities, it will probably work just fine. If not, you can just take Magento functionality in one place, and insert it in latest version, so all your Modules that depend on it, work with “single strike”.

To conclude, you (and I) should never go “one level too deep” when extending a framework written in framework. Not only you will have less problems with updates / changes in parent framework, but you’ll need much less time to fix the problems that weren’t your problem initially.

A small example is in order, I think.

A class “Mage_Payment_Block_Form” extends some “Varien_Object” classes, but on top of that all, it uses Zend_Form, and its methods, to give you most usable class for our Magento platform. But if you use some of Zend_Form’s methods directly, like “setCaptcha”, and Varien decides to rewrite it in Magento (and exclude it from Zend library), all your modules that use that mehod will no longer be functional.

To make a long story short. Best practice would suggest that we all use only top level framework in our projects. Yes, it takes a bit longer (usually) to develop it, but at the end, it pays of big time. If nothing, when some of your colleagues start fixing their Modules, you will have your satisfaction.

I hope this helped someone, and feel free to correct me if I’m wrong.

]]> I was playing with SOAP for the last few days. I must say, it looks somewhat complicated in some areas. After some google-ing on SOAP vs REST stuff I decided to write this simple ZendFramework REST how to. Actualy this is a PHP part of tutorial since I was working on a PHP and C# solution using Mono framework for C# part can be found on my site. My desire was to create a web service in PHP environment and consume that service in C# environment.Getting started with REST using ZendFramework. Here’s the PHP REST server part.

Basic example is really, really simple. Aren’t they always. Seriously, it’s not my intention to go into outermost details.

Creating a REST server in ZendFramework can be simple as 3 lines of code. For the sake of simplicity, let’s suppose we’ll place all of our code logic in one file, the IndexController.php. The basic building block of each and every Zend Framework application. Code for creating a REST server looks like

public function restAction()
{
$server = new Zend_Rest_Server();
$server->setClass(‘CustomTestClass’);
$server->handle();
exit;
}

Notice the CustomTestClass? This is the name of the class we wish to make availabe trough REST server. For the sake of simplicity, this class is placed in same file as our IndexController class. Below is the sample of class body

class CustomTestClass
{
/**
* Write to a file
*
* @param string $string
* @return string Some return message
*/
public function sayHello($name)
{
$message = ‘Hello ‘.$name;
return $message;
}
}

Now all that’s left is to make a call to our REST server using GET method. Since our REST server code is placed inside restAction function in IndexController, it can be accessed using url like

http://localhost/myzendapp/index.php/index/rest

And the result should look like

<?xml version=”1.0″ encoding=”UTF-8″?>
<rest generator=”zend” version=”1.0″>
<response>
<message>No Method Specified.</message>
</response>
<status>failed</status>
</rest>

Although these are error messages, it’s ok, it means our REST server is working. Now if we were to enter url like

http://localhost/myzendapp/index.php/index/rest?method=sayHello

we would get response error message like
<?xml version=”1.0″ encoding=”UTF-8″?>
<CustomTestClass generator=”zend” version=”1.0″>
<sayHello>
<response>
<message>Invalid Method Call to sayHello. Requires 1, 0 given.</message>
</response>
<status>failed</status>
</sayHello>
</CustomTestClass>

This too is ok. It simply means we omited the parametars we were supose to pass to function. Remember, our sayHello function has signature like

public function sayHello($name)

meaning we should pass it a parametar $name. Now if we were to type into our browser url like

http://localhost/myzendapp/index.php/index/rest?method=sayHello&name=Branko

We would get response like

<?xml version=”1.0″ encoding=”UTF-8″?>
<CustomTestClass generator=”zend” version=”1.0″>
<sayHello>
<response>Hello Branko</response>
<status>success</status>
</sayHello>
</CustomTestClass>

As I said, simple example, more like proof of concept. Hope you find it usefull as a entry point to REST-full Zend development.

]]> For the last 3 months, all of my Web development has been done in NetBeans 6.5. I got hooked on it ever since the beta version brought PHP support to it. NetBeans has several great advantages and even greater features to shadow out most of the commercial, freeware, or open source IDE solutions.

One of the best things about NetBeans is a excellent support for HTML code and added support for jQuery, Prototype, and general JavaScript. However, one thing I simply hate about NetBeans is its speed. Since most of my development is in Magento and WordPress platforms (and Magento itself comes with more than 7000 files), this can really slow down NetBeans. So I decided to look for another solutions, if any Today I decided to download and try out the latest Zend Studio release, Zend Studio for Eclipse Professional Edition.

You can download the trial version of Zend Studio for Eclipse from http://www.zend.com/en/products/studio/. Zend Studio is not free, it’s a commercial platform, and although the price might seem high at first, ask yourself what made you even look for Zend Studio as a development IDE solution—and how much time are you wasting right now?
I make my living with PHP and my everyday job evolves around Magento (which is based on Zend Framework platform). My question is: If buying $999 for Zend Studio can make my life a lot easier and speed up my development by some percent, wouldn’t it be worth the investment? My answer is: Yes, it would. Time saved means more time for new projects.
Enough blabbering, let’s checkout some Zend Studio features.

Now, if you click on the Creating a PHPDoc, you get something like the image below:

This might not seem like much to an experienced developer, but it sure helps.

If you go back to the Welcome page of Zend Studio, you will notice a few more useful things, like Create a Zend Framework Example Project and Watch a demo on Event debugging. I give them 5 out of 5 for this getting started section.

Then, on the right side of the screen there are few intro-level tutorials on essential development topics like Code Assist, Debugging, Profiler, Refactoring, PHPUnit testing, CVS, and SVN. (Unfortunately, most “wannabe” developers skip these topics, even though they are essential to healthy application life cycle.)

Now let’s create our first project. As you know, one of the most annoying things is the time required to manually configure when setting up Zend Framework project. Some of you might say, “So what, I only have to do it once and paste it every time after.” Well, this is exactly the scenario I dislike with PHP-related development, everyone seems to have his or her own solution to reinventing the wheel. I love standards; I adore them. This is why I like solutions like this and why I like frameworks—they make you stick to some standard.

Upon creating our new project via File > New > Zend Framework Project, we get a working Zend app that echoes simple Hello, world! to browser. Actually, we still need to copy/paste Zend Framework library to the /library directory and we are done. This is simply beautiful; I love it.

Below is the example of the bootsrap.php file it generated for us:

$this->use…

then you won’t get auto complete from Code Assistant. It does not seem to recognize this kind of connection.

Another problem with Code Assistant is that it behaves differently in .phtml files and html files when writing html code. It does not work very well in .phtml files in this case. However, despite these problems, Zend Studio is still a powerful and extremely useful developer tool.

One of the first features I looked for in Zend Studio was its ability to manage database connections. There is a nice little icon on the main toolbar called Create new SQL connection (Oracle, Postgre, MySQL, MS SQL, Derby, IBM DB2, their variations and addition of new ones).

Combined with a nice little feature called Scrapbook, we get simple but effective developer to database relation solutions. It’s so easy you may never look back at other solutions again!

Below is the screenshot of Zend Studio’s Database Development Perspective view:

This brings me to the next topic, Perspective view. This too might not look as cool or seem necessary, but I love it. In my opinion it’s a step in right direction towards smart applications. Zend Studio Eclipse uses this concept of Perspective views (the way of rearranging the application interface based on the technology you’re working on) from PHP to SQL.

Remote Systems monitor is another cool and extremely useful feature. Below are two screenshots for you to see it:

Everything mentioned so far is just a fraction of what Zend Studio Eclipse is made of and what it can enable you to do.

I recommend you try it out.

]]> Every developer knows what CRUD stands for. Its an acronym for (C)reate, (R)ead, (U)pdate, and (D)elete. Dealing with CRUD is one of the most time-consuming tasks in a Web developer’s day. Combine that with website styling process and you get at least 50-60% of the development time spent on each site, on average (at least that is my experience).

You can use any number of frameworks or approach a problem from any number of angles, but the CRUD is always there. And every time we use it, it is like we’re reinventing the wheel. We struggle with all those $_GET and $_POST, if, switch, else… (and so on) statements over and over again, but it often feels more like a waste of time and resources more than anything.

So, what do we do? When most developers need to write something to database tables, or make a update interface for some table, we write down the custom form for it (including the CRUD). On one hand, it keeps our skills sharp. But on the other hand, it’s time we could better spend on focusing and developing additional features, bug-fixing our applications, and so on. But the CRUD is relevant as well.

CRUD is almost always important at the user interface level of most applications. For example, in address book software, the basic storage unit is an individual contact entry. As a bare minimum, the software must allow the user to:

• (C)reate or add new entries
• (R)ead, retrieve, search, or view existing entries
• (U)pdate or edit existing entries
• (D)elete existing entries

Without at least these four operations, the software cannot be considered complete.Because these operations are so fundamental, they are often documented and described under one comprehensive heading, such as “contact management” or “contact maintenance” (or “document management” in general, depending on the basic storage unit for the particular application), but they are really just CRUD.

So how do you deal with it?

PHP has numerous frameworks, meaning numerous philosophies of building a website. Personally, I love frameworks because they establish order in the midst of chaos. And, although some of these frameworks can help you avoid CRUD, it is worth considering the price you will pay by using these solutions.

Recently I came across Doctrine. Not many developers know about the term ORM. Hard to imagine, but true. So what is ORM? ORM stands for Object Relational Mapping, and it’s a promising concept that is slowly becoming popular for developers. One of the best features of ORM is that it can help us greatly when we are in need of dealing with many relational tables. However, ORM does not solve issues with CRUD because it uses somewhat complex configurations to solve the same problems. A solution that truly saves time with CRUD has yet to be developed. So, we return to the same CRUD again and again. There simply does not seem to be a flexible, fast, and easy (two or three lines of code) solution to map and auto-generate all the necessary fields from database to form.

But I’ll keep looking.

Feel free to post your thoughts, ideas, and solutions on dealing with CRUD problems.