• 
  [ZF-6800]: testExceptionClassMap(Zend_Amf_TypeloaderTest)
• 
  [ZF-6799]: testAmf0TypedObjecDeserializedToNativePHPObjectException(Zend_Amf_RequestTest)
• 
  [ZF-6601]: Unable to send ArrayCollection as input argument from flex
• 
  [ZF-5391]: Flash Media Server 3 – Zend Amf
• 
  [ZF-6609]: testInitializationShouldSkipModulesWithoutBootstraps(Zend_Application_Resource_ModulesTest) and testShouldReturnExecutedBootstrapsWhenComplete(Zend_Application_Resource_ModulesTest)
• 
  [ZF-6608]: Problem if /tmp Dir not readable
• 
  [ZF-6770]: Move the Table, Row, & Rowset files for Zend_Db_Table unit tests into the _files directory
• 
  [ZF-6762]: wrong order in PHPDoc of _quoteIdentifierAs()
• 
  [ZF-6662]: misspelling in Zend_Db_Adapter_Abstract: Zend_Db_Statment instead of Zend_Db_Statement
• 
  [ZF-1816]: PostgreSQL: Incorrect sequence name quoting
• 
  [ZF-5342]: Mysqli::__connect() forget to reset internal mysqli _connection object when connection failed
• 
  [ZF-3984]: connection control not sufficient in case of “Too many open links”.
• 
  [ZF-2925]: Problem using join in Zend_Db_Table
• 
  [ZF-5970]: Optimize Zend_Db_Table::find();
• 
  [ZF-4167]: Zend_Db_Table_Row_Abstract does not properly rely on autoloading
• 
  [ZF-3991]: Add possibility to change loader class
• 
  [ZF-2798]: JOIN requires FROM otherwise it acts just like FROM
• 
  [ZF-6780]: Zend_Filter_Input doesn’t collect validation messages for different values in the specified field
• 
  [ZF-6765]: Zend_Filter_Input::_validateRule() iterates through provided fields when it’s not necessary
• 
  [ZF-6761]: Zend_Filter_Input does nothing if field is required and default values are provided for other fields but not for this field.
• 
  [ZF-6711]: Zend_Filter_Input skips ALLOW_EMPTY metacommand processing if rule refers several fields.
• 
  [ZF-6710]: Describe an ability to provide messages array for all specified validator
• 
  [ZF-6709]: Zend_Filter_Input doesn’t process messages -> validators mapping correctly
• 
  [ZF-6708]: Zend_Filter_Input skips ALLOW_EMPTY metacommand processing if any validator is applied to the field
• 
  [ZF-1912]: Message concurrency between options notEmptyMessage and Zend_Validate_Alpha::STRING_EMPTY
• 
  [ZF-6714]: Zend_Decorator not exists.
• 
  [ZF-6607]: Problem with Zend_Soap_Wsdl class loading
• 
  [ZF-3151]: The ZF is not able to use user-defined autoloaders for user-defined classes
• 
  [ZF-2533]: Zend internally doesn’t use user-defined class loader
• 
  [ZF-6619]: Invalid @return value for getLanguage()
• 
  [ZF-6639]: Typo in file arrray (should be array)
• 
  [ZF-6730]: Zend_Service_Amazon_Abstract unit test missing
• 
  [ZF-6669]: Amazon S3 Stream Wrapper – Upload & Uri
• 
  [ZF-6648]: Amazon S3 StreamWrapper – is_dir Funktion
• 
  [ZF-6477]: Zend_Service_Amazon_S3 : Does not work for buckets located in EU
• 
  [ZF-6643]: Signature version should be upgraded ASAP
• 
  [ZF-6483]: Zend_Service_Amazon_Ec2 describe() won’t work for european instances
• 
  [ZF-6072]: $_singleInstances are not cleaned up with namespaceUnset()
• 
  [ZF-2060]: missing method Zend_Session::getOption / getOptions
• 
  [ZF-6417]: Zend_Db_Table createRow() call Zend_Loader::loadClass unconditionally
• 
  [ZF-6016]: Zend_* ignoring my Zend_Loader::registerAutoload()

Download Zend Framework

Related posts:

1. Zend Framework 1.8 Beta 1 disponibile Zend Framework 1.8 Beta 1 is available at: http://framework.zend.com/download/latest Questa...
2. Zend Framework 1.8.1 disponibile Lo Zend Framework Team annuncia l'immediata disponibilità della nuova versione...
3. Creare un progetto Zend Framework 1.8.0 con Zend_Tool e Wamp Server Sono numerose le novità portate dalla nuova versione 1.8.0 di...

Related posts brought to you by Yet Another Related Posts Plugin.

Potete scaricarlo da http://framework.zend.com/download/latest.

Qui di seguito un breve riepilogo:

* Zend_Loader::registerAutoload() now proxies to
Zend_Loader_Autoloader, and marks the instance as a fallback
autoloader. This will ensure equivalent functionality, and reduces
the number of deprecation notices emitted to one.

* Many bugfixes and improvements to Zend_Application.

* Addition of module generation capabilities to Zend_Tool

* Addition of strong object typing capabilities to Zend_Amf

* Many more manual translations!

For a full list of resolved issues, please visit:

http://short.ie/zf1-8-1-issues

Related posts:

1. Zend Framework 1.8.2 disponibile La notizia è di 2 giorni fa, in ogni caso...
2. Zend Framework 1.8 Beta 1 disponibile Zend Framework 1.8 Beta 1 is available at: http://framework.zend.com/download/latest Questa...
3. Rilasciato Zend Framework 1.8.0 E' stata rilasciata oggi la versione definitiva di Zend Framework...

Related posts brought to you by Yet Another Related Posts Plugin.

Per far ciò abbiamo prima la necessità di apportare alcune modifiche al nostro sistema operativo, niente di complicato, solo aggiungere alcune variabili d’ambiente. Ma andiamo con ordine.

Recatevi a questo indirizzo http://framework.zend.com/download/latest e scaricate la versione di zend framework ‘Zend Framework 1.8.0 Minimal’. Create quindi una directory all’interno di Program Files e chiamatela ZendFrameworkCli, dovreste quindi avere il percorso C:\Program Files\ZendFrameworkCli sul vostro computer.

A questo punto estraete le directories ‘bin’ e ‘library’ dall’archivio scaricato all’interno di C:\Program Files\ZendFrameworkCli. Quindi al suo interno dovreste avere ‘bin’ e ‘library’.

A questo punto recatevi su Pannello di Controllo -> Sistema, label ‘Avanzate’, cliccate sul bottone ‘Variabili d’ambiente’. Cercate quindi la voce ‘Path’ sotto il riquadro ‘Variabili di sistema’ ( quello in basso ). Selezionatelo e cliccate ‘Modifica’. Alla fine della stringa aggiungete ‘;C:\Program Files\ZendFrameworkCli\bin’ , mi raccomando al ; iniziale, è importante in quanto serve a terminare l’ultima path precedentemente inclusa da qualche altra installazione.

Se utilizzate php con wampserver avrete la necessità di aggiungere una variabile di sistema per la locazione dell’eseguibile di php. Usando l’ultima versione di wamp server dovreste aggiungere questa ‘;C:\wamp\bin\php\php5.2.9-2′ ovviamente vi consiglio di controllare se php.exe si trova effettivamente in quella posizione nel vostro computer.

Quindi Riavviate, le nuove modifiche saranno attive.

A questo punto andate su start -> esegui, inserite cmd e date invio: se tutto ha funzionato come si deve, scrivendo ‘zf show version’ vi dovrebbe essere restituito ‘Zend Framework Version: 1.8.0′.

Possiamo quindi creare il nostro progetto, date il comando ‘zf create project zfproject’, dove ‘zfproject’ sarà il nome della directory in cui il vostro progetto sarà creato, potete sostituirlo con quello che volete. Appena il comando avrà terminato di creare il progetto vi comunicherà dove questo è stato salvato, di default all’interno dela vostra cartella documenti.

Per comodità ho preferito spostare la directory creata da Zend_Tool su C:/wamp/ ( o comunque una directory superiore a www ). All’interno della directory contenente il progetto creato abbiamo la cartella ‘public’. Questa sarà da rinominare a vostro piacimento ed inserire nella parte pubblica del vostro webserver.

Se lo ritenete opportuno potete creare un virtual host per la vostra applicazione di prova con zf1.8.0, come spiegato in .

Problemi riscontrati

Ho incontrato qualche problema nel file index.php pubblico creato da zend tool, le costanti generate tramite l’utilizzo della funzione realpath risultavano stranamente vuote, ho apportato quindi alcune modifiche al file, che posto qui di seguito:

  // Define container to application directory
  defined('DS')
      || define('DS',
                (DIRECTORY_SEPARATOR ? DIRECTORY_SEPARATOR
                                           : '/'));   

  // Define container to application directory
  defined('CONTAINER_DIR')
      || define('CONTAINER_DIR',
                (getenv('CONTAINER_DIR') ? getenv('CONTAINER_DIR')
                                           : 'zend'));  

  // Define application directory
  defined('APPLICATION_DIR')
      || define('APPLICATION_DIR',
                (getenv('APPLICATION_DIR') ? getenv('APPLICATION_DIR')
                                           : 'application'));

  // Define library directory
  defined('LIBRARY_DIR')
      || define('LIBRARY_DIR',
                (getenv('LIBRARY_DIR') ? getenv('LIBRARY_DIR')
                                           : 'library'));

  // Define condiguration directory
  defined('CONFIGS_DIR')
      || define('CONFIGS_DIR',
                (getenv('CONFIGS_DIR') ? getenv('CONFIGS_DIR')
                                           : 'configs'));

  // Define path to application directory
  defined('APPLICATION_PATH')
      || define('APPLICATION_PATH',
                dirname(dirname(dirname(__FILE__))).DS.CONTAINER_DIR.DS.APPLICATION_DIR.DS);

  // Define path to library directory
  defined('LIBRARY_PATH')
      || define('LIBRARY_PATH',
                dirname(APPLICATION_PATH).DS.LIBRARY_DIR.DS);

  // Define path to library directory
  defined('CONFIGS_PATH')
      || define('CONFIGS_PATH',
                APPLICATION_PATH.CONFIGS_DIR.DS);

  // Define application environment
  defined('APPLICATION_ENV')
      || define('APPLICATION_ENV',
                (getenv('APPLICATION_ENV') ? getenv('APPLICATION_ENV')
                                           : 'production'));

  // Typically, you will also want to add your library/ directory
  // to the include_path, particularly if it contains your ZF install
  set_include_path(implode(PATH_SEPARATOR, array(
      LIBRARY_PATH,
      get_include_path(),
  )));

  //echo get_include_path();
  //exit;

  /** Zend_Application */
  require_once 'Zend/Application.php';

  // Create application, bootstrap, and run
  $application = new Zend_Application(
      APPLICATION_ENV,
      CONFIGS_PATH.'application.ini'
  );

  $application->bootstrap()
              ->run();

Alcune costanti come potete vedere, prendono un valore se lo trovano all’interno dell’htaccess, altrimenti ne utilizzano uno di default. Le uniche due costanti che hanno la necessità di essere specificate sono:

SetEnv APPLICATION_ENV development
SetEnv CONTAINER_DIR zfproject

Le linee di codice qui sopra dovranno essere inserite in cima all’.htaccess.

Richiamando l’indirizzo locale dove avete inserito la parte pubblica ( o richiamando il vhost creato ), otterrete il seguente risultato

Related posts:

1. Zend Framework 1.8.2 disponibile La notizia è di 2 giorni fa, in ogni caso...
2. Zend Framework 1.8.1 disponibile Lo Zend Framework Team annuncia l'immediata disponibilità della nuova versione...

Related posts brought to you by Yet Another Related Posts Plugin.

* Zend_Tool, contributed by Ralph Schindler
* Zend_Application, contributed by Ben Scholzen and
Matthew Weier O’Phinney
* Zend_Loader_Autoloader and Zend_Loader_Autoloader_Resource,
contributed by Matthew Weier O’Phinney
* Zend_Navigation, contributed by Robin Skoglund
* Zend_CodeGenerator, by Ralph Schindler
* Zend_Reflection, Ralph Schindler and Matthew Weier O’Phinney
* Zend Server backend for Zend_Cache, contributed by
Alexander Veremyev
* Zend_Service_Amazon_Ec2, contributed by Jon Whitcraft
* Zend_Service_Amazon_S3, Justin Plock and Stas Malyshev
* Incorporated Dojo 1.3
* Added support for arbitrary Dojo Dijits via view helpers
* Zend_Filter_Encrypt, contributed by Thomas Weidner
* Zend_Filter_Decrypt, contributed by Thomas Weidner
* Zend_Filter_LocalizedToNormalized and _NormalizedToLocalized,
contributed by Thomas Weidner
* Support for file upload progress support in Zend_File_Transfer,
contributed by Thomas Weidner
* Translation-aware routes, contributed by Ben Scholzen
* Route chaining capabilities, contributed by Ben Scholzen
* Zend_Json expression support, contributed by Benjamin Eberlei and
Oscar Reales
* Zend_Http_Client_Adapter_Curl, contributed by Benjamin Eberlei
* SOAP input and output header support, contributed by
Alexander Veremyev
* Support for keyword field search using query strings, contributed by
Alexander Veremyev
* Support for searching across multiple indexes in Zend_Search_Lucene,
contributed by Alexander Veremyev
* Significant improvements for Zend_Search_Lucene search result match
highlighting capabilities, contributed by Alexander Veremyev
* Support for page scaling, shifting and skewing in Zend_Pdf,
contributed by Alexander Veremyev
* Zend_Tag_Cloud, contributed by Ben Scholzen
* Locale support in Zend_Validate_Int and Zend_Validate_Float,
contributed by Thomas Weidner
* Phonecode support in Zend_Locale, contributed by Thomas Weidner
* Zend_Validate_Db_RecordExists and _RecordNotExists, contributed by
Ryan Mauger
* Zend_Validate_Iban, contributed by Thomas Weidner
* Zend_Validate_File_WordCount, contributed by Thomas Weidner

Potete scaricarlko da http://framework.zend.com/download/latest

Related posts:

1. Zend Framework 1.8 Beta 1 disponibile Zend Framework 1.8 Beta 1 is available at: http://framework.zend.com/download/latest Questa...
2. Zend Framework 1.8.1 disponibile Lo Zend Framework Team annuncia l'immediata disponibilità della nuova versione...
3. Zend Framework 1.8.2 disponibile La notizia è di 2 giorni fa, in ogni caso...

Related posts brought to you by Yet Another Related Posts Plugin.

Se avete seguito questo articolo o comunque state lavorando con un’applicazione fatta con Zend Framework che utilizzi il componente Zend_Search_Lucene, potrebbe essere di grande utilità comprendere esattamente cosa include il vostro Search Index.

A questo scopo vi presento un’utilissima applicazione, Luke, un browser per l’indice di Lucene, che potete recuperare da http://www.getopt.org/luke/ o direttamente da qui (NOTA: richiede Java 1.5 o successivo )

Lo screenshot di sopra rappresenta la schermata iniziale, dove vi sarà richiesto di inserire il percorso dove l’indice di Lucene è salvato. Una volta inserito, vi si presenterà la seguente schermata:

Utilizzo

Vi illustrerò brevemente alcuni possibili utilizzi. Cliccando su un termine rappresentante un campo del vostro indice ( la griglia in basso a sinistra ) e cliccando successivamente il tasto ‘Show top terms’, la griglia alla vostra destra visualizzerà esclusivamente il contenuto del campo selezionato per ogni record, vedi screenshot:

Selezionando la tab ‘Documents’ potrete vedere in dettaglio il contenuto dei vostri documenti ed il tipo di indicizzazione usato. Tramite la tab ‘Search’ potrete effettuare le ricerche, che presumibilmente daranno lo stesso risultato della vostra applicazione.

Related posts:

1. Zend Framework: gestione dei moduli ed esempio modulo di amministrazione Come usare Zend_Layout per la gestione dei moduli In quest'articolo...

Related posts brought to you by Yet Another Related Posts Plugin.

http://framework.zend.com/download/latest

Questa nuova versione è comunque ancora in beta, alcuni bug potrebbero presentarsi ed alcuni problemi sono presenti, quindi il team di Zend Framework ne sconsiglia l’utilizzo in produzione.

Numerosi sono i componenti aggiunti e migliorati in questa versione, ecco il listato completo qui di seguito:

* Zend_Tool, contributed by Ralph Schindler

* Zend_Application, contributed by Ben Scholzen and
Matthew Weier O’Phinney

* Zend_Loader_Autoloader and Zend_Loader_Autoloader_Resource,
contributed by Matthew Weier O’Phinney

* Zend_Navigation, contributed by Robin Skoglund

* Zend_CodeGenerator, by Ralph Schindler

* Zend_Reflection, Ralph Schindler and Matthew Weier O’Phinney

* Zend Server backend for Zend_Cache, contributed by Alexander Veremyev

* Zend_Service_Amazon_Ec2, contributed by Jon Whitcraft

* Zend_Service_Amazon_S3, Justin Plock and Stas Malyshev

* Zend_Filter_Encrypt, contributed by Thomas Weidner

* Zend_Filter_Decrypt, contributed by Thomas Weidner

* Support for file upload progress support in Zend_File_Transfer,
contributed by Thomas Weidner

* Translation-aware routes, contributed by Ben Scholzen

* Zend_Json expression support, contributed by Benjamin Eberlei and
Oscar Reales

* Zend_Http_Client_Adapter_Curl, contributed by Benjamin Eberlei

* SOAP input and output header support, contributed by Alexander
Veremyev

* Support for keyword field search using query strings,
contributed by Alexander Veremyev

* Support for searching across multiple indexes in Zend_Search_Lucene,
contributed by Alexander Veremyev

* Support for page scaling, shifting and skewing in Zend_Pdf,
contributed by Alexander Veremyev

* Locale support in Zend_Validate_Int and Zend_Validate_Float,
contributed by Thomas Weidner

* Phonecode support in Zend_Locale, contributed by Thomas Weidner

* Zend_Validate_Iban, contributed by Thomas Weidner

* Zend_Validate_File_WordCount, contributed by Thomas Weidner

* Zend_Validate_LocalizedToNormalized and NormalizedToLocalized,
contributed by Thomas Weidner

* Zend_Validate_Db_RecordExists and NoRecordExists, contributed
by Ryan Mauger

* Zend_Tag_Cloud, contributed by Ben Scholzen

La versione 1.8.0 definitiva dovrebbe vedere la luce la prossima settimana.

Related posts:

1. Rilasciato Zend Framework 1.8.0 E' stata rilasciata oggi la versione definitiva di Zend Framework...
2. Zend Framework 1.8.1 disponibile Lo Zend Framework Team annuncia l'immediata disponibilità della nuova versione...
3. Zend Framework 1.8.2 disponibile La notizia è di 2 giorni fa, in ogni caso...

Related posts brought to you by Yet Another Related Posts Plugin.

Oggi vedremo come creare una sitemap in xml usando l’oggetto Php SimpleXML. Per chi non lo conoscesse SimpleXML è una classe built in del linguaggio Php dalla versione 5 e per chi invece leggerà queste righe perchè cercava quale utilità ha o che cos’è una sitemap, possiamo dire che è un file XML dove sono listate tutte le url del nostro sito, utile ai motori di ricerca come Google, Yahoo, MSN ecc.. al fine dell’indicizzazione.

Grazie a SimpleXML leggere e scrivere file XML con php è veramente uno scherzo, in quanto sono necessarie poche righe di codice per fare tutto ciò di cui abbiamo bisogno. In questo tutorial costruiremo da zero una classe, che chiameremo Sitemap, che ci permetterà di fare tutto quello di cui abbiamo bisogno in maniera ordinata e semplice.

Il protocollo di Google

Visitando questa pagina possiamo vedere come deve essere costruito il file xml per rispettare il protocollo di google, qui di seguito brevemente riassunto

Sitemap.php

// Il file deve iniziare con questa linea
<?xml version="1.0" encoding="UTF-8"?>

// Deve contenere il tag urlset, che conterra al suo interno le varie url
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">

// Un esempio di url, loc è richiesto, il resto è opzionale
<url>
    <loc>http://www.example.com/</loc>
    <lastmod>2005-01-01</lastmod>
    <changefreq>monthly</changefreq>
    <priority>0.8</priority>
</url> 

// Chiusura del tag urlset
</urlset>

Il listato della classe Sitemap.php

  class Sitemap
  {
    private $xml;
    private $sitemap;

    public function __construct(){
      $this->sitemap = 'percorso_fisico_alla_sitemap/sitemap.xml';
      $this->xml = $this->read($this->sitemap);
    }

    function read($file){
      if (file_exists($file)){
        try{
          return simplexml_load_file($file);
        }catch (Exception $e){
          throw new Exception("Errore nel caricamento del file");
        }
      }else{
        throw new Exception("File xml inesistente");
      }
    }

    function add($data){
      try{
        $node = $this->xml->addChild("url");
        $node->addChild("loc", $data['loc']);
        $node->addChild("lastmod", $this->datetime(isset($data['date']) && !empty($data['date']) && trim($data['date']) != '' ? $data['date'] : NULL));
        $node->addChild("changefreq", $data['changefreq']);
        $node->addChild("priority", $data['priority']);
      }catch(Exception $e){
        throw new Exception("Errore in add... i dati erano un array?");
      }
    }

    function get($couple){
      foreach($this->xml->url as $node){
        if ($node->$couple['node'] == $couple['value']){
          return $node;
        }
      }
      return NULL;
    }

    function edit($couple, $data){
      $node = $this->get($couple);
      $node->loc = $data['loc'];
      $node->lastmod = $this->datetime(isset($data['date']) && !empty($data['date']) ? $data['date'] : NULL);
      $node->changefreq = $data['changefreq'];
      $node->priority = $data['priority'];
    }

    function timestamp($data){
      try{
        $data = explode(" ", $data);
        list($y, $m, $d) = explode("-", trim($data[0]));
        list($h, $mi, $sc) = explode(":", trim($data[1]));
        return mktime($h,$mi,$sc,$d,$m,$y);
      }catch(error $e){
        throw new Exception("Errore in timestamp");
      }
    }

    function datetime($date = NULL){
      try{
        $mktime = $date === NULL && empty($date) ? mktime(date("H"), date("i"), date("s"), date("m"), date("d"), date("Y")) : $this->timestamp($date);
        //return date(DATE_ATOM,$mktime);
        $offset = date("O",$mktime);
        return date("Y-m-d\TH:i:s",$mktime).substr($offset,0,3).":".substr($offset,-2);
      }catch(Exception $e){
        throw new Exception("Errore in datetime");
      }
    }

    function save(){
      //file_put_contents($this->sitemap, $this->xml->asXML());
      $this->xml->asXML($this->sitemap);
    }

    function delete($couple){
      $node = $this->get($couple);
      if ($node != NULL){
        unset($node[0][0]);
      }
    }

    function erase(){
      unset($this->xml->url);
    }
  }
  

La classe possiede due proprietà private, $xml e $sitemap, che conterranno rispettivamente l’oggetto SimpleXML e la path fisica, completa di nome, della nostra sitemap. Alla sitemap dovranno essere impostati i permessi di scrittura. Vediamo qui di seguito una veloce spiegazione di ogni metodo.

Il Costruttore

    public function __construct(){
      $this->sitemap = 'percorso_fisico_alla_sitemap/sitemap.xml';
      $this->xml = $this->read($this->sitemap);
    }

Il costruttore si occupa di attribuire i valori alle proprietà private, quindi istanzia SimpleXML tramite la chiamata al metodo read().

Il metodo read()

    function read($file){
      if (file_exists($file)){
        try{
          return simplexml_load_file($file);
        }catch (Exception $e){
          throw new Exception("Errore nel caricamento del file");
        }
      }else{
        throw new Exception("File xml inesistente");
      }
    }

Questo metodo prova a creare l’oggetto SimpleXML tramire la chiamata alla funzione simplexml_load_file() a cui viene passato come argomento il file da leggere. Se la lettura ha successo ritorna l’oggetto SimpleXML.

Il metodo add()

    function add($data){
      try{
        $node = $this->xml->addChild("url");
        $node->addChild("loc", $data['loc']);
        $node->addChild("lastmod", $this->datetime(isset($data['date']) && !empty($data['date']) && trim($data['date']) != '' ? $data['date'] : NULL));
        $node->addChild("changefreq", $data['changefreq']);
        $node->addChild("priority", $data['priority']);
      }catch(Exception $e){
        throw new Exception("Errore in add... i dati erano un array?");
      }
    }

Add() aggiunge un nodo url alla urlset. L’argomento da passare ad add() è un array che deve contenere necessariamente le chiavi ‘loc’, ‘changefreq’ e ‘priority’. Può contenere anche la chiave ‘date’ ( che diverrà il valore di ‘lastmod’), omettendolo il valore di ‘lastmod’ equivarrà alla data attuale.

Il metodo get()

    function get($couple){
      foreach($this->xml->url as $node){
        if ($node->$couple['node'] == $couple['value']){
          return $node;
        }
      }
      return NULL;
    }

Get() è un metodo utile alla ricerca di un nodo. Particolare ( credo ) il fatto di passare ad argomento un array che deve contenere la chiavi ‘node’ e ‘value’: il valore di ‘node’ sarà uno dei nodi contenuti in url ( quindi loc, lastmod, changefreq o priority ), ‘value’ sarà il valore da ricercare. Da sottolineare che il nodo ritornato è esclusivamente il primo trovato.

Il metodo edit()

    function edit($couple, $data){
      $node = $this->get($couple);
      $node->loc = $data['loc'];
      $node->lastmod = $this->datetime(isset($data['date']) && !empty($data['date']) ? $data['date'] : NULL);
      $node->changefreq = $data['changefreq'];
      $node->priority = $data['priority'];
    }

Edit() modifica i valori di un nodo esistente. Internamente utilizza il metodo get() per trovare il nodo da modificare. Gli argomenti da passare sono l’array per la ricerca e l’array con i dati che andranno a sostituirsi nel nodo trovato.

Il metodo timestamp()

    function timestamp($data){
      try{
        $data = explode(" ", $data);
        list($y, $m, $d) = explode("-", trim($data[0]));
        list($h, $mi, $sc) = explode(":", trim($data[1]));
        return mktime($h,$mi,$sc,$d,$m,$y);
      }catch(error $e){
        throw new Exception("Errore in timestamp");
      }
    }

Timestamp è più che altro una utility, ritorna un timestamp da una data passata in formato dd/mm/yyyy hh/MM/ss. E’ utilizzata in datetime()

Il metodo datetime()

    function datetime($date = NULL){
      try{
        $mktime = $date === NULL && empty($date) ? mktime(date("H"), date("i"), date("s"), date("m"), date("d"), date("Y")) : $this->timestamp($date);
        //return date(DATE_ATOM,$mktime);
        $offset = date("O",$mktime);
        return date("Y-m-d\TH:i:s",$mktime).substr($offset,0,3).":".substr($offset,-2);
      }catch(Exception $e){
        throw new Exception("Errore in datetime");
      }
    }

Datetime() ritorna il corretto formato data da inserire nella sitemap rispetto al protocollo. Da notare che la riga commentata (return date(DATE_ATOM,$mktime);) è un metodo alternativo che ritorna lo stesso risultato delle 2 successive.

Il metodo save()

    function save(){
      //file_put_contents($this->sitemap, $this->xml->asXML());
      $this->xml->asXML($this->sitemap);
    }

Save() salva le modifiche effettuate alla sitemap. La riga commentata è un metodo alternativo per salvare.

Il metodo delete()

    function delete($couple){
      $node = $this->get($couple);
      if ($node != NULL){
        unset($node[0][0]);
      }
    }

Delete() elimina il nodo trovato. L’oggetto SimpleXML non possiede un metodo nativo per eliminare un nodo, a questo scopo utilizziamo la funzione unset() di php. Delete utilizza internamente get(), quindi per eliminare un nodo bisogna passare l’array utile alla sua ricerca.

Il metodo erase()

    function erase(){
      unset($this->xml->url);
    }

Erase() elimina tutte le url della urlset. Utile per la reindicizzazione di tutte le url.

Esempio di utilizzo

Utilizare la classe è semplice, la si istanzia, si effettuano le varie modifiche, quindi si chiama il metodo save().

  // Istanziare la classe
  $map = new Sitemap();

  // esempi di aggiunta nodi
  $map->add(array(
    'loc'=>'http://www.miosito.com/uno/',
    'changefreq'=>'monthly',
    'priority'=>'0.2'
  ));
  $map->add(array(
    'loc'=>'http://www.miosito.com/due/',
    'changefreq'=>'monthly',
    'priority'=>'0.2'
  ));

  // Esempio di eliminazione nodo
  $map->delete(array('node'=>'loc','value'=>'http://www.miosito.com/uno/'));

  // Salviamo la sitemap. Da chiamare dopo aver effettuato le modifiche
  $map->save();

Si conclude qui il tutorial, spero che sia utile a qualcuno, mi raccomando i commenti

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

A questo scopo utilizzeremo, come potete immaginare la funzione header, ma prima di effettuare la redirezione vera e propria comunicheremo al client che si tratta di un codice 301, ovvero pagina trasferita in modo permanente ( Header 301 Redirect – Moved Permanently ), in questo modo:

$location = // il vostro codice per ricavare l'indirizzo di destinazione
header ('HTTP/1.1 301 Moved Permanently');
header ('Location: '.$location);

Si conclude qui questo breve articolo, probabilmente potrà tornare utile a molti.

Related posts:

1. PHP Warning: Cannot modify header information – headers already sent Eliminare per sempre questo errore dai vostri script. Uno degli...

Related posts brought to you by Yet Another Related Posts Plugin.

In quest’articolo vedremo come gestire differenti moduli con Zend Framework oltre a quello di default per creare, per esempio, un modulo di amministrazione.

A titolo riassuntivo, ecco un elenco di cosa abbiamo già visto di Zend Framework:

• Introduzione a Zend Framework con esempio pratico minimalista di utilizzo
• Configurazione Avanzata
• Two Step View per la gestione dei layouts
• Implementazione di un layout complesso per la gestione dei layouts
• Gestione dei modelli ed interazione con database
• Gestione delle richieste asincrone ( Ajax ) aiutandoci con l’utilizzo di jQuery
• Gestione del database
• Database e reference map
• Autenticazione con Zend_Auth
• Autorizzazione con Zend_Acl con esempio integrato al database
• Zend Framework e Zend_Search_Lucene motore di ricerca interno
• Zend Framework e Zend_Mail con esempio di invio email
• Zend Lucene e UTF8 con esempio di applicazione scaricabile
• Zend_Log e gestione errore 404
• Zend Framework Bootstrap Object Oriented
• Form Con Zend_Form
• Il componente Recapcha per la sicurezza dei form

Per la comprensione di questo articolo consiglio prima di leggere gli articoli a proposito della gestione di un bootstrap object oriented ma ancora prima della gestione dei layouts con Zend_Layout e two step view.

Il modulo default

Per convenzione, il modulo di default utilizzato dalla vostra applicazione sviluppata con Zend Framework si chiama, non a caso, default. Che significa questo? Immaginiamo che voi abbiate un controller chiamato ’search’ all’interno della vostra applicazione, una chiamata al suddetto controller potrebbe essere effettuata tramite la url ‘http://www.miosito.xx/search’. Non abbiamo specificato nessun modulo, quindi, per convenzione, è come se avessimo chiamato default. Infatti, possiamo ottenere lo stesso risultato richiamando la url ‘http://www.miosito.xx/default/search’.

Allo stesso modo, creando una directory chiamata ‘default’ all’interno della directory ‘application’ ed inserendo tutto il contenuto della seconda nella prima ( tranne che il file bootstrap.php ) tutto continuerebbe a funzionare.

Creiamo il modulo di amministrazione

Non è strettamente necessario, ma siccome non ho scoperto nessun genere di controindicazione ed aiuta a dare all’albero dell’applicazione quel pizzico di ordine aggiuntivo, creiamo all’interno di ‘application’ la directory ‘default’ ed inseriamo ‘controllers’, ‘models’ e ‘views’ all’interno di essa. Creiamo all’interno di ‘application’ la directory ‘admin’ ed al suo interno le 3 directories ‘controllers’, ‘models’ e ‘views’.

Il nuovo albero dell’applicazione dovrebbe risultare quindi come il seguente:

• la_mia_applicazione
  • application
    • default
      • controllers
      • models
      • views
        • scripts
          • index
          • error
        • layouts
        • filters
        • helpers
    • admin
      • controllers
      • models
      • views
        • scripts
          • index
        • layouts
        • filters
        • helpers
  • db
  • library
    • Zend
  • tests
    • controllers
    • models
• web_root (www)
  • css
  • img
  • js

Rendere operativo il nuovo modulo

Attualmente il nostro modulo di amministrazione non è nient’altro che una directory all’interno del nostro albero dell’applicazione, e non abbiamo ancora provveduto ad effettuare nessuna modifica al codice per ‘dire’ a Zend Framework che, quando il modulo richiamato è ‘admin’, di andarsi a leggere il contenuto di admin e non di default.

Questo è proprio il nostro problema attuale: dobbiamo riuscire a recuperare il nome del modulo richiesto prima che Zend_Layout lo renderizzi. Per questo scopo creeremo il plugin library/MiaApplicazione/Layout/Controller/Plugin/Layout.php

  class MiaApplicazione_Layout_Controller_Plugin_Layout extends Zend_Layout_Controller_Plugin_Layout
  {
    public function preDispatch(Zend_Controller_Request_Abstract $request){
      switch ($request->getModuleName()){
        case 'admin':
          $this->_moduleChange('admin');
        }
      }

    protected function _moduleChange($moduleName){
      $basePath = dirname(dirname(dirname($this->getLayout()->getLayoutPath())));
      $this->getLayout()->setLayoutPath($basePath.DIRECTORY_SEPARATOR.$moduleName.'/views/layout');
      $this->getLayout()->setLayout($moduleName);
    }
  }

Il passo successivo è rendere operativo questo plugin. Per far ciò dobbiamo modificare il bootstrap modificando l’array passato ad argomento alla chiamata di Zend_Layout::startMvc.

    public static function setupView(){
      $view = new Zend_View;
      $view->setEncoding('UTF-8');
      $viewRenderer = new Zend_Controller_Action_Helper_ViewRenderer($view);
      Zend_Controller_Action_HelperBroker::addHelper($viewRenderer);
      Zend_Layout::startMvc(
        array(
          'layoutPath' => ROOT_DIR.'/application/default/views/layouts',
          'layout' => 'layout',
          'pluginClass' => 'MiaApplicazione_Layout_Controller_Plugin_Layout'
        )
      );
    }

Inoltre dovremo apportare la seguente modifica al metodo setupFrontController per quanto riguarda l’assegnazione della directory dei controllers:

    public static function setupFrontController(){
      self::$frontController = Zend_Controller_Front::getInstance();
      self::$frontController->throwExceptions((bool)self::$registry->config->front->throwExceptions);
      self::$frontController->returnResponse((bool)self::$registry->config->front->returnResponse);
      self::$frontController->registerPlugin(new Zend_Controller_Plugin_ErrorHandler());
      self::$frontController->setControllerDirectory(
        array(
          'default' => ROOT_DIR.'/application/default/controllers',
          'admin' => ROOT_DIR.'/application/admin/controllers'
        )
      );
    }

Il layout di amministrazione

Creiamo il file admin.phtml, che sarà il layout del modulo di amministrazione. Questo file dovrà trovarsi all’interno di application/admin/views/layout.

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
      "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
  <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="it" lang="it">
    <head>
      <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
      <title>Amministrazione <?php echo $this->escape($this->pageTitle); ?></title>
    </head>
  <body>
    <!-- start container -->
    <div id="container">

      <!-- start subContainer -->
      <div id="subContainer">

        <!-- start header -->
        <div id="header"><?php //echo $this->layout()->header;?></div>
        <!-- end header -->

        <!-- start content -->
        <div id="content"><?php echo $this->layout()->content;?></div>
        <!-- end content -->

        <!-- start footer -->
        <div id="footer"><?php //echo $this->layout()->footer;?></div>
        <!-- end footer -->

      </div>
      <!-- end subContainer -->

    </div>
    <!-- end container -->
  </body>
</html>

Infine avremo bisogno del file della view index.phtml che dovrà trovarsi all’interno di admin/views/script/index.

<h2>Modulo di amministrazione</h2>

Fatto ciò siete pronti per richiamare la url ‘http://www.miosito.xx/admin/’ e contemplare il risultato del vostro lavoro.

Riferimenti

blog.astrumfutura.com

Related posts:

1. Neobazaar annunci gratuiti: esempio di una applicazione sviluppata con Zend Framework Nasce Neobazaar.com, annunci gratuiti in Italia: interamente sviluppato con Zend...
2. Zend Framework 1.8.2 disponibile La notizia è di 2 giorni fa, in ogni caso...
3. Zend Framework: Zend_Form con ReCaptcha Utilizzare il webservice ReCaptcha per validare i form ReCaptcha è...

Related posts brought to you by Yet Another Related Posts Plugin.

PHPMailer è un’utilissima classe che rende l’invio di email con PHP davvero semplice. Potete scaricare gratuitamente questa classe dal sito http://phpmailer.codeworxtech.com/ o scaricarla direttamente da sourceforge.

Per poter utilizzare PHPMailer dovrete scompattare il contenuto dell’archivio scaricato ed inserire la directory ‘phpmailer’ ( restituita dopo la scompattazione ) all’interno del vostro progetto. Quindi, per utilizzarla nel vostro script, dovrete istanziare PHPMailer in questo modo:

<?php
require("class.phpmailer.php");
$mail = new PHPMailer();
?>

Provate a richiamare il vostro script contenente queste sole righe di codice, se non ottenete nessun errore la classe è stata correttamente installata ed istanziata e il nuovo oggetto $mail è pronto per essere utilizzato.

Tramite PHPMailer possiamo inviare email usando Sendmail ( solo su ambienti unix, corrisponde all’uso della funzione buil in mail() ), SMTP E qmail. Nel seguente esempio vedremo come inviare utilizzando SMTP, quello di cui avremo bisogno quindi sarà un account email valido. Se possedete un dominio di primo livello con la possibilità di creare account email vi consiglio di farlo, in caso contrario ( per esempio nel caso voleste inviare email lavorando in locale ) potreste utilizzare un account email free.

require("class.phpmailer.php");

$mail = new PHPMailer();

$mail->IsSMTP();  // diciamo alla classe di usare SMTP
$mail->Host     = "smtp.example.com"; // SMTP server, questo valore è da modificare!

$mail->From     = "from@example.com"; // L'account email che state utilizzando
$mail->AddAddress("myfriend@example.net"); // L'indirizzo email di destinazione

$mail->Subject  = "First PHPMailer Message"; // L'oggetto della email
$mail->Body     = "Hi! \n\n This is my first e-mail sent through PHPMailer."; // Il corpo del messaggio
$mail->WordWrap = 50;

if(!$mail->Send()) {
  echo 'Message was not sent.';
  echo 'Mailer error: ' . $mail->ErrorInfo;
} else {
  echo 'Message has been sent.';
}

Inviare email con allegati

Basicamente esistono due possibilità per inviare un allegato

• Specificando un file da un percorso fisico
• Inserendo l’allegato in formato binario in una variabile

L’invio di un allegato, grazie a PHPMailer, si riduce all’inserimento si una semplice linea di codice:

$mail->AddAttachment($path,$name,$encoding,$type);

Questa dovrà essere inserita dopo aver instanziato la classe ed ovviamente prima di aver inviato la mail tramite il metodo send().

AddAttachment ha un unico parametro obbligatorio, $path, parametro che dovrà equivalere al percorso fisico del file da inviare come allegato.

Gli altri parametri non sono obbligatori, ma vediamo nel dettaglio a che cose servono.

• $name: è il nome che vogliamo attribuire all’allegato. L’utente destinatario visualizzerà questo nome come nome dell’allegato in alternativa al nome d’origine.
• $encoding: questo parametro è decisamente più tecnico, di default è base64, ma può assumere i valori di 7bit, 8bit, binary & quoted-printable. Se specificheremo un valore che il mailserver non può gestire, questo convertirà l’encoding passato a parametro con un encoding gestibile.
• $type: questo parametro corrisponde al MIME type per il file allegato, ovvero determina il tipo del file ( se è una immagine JPG, GIF o se è un file audio MP3, WAV o quant’altro ). Il valore di default, valido per qualsiasi genere di file è application/octet-stream.

Inviare email in formato HTML

PHPMailer ci da la possibilità di inviare email usando il formato HTML in maniera estremamente semplice. Basterà inserire, anche in questo caso, una semplice linea di codice, prima della chiamata a send():

$mail->IsHTML(true);

Il codice HTML della email dovrà essere specificato per il body:

$mail->Body = "Hello, my friend! \n\n This message uses HTML entities!";

PHPMailer ci offre alcune altre possibilità avanzate per la gestione degli allegati ( per esempio inline attachment ), potete leggere di più a riguardo nella documentazione ufficiale.

Estendere PHPMailer

Nel caso aveste bisogno di inviare email in più parti della vostra applicazione, senza dover specificare ogni volta i parametri di connessione all’account SMTP, la soluzione è estendere la classe.

require("class.phpmailer.php");

class MyMailer extends PHPMailer {
    // Set default variables for all new objects
    var $From     = "from@email.com";
    var $FromName = "Mailer";
    var $Host     = "smtp1.site.com;smtp2.site.com";
    var $Mailer   = "smtp";                         // Alternative to IsSMTP()
    var $WordWrap = 75;
}

Fatto ciò, bisognerà fare attenzione ad utilizzare istanze della nuova classe creata e non direttamente di PHPMailer, come nel seguente esempio

$mail = new MyMailer();

$mail, istanza di MyMailer, conterrà al suo interno già tutte le variabili di configurazione, quindi non ci resterà che inserire destinatari, eventualmente degli allegati ed inviare.

Per saperne di più potete consultare questo link al sito del produttore.

Note: There is a rating embedded within this post, please visit this post to rate it.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.