Now we can create new Php project based on Zend framework, or open some existing Zend project in which we will write our first test. In NB I am using Zend tool integration to generate first project sources.

When the project is opened/created, in projects window right click on project name and choose Properties.
After the project properties window is opened, click on PHPUnit category on the left side, and on the right of the window we can see PHPUnit configuration options. For this tutorial, let’s select “Use bootstrap” option and click “Generate” button on the right, so new bootstrap.php file is generated inside folder “tests” of our Zend application.

In that file we will put all basic configuration for our application testing and necessary include paths like this:

bootstrap.php

<?php
error_reporting( E_ALL | E_STRICT );
ini_set('display_startup_errors', 1);
ini_set('display_errors', 1);

define('APPLICATION_PATH', realpath(dirname(__FILE__) . '/../application'));
define('APPLICATION_ENV', 'testing');
define('LIBRARY_PATH', realpath(dirname(__FILE__) . '/../library'));
define('TESTS_PATH', realpath(dirname(__FILE__)));

$_SERVER['SERVER_NAME'] = 'http://cea.local';

$includePaths = array(LIBRARY_PATH, get_include_path());
set_include_path(implode(PATH_SEPARATOR, $includePaths));

require_once "Zend/Loader/Autoloader.php";

$loader = Zend_Loader_Autoloader::getInstance();
$loader->setFallbackAutoloader(true);
$loader->suppressNotFoundWarnings(false);

Zend_Session::$_unitTestEnabled = true;
Zend_Session::start();

?>

When this is done, let’s write first controller test case to see if that’s working properly.
(In my current configuration, when I create new controller in project using Zend tool integration,
there is also new file created inside “tests/Application/Controllers” folder named “Original_controller_nameTest.php”).

If controllerTest is not created , we can always create it manually.

Create new php class document and save it inside “tests/application/controllers/” folder and give it a name: “IndexControllerTest.php”.
Enter code inside like this:

<?php

class IndexControllerTest extends Zend_Test_PHPUnit_ControllerTestCase {

    public function setUp() {
        $this->bootstrap = new Zend_Application(
                        'testing',
                        APPLICATION_PATH . '/configs/application.ini'
        );
        parent::setUp();
    }

    public function testHomePageIsASuccessfulRequest() {
        $this->dispatch('/index');
        $this->assertFalse($this->response
                        ->isException());
        $this->assertNotRedirect();
    }

    public function tearDown() {
        /* Tear Down Routine */
    }

}

Now it’s time for testing: right click on the project name in projects explorer and choose “Test” or press Alt+F6 combination to run tests.

If everything is set up properly, then you will see test results in “test result” window.

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.

Latin introduction

Well, the story about style standards is quite like goes pretty much like old Latin saying “De gustibus non est disputandum” which means “There is no disputing about tastes”. But same things apply to it as well, if you have a big corporate meeting, you won’t go dressed in diving suit, but in a regular one. If you take an parallel look at the coding styles, its pretty much the same. If you’re going to work with a team on new Zend project, some things must be applied. Otherwise you’ll end up in quite a mess.

The main stuff

There are couple of things that matter the most, and I’ll only cover those, according to Zend framework official documentation.

PHP open / close tags

Well, regarding Zend framework official documentation, as well as some of my personal experience, there’s one main rule:

< ?php
//Always and I do mean always, use full php tags, not the short ones
?>

Second rule is (from my experience), although I wrote it in example above, omit the closing tag, and make sure that opening tag is starting from character one of the file. I’m saying this because it wont break the compiling, nor will it cause any errors / warnings. And by this, you’re making sure that in your included files (controllers / models) you don’t have any blank characters which would cause problems with headers most likely.

Of course, if you’re in phtml file, you must use closing tag as well.

Working with strings

When working with string literals, like this one:

< ?php
$string = 'My string.';

Try to make a habit of using single quotes around the string. This one is because when you use double quotes PHP will search for variable replacement inside a string, opposed to single quotes. Obviously, single quotes are faster when working with strings.

If you’re using much of single quotes as literals (SQL for example), or if you have a variable/s inside it, you should use double quotes, like in following example:

//As for single quotes, something like in this simple example:
$sql = "SELECT * FROM table WHERE name='John', date='2010-12-29'";
//And as far for variables, you can use either of these:
$greeting = "Hello $name, welcome back!";
$greeting = "Hello {$name}, welcome back!";

Of course, this is one that doesn’t have to be followed to the letter, but you should make a practice of it.

And another important thing to mention here is concatenation. In PHP it’s achieved by “.” sign. Like this:

//This is the right way, with spacing
$string = 'First part' . ',and second one.';
//And this is the wrong way:
$string = 'First part'.',and second one.';
//>

A little bit about Classes

First, take a look at this (Example 1.):

class MyClass{
function method1(){
while(1 < 1000){
for($i=0;$i < 500;$i+=100){
echo"Something";
}}}
$var1=5;
function method2(){
while(1 < 1000){
for($i=500;$i>0;$i-=100){
echo"$var1";
}}}}

And the, take a look at this (Example 2.):

class MyClass
{
    public $var1 = 5;
    function method1()
    {
        while(1 < 1000)
        {
            for($i = 0; $i < 500; $i += 100)
            {
                echo "Something";
            }
        }
    }

    function method2()
    {
        while(1 < 1000)
        {
            for($i = 500; $i > 0; $i -= 100)
            {
                echo "$var1";
            }
        }
    }
}

Now, you tell me which one is more readable? “Example 1″ or “Example 2″? Joking a side, a couple of rules are applied here, as follows:

1. Don’t mess with your indents, or the’ll mess with you
2. Put out a proper spacing in method parameters, logic conditions, etc. It really improves the readability.
3. Variables with visibility set declared at the beginning of the class (by default its set to public, but that’s just PHP’s compatability, not the right way)

And I must mention documentation as well here

Well, personally I didn’t like overkill on documentation, but on the other hand, it became quite a help in Zend framework. So I changed my mind. I’ll say that you only need 6 things by order to apply to rules, and here they are:

/**
* @category   Zend
* @package    Zend_Magic
* @subpackage Wand
*/

Goodbye

And that’s pretty much it. If you follow these rules, or rather guidelines, you’ll be more productive both as an individual, and as a team.

Cheers!

First of all, I’m going to use PHP’s built in function memory_get_usage() to get difference. Just look at this example, and you’ll know what I’m talking about:

public static function findById($collectionId,$show_all=false) {
$result = new Application_Model_Collection();
$query_result = $result->queryById($collectionId);
$var1 = memory_get_usage();
//HERE I TOOK MEMORY USAGE BEFORE POPULATING THE RESULT
$result->populateFromQuery($query_result);
$var2 = memory_get_usage();
//AND HERE AGAIN AFTER POPULATING
echo ($var2 - $var1);
//ECHO THE DIFFERENCE IN BYTES
echo ' ';
$clean_result = Application_Model_Collection_Object::parseCollection($result);
return $clean_result;
}

And another snippet:

public static function parseCollection(Application_Model_Collection $obj)
{
$return = new Application_Model_Collection_Object();
$var3 = memory_get_usage();
//AND AGAIN BEFORE CLEANING THE OBJECTS
$i = 0;
foreach($obj->columns as $column)
{
$return->columns[$i]->values = $column->values;
$return->columns[$i]->old_values = $column->old_values;
$i++;
}
$i = 0;
foreach($obj->data as $data)
{
$return->data[$i]->values = $data->values;
$return->data[$i]->old_values = $data->old_values;
$i++;
}
$var4 = memory_get_usage();
//AND AFTER
echo $var4 - $var3;
//ECHO THE OUTPUT
return $return;
}

Note: above examples are cleaned methods from my existing Zend project

For my ~60 records in collection I got this as output: 1854968 17644.

Now, if I’d divide those two, I’d get something like this: 1854968 / 17644 = 105.1331, and that’s how many times new collection is smaller than the original one. All I did here was that I stripped unnecessary data from objects (like link to the database), and returned that back to the application to work with it. Again, this is only for cca 60 objects in collection, and on this same project, I got collections wit over 1000 records. Simple math would say that application would need around 30 MB for a collection of that size, compared to less than 0.5 MB when its optimized.

Anyway, I don’t want to say that you’re wrong if you don’t do this, but rather that you’ll get a much faster application, for exchange in small effort of optimizing the collections.

That’s all from me for now, and I hope you learned something today.

Cheers!

What is transaction?

A simple answer would be – a number of individual queries that are grouped together.

An example would be something like this:

UPDATE balance SET total = total - 100 WHERE account_id=1;
UPDATE balance SET total = total + 100 WHERE account_id=2;

Why transactions?

In general web development, transactions are unnecessary. If for some reason post in your CMS isn’t saved, you’ll write it again. It is a problem, but only annoying one, not a crucial one. But if you own a web shop, and someone create an order, pay for it, and you – owner of that store can’t see it because of database glitch, that would be a problem. Take a look at example above. I only first query in that transaction was executed, total amount of money from account would be decreased by 100, and that money would simply disappear (if we’re looking at your database). Or if only second was executed, account 2 would have 100 extra in its total sum – again virtually from nowhere.

This is the place where transactions are necessary. Because transactions either execute all queries assigned to it, or none of them. I hope you see the point.

The syntax

This is a basic example from official MySQL documentation:

START TRANSACTION;
--BEGIN TRANSACTION
SELECT @A:=SUM(salary) FROM table1 WHERE type=1;
UPDATE table2 SET summary=@A WHERE type=1;
--SET SOME QUERIES
COMMIT;
--AND COMMIT THEM

When the Zend framework comes in

Its pretty much self explained, so here’s a code snippet with comments:

$db = self::db();
//GET DATABASE CONNECTION (DEPENDING ON YOUR SETUP)

$q =  "UPDATE balance SET total = total - 100 WHERE account_id=1;UPDATE balance SET total = total + 100 WHERE account_id=2;";
//PREPARE QUERY

$db->beginTransaction();
//BEGIN TRANSACTION ON DATABASE CONNECTION
try
{
$db->exec($q);
//SET QUERY YOU WISH TO EXECUTE

$query = $db->commit();
//COMMIT QUERY TO DATABASE
}
catch(Exception $e)
{
$db->rollBack();
//ROLLBACK IF TRANSACTION FAILS

$error_result = Array();
$message = $e->getMessage();
$code = $e->getCode();
$error_result[0] = $message;
$error_result[1] = $code;
//GET ERROR INFORMATION IF SQL FAILS
}

Conclusion

Now, You’ve created a transaction in your Zend project. You’ll get a rollback on your database if any of the queries fails and you won’t have any “missing records and values” in your database. This isn’t so complicated to create for every crucial query in your application, especially when you know its going to work like a charm!

Feel free to comment, as I might learn something new as well. Bye!

Well, yous should know that SOLID stands for:

1. Single responsibility principle
   
2. Open-closed principle
3. Liskov substitution principle
4. Interface segregation principle
5. Dependency inversion principle

Those are five basic patterns used in OO Programming and OO Design Those are the principles that can be used in agile and test driven development. Also, those are a good principles, good advices, but it’s not pure truth, nor is it a rule.Just a quote of a sentence I ran into internet: “They are common-sense disciplines that can help you stay out of trouble”. That’s why it’s a good idea.

Let me introduce you to them one by one:

Single responsibility principle

It states that every object should have a single responsibility, and that responsibility should be entirely encapsulated by the class. All its services should be narrowly aligned with that responsibility. In other words the meaning of this phrase is that when you’re adding features to your application, two different, unrelated stories to implement should not affect the same class.

Open/Closed Principle

The meaning of this principle is that when a get a request for a feature that needs to be added to your application, you should be able to handle it without modifying old classes, only by adding subclasses and new implementations (in pure OOP language – extending old ones ).

Liskov Substitution Principle

The meaning of this principle is that every time you extend a class, you have to make sure it is substitutable in every place where you use an instance of the original class. Extended class must respect the contract of the parent class. Meaning that you should edit it in a way so that it will stay recognizable compared the the parent class.

Interface segregation principle

This one means that you should avoid getting your classes included to other ones if only small portion of it will be used (say 3 out of 12). Often you will see classes with too much methods implemented in it which it’s not a good idea because it conflicts with Single Responsibility Principle in a way. Basically, if you don’t listen to this one, its considered to be a “bad design”.

Dependency Inversion Principle

Well, as last principle, I find it most valuable. It says that you should decouple your software modules. To achieve that you’d need to isolate dependencies. Why you might ask? Well, the answer is simple – for code re-usage. This way you’ll get more efficient and affordable at the same time. That’s why I find it most valuable.

In our environment (around 20 people) – this helps. It helps because when we have to do additional work on project done by other developer, you don’t have to trace code line by line, you only need to think logically, and you’re there. Besides the “Dependency Inversion Principle”, this I value the most in SOLID programming.

I’d like to conclude this one by repeating myself: “They are common-sense disciplines that can help you stay out of trouble”, they aren’t rules.

Cheers!

On you first app launch run update.
So check for updates and update!
Help>Check for Updates

Restart editor if needed.

Navigate to Help>Install New Software:

Find repository for SVN – http://download.eclipse.org/technology/subversive/0.7/update-site/
If it’s not in the list, then add it by clicking on “Add” button or find it among other repositories on “Avaliable Software Sites” link.

Select (check) Subversive SVN Team Provider Plugin (Ioncubation) and finish install process.
Restart editor if needed.

Then you will need to select SVN Connector:

Restart if needed.
Now you are ready to have all your projects in eclipse syncronized with SVN.

If you are working with Zend Framework and wish to have Zend Framework perspective enabled for your projects you can install additional plugin for you eclipse.

Again navigate to Help>Install New Software and add new repository with location:

http://downloads.zend.com/studio-eclipse/updates/8_0

Check:
“Zend Studio CE Feature” (for project perspective) and
“Zend Debugger Feature” (fro debugging if you like it)

Finish install process, restart eclipse if needed.

And

you are ready for developing your zend framework projects.

Enjoy coding!

Each time I check new features it seems to me that the things are more simplier than the last time,
I might be wrong (I wouldn’t bet on that) or I’m just getting better

Let’s check this piece of cake – how you can create navigation with breadcrumbs in Zend Framework project.
As many things in Zend Framework you can get same features in different ways,
so the same thing goes with the Zend_Navigation class.

First of all you need to decide which way you will choose:
- navigation with xml setup file or
- from application.ini file

I suggest you to try both ways and then choose the one you like most, I’ll show you the both ways.

In Boostrap.php class you need to initialize your navigation.
- xml way tells where your navigation.xml file is:

protected function _initNavigationXml()
{
$this->bootstrap('layout');
$layout = $this->getResource('layout');
$view = $layout->getView();
$config = new Zend_Config_Xml(APPLICATION_PATH.'/configs/navigation.xml');

$navigation = new Zend_Navigation($config);
$view->navigation($navigation);
}

- or in “config” way from application.ini file you simply tell your Bootstrap class which part needs to be processed:

protected function _initNavigationConfig()
{
$this->bootstrap('layout');
$layout = $this->getResource('layout');
$view = $layout->getView();

$navigation = new Zend_Navigation($this->getOption('navigation'));
$view->navigation($navigation);
}

Now you have setup your configuration for navigation, next thing you need to do is in your
application/layouts/layout.phtml file call the data you insert into your application.ini or navigation.ini files, you do that with this line of code:

< ?php
echo $this->navigation()->menu();
?>

For desert you can add breadcrumbs into same file like this:

< ?php
echo $this->navigation()->breadcrumbs()
->setLinkLast(false)->setMinDepth(0)->render();
?>

At the end you get something like on picture below:

Here is full featured project zf.navigation.sample (without Zend Framework, which you need to copy in library folder) to download.

Enjoy coding.

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.

We are looking for individuals for following positions:

1. Magento/ZEND developer is a hard core programmer. You need to have great PHP/ZEND knowledge and good English skills. You need to have at least 2 years of web programming experience and a few projects behind you can show. You don’t need to know Magento for this position, but you should have ZEND knowledge or at least know some PHP framework. You’ll learn Magento in time.
2. Mobile Apps Developer needs to be an experienced programmer ready to learn new languages. iPhone SDK will be the first one since our team has the most demand for iPhone and iPad applications. You also need to speak English. If you also have project management experience, be sure to mention this. We like the people who have project management skills. You will learn in time how to use Mac and develop for iPhone and iPad.

Now, the tricky part for some of you who are reading this is: the position is in our office in Osijek, Croatia. If you are from our town, don’t hesitate to contact us. If you are not, don’t be discouraged. We might soften the policy to hire a local resource. In either case, send us your resume and portfolio to this address and we’ll get in touch with you.

I called my plugin “Example_Controller_Plugin_Param”, it means that I have created file (class) called “Param.php”
in “library/ Example/Controller/Plugin/”.
Then in “application/Bootstrap.php” class I created method “_initAutoload” in which we need to register nampspace.

< ?php
class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
{
	protected function _initAutoload()
    {
    	/*
    	 * If you don't register namespace
    	 * You will get error :
    	 * Fatal error: Class 'Example_Controller_Plugin_Param' not found in
    	 * ...\library\Zend\Application\Resource\Frontcontroller.php on line 92
    	 *
    	 */

    	$autoloader = Zend_Loader_Autoloader::getInstance();
        $autoloader->registerNamespace('Example_');
        $autoloader->suppressNotFoundWarnings(true);

        /*
         * also you will get Exception :
         * No entry is registered for key 'Zend_Request_Example'
         * called in helper ParamHelper.php
         *
         */

    }

}

Also in “application/configs/application.ini” file we need to prepare plugin ready for usage with line:
resources.frontController.plugins.param = “Example_Controller_Plugin_Param”

When you do this steps, check your application if you got some errors or warnings before you go to coding.
Now when we set up environment, we can start with coding our plugin.

I tried to simplyfie this example so our plugin will only create new custom request parameter,
which will appear when you debug

Zend_Debug::dump($this->_request->getParams()); 

in any Controller class.
And it will start the session, create session namespaces with simple logic which will check if the session params are set or not and it will throw an Exception.

< ?php
class Example_Controller_Plugin_Param extends Zend_Controller_Plugin_Abstract
{
	protected $_param;

	private $_userID;

	public function routeShutdown(Zend_Controller_Request_Abstract $request)
	{
		/*
		 * we start session here
		 * so we do not need to start it in each action, controller or module
		 */
		Zend_Session::start();

		/*
		 * we create session with namespace 'login'
		 */
    	$namespace = new Zend_Session_Namespace('login'); 

    	/*
    	 *
    	 */
    	$this->_userID = $namespace->user; 

			/*
			 * create some simple logic, just to see application behaviour
			 */

    		if (!isset($this->_userID) or $this->_request->getParam("user") != null) {
				$this->_userID = $this->_request->getParam("user", null);

				if ($this->_userID == null) {
					throw new Exception("user id not found");
				}

				$namespace->user = $this->_userID;
			}

		/*
		 * Just for example we also create new custom request parameter
		 *  with name and value, cannot set this in helper
		 *
		 */
		$this->_param = $this->_request->setParam('param', 'custom');

		Zend_Registry::set('Zend_Request_Example', $this->_param->param);

	}

}

What is so special here?
Well, in this example you do not need to create session namespaces in any action, controller or module and this is something what spares our development time and lines of code.

Source code link: zf.plugin.example
Test your new plugin and enjoy in coding with Zend Framework.

We need to insert this line in application/config.ini to register path to helpers:

application/configs/application.ini
resources.view.helperPath = APPLICATION_PATH “/views/helpers”

First create model which will give you an array,
in my example it’s list of states, which you will call in you helper file:

application/models/DbTable/States.php

class Model_DbTable_States extends Zend_Db_Table_Abstract
{
    protected $_name = 'state_list';

    public function getStates()
    {

        $row = $this->fetchAll();
        if (!$row) {
            throw new Exception("No States");
        }

        $row = $row->toArray();

        return $row;
    }
}

Class needs to begegins with “Zend_View_Helper_”
That is why it is “view helper” and it cannot be called in controller or model files,
if you do that you will get error that “method deoesn’t exists”.

application/view/helpers/State.php

class Zend_View_Helper_State
{
	protected $_list;

	public function state()
    {
    	$state = new Model_DbTable_States();
	return $this->_list->getStates();

    }
}

After that and make a list of states in:

application/layouts/sidebar.phtml

<ul>
	< ?php foreach ($this->state() as $item):?>

		<li>< ?php echo $item['state']?></li>

	< ?php endforeach;?>
</ul>

and call it in main layout file:

application/layouts/layout.phtml

< ?php
echo $this->partial('sidebar.phtml');
?>

In this case you will get content from your helper file in all views which will render main layout file from application/layouts/layout.phtml.
However, if you wish to call your helper in particular view all you need to do is to call the helper in view file:

< ?php
$this->state();
?>

<?php 

$emailSmtpConf = array(
	'auth' => 'login',
	'ssl' => 'tls',
    'username' => 'email2@domain.com',
    'password' => 'mypasshere'
);

$transport = new Zend_Mail_Transport_Smtp('smtp.gmail.com', $emailSmtpConf);

$mail = new Zend_Mail();
$mail->addTo('email1@domain.com', 'Name 1');
$mail->setFrom('email2@domain.com', 'Name 2');
$mail->setSubject('Demo Email');
$mail->setBodyText('Email content here');
$mail->send($transport);

$this->_helper->flashMessenger();

First you need to register your view variable in init() method if you want to have notifications in all view files of your controller.

public function init()
{

/* Initialize action controller here*/
$this->view->messages = $this->_helper->flashMessenger->getMessages();

}

Then you simply add messages in your action methods like this:

$this->_helper->flashMessenger->addMessage(array("ok_message" => 'record deleted'));
or
$this->_helper->flashMessenger->addMessage(array("err_message" => 'unable to comply'));

Why wasting you code when you got all in one place, right?

Once you register the message notification all you need is to choose where message should appear.That’s the easy part, just need to style your div ids and classes in view files.

< ?php if(isset($this->messages)):?>
<div class="grid_12">
< ?php foreach($this->messages as $message):?>
<div id="site_info">
<div class="box">
< ?php if(isset($message["error"])):?>
<p>< ?php echo $message["error"]?></p>
< ?php elseif(isset($message["ok"])):?>
<p>< ?php echo $message["ok"]?></p>
< ?php endif?>
</div>
</div>
< ?php endforeach?>
</div>
< ?php endif?>

One trick, if you want to show them on all view pages, edit your layout file and paste the code above at header,footer or wherever you want them to be shown
(there is no need to put them in you view files, unless you want to show same notifications twice ).

The easiest way to have notifications in other modules is to register it like session variable and unset them manually.

Check class Zend_Controller_Action_Helper_FlashMessenger for additional purposes.
Enjoy coding.

Module is really simple, not much to it. Note that Zend Framework library it self is not packed with module, you need to download is separately and copy paste to modules /library folder.

It has only two files, one .info file needed for Drupal to recognize it and one .module file whose content you can see below.

function ZendFrameworkLoader_boot()
{
	//Get current file path, cut off the file name and use the rest as folder path
	$siteBasePath = str_replace('ZendFrameworkLoader.module', '', __FILE__);

	//Append subfolder named 'library' to the path
	$siteLibraryPath = $siteBasePath.'library';

	//Add script wide include paths
	set_include_path('.'	. PATH_SEPARATOR . $siteLibraryPath
							. PATH_SEPARATOR . $siteLibraryPath.'/Zend'
							. PATH_SEPARATOR . get_include_path());

	include_once $siteLibraryPath.'/Zend/Loader/Autoloader.php';
	Zend_Loader_Autoloader::getInstance();
}

As you can see module is using hook_boot() to handle (inject) auto-loading code. Therefore try not to call any of the Zend library components in hook_boot functions, latter is good.

Installing a module is done by simply copy-pasting unarchived module to /sites/all/modules/ folder. By doing so you should have /sites/all/modules/ActiveCodeline folder in place if you copy-pasted it ok.

Download ActiveCodeline_ZendFrameworkLoader.

I used ZendFrameworkQuickstart application for you so you can easier test the code I provided.
You just need to download and setup latest ZendFrameworkQuickstart and replace default files with files I posted.
Here is the post:

In layout file (our case “layout.phtml” in application/layouts/scripts/)
we just need to call helper $this->partial and correct path to partial file

<div id="categories">
    < ?php echo $this->partial('partials/categories.phtml',
				            array('categories' => $this->data)); ?>
</div>

with correct “keys” and “values” (our case ‘categories’ and $this->data).
Key (‘categories’) will stand for entity which is iterrated in our partial file in foreach loop
(our case “categories.phtml” in application/layouts/scripts/partials)

<ul>
< ?php foreach($this->categories as $item) : ?>
	<li class="item">
	  <a href="<?php echo $this->url(
	  					array(
							"cat"=>$item['key'],
                                                        "action"=>"index",
	  						"controller"=>"index",
	  						"module"=>"default"
	  										))?>">
		< ?php echo $item['value']; ?></a>
    	</li>
< ?php endforeach; ?>
</ul>

and value ($this->data) must be defined in our controller class file as a view helper ($this->view->data),
I defined it in init() method so it will be set for all actions in IndexController.

public function init()
	{
		$this->view->data =
				array(
					array('key' => 'key_1', 'value' => 'category_1'),
					array('key' => 'key_2', 'value' => 'category_2'),
					array('key' => 'key_3', 'value' => 'category_3'),
					array('key' => 'key_4', 'value' => 'category_4'),
				);
	}

I added demoAction so you can try to set different data set or you can try to play with the code and create some data set from query result.
Enjoy.

Link to code files.

Important thing to keep in mind. Few days ago, Zend Framework 1.8 came out. It uses different auto loading approach. I did not had time to study it in detail so some things in /public/index.php file might look out of order. The parts where I auto-loaded Doctrine and models directory. Don’t worry, it’s working either way What you SHOULD do is CHANGE THE INCLUDE PATH line 28 of the index.php file to reflect your machine path to library folder.

Here are some screenshot of my final application:

Here is the screenshot of my library folder

DOWNLOAD toody (need to download Zend Framework and Doctrine ORM separatly).

Took me around 3 and a half hour to write the app, take the screenshots and write this post. Therefore, use it only in education purpose, cause there is much more to be done to use it for real.

Project is set for auto loading both Zend and Doctrine Frameworks so all you need to do is to instantiate -Also, below you can see few screenshots of the sample code I implemented. Also, I provide you with the .sql dump (doctrinesql) file that goes with this project. Note the use of InnoDB engine in database. Since Doctrine comes with this cool hasOne, hasMany relation mappings, you can use bunch of cool stuff to easily do various actions on database once you get familiar with Doctrine. Although MyISAM engine is somewhat faster than InnoDB, without second thoughts I choose InnoDB due to foreign keys features.

Download project files:
doctrinesql
doctrine_example_project (doctrine orm and zend framework)

I made a little screencast on topic of Zend_Auth database table authentication. Screencast is video only, plus some visual pointers, no audio. Hope some of you find it useful as starting point.

I had to slice video onto two parts since YouTube as limit on 10 minute per video.

Zend_Auth Database Table Authentication part 1

Zend_Auth Database Table Authentication part 2

Note: Please consult the official Zend Framework API documentation for detailed overview of Zend_Auth and all other componets.

It is a simplified installation of the full PHP application stack, including web server, databases, extensions and Zend Framework. This last is really interesting if you prefer Zend Framework for development.

Zend Core comes with 3 subscription models (levels): Silver, Gold and Platinum. With prices ranging from $250 – $750 per dual processor-core. Subscriptions provide support for bug fixes, security patches and maintenance releases for automatic and manual downloading & deployment via the Zend Network. All of this trough Web-based support & phone support.

Below are the screen shots of entire installation process and application overview. I screen shotted entire administration interface, so if you are considering going Zend Core you might find it useful.

And that’s it. Complete screen shot tour of Zend Core.