Vite fait, le schéma utilisé :

...
Region:
  tableName:  region
  actAs:
    Sluggable:
      unique: true
      fields: [nom]
  columns:
    id:       { type: integer(4), unsigned: true, primary: true, autoincrement: true }
    nom:      { type: string(255), notnull: true }
 
Departement:
  tableName: departement
  actAs:
    Sluggable:
      unique: true
      fields: [nom]
  columns:
    id:        { type: integer(4), unsigned: true, primary: true, autoincrement: true }
    nom:       { type: string(255), notnull: true }
    region_id: { type: integer(4), unsigned: true }
  relations:
    Region:
      local:        region_id
      foreign:      id
      foreignAlias: Departements
      onDelete:     CASCADE
...

Juste pour mettre en évidence la relation entre le Département et la Région, avec le très important le foreignAlias que j’aime tant

Pour faire fonctionner tout ça on va avoir besoin de :
– 1 route
– 1 action minuscule
– 1 partial de 4 lignes
– 1 tout petit bout de javascript

La route :

# routing.yml
...
ajax_departement:
  url:   /ajax/departement
  param: { module: lambda, action: ajaxDepartement }
...

L’action :

// actions.class.php
 
  /**
   * requete ajax pour avoir la liste des déparements de la région
   *
   * @param sfWebRequest $request
   */
  public function executeAjaxDepartement(sfWebRequest $request)
  {
    $region = Doctrine::getTable('Region')->findOneById($request->getParameter('region'));
    return $this->renderPartial('lambda/selectDepartement', array('region' => $region));
  }

Le partial :

// _selectDepartement.php
<option value=""></option>
<?php foreach($region->getDepartements() as $departement): ?>
<option value="<?php echo $departement->getId() ?>"><?php echo $departement->getNom() ?></option>
<?php endforeach; ?>

Et enfin le petit bout de code jQuery à rajouter au formulaire :

<script language="javascript">
$(document).ready(function(){
  $("#mon_formulaire_lambda_region_id").change( function() {
    $.post("/ajax/departement", { region: $(this).val() },
    function(data){
      $("#mon_formulaire_lambda_departement_id").html(data);
    });
  });
});
</script>

Pour le javascript plusieurs solutions. Soit l’inclure directement dans la vue avec les balises comme je l’ai fait ici.
Soit faire un fichier .js que l’on met dans /web/js/mon_fichier.js (bien mais pas top ).

Le plus « propre » est de faire une vue et d’utiliser le sf_format et d’inclure le fichier via une route.
On verra ça lors d’un prochain post

@bientôt !

NB : Bien entendu il faut que jQuery soi inclus :
– Soit il est inclus dans le view.yml
– Soit directement dans la vue avec un use_javascript(‘jQuery.js’)

On dispose d’un ensemble d’éléments (ici des messages) que l’on nous propose de noter.

Dans une première étape, le principe est de créer le système de vote, dans une deuxième étape on limitera les votes : un visiteur ne peut voter sur un élément qu’une fois par jour.
(Attention, ne pas pas oublier d’ajouter les include et use_javascript dans le layout de votre appli)

Etape 1 :

Schéma :

Message:
  columns:
    text:
      type: string(255)
    relations:
      Ratings:
        type: many
        class: Rating
        local: id
        foreign: message_id

Rating:
  actAs: { Timestampable: ~ } //permet d'avoir les champs "created_at" et "updated_at", pour limiter le nombre de vote à 1 par jour
  columns:
    value:
      type: boolean
    message_id:
      type: integer
  relations:
    Message:
      onDelete: CASCADE
      local: message_id
      foreign: id

On a donc une table contenant nos messages (ici on n’a besoin que du texte) et une table contenant les votes : un vote est donc décrit par une id, et un message, donc à chaque click un nouveau vote est inséré dans la base de données.

Pour éviter de se retrouver avec une BDD sur-remplie, on pourra rajouter une 3° étape qui consiste à créer une tâche qui compile chaque vote sur un message pour en faire un résumé (qui fait la somme par exemple) et qui ensuite supprime les votes compilés.

Bref, les fonctionnalités utiles maintenant sont : afficher la note du message, afficher le nombre de votes (pour pouvoir faire la différence entre un message qui a une bonne note mais 3 votes et un message qui a une bonne note mais 1000 votes, par exemple), et afficher les liens permettant de voter, tout ça à coté du message en question, bien évidemment.

Voici donc le code de l’index des message (apps/*votre appli*/modules/message/templates/indexSuccess.php)

Message List


<div id ="ratinggetId() ?>">
  
   $message)) ?>




   'rating'.$message->getId(),
                          'url'      => '@message_vote_plus?id='.$message->getId()
    )); ?>
   'rating'.$message->getId(),
                  'url'      => '@message_vote_moins?id='.$message->getId()
    )); ?>




  gettext() ?>

Partial message/rating (apps/*votre appli*/module/template/_rating.php) :

Note : getGlobalRating(); ?>/,
Nombre de votes : getRatingsCount() ?>

La syntaxe utilisée ici pour les fonction link_to_remote est :
link_to_remote(‘texte à afficher pour le lien’, tableau des options(‘update’ => id de la div a update, ‘url’ => adresse de l’action))

Vous noterez aussi que les url des link_to_remote utilisent des routes, voici les routes utilisées(apps/*votre appli*/config/routes.yml) :

message_vote_plus:
  url:      /message-vote-plus/:id
  param:    { module: message, action: votePlus }

message_vote_moins:
  url:      /message-vote-moins/:id
  param:    { module: message, action: voteMoins }

Un click sur un lien va donc engendrer l’action votePlus ou voteMoins de l’objet message en question, spécifié par l’id.
Voici les actions (apps/*votre appli*/modules/message/actions.class.php) :

  //execute le vote "j'aime"
  public function executeVotePlus(sfWebRequest $request)
  {
    //on récupère le message courant
    $this->message = Doctrine::getTable('Message')->find($request->getParameter('id'));
    //on effectue le vote positif
    $this->message->votePlus();
    //on génère le partial du message, c'est ce résultat qui sera utilisé par le link_to_remote pour mettre à jour la div spécifiée, cela évite également le passage par le template votePlusSuccess.php (qui donc n'est pas à créer)
    return $this->renderPartial('message/rating',array('message' => $this->message));
  }

  //execute le vote "j'aime pas"
  public function executeVoteMoins(sfWebRequest $request)
  {
    //on récupère le message courant
    $this->message = Doctrine::getTable('Message')->find($request->getParameter('id'));
    //on effectue le vote négatif
    $this->message->voteMoins();
    //on génère le partial du message, c'est ce résultat qui sera utilisé par le link_to_remote pour mettre à jour la div spécifiée, cela évite également le passage par le template voteMoinsSuccess.php (qui donc n'est pas à créer)
    return $this->renderPartial('message/rating',array('message' => $this->message));
  }

L’action utilise donc naturellement des méthodes du controlleur (lib/model/doctrine/Message.class.php) :
-récupération du nombres de vote sur 1 message :

  //retourne le nombre de votes sur ce message
  public function getRatingsCount()
  {
    return Doctrine::getTable('Rating')->getMessageRatingsQuery($this->getId())->count();
  }

-récupération de la note d’un message :

  //retourne la note globale du message courant
  public function getGlobalRating()
  {
    //on récupère tous les votes sur ce message
    $ratings = Doctrine::getTable('Rating')->getMessageRatingsQuery($this->getId())->execute();
    //on initialise la note a 0
    $note = 0;
    //pour chaque vote positif on incrémente la note (rappel : la note est stockée sous forme de boolean dans la base)
    foreach ($ratings as $rating)
    {
      if ($rating->getValue())
      {
        $note++;
      }
    }
    //on récupère le nombre de votes, pour calculer la moyenne
    $nbvotes = $this->getRatingsCount();
    //si il n'y pas encore eu de vote sur ce message, on est obligé de donner la valeur 1 à nbvotes, pour éviter une division par 0
    if($nbvotes == 0){ $nbvotes = 1; }

    //on retourne la moyenne : (note/nb_votes)*"valeur sur laquelle on rapporte la note" et on arrondi (round)
    //la valeur sur laqelle on rapporte la note est stockée dans la config (app.yml), ainsi que le nombre de chiffres apres la virgule
    return round(($note/$nbvotes)*sfConfig::get('app_moyenne_sur'), sfConfig::get('app_round'));
  }

-votes :

  //ajoute un vote positif relatif à ce message
  public function votePlus()
  {
    return $this->vote('1');
  }

  //ajoute un vote négatif relatif à ce message
  public function voteMoins()
  {
    return $this->vote('0');
  }

  //effectur le vote
  public function vote($value)
  {
    $rating = new Rating(); //nouveau vote
    //on set ses champs
    $rating->setMessageId($this->getId()); //message_id
    $rating->setValue($value); //value
    $rating->save(); //on l'enregistre dans la base
  }

Voilà pour la première étape, le système de votes est opérationnel, reste plus qu’à limiter les votes.

Etape 2
De quoi a-t-on besoin pour la suite ?
1) Modifier le schéma pour ajouter l’attribut ip_user, correspondant à l’adresse ip de l’utilisateur
2) De vérifier au moment du vote dans le modèle, s’il existe déjà un vote récent pour ce message et pour cette adresse ip
3) Donc, on a aussi besoin d’une méthode dans la classe RatingTable.class.php qui récupère les votes récents
4) On ajoutera également un message à l’utilisateur pour le remercier de son vote ou lui indiquer qu’il n’a plus le droit de voter.

Mise à jour de la table Rating dans le schéma :

Rating:
  actAs: { Timestampable: ~ }
  columns:
    value:
      type: boolean
    message_id:
      type: integer
    user_ip:
      type: string(12)
      notnull: true
  relations:
    Message:
      onDelete: CASCADE
      local: message_id
      foreign: id

1) Modification de la méthode vote()

public function vote(sfWebRequest $request, $value)
  {
    //on récupère l'adresse ip du visiteur/utilisateur
    $user_ip = $request->getRemoteAddress();
    //on récupère les votes effectués par cet utilisateur sur ce message
    $recent_rating = Doctrine::getTable('Rating')->getRecentRating(array('user_ip' => $user_ip, 'message_id' => $this->getId()));
    //si il n'existe pas de vote trop récent
    if(!($recent_rating->count() > 0))
    {
      $rating = new Rating(); //nouveau vote
      //on set ses champs
      $rating->setUserIp($user_ip); //user_ip
      $rating->setMessageId($this->getId()); //message_id
      $rating->setValue($value); //value
      $rating->save(); //on l'enregistre dans la base et on retourne vrai
      return true;
    }
    else //si le vote est trop récent, pas de vote, on retourne faux
    {
      return false;
    }
  }

Ce qui implique évidemment la création de la méthode getRecentRating() (dans lib/model/doctrine/RatingTable.class.php) :

  //retourne les votes récents dans la query
  public function getRecentRating($params, Doctrine_Query $query = NULL)
  {
    if(is_null($query)) //si pas de requete, on récupère tous les votes de la base
    {
      $query = $this->createQuery('c');
    }
    //on récupère tous les votes faits avec cette ip
    $query = $this->getRatingsByUserIp($params['user_ip'], $query);
    //on récupère tous les votes sur ce message
    $query = $this->getMessageRatingsQuery($params['message_id'], $query);
    //on sélectionne uniquement les message récents
    $query->andWhere('c.created_at >= ?', date('Y-m-d h:i:s', time() - 86400 * (sfConfig::get('app_vote_time_limit') / 24)));
    return $query;
  }

La valeur de la limite de temps pour le vote et stockée dans la config, de la même manière que round et moyenne_sur dans la première partie

All:
  moyenne_sur: 20
  round: 1
  #limite de temps pour le vote (en heures)
  vote_time_limit: 24

Vous noterez sûrement la présences des fonctions getRatingsByUserIpQuery() et getMessageRatingsQuery() :

  //retourne la requête permettant de récupérer tous les votes sur un message donné, parmis ceux récupérés par la requete $query
  public function getMessageRatingsQuery($message_id, Doctrine_Query $query = NULL)
  {
    if(is_null($query)) //si aucune requête passée, on génère la requête pour récup tous les votes
    {
      $query = $this->createQuery('c');
    }
    $query->andWhere('c.message_id = ?', $message_id); //on ajoute le where pour filtrer par message_id

    return $query;
  }

  //retourne la requete permettant de récupérer tous les votes passé par une adresse ip, parmis ceux récupérés par la requete $query
  public function getRatingsByUserIp($user_ip, Doctrine_Query $query = NULL)
  {
    if(is_null($query)) //si aucune requête passée, on génère la requête pour récup tous les votes
    {
      $query = $this->createQuery('c');
    }
    $query->andWhere('c.user_ip = ?', $user_ip); //on ajoute le where pour filtrer par user_ip

    return $query;
  }

Il ne reste plus qu’à afficher un petit message à notre utilisateur (dans l’action) :

  //execute le vote "j'aime"
  public function executeVotePlus(sfWebRequest $request)
  {
    //on récupère le message courant
    $this->message = Doctrine::getTable('Message')->find($request->getParameter('id'));
    //on effectue le vote positif
    if($this->message->votePlus($request))
    {
      $this->getUser()->setFlash('vote', "Merci d'avoir voté", false);
    }
    else
    {
      $this->getUser()->setFlash('vote', "vous ne pouvez plus voter", false);
    }
    //on génère le partial du message, c'est ce résultat qui sera utilisé par le link_to_remote pour mettre à jour la div spécifiée
    //cela évite également le passage par le template votePlusSuccess.php (qui donc n'est pas à créer)
    return $this->renderPartial('message/rating',array('message' => $this->message));
  }

  //execute le vote "j'aime pas"
  public function executeVoteMoins(sfWebRequest $request)
  {
    //on récupère le message courant
    $this->message = Doctrine::getTable('Message')->find($request->getParameter('id'));
    //on effectue le vote négatif
    if($this->message->voteMoins($request))
    {
      $this->getUser()->setFlash('vote', "Merci d'avoir voté", false);
    }
    else
    {
      $this->getUser()->setFlash('vote', "vous ne pouvez plus voter", false);
    }
    //on génère le partial du message, c'est ce résultat qui sera utilisé par le link_to_remote pour mettre à jour la div spécifiée, cela évite également le passage par le template voteMoinsSuccess.php (qui donc n'est pas à créer)
    return $this->renderPartial('message/rating',array('message' => $this->message));
  }

On utilise la méthode sfUser::setFlash(). Comme la mise à jour de l’affichage sera le partial rendu, il faut donc intégrer encore quelques lignes dans le template correspondant (apps/*votre appli*/module/message/template/_rating.php :

Note : getGlobalRating(); ?>/,
Nombre de votes : getRatingsCount() ?>

hasFlash('vote')): ?>
getFlash('vote') ?>

Et voilà !!

La réponse à cette question ne pouvant pas tenir dans le modeste blog de Lexik.fr, je vais seulement vous expliquer comment intégrer la modification d’un champ « INPUT » en ajax dans un formulaire Symfony 1.2, à l’aide du plugin jQuery JEditable.

A ce stade, je vous recommande ce lien : JEditable

Pré-requis

• Comme d’habitude, l’éternel plugin : sfFormExtraPlugin
• Les JS :
  • jquery-1.3.2.min.js
  • jquery.jeditable.js

Le widget

Chemin :
[votre_projet]/plugins/sfFormExtraPlugin/lib/widget/sfWidgetFormInputEditInPlace.class.php

Code source :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

<?php
class sfWidgetFormInputEditInPlace extends sfWidgetFormInput
{
  public $object;
  public $route;
  public function __construct($option = array(), $messages = array(), $object = null, $route = null)
  {
    parent::__construct($option, $messages);
    $this->object = $object;
    $this->route = $route;
  }
  public function configure($options = array(), $messages = array())
  {
    parent::configure($options, $messages);
  }
  public function render($name, $value = null, $attributes = array(), $errors = array())
  {    
    $prefix = $this->generateId($name);    
    return sprintf(<<<EOF
<b id="%s">%s</b>
<script type="text/javascript">
$(function() {
  $("#%s").editable(
    "%s",
    {
      indicator : 'Saving...',      
      type   : "text",
      submit : "OK",
      style  : "inherit",
      id       : 'ajaxfield_id'
  });
});
</script>
EOF
    , $prefix, $value,
      $prefix,
      url_for($this->route, $this->object, array('absolute'=>true))
   );
  }
}

Pour ce widget, j’ai créer 2 attributs.

• object
  Cet attribut contient l’objet de la route objet Symfony.
  ^?View Code PHP

  4	public $object;

• route
  Cet attribut contient le nom de la route objet Symfony.
  ^?View Code PHP

  5	public $route;

Ces attributs nous permettent de générer l’URL de la page qui va valider et éventuellement sauvegarder les données postées par le widget JQuery.

36

url_for($this->route, $this->object, array('absolute'=>true))

Maintenant que l’outil est créé, utilisons le !
Toute la suite de l’article n’est qu’un exemple d’utilisation.

Schéma

Person:
  columns:
    firstname:
      type: string(255)
    lastname:
      type: string(255)
    email:
      type: string(255)

Routing

• show_person
  La route du formulaire.
• save_person_eip
  Route de l’action « executeSaveEIP » qui valide et sauve les champs du modèle « Person »

# Route du formulaire
show_person:
  url:     /person/show/:id
  class:   sfDoctrineRoute
  options: { model: Person, type: object }
  param:   { module: person, action: show }
 
# Route de la page sauvant les données postées en ajax
save_person_eip:
  url:     /person/saveEIP/:id
  class:   sfDoctrineRoute
  options: { model: Person, type: object }
  param:   { module: person, action: saveEIP }
  requirements:
    id: d+
    sf_method: [post]

Actions

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

// L'action pour le formulaire de base
public function executeShow(sfWebRequest $request)
{
  $this->person = $this->getRoute()->getObject();
  $this->form = new PersonForm($this->person);
}
 
// L'action qui traite le post en ajax
public function executeSaveEIP(sfWebRequest $request)
{
  // Récupération de l'objet de la route
  $this->person = $this->getRoute()->getObject();
 
  // Récupération des données postées par le widget JQuery
  $id = $request->getParameter('ajaxfield_id');
  $this->value = $request->getParameter('value');
 
  // Récupération du nom du champ
  if(ereg("person_(.*)$", $id, $key))
  {
    $champ = $key[1]; 
  }
 
  // Instanciation d'un formulaire lié à notre objet
  $form = new PersonForm();
 
  // Récupération du validateur du champ
  $validator = $form->getValidator($champ);
 
  // On tente de valider le champ
  try
  {
    $cleaned = $validator->clean($this->value);
    $this->person->set($champ, $this->value);
    $this->joueur->save();
  }
  catch(sfValidatorError $e)
  {
     // Erreur lors de la validation du champ 
     // La valeur à afficher dans le template doit être la valeur actuelle de l'objet
     $this->value = $this->person->get($champ);
  }
}

Templates

• showSuccess.php
  ^?View Code PHP

  <h1>Edition d'une personne</h1> <?php echo $form['firstname']->render();?><br> <?php echo $form['lastname']->render();?><br> <?php echo $form['email']->render();?><br>

• saveEIPSuccess.php
  ^?View Code PHP

  <?php echo $value ?>

Formulaire

• On construit chacun des widgets avec l’objet et le nom de la route.
• On définit les validators.

  public function configure()
  {
    // Widgets
    $this->widgetSchema['firstname'] = new sfWidgetFormEditInPlace(array(), array(), $this->getObject(), 'save_joueur_eip');
    $this->widgetSchema['lastname'] = new sfWidgetFormEditInPlace(array(), array(), $this->getObject(), 'save_joueur_eip');
    $this->widgetSchema['email'] = new sfWidgetFormEditInPlace(array(), array(), $this->getObject(), 'save_joueur_eip');
 
    // Validators
    $this->validatorSchema['firstname'] = new sfValidatorString();
    $this->validatorSchema['lastname'] = new sfValidatorString();
    $this->validatorSchema['email'] = new sfValidatorEmail();  
  }

View.yml

[...]
default:
  javascripts:    [jquery-1.3.2.min.js, jquery.jeditable.js]
[...]

Il serait maintenant intéressant de pouvoir l’utiliser dans une application et également de pouvoir suivre l’évolution de notre tâche.

Pour lancer la tâche nous avions dans un premier penser la lancer grâce à la fonction proc_open() de PHP qui inclut une gestion des logs assez intéressante. Nos premiers tests en local se sont déroulés sans problèmes mais une fois en production il semble que la configuration du serveur ne permette pas d’utiliser cette commande.
On s’est donc rabattus sur la façon qui semble la plus utilisée :

 
chdir(sfConfig::get('sf_root_dir')); 
$myTask = new importExecuteTask(sfContext::getInstance()->getEventDispatcher(), new sfFormatter());
$myTask->run(array(), array());

Il est important de ne pas oublier le chdir() pour permettre l’exécution de notre tâche.

La première étape est donc terminée, on a pu lancer notre tâche depuis notre application, on va maintenant s’intéresser à suivre l’évolution de celle-ci.
Pour cela je vais créer un fichier que j’appelerai lock.txt dans mon répertoire d’import et je vais même l’utiliser comme compteur. Pour des raisons que nous verrons un peu plus bas, je vais créer une constante dans la classe de ma tâche qui correspondra au nom du fichier.

 
const LOCK_FILE = 'lock.txt';

Au début de ma boucle je donc avoir le code suivant :

 
$handle = fopen($options['file'], 'r');
fopen($arguments['import_dir'].'/'.self::LOCK_FILE, 'x');
while (($data = fgetcsv($handle, 5000, ";")) !== false)
{
 /* Mon code d'insertion */
}

Bon ok on a notre fichier mais à quoi nous sert-il ?
On peut dès à présent l’utiliser pour faire un redirect dans notre action pour empêcher de lancer plusieurs tâches en même temps :

 
$this->redirectIf(is_file('chemin/de/mon/dossier/import'.'/'.importExecuteTask::LOCK_FILE), 'import/loading');

Ici je redirige vers une page « loading » qui permettra de faire « patienter » notre utilisateur.

On vient de voir la première utilisation de notre fichier lock on va maitenant l’utiliser pour suivre l’évolution de la tâche. Pour cela je vais utiliser un compteur dans la boucle de ma tâche et l’écrire dans mon fichier. Il me faut tout d’abord obtenir le nombre maximum de mon fichier CSV.

 
            $handle = fopen($arguments['import_dir'].$file, 'r');
            $contenu_fichier = fread($handle, filesize($arguments['import_dir'].$file));
            $max = substr_count($contenu_fichier, "\n");
            fclose($handle);

Dans ma boucle je vais maintenant incrémenter mon compteur et mettre tout ça dans notre fichier lock :

 
$count = 0;
while (($data = fgetcsv($handle, 5000, ";")) !== false)
{
//- Début de mon code
 
file_put_contents($arguments['import_dir'].self::LOCK_FILE, $count.'/'.$max);
 
$count++;
}

Maintenant que mon fichier contient les informations nécessaires je vais les utiliser dans l’action :

 
        $filename = sfConfig::get('app_chemin_import').'/'.importExecuteTask::LOCK_FILE;
        if (is_file($filename))
        {
            $handle = fopen($filename , 'r');
 
            $moyenne = fread($handle, filesize($filename));
 
            $a = explode("/", $moyenne);
 
            $this->content = floor(($a[0] * 100) / $a[1]);
 
            fclose($handle);
 
        }

Voilà maintenant lorsque l’utilisateur sera redirigé vers notre page d’attente. On pourra lui afficher le pourcentage de l’évolution de la tâche. Petit problème si l’on veut suivre en direct cette évolution on va recharger la page indéfiniment ? Non pour cela on va utiliser un Helper Javascript : periodically_call_remote()

On va donc créer une action page progess qui ne sera appeler que par le javacript et qui sera inclut dans notre page « loading » par l’appel d’un component ce qui nous donnera :

// actions.class.php
 
    public function executeProgress()
    {
 
        $filename = sfConfig::get('app_chemin_import').'/lock.txt';
        if (is_file($filename))
        {
            $handle = fopen($filename , 'r');
 
            $moyenne = fread($handle, filesize($filename));
 
            $a = explode("/", $moyenne);
 
            $this->content = floor(($a[0] * 100) / $a[1]);
 
            fclose($handle);
 
        }
}

Notre template :

 
<div style="width: 220px;">
<div style='width:<?php echo $content ?>%; background-image: url(/images/progress.gif); float: left;'><?php echo $content ?> %</div>
</div>

Une div qui contiendra une image gif que l’on fera grandir au fur et à mesure tel une barre de progression.
Et pour terminer notre page d’attente :

 
<?php use_helper('Javascript') ?>
 
<div id="progress"></div>
 
<?php echo periodically_call_remote(array(
   'frequency'  => '1',
   'update'     => 'progress',
   'url'        => 'import/progress'
)) ?>

Tout les secondes la div va donc être rafraîchie en appelant notre page progress ce qui simulera l’évolution de notre tâche.

Pour terminer, il ne faudra surtout pas oublier de supprimer le fichier lock à l’aide d’un petit unlink().