]]> NOTE: Tested on Symfony2 PR12. Might not work on later releases!
There is a newer version article about Symfony2 pagination that is compatible with Symfony2 – beta1.

Using Symfony 2, I noticed that there is no pagination included in framework (just some additional Bundle for download -and it uses Zend pagination but I don’t want to mix Zend into my Symfony 2 project), so I decided to write class for that on my own.This class is just in basic format (in the future will be added more features) but for basic purposes is usable.

Here is the case: I have view with list of items loaded from database and need pagination for that.

Basic idea:
Create ‘Paginator’ class and put all logic of pagination inside that class, and leave all database logic to Entity classes.

Here is the source code:

<?php
/**
 * Class to generate pagination for items
 *
 * @author Darko Goleš
 * @www.inchoo.net
 */
namespace Surgeworks\AdminBundle\Helpers;

class Paginator {

 //current displayed page
 protected $currentpage;
 //limit items on one page
 protected $limit;
 //total number of pages that will be generated
 protected $numpages;
 //total items loaded from database
 protected $itemscount;
 //starting item number to be shown on page
 protected $offset;

 function __construct($itemscount) {
 //set total items count from controller
 $this->itemscount = $itemscount;
 //get params from request URL
 $this->getParamsFromRequest();
 //Calculate number of pages total
 $this->getNumPages();
 //Calculate first shown item on current page
 $this->calculateOffset();
 }

 private function getParamsFromRequest() {
 //If current page number is set in URL
 if (isset($_GET['page'])) {
 $this->currentpage = $_GET['page'];
 } else {
 //else set default page to render
 $this->currentpage = 1;
 }
 //If limit is defined in URL
 if (isset($_GET['limit'])) {
 $this->limit = $_GET['limit'];
 } else {   //else set default limit to 20
 $this->limit = 10;
 }
 //If currentpage is set to null or is set to 0 or less
 //set it to default (1)
 if (($this->currentpage == null) || ($this->currentpage < 1)) {
 $this->currentpage = 1;
 }
 //if limit is set to null set it to default (10)
 if (($this->limit == null)) {
 $this->limit = 10;
 //if limit is any number less than 1 then set it to 0 for displaying
 //items without limit
 } else if ($this->limit < 1) {
 $this->limit = 0;
 }
 }

 private function getNumPages() {
 //If limit is set to 0 or set to number bigger then total items count
 //display all in one page
 if (($this->limit < 1) || ($this->limit > $this->itemscount)) {
 $this->numpages = 1;
 } else {
 //Calculate rest numbers from dividing operation so we can add one
 //more page for this items
 $restItemsNum = $this->itemscount % $this->limit;
 //if rest items > 0 then add one more page else just divide items
 //by limit
 $restItemsNum > 0 ? $this->numpages = intval($this->itemscount / $this->limit) + 1 : $this->numpages = intval($this->itemscount / $this->limit);
 }
 }

 private function calculateOffset() {
 //Calculet offset for items based on current page number
 $this->offset = ($this->currentpage - 1) * $this->limit;
 }

 //Returns HTML string with paginator elements - will be used from Controller
 public function RenderPaginator() {
 $html = '';
 //Insert all in one div tag
 $html.= '<div>';
 //We need this form for sumbitting limit into URL via GET call
 $html.='<form id= "paginator" name="paginator" method="get" action="#" >';
 //When limit is changed - just submit form
 $html.= '<select name="limit" onchange="javascript:document.forms.paginator.submit()">';
 $html.= '<option value="10" ';
 if ($this->limit == 10) {
 $html.='selected';
 } $html.='>10</option>';
 $html.= '<option value="20" ';
 if ($this->limit == 20) {
 $html.='selected';
 } $html.='>20</option>';
 $html.= '<option value="30" ';
 if ($this->limit == 30) {
 $html.='selected';
 } $html.='>30</option>';
 $html.= '<option value="50" ';
 if ($this->limit == 50) {
 $html.='selected';
 } $html.='>50</option>';
 $html.= '<option value="100" ';
 if ($this->limit == 100) {
 $html.='selected';
 } $html.='>100</option>';
 $html.= '<option value="500" ';
 if ($this->limit == 500) {
 $html.='selected';
 } $html.='>500</option>';
 $html.= '<option value="0" ';
 if ($this->limit == 0) {
 $html.='selected';
 } $html.='>All</option>';
 $html.='</select>';
 $html.='</form>';
 $html.='<ul>';

 //Generate links for pages
 for ($i = 1; $i < $this->numpages + 1; $i++) {

 $html.='<li><a href="' . $_SERVER['PHP_SELF'] . '?limit=' . $this->limit . '&amp;page=' . $i . '">' . $i . '</a></li>';
 }
 $html.='</ul>';
 $html.= '</div>';

 return $html;
 }

 //For using from controller
 public function getLimit() {
 return $this->limit;
 }
 //For using from controller
 public function getOffset() {
 return $this->offset;
 }

}

Now let’s look in database repository class:

<?php
namespace Surgeworks\AdminBundle\Entity;

use Doctrine\ORM\EntityRepository;

class LanguageRepository extends EntityRepository {

 public function getLanguagesListWithPagination($order_by = array(), $offset = 0, $limit = 0) {
 //Create query builder for languages table
 $qb = $this->createQueryBuilder('l');

 //Show all if offset and limit not set, also show all when limit is 0
 if ((isset($offset)) && (isset($limit))) {
 if ($limit > 0) {
 $qb->setFirstResult($offset);
 $qb->setMaxResults($limit);
 }
 //else we want to display all items on one page
 }
 //Adding defined sorting parameters from variable into query
 foreach ($order_by as $key => $value) {
 $qb->add('orderBy', 'l.' . $key . ' ' . $value);
 }
 //Get our query
 $q = $qb->getQuery();
 //Return result
 return $q->getResult();
 }

 public function getLanguagesCount() {
 //Create query builder for languages table
 $qb = $this->createQueryBuilder('l');
 //Add Count expression to query
 $qb->add('select', $qb->expr()->count('l'));
 //Get our query
 $q = $qb->getQuery();
 //Return number of items
 return $q->getSingleScalarResult();
 }

}

Now it’s time to use it in our controller action:

<?php

namespace Surgeworks\AdminBundle\Controller;

use Symfony\Bundle\FrameworkBundle\Controller\Controller;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Security\Core\SecurityContext;
use Surgeworks\AdminBundle\Forms\LanguageForm;
use Symfony\Component\HttpKernel\Exception\HttpException;
use Symfony\Component\HttpFoundation\RedirectResponse;
use Surgeworks\AdminBundle\Helpers\Paginator;

class LanguagesController extends Controller {

 /**
 * @extra:Route("/admin/languages", name="_admin_languages")
 * @extra:Template()
 */
 public function indexAction() {

 //order of items from database
 $order_by = array();
 //get Entity manager instance
 $em = $this->get('doctrine.orm.entity_manager');
 //get repository for class 'Language' : LanguageRepository.php
 $repository = $em->getRepository('Surgeworks\AdminBundle\Entity\Language');
 //get count of languages for using with Paginator class
 //Using custom made database query function in LanguageRepository class
 $languagesCount = $repository->getLanguagesCount();
 //When creating new paginator object it takes care for pages and items
 //organization based on numbers of items from database and limit variable in $_GET
 $paginator = new Paginator($languagesCount);
 //get returned HTML string from Paginator to render paginator HTML
 //elements in the template
 $strPaginator = $paginator->RenderPaginator();

 //If we have POST variable defined, than it is defined order of items
 //from inside form (clicking on sorting column for example)
 if ('POST' === $this->get('request')->getMethod()) {
 $order_by = array($_POST['filter_order'] => $_POST['filter_order_Dir']);
 $sort_direction = $_POST['filter_order_Dir'] == 'asc' ? 'desc' : 'asc';
 } else {
 //We know that nothing is changed for ordering columns -
 //this is alse default order of items when page is first opened
 $order_by = array('sort_order' => 'asc', 'id' => 'asc');
 $sort_direction = 'desc';
 }
 //To fill $languages for forwarding it to the template, we first call database function
 //with $offset and $limit to get items we wanted
 $languages = $repository->getLanguagesListWithPagination($order_by, $paginator->getOffset(), $paginator->getLimit());
 //Finally - return array to templating engine for displaying data.
 return array('languages' => $languages, 'sort_dir' => $sort_direction, 'paginator' => $strPaginator);
 }
...

Then in your twig template show it like that:

{{ paginator|raw }}

and maybe after all of this, add some CSS styles to make that paginator beautiful…

]]> In one of my previous articles I showed you how to use getModel and getData methods in Magento. Although we should not put those to methods at the same level, since I’d say the getModel is a bit more higher. Higher in sense, you first use the geModel to create the instance of object then you use getData to retrieve the data from that instance. I have said it before, and I’m saying it again; Magento is a great peace of full OOP power of PHP. It’s architecture is something not yet widely seen in CMS solutions.

One of the architectural goodies of Magento is it’s Singleton design pattern. In short, Singleton design pattern ensures a class has only one instance. Therefore one should provide a global point of access to that single instance of a class.

So why would you want to limit yourself to only one instance? Let’s say you have an application that utilizes database connection. Why would you create multiple instance of the same database connection object? What if you had references to an object in multiple places in your application? Wouldn’t you like to avoid the overhead of creating a new instance of that object for each reference? Then there is the case where you might want to pass the object’s state from one reference to another rather than always starting from an initial state.

Inside the Mage.php file of Magento system there is a getSingleton method (function if you prefer). Since it’s footprint is rather small, I’ll copy paste the code for you to see it.

public static function getSingleton($modelClass=”, array $arguments=array())
{
$registryKey = ‘_singleton/’.$modelClass;
if (!Mage::registry($registryKey)) {
Mage::register($registryKey, Mage::getModel($modelClass, $arguments));
}
return Mage::registry($registryKey);
}

First, notice the word static. In PHP and in other OOP languages keyword static stands for something like “this can be called on non objects, directly from class”. Now let me show you the footprint of the getModel method.

public static function getModel($modelClass=”, $arguments=array())
{
return Mage::getConfig()->getModelInstance($modelClass, $arguments);
}

Do you notice the parameters inside the brackets? They are the same for both of theme. Where am I getting with this? Well, I already showed you how to figure out the list of all of the available parameters in one of my previous articles on my site. So all we need to do at this point is, play with those parameters using getSingleton() method and observe the results.

Most important thing you need to remember is that using getSingleton you are calling already instantiated object. So if you get the empty array as a result, it means the object is empty. Only the blueprint is there, but nothing is loaded in it. We had the similar case using getModel(‘catalog/product‘) on some pages. If we done var_dump or print_r we could saw the return array was empty. Then we had to use the load method to load some data into our newly instantiated object.

What I’m trying to say, you need to play with it to get the feeling. Some models will return data rich objects some will return empty arrays. If we were to do Mage::getSingleton(‘catalog/session) on view.phtml file we would retrieve an array with some useful data in it. Do not get confused with me mentioning the view.phmtl file, it’s just he file i like to use to test the code. Using Mage::getSingleton(‘core/session) would retrieve us some more data. You get the picture. Test, test, test… What’s great about the whole thing is that naming in Magento is perfectly logical so most of the time you will probably find stuff you need in few minutes or so.

For the end here are some screenshots for you to see the results of calling getSingleton with catalog/product and catalog/session parametars.

Hope this will be useful for some of you.

]]> One of the problems working under the hood of the Magento CMS is determining the context of $this. If you are about to do any advanced stuff with your template, besides layout changes, you need to get familiar with Magento’s objects (classes).

Let’s have a look at the /app/design/frontend/default/default/template/catalog/product/view.phtml file. If you open this file and execute var_dump($this) your browser will return empty page after a short period of delay. By page I mean on the product view page; the one you see when you click on Magetno product. Experienced users will open PHP error log and notice the error message caused by var_dump(). Error message:
PHP Fatal error:  Allowed memory size of 134217728 bytes exhausted (tried to allocate 121374721 bytes)

I like using print_r() and var_dump(), mostly because so far I had no positive experience using fancy debug or any other debugger with systems like Magento.

Why is PHP throwing errors then? If you google out the error PHP has thrown at you, you’ll see that PHP 5.2 has memory limit. Follow the link http://www.php.net/manual/en/ini.core.php#ini.memory-limit to see how and what exactly.

Google search gave me some useful results trying to solve my problems. I found Krumo at http://krumo.sourceforge.net/. It’s a PHP debugging tool, replacement for print_r() and var_dump(). After setting up Krumo and running it on Magento it gave me exactly what I wanted. It gave me the object type of the dumped file; in this case it gave me object type of $this.

If you’re using an IDE studio with code completion support like NuSphere PhpED, ZendStudio or NetBeans and you decide to do something like $this-> you won’t get any methods listed. I haven’t yet seen the IDE that can perform this kind of smart logic and figure out the context of $this by it self.

What you can do is use the information obtained by krumo::dump($this). Performing krumo::dump($this) on /app/design/frontend/default/default/template/catalog/product/view.phtml file will return object type, Mage_Catalog_Block_Product_View.

Now if you do

Mage_Catalog_Block_Product_View::

your IDE supporting code completion will give you a drop down of all the available methods, let’s say canEmailToFriend();

Mage_Catalog_Block_Product_View::canEmailToFriend();

Now all you need to do is to replace  Mage_Catalog_Block_Product_View with $this like

$this->canEmailToFriend();

And you’re done. All of this may look like “why do I need this”. What you need it a smart IDE, one that can figure out the context of $this by it self and call the methods accordingly. No IDE currently does that, if I’m not missing on something. For now I see no better solution to retrieve the object context of $this across all those Magento files.

If you need some help setting up Krumo with Magento you can read my other, somewhat detailed article on activecodeline.com.

Hope this was useful for you.