Generating print-ready well-formatted PDF documents with PHP is not an easy task. Traditionally, there are two main approaches to PDF generation with PHP. Given sufficient time and patience, both partially get the job done, but still leave a lot to be desired:

HTML-to-PDF: This approach is widely used in mainstream applications. Here an HTML document is programmatically created and converted to a PDF, using one of the many open source libraries ¹. Since HTML, however, is not a page-oriented format (as is PDF), it is impossible to perform a 1-to-1 mapping between HTML and PDF. Typical word processing file format features, such as header and footers, orphans and widows or even page numbers can simply not be represented in HTML.

Table of contents

• A completely new approach
• Introducing LiveDocx
• Templates and documents
• Using LiveDocx
  • Creating a template in Microsoft® Word 2007
  • Assigning scalar data types in LiveDocx
  • Assigning compound data types in LiveDocx
  • Generating image files with LiveDocx
• Deploying LiveDocx in your own applications
• Learn more
  • LiveDocx in PHP 5
  • LiveDocx SOAP service
• Footnotes

Programmatic: This approach offers total control of the resulting PDF. However, it requires that the x and y coordinates of every line of text, every geometrical shape and graphic be set from program code ². Not only is this an extremely time-consuming solution, but is also very brittle: Every time a graphical designer changes the layout of a document, a programmer must re-work his or her program code.

A completely new approach

In this article, the author presents an entirely new, third approach. It relies on templates being created in a WYSIWYG environment, such as Microsoft® Word or Open Office, and then being populated with data in PHP. The resulting document can be saved not only to PDF, but also DOCX, DOC and RTF.

Before we delve into a technical discussion on the inner workings of this new approach, let us first take a look at a practical example. The following PHP 5 code illustrates PDF generation, in which the merge fields software, licensee and company in the template template.docx [46.7 KB] are populated with scalar data in PHP. The resulting document document.pdf [104.7 KB] is created and written to disk.

The code demonstrated in this article will be shipped with the Zend Framework 1.10 when it becomes available. Although at the time of writing, there is no official release date, 1.10 is expected to release in Q4 2009. In the meantime, you can check the components out of the Standard Incubator SVN repository.

Introducing LiveDocx

LiveDocx is a SOAP-based document generation service, based on the market-leading, word processing component TX Text Control .NET. LiveDocx allows word processing templates to be populated in any programming language that supports SOAP. The resulting document can be saved to any supported format. This article, however, concentrates on using LiveDocx in PHP 5.

The components of the Zend Framework implementation of LiveDocx are located at /Zend/Service/LiveDocx/ in the standard Zend Framework distribution file. It is possible to use LiveDocx directly with the PHP 5 SoapClient, without the Zend Framework, and with the third party library NuSOAP. The NuSOAP approach even allows LiveDocx to be used in PHP 4. This article, however, concentrates on the official Zend Framework components in PHP 5.

Templates and documents

Throughout this article, we refer to the terms templates and documents. It is important to understand the difference between the two.

Templates: The term template is used to refer to the input file, containing formatting and text fields. Templates can be in any one of the following file formats:

• DOCX - Office Open XML Format
• DOC - Microsoft® Word DOC Format
• RTF - Rich Text Format
• TXD - TX Text Control® Format

Templates can be stored either locally on the client machine (the one from which the SOAP request is initiated) or remotely on the backend server. The decision on which one you should use depends upon the kind of application you are developing.

If you store the templates locally, you have to transfer the template together with the data that should be populated on every request. In the case that the template remains the same on every request, this approach is very inefficient. It would be better to upload the template to the backend server once and then reference it on all subsequent requests. This way, only the data that should be populated is transfered from the client to the backend server. Most applications, using LiveDocx fall into this category.

On the other hand, if you have a template that is constantly changing, or an application in which you enable end-users to upload templates, you may consider storing templates locally and transfer them every request. This approach, is obviously slower, as every request contains the template itself, in addition to the data to populate it.

Documents: The term document is used to refer to the generated output file that contains the template file, populated with data - i.e. the finished document. Documents can be saved in any one of the following file formats:

• DOCX - Office Open XML Format
• DOC - Microsoft® Word DOC Format
• HTML - XHTML 1.0 Transitional Format
• RTF - Rich Text Format
• PDF - Acrobat® Portable Document Format
• TXD - TX Text Control Format
• TXT - ANSI Plain Text

In addition to the above word processing file formats, documents can also be saved to the following image file formats:

• BMP - Bitmap Image Format
• GIF - Graphics Interchange Format
• JPG - Joint Photographic Experts Group Format
• PNG - Portable Network Graphics Format
• TIFF - Tagged Image File Format
• WMF - Windows Meta File Format

Using LiveDocx

In this section, we are going to look at the entire process of creating a document using LiveDocx from scratch.

Creating a template in Microsoft® Word 2007

The first step in any LiveDocx project is the creation of a template. To do this, you can use either Open Office or Microsoft® Word. For the purpose of this article, we are going to use Microsoft® Word 2007. For instructions on using Open Office, please take a look at the LiveDocx Blog.

Start off by creating a new file in Microsoft® Word 2007 and save the template file as template.docx.

You can then start to compose the template, inserting text, graphics and merge fields with the Field dialog box, shown to the right.

After a while, you will have a template, which contains images, text and a number of merge fields. The merge fields are represented by { MERGEFIELD name } and will be populated with scalar data in the next step. The follow screenshot of the template in Microsoft® Word 2007 illustrates how your template may look:

Save the template template.docx [46 KB] when you are done.

Assigning scalar data types in LiveDocx

Now that we have the template file, the next step is to populate it with data. In the following example, we are going to assign scalar data types - in this case strings - to the template.

For many applications, in particular those in which PDF files are used of archiving purposes, you may wish to set the meta data of the PDF file. You can do this, by specifying an associative array with the meta data that should be embedded into the PDF file. The setDocumentProperties() method must be called before createDocument():

The resulting document document.pdf [104 KB] is written to disk and can now be opened in your favorite PDF reader, such as the shipped Document Viewer in Ubuntu:

Assigning compound data types in LiveDocx

In addition to the scalar data types, which were assigned to the template in the previous example, you can also assign compound data types, such as an associative array. Consider the template template.doc [20.5 KB] and the resulting document document.pdf [77.6 KB]. In particular, take a look at the following section of the template (click to enlarge):

The section of the template between the bookmarks

and is repeated in the final document to produce rows of a table. One sub-array of the following associate array is used for each row.

Using the following PHP 5 code, we are going to populate the template with an associative array of telephone connection data. For clarity, this example shows only the part in which an associative array is assigned. The instantiation of LiveDocx and the document creation and retrievable processes are identical to the previous examples and have been omitted:

The resulting document contains the following table with the data from the assigned associate array (click to zoom):

Generating image files with LiveDocx

In addition to the word processing file formats listed above that are supported by LiveDocx, you can also save the resulting documents as one or more image files. For this purpose, Zend_Service_LiveDocx_MailMerge offers the methods getAllBitmaps() and getBitmaps():

Similarly, it is possible to retrieve images for pages in a specific range:

Note that zoomFactor parameter. This is a per cent value, in the range of 10% to 400%. These methods are ideally suited to generating thumbnail images of the created document, for example, to display in the browser as a preview.

The actual image files can be written to disk by iterating through the $bitmaps array. There is one page of binary data per record in the array:

Deploying LiveDocx in your own applications

The code, which constitutes the PHP 5 implementation of LiveDocx, shipped in the Zend Framework, is released under the New BSD license and thus may be deployed, modified and redistributed in most projects, according to that terms of the license. The actual LiveDocx SOAP server, however, is proprietary software. There are three ways in which the SOAP service can be deployed in your own applications.

1. Free public server
   For the vast majority of applications, developers choose this approach. The default LiveDocx server that is referenced in the Zend Framework components is the free public server. It may be used in your own applications completely free of charge. Sign up for a LiveDocx account.
2. Premium hosted server
   In the case that your application generates several thousand documents per hour, you may consider paying a small monthly fee to have access to your own personal LiveDocx server. In association with leading hosting providers, you can rent such a premium hosted server.
3. Local licensed server
   In the case that your application generates more than about ten thousand documents her hour, you may consider installing a LiveDocx server in your local network. Having direct access in a local gigabit network is by far the fastest way of deploying LiveDocx.

Learn more

This article has scratched the surface of what you can do with LiveDocx. If you would like to learn more about this new powerful document generation platform, please take a look at the following resources:

LiveDocx in PHP 5

• phpLiveDocx blog.
• phpLiveDocx technical articles.

LiveDocx SOAP service

• LiveDocx blog.
• LiveDocx API reference.

Please do not hesitate to contact the author or request technical support in the support forum (free of charge) at any time.

Footnotes

[1]
domPDF, HTML 2 (F)PDF, HTML_ToPDF, mPDF etc.

[2] Zend_Pdf, PDFlib, FPDF, Cpdf etc.

]]> http://www.gsdesign.ro/blog/pdf-generation-with-zend-framework/feed/ 0 http://www.gsdesign.ro/blog/optimizing-zend-routing/ http://www.gsdesign.ro/blog/optimizing-zend-routing/#comments Wed, 06 May 2009 20:47:05 +0000 Gabi Solomon http://www.gsdesign.ro/blog/?p=379 After playing with zend framework for a while, and reading left and right, i came to the conclusion that i need to find a way to optimize the Routing in my application.
If you havent notice by now, the routing in Zend takes quite a while, and it increases with the number of routes you have, and with the number of routes that use Regular Expressions.

The easiest way to optimise it would be to reduce the number of rules that use regular expressions and the number of rules all together. But for SEO reasons that is not always possible.

Current Situation

Info: I have my routes wrote in INI files.

In my application i have started to have quite a few rules, so i have thought i would break them into separate files and include only the rules that i need for the section i am in. While that sounds like a plan, its not that simple ... i still need to have all the routes on page generation, because i have links point to a different section, so i need all the routes.

Solution

The solution that i came with is to write a plugin that will include some routes routeStartup and the rest on routeShutdown.

Step 1 - Routes files

To make this work, you need to have a directory where to store the routes ini files.
I have placed it in my application config dir. I recommend having a default one that is always included. Here is an example of a routing file:

PLAIN TEXT

PHP:

1. lang_default.type                = "GSD_Controller_Router_Route_Language"
2. lang_default.route               = ":language/:controller/:action/*"
3. lang_default.defaults.module     = default
4. lang_default.defaults.controller = index
5. lang_default.defaults.action     = index
6. lang_default.defaults.language   = ro
7. lang_default.reqs.language       = "(ro|en)"

Step 2 - Bootstraping the plugin

I have a simple bootstrap class that i wrote about, and i overwrote the setupRoutes method, but you can port this to your own setup with ease if you have used plugins before.

PLAIN TEXT

PHP:

1. public static function setupRoutes() {
2.         $plugin = new GSD_Controller_Plugin_Router();
3.         $plugin->setDir(self::$root . '/application/config/routes/');
4.         $plugin->setDefault('default.ini');
5.         self::$frontController->registerPlugin($plugin);
6.     }

In the code you see that i add a default file that is included everytime. just because some routes are 90% used.

Step 3 - The actual plugin

Here it is, full and uncensored :

PLAIN TEXT

PHP:

1. <?php
2.  
3. /**
4. * Front Controller Plugin
5. *
6. * @uses       Zend_Controller_Plugin_Abstract
7. * @category   GSD
8. * @package    GSD_Controller
9. * @subpackage Plugins
10. */
11. class GSD_Controller_Plugin_Router extends Zend_Controller_Plugin_Abstract
12. {
13.     protected $_dir;
14.     protected $_default = array();
15.     protected $_request;
16.  
17.     protected $_initialConfig;
18.     protected $_remainingConfig;
19.  
20.     public function routeStartup(Zend_Controller_Request_Abstract $request)
21.     {
22.         // define some routes (URLs)
23.         $router = Zend_Controller_Front::getInstance()->getRouter();       
24.        
25.         $this->setRequest($request);       
26.        
27.         $config = $this->getInitial();
28.         $router->addConfig($config);
29.     }
30.    
31.  
32.     public function routeShutdown(Zend_Controller_Request_Abstract $request)
33.     {
34.         $router = Zend_Controller_Front::getInstance()->getRouter();
35.        
36.         $config = $this->getRemaining();
37.  
38.         $router->addConfig($config);
39.     }
40.  
41.     public function setDir($dir) {
42.         $this->_dir = $dir;
43.     }
44.  
45.  
46.     public function setDefault($default) {
47.         if (is_array($default)) {
48.             $this->_default = array_merge($this->_default, $default);
49.         } else {
50.             $this->_default[] = $default;
51.         }
52.     }
53.  
54.  
55.     public function setRequest($request) {
56.         $this->_request = $request;
57.     }
58.  
59.     public function getInitial() {
60.         if ($this->_initialConfig == null) {
61.             $this->parseIniDir();
62.         }
63.  
64.         return $this->_initialConfig;
65.     }
66.  
67.  
68.     public function getRemaining() {
69.         if ($this->_remainingConfig == null) {
70.             $this->parseIniDir();
71.         }
72.  
73.         return $this->_remainingConfig;
74.     }
75.  
76.     protected function parseIniDir() {
77.         $files = $this->getFiles();
78.         $this->_default;
79.  
80.         $this->_default[] = $this->determineInitial();
81.  
82.         $this->_initialConfig = new Zend_Config(array(), true);
83.         $this->_remainingConfig = new Zend_Config(array(), true);       
84.  
85.         if (is_array($files)) {
86.             foreach ($files as $file) {
87.                 $routerFile = $this->compilePath($file);
88.  
89.                 if (in_array($file, $this->_default)) {
90.                     $this->_initialConfig->merge(new Zend_Config_Ini($routerFile));
91.                 } else {
92.                     $this->_remainingConfig->merge(new Zend_Config_Ini($routerFile));
93.                 }
94.             }
95.         }
96.     }
97.  
98.     protected function getFiles() {
99.         if (is_dir($this->_dir)) {
100.             $dir = new DirectoryIterator($this->_dir);
101.             $files = array();
102.             foreach($dir as $fileInfo) {
103.                 if(!$fileInfo->isDot() && $fileInfo->isFile()) {
104.                     $files[] = $fileInfo->__toString();
105.                 }
106.             }
107.  
108.             return $files;
109.         }
110.  
111.         return false;
112.     }
113.  
114.  
115.     protected function getOtherRoutes() {
116.         $routes->merge(new Zend_Config_Ini($routerFile));
117.     }
118.  
119.  
120.     protected function determineInitial() {
121.         if ($this->_request) {
122.             $uri = $this->_request->getRequestUri();
123.             $base = $this->_request->getBasePath() . '/';
124.  
125.             $request = str_replace($base, '', $uri);
126.             $requestParts = explode('/', $request);
127.  
128.             $lang = $requestParts[0];
129.             $section = $requestParts[1];
130.  
131.             if (!empty($section) && $section == 'user') {
132.                 return 'user.ini';
133.             }
134.  
135.         }
136.         return false;
137.     }
138.  
139.  
140.     protected function compilePath($file) {
141.         return $this->_dir . '/' . $file;
142.     }
143. }

In there you can see that the plugin reads all the ini files and at first only includes the ones from the default route you specify in bootstrap, and the one determined in the method determineInitial. I left there a small part of my method to give you an example of how i detect wich file to include based on the URL.

After routing, the routeShutdown is fired and all the rest of the routes are added into the router.

Final words

I think that cutting down on the number of routes at routing really speeds up your application, especially if its one with high trafic. All those regular expressions really make a mark in your server load.
PS: Load test your application, i had a wake up call about this a few weeks ago.

Unfortunately i am really short on time so i didn't do some comparations to see what improvements you get. If you have the time and do it out of curiosity i would appreciate if you would post a comment with your results ( i take critics well ... at least i like to think so )

Awaiting curiously your comments.
Cheers

]]> http://www.gsdesign.ro/blog/optimizing-zend-routing/feed/ 2 http://www.gsdesign.ro/blog/current-zend-view-path-helper/ http://www.gsdesign.ro/blog/current-zend-view-path-helper/#comments Sun, 29 Mar 2009 11:33:04 +0000 Gabi Solomon http://www.gsdesign.ro/blog/?p=372 Many times when i use Zend_View i have to include view files that are in the same directory, and i am forced to type in the same path over again. Which is and isnt so much work, but during development i often have to place those files in a different folder or rename one of the folders. In witch case i would be forced to change those path i gave in the view file.

This is why i wrote a small View_Helper to return the current view folder.
Unfortunately this will not work on a Zend framework out of the box, it will require some modifications to Zend_View_Abstract.

I have placed the code on ZF Snippets website, a project that i really like, and i would ask you to place any comments and suggestions for this helper on that webpage.

[ZF Snippets code]

Cheers

]]> http://www.gsdesign.ro/blog/current-zend-view-path-helper/feed/ 4 http://www.gsdesign.ro/blog/cron-jobs-in-zend-framework/ http://www.gsdesign.ro/blog/cron-jobs-in-zend-framework/#comments Wed, 11 Mar 2009 22:25:31 +0000 Gabi Solomon http://www.gsdesign.ro/blog/?p=369 Recently i had to implement a cronjob for a website that was build with zend framework, and to be honest i haven't done this before. I did some googling and as a lot of times with zend framework there arent to many resources about this topic.

I did find some topics on stackoverflow.com about it ( found out about zend cli proposal wich sounds interesting ) but not really an answer. So i decided to go ahead and try a solution on my own.

I wrote a while ago about my implementation of the bootstrap file and although that doesn't look to impressive that helped me to build an easy init for the backup files.

So first of all i must tell you that i added a folder in my root folder ( same level with library ) called crons.
In it i added a file called init.php in witch i "start" the zend machine. I only call some methods from the bootstrap class since you don't really need all the zend machine.

PLAIN TEXT

PHP:

1. $time = microtime(true);
2. $memory = memory_get_usage();
3.  
4. require '../application/bootstrap.php';
5.  
6. Bootstrap::setupEnvironment();
7.  
8. Bootstrap::setupRegistry();
9. Bootstrap::setupConfiguration();
10.  
11. Bootstrap::setupDatabase();
12. Bootstrap::setupTranslation();
13.  
14. register_shutdown_function('__shutdown');
15.  
16. function __shutdown() {
17. global $time, $memory;
18. $endTime = microtime(true);
19. $endMemory = memory_get_usage();
20.  
21. echo '
22. Time [' . ($endTime - $time) . '] Memory [' . number_format(( $endMemory - $memory) / 1024) . 'Kb]';
23. }

As you see i added some extra lines to do some little debugging of the cronjobs.

To add a cronjob you place a file in the crons folder you just created and you just include the init file and then you are on your way to code the cron functionality.

Cheers.

]]> http://www.gsdesign.ro/blog/cron-jobs-in-zend-framework/feed/ 6 http://www.gsdesign.ro/blog/minify-css-in-zendframework/ http://www.gsdesign.ro/blog/minify-css-in-zendframework/#comments Wed, 11 Mar 2009 09:07:54 +0000 Gabi Solomon http://www.gsdesign.ro/blog/?p=364 After coming across Matthew Turland Minify Filter for Zend Framework i decided to implement the minify app to also minify the css and javascript external files.

But i only did the implementation for the stylesheets for now, and i wanted to share it .

Pre info

Before we go any further i must tell you that this only works if you are using the Zend_View HeadLink Helper to place your css files.

First step i download the minify app and place it in my /public/min folder.

So i already had in my application a lot of calls to the HeadLink Helper and i didnt want to make a new class for this, since that would meant to change all those calls. I wanted a simple method of overwriting the helpers rendering method ( toString ).
To do this i only made my class extend the HeadLink class and wrote a new method for rendering, and also changed the call from the layout file.

PLAIN TEXT

PHP:

1. // old call
2.     <?php echo $this->headLink(); ?>
3.  
4.     // new call
5.     <?php echo $this->minStyleSheets(); ?>

The actual class

PLAIN TEXT

PHP:

1. <?php
2.  
3. class GSD_View_Helper_MinStyleSheets extends Zend_View_Helper_HeadLink {
4.    
5.     public function minStyleSheets() {
6.  
7.         $items = array();
8.         $stylesheets = array();
9.         foreach ($this as $item) {
10.             if ($item->type == 'text/css' && $item->conditionalStylesheet === false) {
11.                 $stylesheets[$item->media][] = $item->href;
12.             } else {
13.                 $items[] = $this->itemToString($item);
14.             }
15.         }
16.  
17.         foreach ($stylesheets as $media=>$styles) {
18.             $item = new stdClass();
19.             $item->rel = 'stylesheet';
20.             $item->type = 'text/css';
21.             $item->href = $this->getMinUrl() . '?f=' . implode(',', $styles);
22.             $item->media = $media;
23.             $item->conditionalStylesheet = false;
24.             $items[] = $this->itemToString($item);
25.         }
26.  
27.         return $indent . implode($this->_escape($this->getSeparator()) . $indent, $items);
28.     }
29.  
30.     public function getMinUrl() {
31.         return $this->getBaseUrl() . '/public/min/';
32.     }
33.  
34.     public function getBaseUrl() {
35.         return GSD_View_Helper_GetUrl::getBaseUrl();
36.     }
37.  
38. }

Info
I have another helper to get the base Url, but you can replace that to what ever you are using to keep the base Url of your application.

That is it folks.
Cheers

]]> http://www.gsdesign.ro/blog/minify-css-in-zendframework/feed/ 6 http://www.gsdesign.ro/blog/zend-framework-user-auth-model/ http://www.gsdesign.ro/blog/zend-framework-user-auth-model/#comments Wed, 04 Mar 2009 21:42:33 +0000 Gabi Solomon http://www.gsdesign.ro/blog/?p=351 All of the applications this days will involve a database to store data and most of them will also have a user system. This means that beside building a login/register page you also need a method to store the data of the logged-in user while they are logged in.

Normally in php driven websites you will have that data storred in sessions, but in Zend Framework its easyer to use Zend_Auth to help you manage that part for you. The way i implemented my login is that i save the the user model in Zend_Auth storage, this helps me by having acces to the models methods like isAdmin for example.

Although this is so far pretty ok, i dont really like calling Zend_Auth to get the current user all the time, plus i would enjoy to have an empty user model returned if no user is logged in. This is why i wrote a small model that i named Users_Auth.

PLAIN TEXT

PHP:

1. class Users_Auth
2. {
3. private $_user;
4.  
5. public function  __construct()
6. {
7. $table = Users::instance();
8.  
9. if ($this-&gt;hasIndentity()) {
10. $this-&gt;_user = $this-&gt;getIdentity();
11. $this-&gt;_user-&gt;setTable($table);
12. } else {
13. $this-&gt;_user = $table-&gt;fetchNew();
14. }
15. }
16.  
17. public function get() {
18. return $this-&gt;_user;
19. }
20.  
21. public function set(Users_Row $user) {
22. $this-&gt;_user = $user;
23. Zend_Auth::getInstance()-&gt;getStorage()-&gt;write($user);
24. }
25.  
26. private function hasIndentity()
27. {
28. return ($this-&gt;getIdentity() !== null);
29. }
30.  
31. private function getIdentity()
32. {
33. return Zend_Auth::getInstance()-&gt;getIdentity();
34. }
35.  
36. /**
37. * Singleton pattern
38. *
39. * @staticvar Users_Auth $instance
40. * @return Users_Auth
41. */
42. public function getInstance()
43. {
44. static $instance;
45. if (!($instance instanceof Users_Auth)) {
46. $instance = new Users_Auth();
47. }
48. return $instance;
49. }
50. }

The use is quite easy to understand, you just call Users_Auth::getInstance()->get(); to have the current logged user.

If you look in the construct you will see this line $this->_user->setTable($table); that is there because for some reason ( if you can figure it out pls tell me in the comment section ) after storing the model in Zend_Auth it looses connection with the model table.

That is it, not a very complicated post, just something that makes my coding just a little easyer.
Cheers.

]]> http://www.gsdesign.ro/blog/zend-framework-user-auth-model/feed/ 2 http://www.gsdesign.ro/blog/zend-framework-losing-session-on-swfflash-upload/ http://www.gsdesign.ro/blog/zend-framework-losing-session-on-swfflash-upload/#comments Wed, 04 Mar 2009 09:04:56 +0000 Gabi Solomon http://www.gsdesign.ro/blog/?p=349 Recently i tried to integrate the well known swfupload script into a website.
If you are here you must probably know that normally the flash request looses session since it doesn't send cookie headers. The recommended workaround is to send the sessionid as a parameter through post, and in the action page set the session_id() to the post variable before the session start.

I did this but for some reason, my zend application refused to accept the new session_id. I struggled with it for quite a few hours, and finally narrowed it down to a php problem since the session_id would get set properly but after session start the session would be empty.

Really hitting a dead end i headed to stackoverflow ( really thankful for the guys that made this site possible ) and tried my luck there and wrote a question. And i got my answer

Seemed like the problem was with the php extension Suhosin witch has a session protection to prevent session stealing. A very useful thing but in this case it made me spend quite a few hours puzzled and staring at the monitor.

Hope you this is also your problem,
Cheers

]]> http://www.gsdesign.ro/blog/zend-framework-losing-session-on-swfflash-upload/feed/ 1 http://www.gsdesign.ro/blog/zend-framework-bootstrap-file-class/ http://www.gsdesign.ro/blog/zend-framework-bootstrap-file-class/#comments Fri, 27 Feb 2009 00:02:11 +0000 Gabi Solomon http://www.gsdesign.ro/blog/?p=342 After starting working with zend framework i found all sorts of examples of bootstrap files, but a lot of them seem pretty messy to me since all the calls to zend components were basically thrown in there.

So after a lot of looking around i came up with a bootstrap files that is more to my liking. I found the initial class on a blog post when i was looking around but i don't remember where, so sorry for not giving it the credit.

First i will show you my index file.

PLAIN TEXT

PHP:

1. require './init.php';
2.  
3. Bootstrap::run();

Pretty simple isnt it . And now the init file.

PLAIN TEXT

PHP:

1. // Add /library and /application directory to our include path
2. $siteRootDir = dirname(__FILE__);
3.  
4. define('APPLICATION_PATH', $siteRootDir . '/application');
5.  
6. set_include_path(
7. APPLICATION_PATH . '/models' . PATH_SEPARATOR
8. . APPLICATION_PATH . '/modules/default/controllers' . PATH_SEPARATOR
9. . APPLICATION_PATH . '/controllers' . PATH_SEPARATOR
10. . APPLICATION_PATH . PATH_SEPARATOR
11. . $siteRootDir . '/library' . PATH_SEPARATOR
12. . get_include_path()
13. );
14.  
15. require APPLICATION_PATH . '/bootstrap.php';

Ok now lets go into the bootstrap . I will firs just paste it here and then write some explinations to it.

PLAIN TEXT

PHP:

1. function __autoload($className) {
2. require $className = str_replace('_', '/', $className) . '.php';
3. }
4.  
5. class Bootstrap{
6.  
7. public static $frontController = null;
8.  
9. public static $root = '';
10.  
11. public static $registry = null;
12.  
13. public static function run(){
14. self::prepare();
15.  
16. $response = self::$frontController-&gt;dispatch();
17. self::sendResponse($response);
18. }
19.  
20. public static function prepare(){
21. self::setupEnvironment();
22.  
23. self::setupRegistry();
24. self::setupConfiguration();
25.  
26. self::setupFrontController();
27. self::setupErrorHandler();
28.  
29. self::setupController();
30. self::setupView();
31. self::setupDatabase();
32. self::setupSessions();
33. self::setupTranslation();
34. self::setupRoutes();
35. self::setupAcl();
36. }
37.  
38. public static function setupEnvironment(){
39. error_reporting(E_ALL ^ E_NOTICE);
40. ini_set('display_errors', true);
41.  
42. date_default_timezone_set('Europe/Bucharest');
43.  
44. self::$root = dirname(dirname(__FILE__));
45.  
46. $configType = (isset($_SERVER['SERVER_NAME']) &amp;&amp; ($_SERVER['SERVER_NAME'] == '127.0.0.1' OR $_SERVER['SERVER_NAME'] == 'localhost')) ? 'development' : 'production';
47. define('APPLICATION_ENVIRONMENT', $configType);
48.  
49. define('HTMLPURIFIER_PREFIX', self::$root . '/library');
50. }
51.  
52. public static function setupRegistry() {
53. self::$registry = new Zend_Registry(array(), ArrayObject::ARRAY_AS_PROPS);
54. Zend_Registry::setInstance(self::$registry);
55. }
56.  
57. public static function setupConfiguration() {
58.  
59. $config = new Zend_Config_Ini(
60. self::$root . '/application/config/main.ini',
61. APPLICATION_ENVIRONMENT
62. );
63.  
64. self::$registry-&gt;configuration = $config;
65.  
66. //save $siteRootDir in registry:
67. self::$registry-&gt;set('siteRootDir', self::$root );
68. self::$registry-&gt;set('applicationRootDir', self::$root . '/application' );
69.  
70. self::$registry-&gt;set('siteRootUrl', 'http://' . $_SERVER['HTTP_HOST'] );
71. }
72.  
73. public static function setupFrontController(){
74. self::$frontController = Zend_Controller_Front::getInstance();
75. self::$frontController-&gt;throwExceptions(true);
76. self::$frontController-&gt;returnResponse(true);
77.  
78. self::$frontController-&gt;addModuleDirectory(self::$root . '/application/modules');
79.  
80. self::$frontController-&gt;setParam('registry', self::$registry);
81.  
82. self::$frontController-&gt;setParam('env', APPLICATION_ENVIRONMENT);
83.  
84. $response = new Zend_Controller_Response_Http; // Set default Content-Type
85. $response-&gt;setHeader('Content-Type', 'text/html; charset=UTF-8', true);
86. self::$frontController-&gt;setResponse($response);
87. }
88.  
89. public static function setupErrorHandler() {
90. self::$frontController-&gt;throwExceptions(false);
91.  
92. self::$frontController-&gt;registerPlugin(new Zend_Controller_Plugin_ErrorHandler(
93. array(
94. 'module'     =&gt; 'default',
95. 'controller' =&gt; 'error',
96. 'action'     =&gt; 'error')
97. ));
98.  
99. $writer = new Zend_Log_Writer_Firebug();
100. $logger = new Zend_Log($writer);
101. Zend_Registry::set('logger',$logger);
102. }
103.  
104. public static function setupController(){
105. // place to put in your Controll Action Helpers
106. // ex: Zend_Controller_Action_HelperBroker::addHelper(new GSD_Controller_Action_Helper_AuthUsers());
107. }
108.  
109. public static function setupView() {
110.  
111. $view = new Zend_View(array('encoding'=&gt;'UTF-8'));
112. $view-&gt;addHelperPath('GSD/View/Helper', 'GSD_View_Helper_');
113.  
114. $viewRendered = new Zend_Controller_Action_Helper_ViewRenderer($view);
115. Zend_Controller_Action_HelperBroker::addHelper($viewRendered);
116.  
117. Zend_Layout::startMvc(
118. array(
119. 'layoutPath' =&gt; self::$root . '/application/layouts',
120. 'layout' =&gt; 'default'
121. )
122. );
123. }
124.  
125. public static function sendResponse(Zend_Controller_Response_Http $response){
126. $response-&gt;sendResponse();
127. }
128.  
129. public static function setupDatabase(){
130. $config = self::$registry-&gt;configuration;
131.  
132. $db = Zend_Db::factory($config-&gt;db-&gt;adapter, $config-&gt;db-&gt;toArray());
133.  
134. $profiler = new Zend_Db_Profiler_Firebug('All DB Queries');
135. $profiler-&gt;setEnabled(true);
136. $db-&gt;setProfiler($profiler);
137.  
138. $db-&gt;query("SET NAMES 'utf8'");
139.  
140. self::$registry-&gt;database = $db;
141. Zend_Db_Table::setDefaultAdapter($db);
142.  
143. $frontendOptions = array(
144. 'automatic_serialization' =&gt; true
145. );
146.  
147. $backendOptions  = array(
148. 'cache_dir'                =&gt; self::$root . '/data/cache/db_table'
149. );
150.  
151. $cache = Zend_Cache::factory('Core',
152. 'File',
153. $frontendOptions,
154. $backendOptions);
155.  
156. // Next, set the cache to be used with all table objects
157. Zend_Db_Table_Abstract::setDefaultMetadataCache($cache);
158. }
159.  
160. public static function setupSessions(){
161.  
162. // Now set session save handler to our custom class which saves the data in MySQL database
163. $sessionManager = new GSD_Session_Manager();
164. Zend_Session::setOptions(array(
165. 'gc_probability' =&gt; 1,
166. 'gc_divisor' =&gt; 5000
167. ));
168. Zend_Session::setSaveHandler($sessionManager);
169.  
170. $defSession = new Zend_Session_Namespace('Main', true);
171. Zend_Registry::set('defSession', $defSession);
172. }
173.  
174. public static function setupTranslation(){
175. $options = array(
176. 'scan' =&gt; Zend_Translate::LOCALE_FILENAME,
177. 'disableNotices' =&gt; true,
178. );
179. $translate = new Zend_Translate('gettext', Zend_Registry::get('siteRootDir') . '/application/languages/', 'auto', $options);
180. Zend_Registry::set('Zend_Translate', $translate);
181.  
182. if (self::$frontController) {
183. self::$frontController-&gt;registerPlugin(new GSD_Controller_Plugin_Language());
184. }
185. }
186.  
187. public static function setupRoutes(){
188. // define some routes (URLs)
189. $router = self::$frontController-&gt;getRouter();
190.  
191. $config = new Zend_Config_Ini(
192. self::$root . '/application/config/routes.ini',
193. 'development'
194. );
195.  
196. $router-&gt;addConfig($config, 'routes');
197. }
198.  
199. public static function setupAcl(){
200. self::$frontController-&gt;registerPlugin(new GSD_Controller_Plugin_Acl());
201. }
202. }

As you can see basicly i just grouped toghether similar comands and make it all look much more nicer and cleaner. And also i added the autoload function since i really think this is a much faster way then the Zend_Loader option. As for what is run, lets take it one by one:
function run
This is the main function that calls the prepare function and starts up the whole Zend Framework.

function prepare
Calls all the internal methods that setup the framework to start dispatching the request.

function setupEnvironment
Here i added the error reporting options and also i define some constants like configuration type ( development - production )

function setupRegistry()
Start the Zend Registry.

function setupConfiguration
Get the config file ( contains the db conection data etc. ) and save the configuration in Zend_Registry

function setupFrontController
Starts the front controller and setup the modular aproach.

function setupErrorHandler
Registers the Error handler plugins and logger.

function setupController
Here is the place to put your Controll Action Helpers

function setupView
start the Zend_View and MVC structure, add the custom HelperPath

function setupDatabase
start your db connection bassed on the configuration we stored in the registry. Also started the Zend_Db_Table cache system.

function setupSessions
Start you session, i used a custom Session Manager that uses a mysql database as storage.

And that is about it. I skipped some of them because i thought they were pretty obvious.

Hope you will find this usefully, and await your comments.
Cheers

]]> http://www.gsdesign.ro/blog/zend-framework-bootstrap-file-class/feed/ 4 http://www.gsdesign.ro/blog/zend-framework-routing-in-models/ http://www.gsdesign.ro/blog/zend-framework-routing-in-models/#comments Sun, 08 Feb 2009 18:11:35 +0000 Gabi Solomon http://www.gsdesign.ro/blog/?p=340 this post is more of a personal best practice and thought to share it with you guys. I like to do things this way, and think this is the best aproach, but i might be wrong and i would like your feedback on this .

So in Zend Framework first of all you are recommended to always use the routers assemble method to generate the Urls. Wich is very good since you will then have an easy way of updating an URL, for example when the SEO guy tells you to switch 2 url params around.

The problem is where you place your call to the router ?

One way to go about it is to place it in the controller, or in the view. But i think that is not the best ideea since this would mean in case you would want to change the route, the name for example, you would need to change it in all the places you made it.

A second choice would be to have the router call in a function somewhere that you would call from everywhere you would want the URL generated. But that seems to me like an extra layer.

My approch.

Almost all the time that URL is related to a model. For example if u have an article model. then you could make a method buildUrl :

PLAIN TEXT

PHP:

1. public function buildUrl()
2. {
3.         $router = Zend_Controller_Front::getInstance()->getRouter();
4.  
5.         $url    = $router->assemble(
6.                             array(
7.                                 'article_id'    => $this->id,
8.                             ),
9.                             'article_page');
10.         return $url;
11. }

and then in your controllers and views you would just do:

PLAIN TEXT

PHP:

1. $offer->buildUrl()

which looks nicer and you are keeping the call to the router in one place.

Thats about it, i know this might look like pretty simple stuff for most of you, but i hope some will find this useful.
Cheers

]]> http://www.gsdesign.ro/blog/zend-framework-routing-in-models/feed/ 3 http://www.gsdesign.ro/blog/optimizing-zend-performance/ http://www.gsdesign.ro/blog/optimizing-zend-performance/#comments Wed, 28 Jan 2009 23:48:01 +0000 Gabi Solomon http://www.gsdesign.ro/blog/?p=338 If you started working with Zend Framework you have notice that it is a bit slower then your regular php application.
This is due more or less to the double sword of having such a big framework to work with.

There are a lot of tips and tutorial out there on how to optimize your Zend Framework, and in all of them you will see the recommendation to remove the require_once from the library and to use Zend_Loader. Wich is a good advice since all those require_onces do put some stress on your application.

But after a bit of testing i camed to the conclusion that Zend_Loader isn't so fast. So i decided to go revert to a simple solution: writing my own autoloader.
I just put this small function at the top of my zend bootstrap file.

PLAIN TEXT

PHP:

1. function __autoload($class) {
2.     require str_replace('_', '/', $class) . '.php';
3. }

And because i wrote all my application using Zend / Pear naming standard it works pretty good.

Hope you find this useful.
Cheers

]]> http://www.gsdesign.ro/blog/optimizing-zend-performance/feed/ 7