$conn = new PDO('dblib:host=127.0.0.1;dbname=database', 'user', 'pass');
    $stmt = $conn->prepare("EXEC sp_SaveMagicNumber ?");
    $stmt->bindValue(1, 5, PDO::PARAM_INT);
    $stmt->execute();

Kod z powyższego listingu wywoła procedurę sp_SaveMagicNumber z parameterem 5. Jeśli używamy symfony wraz z Doctrine, możemy (a nawet powinniśmy) zamienić pierwszą linijkę na:

    $conn = Doctrine_Manager::getInstance()->getConnection();

Można też przekazywać parametry jako “placeholdery”, jak na listingu poniżej:

    $conn = Doctrine_Manager::getInstance()->getConnection();
    $stmt = $conn->prepare("EXEC sp_IntroduceYourself :name, :surname");
    $stmt->bindValue(':surname', 'Sznapka', PDO::PARAM_STR);
    $stmt->bindValue(':name', 'Wojtek', PDO::PARAM_STR);
    $stmt->execute();

Ostatnim punktem programu są parametry typu OUTPUT, czyli zwracające wartości z procedury składowanej (podobnie jak parametry funkcji PHP przekazywanych przez referencję). Niestety biblioteka PDO posiada błąd, który uniemożliwia poprawne działanie metod z takimi parametrami. W idealnym przypadku, jeśli parametr w MSSQL jest zdefiniowany jako OUTPUT powinniśmy go dostać następujący sposób:

    $conn = Doctrine_Manager::getInstance()->getConnection();
    $stmt = $conn->prepare("EXEC sp_GetCountry :city, :country OUTPUT");
    $stmt->bindValue(':city', 'Gliwice', PDO::PARAM_STR);
    $country = NULL;
    $stmt->bindParam(':country', $country, PDO::PARAM_STR | PDO::PARAM_INPUT_OUTPUT);
    $stmt->execute();
    printf("Dla miasta %s procedura zwraca kraj %s", $city, country);

Niestety pomimo wielu prób, nie udało się obejść tego błędu i na chwilę obecną wygląda na to, że nie ma sposobu na pozyskiwanie parametrów typu OUTPUT z procedur składowanych MSSQL. Podobne problemy można spotkać na bugtrackerze PHP: http://bugs.php.net/bug.php?id=50555

  class myWidgetFormSelect extends sfWidgetFormSelect
  {
    public function renderContentTag($tag, $content = null, $attributes = array())
    {
      if ($tag == 'option' && isset($attributes['value'])
        && $this->disableCondition($attributes['value'])
      ) {
        $attributes['disabled'] = 'disabled';
      }
      return parent::renderContentTag($tag, $content, $attributes);
    }   

    protected function disableCondition($value)
    {
      return (int)$value < 0;
    }
  }

class MobileBrowserDetector
{
  private static $mobileAgentPrefixes = array(
    'w3c ','acs-','alav','alca','amoi','audi','avan','benq','bird','blac',
    'blaz','brew','cell','cldc','cmd-','dang','doco','eric','hipt','inno',
    'ipaq','java','jigs','kddi','keji','leno','lg-c','lg-d','lg-g','lge-',
    'maui','maxo','midp','mits','mmef','mobi','mot-','moto','mwbp','nec-',
    'newt','noki','oper','palm','pana','pant','phil','play','port','prox',
    'qwap','sage','sams','sany','sch-','sec-','send','seri','sgh-','shar',
    'sie-','siem','smal','smar','sony','sph-','symb','t-mo','teli','tim-',
    'tosh','tsm-','upg1','upsi','vk-v','voda','wap-','wapa','wapi','wapp',
    'wapr','webc','winw','winw','xda','xda-'
  );

  private static $mobileAgentParts = array(
    'up.browser', 'up.link', 'mmp', 'symbian', 'mobile safari',
    'opera mobi', 'android', 'smartphone', 'midp', 'wap', 'phone'
  );

  public static function isMobile($userAgent = '')
  {
    if (!strlen($userAgent)) {
      $userAgent = $_SERVER['HTTP_USER_AGENT'];
    }
    $isMobile = false;
    $isMobile |= in_array(strtolower(substr($userAgent, 0, 4)), self::$mobileAgentPrefixes);
    $isMobile |= preg_match(sprintf('#(%s)#i', implode('|', self::$mobileAgentParts)), $userAgent);
    $isMobile |= strpos(strtolower($_SERVER['HTTP_ACCEPT']),'application/vnd.wap.xhtml+xml') !== false;
    $isMobile |= isset($_SERVER['HTTP_PROFILE']);
    $isMobile |= isset($_SERVER['HTTP_X_WAP_PROFILE']);
    $isMobile |= isset($_SERVER['ALL_HTTP']) && strpos(strtolower($_SERVER['ALL_HTTP']),'OperaMini') !== false;
    return (bool)$isMobile;
  }
}

Możemy łatwo użyć tej klasy na przykład w projekcie symfony, podmieniając główny layout na layout mobilny (apps/APLIKACJA/templates/layout_mobile.php) w filtrze, w poniższy sposób.
Zawartość apps/APLIKACJA/config/filters.yml

rendering: ~
security:
  class: sfGuardBasicSecurityFilter
mobile:
  class: MobileFilter
cache:     ~
common:    ~
execution: ~

Klasa filtra lib/MobileFilter.class.php:

class MobileFilter extends sfFilter
{
  public function execute($filterChain)
  {
    if (MobileBrowserDetector::isMobile()) {
      $this->getContext()->getActionStack()->getFirstEntry()->getActionInstance()->setLayout('layout_mobile');
    }
    $filterChain->execute();
  }
}

Natchnęło mnie dziś do pomyślenia jak uchronić się przed niebezpieczeństwami związanymi z stosowaniem die() w kodzie…tak wiem że była o tym parę razy mowa, że to zło w najczystszej postaci,  że najlepiej korzystać z xdebug, a najlepiej nigdy nie korzystać z die() w kodzie.

Wszystko ma jednak swoje wady i zalety – o ile w pracy xdebuga mogę sobie skonfigurować pod netbeansa to w domu nie korzystam z tego IDE (połączenie przez OpenVPN i dość częste skanowanie projektu jest nader uciążliwe). Dlatego zaczerpnąłem nieco mocy googla i po kilku testach przedstawiam:  FirePHP.

FirePHP to całkiem zgrabny logger dla PHP wykorzystujący Firebuga – ku mojemu zdziwieniu jest to całkiem niezły plugin, do jego działania wystarczy mieć zainstalowaną wtyczkę Firebug z włączoną zakładką sieć i konsola. Instalując FirePHP trzeba jeszcze pamiętać o zaciągnięciu biblioteki FirePHPCore, którą rozpakowujemy do katalogu roota (w moim przypadku to katalog web w symfony).  FirePHP pokaże się jako niebieski robal (widoczny na poniższym zrzucie).

Mając to wszystko jesteśmy niemal gotowi by bezpiecznie debugować skrypty. Do skryptu dołączamy:

require_once('FirePHPCore/FirePHP.class.php');

Teraz już poprzez wywołanie w postaci:

$firephp = FirePHP::getInstance(true);
$firephp->log($var, 'nieobowiazkowy opis dla loga');

Zobaczymy w zakładce konsola Firebuga wartość zmiennej $var poprzedzoną opisem podanym jako drugi parametr funkcji log.
Dla własnej wygody napisałem krótką funkcję ustawiającą podstawowe parametry debugowania:

/**
* Function is used for debuging this scrypt, in prod environment change
* $firephp->setEnabled(true); to false.
*
* @param object $var
* @param string $desc[optional]
*/
public function keep($var, $desc = null)
{
  $options = array(
  'maxObjectDepth' => 10,
  'maxArrayDepth' => 20,
  'useNativeJsonEncode' => true,
  'includeLineNumbers' => true);

  $firephp = FirePHP::getInstance(true);
  $firephp->setEnabled(true);
  $firephp->setOptions($options);
  $firephp->log($var, $desc);
}

Ważne aby pamiętać iż dla własnego bezpieczeństwa należy w środowisku produkcyjnym ustawić setEnabled na false.

Posłużę się Jobeetem, zatem moja funkcja index wygląda tak:

public function executeIndex(sfWebRequest $request)
{
  $vars = 0;
  $this->categories = Doctrine::getTable('JobeetCategory')->getWithJobs();
  $this->keep($vars, "at line: ".__LINE__);
  $vars = 12;
  $this->keep($vars, "at line: ".__LINE__);
}

drugi parametr funkcji keep służy mi jako informacja pozwalająca szybko odnaleźć miejsce z wywołaniem logera. Wynik logowania prezentuje się następująco:

Ciekawsze wyniki można uzyskać deklarując przykładową tablicę z danymi – najeżdżając kursorem myszy na wynik debugowania tablicy ukaże się okienko jak na poniższym zrzucie – możemy tutaj nieco dokładniej przyjrzeć się zwróconym wartościom.

Na koniec chciałbym zauważyć, że odświeżenie strony nie zawsze powoduje odświeżenie wyników debugowania, prowadzi to wręcz do ich utraty – należy wówczas kliknąć w Firebugu opcję Off a następnie On dzięki czemu zobaczymy aktualne dane.

Zachęcam do korzystania z FirePHP i testowania jego pozostałych funkcjonalności.

http://www.firephp.org/HQ/Use.htm

class Pager
{
  private
    $page = 1,
    $per_page = 10;

  public function calculate()
  {
    return $this->page * $this->per_page - $this-per_page + 1;
  }
}

Jedna mała pomyłka. Zamiast

$this->per_page

do kodu wkradło się:

$this-per_page

Co to zmienia? Na pierwszy rzut oka parser PHP powinien poinformować o błędzie… jednak linia kodu zawierająca błąd interpretowana jest następująco:

$this->page // 1

$this->per_page // 10

$this  // rzutowane na int to 1, bo obiekt istnieje

per_page // jako stała niezdefiniowana to 0

Wykonywane działanie matematyczne wygląda zatem następująco:

1 * 10 - 1 - 0 + 1

Wynik działania to o dziwo 10… Dlatego kocham PHP!

  public function addToCache($page_url, $image_url)
  {
    Debug::Log("Adding to cache");
    $this->cache[$page_url] = $image_url;
  }

  public function loadCache()
  {
    Debug::Log('Reading cache');
    if (file_exists("cache.csv"))
    {
      $fh = fopen("cache.csv", "r");
      while (($data = fgetcsv($fh, 1000, ",")) !== FALSE)
      {
        $this->cache[$data[0]] = $data[1];
      }
      fclose($fh);
      return $this->cache;
    }
  }

  public function saveCache()
  {
    Debug::Log("Saving cache");
    $fh = fopen('cache.csv', 'w');
    foreach ($this->cache as $page_url=>$image_url)
    {
      fputcsv($fh, array($page_url, $image_url));
    }
    fclose($fh);
  }

  public function isCached($page_url)
  {
    Debug::Log("Checking cache");
    if (empty($this->cache))
    {
      $this->loadCache();
    }
    if (isset($this->cache[$page_url]))
    {
      Debug::Log("Found in cache");
      return $this->cache[$page_url];
    }
    Debug::Log("Not found in cache");
    return false;
  }

oraz użyć ich w odpowiedni sposób. Cały plik wygląda następująco:

url = $url;
  }

  /*
   *  Read remote rss file
   */
  public function getOrginalContent()
  {
    if (is_null($this->url))
    {
      throw new FeedException("You have to set url first!");
    }

    $this->orginalContent = Remote::get_remote_file_content($this->url);
    return $this->orginalContent;
  }

  /*
   * Create a DOMDocument from rss.xml file
   */
  public function getDomOrginalContent()
  {
    if (false === $this->orginalContent || is_null($this->orginalContent))
    {
      throw new FeedException("Can not download rss file");
    }

    $domDocument = new DOMDocument();
    $domDocument->loadXML($this->orginalContent);
    return $domDocument;
  }

  public function addToCache($page_url, $image_url)
  {
    Debug::Log("Adding to cache");
    $this->cache[$page_url] = $image_url;
  }

  public function loadCache()
  {
    Debug::Log('Reading cache');
    if (file_exists("cache.csv"))
    {
      $fh = fopen("cache.csv", "r");
      while (($data = fgetcsv($fh, 1000, ",")) !== FALSE)
      {
        $this->cache[$data[0]] = $data[1];
      }
      fclose($fh);
      return $this->cache;
    }
  }

  public function saveCache()
  {
    Debug::Log("Saving cache");
    $fh = fopen('cache.csv', 'w');
    foreach ($this->cache as $page_url=>$image_url)
    {
      fputcsv($fh, array($page_url, $image_url));
    }
    fclose($fh);
  }

  public function isCached($page_url)
  {
    Debug::Log("Checking cache");
    if (empty($this->cache))
    {
      $this->loadCache();
    }
    if (isset($this->cache[$page_url]))
    {
      Debug::Log("Found in cache");
      return $this->cache[$page_url];
    }
    Debug::Log("Not found in cache");
    return false;
  }
  /*
   * Get image URL from remote webpage
   */
  public function getImage($item)
  {
    if ('link' == $item->nodeName)
    {
      if ($cache = $this->isCached($item->nodeValue))
      {
        return $cache;
      }
      $htmlContent = Remote::get_remote_file_content($item->nodeValue);
      if (false !== $htmlContent)
      {
        //Search image tag
        $pattern = "/bigurl=\".*\"/";
        preg_match($pattern, $htmlContent, $urls);

        //Finally url to the image
        $url = substr($urls[0], 8, -1);
        $this->addToCache($item->nodeValue, $url);
        return $url;
      }
      return 'http://demotywatory.pl/res/img/demotywatory-logo.gif';
    }
  }

  /*
   * Set new description for current item
   */
  public function setImage($item)
  {
    //Find element link
    foreach ($item->childNodes as $rssDomItemChild)
    {
      if ('link' == $rssDomItemChild->nodeName)
      {
        //Download demot page
        $url = $this->getImage($rssDomItemChild);
        break;
      }
    }

    //Find element description
    foreach ($item->childNodes as $rssDomItemChild)
    {
      if ('description' == $rssDomItemChild->nodeName)
      {
        $rssDomItemChild->nodeValue = '<img src="'.$url.'">';
        break;
      }
    }
    Debug::Log('Found url: ['.$url.']');
  }

  /*
   * Convert rss.xml to rss.xml with images in description
   */
  public function transform()
  {
    //Get DOMDocument
    $this->transformedDom = $this->getDomOrginalContent();
    //Find all items
    $rssItems = $this->transformedDom->getElementsByTagName('item');

    //Foreach feed
    Debug::Log('Starting retriving feeds');

    foreach ($rssItems as $rssItem)
    {
      //Set image in description for node
      $this->setImage($rssItem);
    }
    Debug::Log('Finished retriving feeds!');
  }

  /*
   * Get transformed XML
   */
  public function getResults()
  {
    return $this->transformedDom->saveXml();
  }

  /*
   * Save results to file (xml)
   */
  public function save($filename)
  {
    Debug::Log('Saving file ('.$filename.')');
    $fh = fopen($filename, 'w');
    if (!$fh)
    {
      throw new FeedException('Can not open file ('.$filename.') to write!');
    }
    fwrite($fh, $this->getResults());
    fclose($fh);
  }
}

Należy jeszcze zmienić skrypt wywołujący, czyli index.php:

setUrl('http://demotywatory.pl/rss.xml');
//Get rss file content
$feed->getOrginalContent();
//Convert to new format
$feed->transform();
//Save to file
$feed->save('result.xml');
$feed->saveCache();

I to wszystko. Teraz skrypt pobierze informacje jedynie o nowych rssach. Informacje które już posiada w razie potrzeby zostaną użyte ponownie.
Efekt działania można zobaczyć na http://drymek.hostei.com/.
Gotowy do użycia plik rss znajduje się tutaj: http://feeds.feedburner.com/demotywatorator?format=xml

Zestaw wszystkich plików do ściagnięcia: Demotywatorator2

1. Remote.php
2. FeedException.php
3. Debug.php
4. Feed.php
5. index.php

Pierwszy z nich, rozbudowany aż nadto co powinien być, jednak faza testowania wymagała porównania prędkości działania kilku rozwiązań. Curl został domyślnym, ze względu na jego szybkość i niezawodność.

<?php

/*
 * Read remote file with some methods
 *
 * @author drymek
 *
 */
class Remote
{
  /*
   * Read file with default method
   */
  public static function get_remote_file_content($url)
  {
    return self::get_with_curl($url);
  }

  /*
   * Curl - default method for Remote
   */
  public function get_with_curl($url)
  {
    // create a new cURL resource
    $ch = curl_init();

    // set URL and other appropriate options
    curl_setopt($ch, CURLOPT_URL, $url);
    curl_setopt($ch, CURLOPT_HEADER, 0);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

    // grab URL and pass it to the browser
    $content = curl_exec($ch);

    // close cURL resource, and free up system resources
    curl_close($ch);
    return $content;
  }

  /*
   * file_get_contents use buildin PHP function
   */
  public function get_with_file_get_contents($url)
  {
    return file_get_contents($url);
  }

  /*
   * fopen and fgets functions to read file
   */
  public function get_with_fopen($url)
  {
    $fh = fopen($url, 'rb');
    if (!$fh)
    {
      return '';
    }

    $content = '';
    while (!feof($fh))
    {
      $content .= fgets($fh, 1024);
    }
    fclose($fh);
    return $content;
  }
}

Drugi z plików zapewnia jedynie możliwość wyrzucania wyjątków z klasy Feed.

<?php
/*
 * Feed Exception class
 *
 * @author drymek
 *
 */
class FeedException extends Exception
{
}

Klasa Debug umożliwia wypisywanie informacji kontrolnych podczas pisania kodu:

<?php
/*
 * Simple debug class
 *
 * @author drymek
 *
 */
class Debug
{
  /*
   * Print debug message on default output
   */
  public static function Log($message)
  {
    //Check debug mode
    if (DEBUG)
    {
      echo $message."\n";
    }
  }
}

Klasa Feed! Czyli mięso właściwe. To co pobiera wszystkie informacje, przetwarza je i zapisuje:

<?php
require_once 'Remote.php';        //Read remote files
require_once 'FeedException.php'; //Implementation of Feed Exception
require_once 'Debug.php';         //Debug message

/*
 * Class to convert demotywatory.pl rss
 *
 * @author drymek
 *
 */
class Feed
{
  private
    $url,             //rss.xml file url
    $orginalContent,  //rss.xml file content
    $transformedDom;  //rss.xml file DOMDocument

  /*
   * Set feed url
   */
  public function setUrl($url)
  {
    $this->url = $url;
  }

  /*
   *  Read remote rss file
   */
  public function getOrginalContent()
  {
    if (is_null($this->url))
    {
      throw new FeedException("You have to set url first!");
    }

    $this->orginalContent = Remote::get_remote_file_content($this->url);
    return $this->orginalContent;
  }

  /*
   * Create a DOMDocument from rss.xml file
   */
  public function getDomOrginalContent()
  {
    if (false === $this->orginalContent || is_null($this->orginalContent))
    {
      throw new FeedException("Can not download rss file");
    }

    $domDocument = new DOMDocument();
    $domDocument->loadXML($this->orginalContent);
    return $domDocument;
  }

  /*
   * Get image URL from remote webpage
   */
  public function getImage($item)
  {
    if ('link' == $item->nodeName)
    {
      $htmlContent = Remote::get_remote_file_content($item->nodeValue);
      if (false !== $htmlContent)
      {
        //Search image tag
        $pattern = "/bigurl=\".*\"/";
        preg_match($pattern, $htmlContent, $urls);

        //Finally url to the image
        return substr($urls[0], 8, -1);
      }
      return 'http://demotywatory.pl/res/img/demotywatory-logo.gif';
    }
  }

  /*
   * Set new description for current item
   */
  public function setImage($item)
  {
    //Find element link
    foreach ($item->childNodes as $rssDomItemChild)
    {
      if ('link' == $rssDomItemChild->nodeName)
      {
        //Download demot page
        $url = $this->getImage($rssDomItemChild);
        break;
      }
    }

    //Find element description
    foreach ($item->childNodes as $rssDomItemChild)
    {
      if ('description' == $rssDomItemChild->nodeName)
      {
        $rssDomItemChild->nodeValue = '<img src="'.$url.'">';
        break;
      }
    }
    Debug::Log('Found url: ['.$url.']');
  }

  /*
   * Convert rss.xml to rss.xml with images in description
   */
  public function transform()
  {
    //Get DOMDocument
    $this->transformedDom = $this->getDomOrginalContent();
    //Find all items
    $rssItems = $this->transformedDom->getElementsByTagName('item');

    //Foreach feed
    Debug::Log('Starting retriving feeds');

    foreach ($rssItems as $rssItem)
    {
      //Set image in description for node
      $this->setImage($rssItem);
    }
    Debug::Log('Finished retriving feeds!');
  }

  /*
   * Get transformed XML
   */
  public function getResults()
  {
    return $this->transformedDom->saveXml();
  }

  /*
   * Save results to file (xml)
   */
  public function save($filename)
  {
    Debug::Log('Saving file ('.$filename.')');
    $fh = fopen($filename, 'w');
    if (!$fh)
    {
      throw new FeedException('Can not open file ('.$filename.') to write!');
    }
    fwrite($fh, $this->getResults());
    fclose($fh);
  }
}

I ostatni z plików który wszystko uruchamia:

<?php
define('DEBUG', true);    //Set debug on
require_once 'Feed.php';  //Include Feed class

//Create new Feed instance
$feed = new Feed();
//Set feed url
$feed->setUrl('http://demotywatory.pl/rss.xml');
//Get rss file content
$feed->getOrginalContent();
//Convert to new format
$feed->transform();
//Save to file
$feed->save('result.xml');

Teraz wystarczy umieścić pliki na serwerze lub jeśli takiego nie posiadamy to można skorzytać np. z hostei.com (webhosting umożliwiający otwieranie plikow curl/fopen).
I magia! Mamy rss z obrazkami demotywatorów w wiadomości! (Należy oczywiście odświeżać co jakiś czas nasze domotywatory, jednak użycie crona i wgeta w tej sytuacji jest w 100% wystarczające

Demotywatorator

« Druga część.

Catchable fatal error:
Argument 1 passed to foo() must be an instance of string, string given, called in
/Users/madmatt/Documents/Projects/foobar/

dosyć mocny WTF. Kod, który to powoduje:

function foo(string $s)
{
}
foo("bar");

Próbujemy tutaj ograniczyć przyjmowane argumenty przez funkcję foo do zmiennych typu string. Co ciekawe, to nie bug, tylko feature (lub też brak tegoż feature). Okazuje się, że php tego nie obsługuje. Powie nam to linijka na samym końcu rozdziału o Type Hinting:

Type Hints can only be of the object and array (since PHP 5.1) type. Traditional type hinting with int and string isn’t supported.

Czyli tablice, klasy – tak, podstawowe typy nie?
Too bad, ale z treścią błędu mogli się bardziej postarać. A to jeszcze inny klasyk z PHP:

Parse error: syntax error, unexpected ')', expecting T_PAAMAYIM_NEKUDOTAYIM in
Command line code on line 1

To po hebrajsku. Znacie inne tego typu niespodzianki rodem z PHP?

Na początek stworzymy sobie możliwość wyświetlania pól z profilu użytkownika podczas listowania. Otwieramy generator.yml z modułu sfGuardUser, który w oryginale wygląda tak:

generator:
  class: sfPropelGenerator
  param:
    model_class:           sfGuardUser
    theme:                 admin
    non_verbose_templates: true
    with_show:             false
    singular:              ~
    plural:                ~
    route_prefix:          sf_guard_user
    with_propel_route:     1

    config:
      fields:
        password_again: { label: "Password (again)" }

      list:
        title:   User list
        display: [=username, created_at, last_login]

      form:
        class: sfGuardUserAdminForm
        display:
          "NONE":                   [username, password, password_again]
          "Permissions and groups": [is_active, is_super_admin, sf_guard_user_group_list, sf_guard_user_permission_list]

      edit:
        title: Editing User "%%username%%"

      new:
        title: New User

Interesuje nas dokładnie sekcja

list:
  title:   User list
  display: [=username, created_at, last_login]

Do wyświetlania informacji z pól z profilu użytkownika, będziemy korzystać z możliwości użycia własnych partiali.
Nas interesuje np. imię, nazwisko, oraz adres e-mail użytkownika, dlatego wprowadzamy takie modyfikacje:

list:
  title:   User list
  display: [=username, created_at, last_login, _first_name, _last_name, _email]

Następnie tworzymy 3 pratiale w katalogu sfGuardUser/templates/ :
_first_name.php

<?php echo $sf_guard_user->getProfile()->getFirstName(); ?>

_last_name.php

<?php echo $sf_guard_user->getProfile()->getLastName(); ?>

_email.php

<?php echo $sf_guard_user->getProfile()->getEmail(); ?>

Po tym

symfony cc

I po odświeżeniu strony z listowaniem użytkowników będziemy mieli także informacje o imieniu, nazwisku oraz adresie email.
Wszytko pięknie tylko po takich modyfikacjach nie można sortować po dodanych polach. A to dlatego, że generator podczas tworzenia kodu naszych template’ów sprawdza czy pole które ma być wyświetlone istnieje w modelu.
Dlatego musimy obejść to sprawdzanie poprzez zmodyfikowanie informacji o polach w listowaniu (generator.yml):

list:
  title:   User list
  display: [=username, created_at, last_login, _first_name, _last_name, _email]
  fields:
    last_name:      { is_real: true }
    first_name:     { is_real: true }
    email:          { is_real: true }

Teraz po wyczyszczeniu cache i odświeżeniu strony mamy już możliwość sortowania po polach z profilu.

Jeżeli przejdziecie teraz w środowisko dev zauważycie, że nagle zwiększyła się bardzo ilość zapytań do bazy.
A to ze względu, że dla każdego użytkownika pobierany jest osobno jego profil.
Należałoby to zoptymalizować, aby nie wywoływać niepotrzebnie tylu zapytań. Tutaj natknęliśmy się na kilka problemów, ponieważ klasa sfGuardUserPeer nie posiada metody doSelectJoinsfGuardUserProfile.
Otwieramy plik sfGuardUserPeer.php i wprowadzamy pewne modfikacje:

<?php
class sfGuardUserPeer extends PluginsfGuardUserPeer
{
  public static function doSelectJoinsfGuardUserProfile(Criteria $c, $con = null, $join_behavior = Criteria::LEFT_JOIN)
  {

    foreach (sfMixer::getCallables('BasesfGuardUserPeer:doSelectJoin:doSelectJoin') as $callable)
    {
      call_user_func($callable, 'BasesfGuardUserPeer', $c, $con);
    }

    $c = clone $c;

    if ($c->getDbName() == Propel::getDefaultDB()) {
      $c->setDbName(self::DATABASE_NAME);
    }

    sfGuardUserPeer::addSelectColumns($c);
    $startcol = (sfGuardUserPeer::NUM_COLUMNS - sfGuardUserPeer::NUM_LAZY_LOAD_COLUMNS);
    sfGuardUserProfilePeer::addSelectColumns($c);

    $c->addJoin(array(sfGuardUserPeer::ID,), array(sfGuardUserProfilePeer::USER_ID,), $join_behavior);
    $stmt = BasePeer::doSelect($c, $con);
    $results = array();

    while ($row = $stmt->fetch(PDO::FETCH_NUM)) {
      $key1 = sfGuardUserPeer::getPrimaryKeyHashFromRow($row, 0);
      if (null !== ($obj1 = sfGuardUserPeer::getInstanceFromPool($key1))) {
      } else {

        $omClass = sfGuardUserPeer::getOMClass();

        $cls = substr('.'.$omClass, strrpos('.'.$omClass, '.') + 1);
        $obj1 = new $cls();
        $obj1->hydrate($row);
        sfGuardUserPeer::addInstanceToPool($obj1, $key1);
      }
      $key2 = sfGuardUserProfilePeer::getPrimaryKeyHashFromRow($row, $startcol);
      if ($key2 !== null) {
        $obj2 = sfGuardUserProfilePeer::getInstanceFromPool($key2);
        if (!$obj2) {

          $omClass = sfGuardUserProfilePeer::getOMClass();

          $cls = substr('.'.$omClass, strrpos('.'.$omClass, '.') + 1);
          $obj2 = new $cls();
          $obj2->hydrate($row, $startcol);
          sfGuardUserProfilePeer::addInstanceToPool($obj2, $key2);
        }
        $obj1->setProfile($obj2);

      }
      $results[] = $obj1;
    }
    $stmt->closeCursor();
    return $results;
  }
}

A w pliku sfGuardUser.php, dodajemy funkcję setProfile :

<?php
class sfGuardUser extends PluginsfGuardUser
{
  public function setProfile( $profile )
  {
    $this->profile = $profile;
  }
}

Na koniec musimy tylko zmienić peer_method wywoływaną przez generator do pobierania wyników.
Otwieramy plik sfGuardUser/lib/sfGuardUserGeneratorConfiguration.class.php i dodajemy funkcję getPeerMethod:

<?php

/**
 * sfGuardUser module configuration.
 *
 * @package    sfGuardPlugin
 * @subpackage sfGuardUser
 */
class sfGuardUserGeneratorConfiguration extends BaseSfGuardUserGeneratorConfiguration
{
  public function getPeerMethod()
  {
    return 'doSelectJoinsfGuardUserProfile';
  }
}

Teraz po wyczyszczeniu cache, odświeżeniu strony ilość zapytań do bazy powinna spaść.

Na dzisiaj to tyle. Zostało jeszcze opisanie jak filtrować po polach z profilu użytkownika ale to już innym razem.