comme vous avez pu le voir avec les récents posts, nous avons eu pas mal de gestion de facturation: conversion de devises, validation d’un numéro de tva intracommunautaire.

Pour continuer sur la lancée, nous allons faire un petit validator sur les numéros siret.

Un numéro siret correspond à un petit algorithme assez simple expliqué ici (algorithme de Luhn)
Le principe est le suivant : on multiplie les chiffres de rang impair à partir de la droite par 1, ceux de rang pair par 2 ; la somme des chiffres obtenus doit être congrue au modulo 10, c’est-à-dire qu’elle doit être multiple de 10.
Un numéro siret comporte 14 chiffre.

Voici le code du validator: sfValidatorSiret.class.php

class sfValidatorSiret extends sfValidatorBase 
{
  protected function doClean($values)
  {
    $siret = trim($values);
    if(empty($siret) || strlen($siret) != 14)
    {
      throw new sfValidatorError($this, 'Le numéro siret est invalide');
    }
    $sum = 0;
    for($i=0; $i<14; $i++)
    {
      if($i%2 == 0)
      {
        $tmp = $siret[$i]*2;
        $tmp = $tmp > 9 ? $tmp - 9 : $tmp;
      }
      else
      {
        $tmp= $siret[$i];
      }
      $sum += $tmp;
    }
    if($sum%10 !== 0)
    {
      throw new sfValidatorError($this, 'Le numéro siret est invalide');
    }
    return $siret;
  }
}

Pour expliquer rapidement:
1. si la valeur est vide ou de longueur différente de 14 on retourne une exception.
2. on parcours les 14 chiffres, si le chiffre est paire alors on le multiplie par 2 et si ce résultat est supérieur à  9 alors on retranche 9.
ex: 7 => 7×2 = 14 => 14 – 9 = 5.
faire 14 -9  reviens à additionner les 2 chiffres: 1 + 4 = 5.
3. On additionne tous les chiffres paires x2 et les chiffres impaires.
4. si le résultat est divisible par 10 alors c’est un numéro siret.

Attention ceci indique que le numéro fourni peut être un numéro siret, MAIS PAS que ce numéro est réellement un numéro siret inscrit à L’INSEE, actif et correspond à une société.

Vous pouvez télécharger le validator ici.

Tout d’abord nous créons un partial _connectWith.php dans le module souhaité dans le backend, par exemple le module sf_guard_user.

$link_connect_with = 'http://www.monsite.fr/connect_by_admin/'.$sf_guard_user->getSalt().'/'.$sf_guard_user->getPassword().'/'.$sf_request->getCookie('nomdemasessionbackend');
echo link_to('SE CONNECTER EN TANT QUE', $link_connect_with, array('target'=>'_blank'));

le $link_connect_with est défini à coté pour plus de lisibilité.
connect_by_admin est le nom de ma route.
getSalt et getPassword sont les méthodes de sf_guard_user pour récupérer les données correspondantes.
$sf_request->getCookie(‘nomdemasessionbackend’) avec nomdemasessionbackend qui doit être défini dans le fichier backend/config/factories.yml, on verra après son utilité.

all:
  storage:
    class: sfSessionStorage
    param:
      session_name: nomdemasessionbackend

pour simplifier, ici je n’ai pas utilisé de routing ou de fonction spéciale qui va récupérer automatiquement les routes du frontend, j’ai écris directement l’url souhaitée. C’est pas très beau mais plus facile pour ce tuto.
c’est tout pour le backend.

maintenant sur le frontend:
routing.yml je rajoute ma route appelée via le backend

connect_with:
  url: /connect_by_admin/:salt/:password/:admin
  param: { module: connect, action: Admin}

mon action:

  public function executeAdmin(sfWebRequest $request)
  {
   //etape 1
    $salt = $request->getParameter('salt', false);
    $password = $request->getParameter('password', false);
    $admin_session = $request->getParameter('admin', false);
 
   //etape 2
    $cookie = $this->getRequest()->getCookie('nomdemasessionbackend');
    if($admin_session != $cookie)
    {
      $this->forward404();
    }
 
    //etape 3
    $user = Doctrine::getTable('sfGuardUser')->findOneBySaltAndPassword($salt, $password);
    $this->forward404Unless($user);
 
   //etape 4
    $this->getUser()->signin($user);
    $this->redirect('@homepage');
  }

étape 1: je récupère les informations de l’url
étape 2: je vérifie si le cookie nomdemasessionbackend correspond à celui passé en paramètre, sinon ERREUR404.
Ceci oblige l’administrateur à être authentifié dans le backend pour pouvoir « se connecter en tant que ».
étape 3: je récupère l’utilisateur qui à ce salt et ce mot de passe, sinon ERREUR404.
étape 4: je connecte cet utilisateur sur le site et je redirige vers la homepage.

Nous avons rajouté lé vérification de la session du backend pour sécurisée cette url, mais cela implique que votre frontend et votre backend n’utilise pas les mêmes nom de sessions: voir http://www.lexik.fr/blog/symfony/symfony/utilisation-de-sfsessionstorage-dans-symfony-901

Un petit tips tout simple mais assez pratique.

Afin d’optimiser l’affichage des pages, il est recommandé de généré plusieurs thumb (vignettes) pour une même image. Il y a l’image d’origine, puis une version en 200×200, une en 150×100 et une 50×50, suivant leur position sur le site.
Une première solution est de générer ces thumbs lors de l’upload, c’est très efficace, le travail ce fait une fois lors de la sauvegarde et est opérationnel directement. Mais on a tous eu un projet où finalement il faut créer un nouveau thumb ou changer le 150×100 en 100×100 et là c’est le drame: il faut re-uploader toutes les images une par une (enfin si le site est déjà en prod, le mieux c’est de s’en rendre compte du problème avant).

Bref, la deuxième solution est d’uploader une image source, et lors de l’affichage demander la taille souhaitée. Là on vérifie si le thumb existe, si oui on l’affiche, sinon , on le crée et on l’affiche.
Voila ce que je vous propose aujourd’hui, un petit helper tout fait qui s’occupe de cette deuxième solution.
Il est basé sur le plugin sfImageTransformPlugin qui est excellent et dont vous avez toute la doc ici: http://www.symfony-project.org/plugins/sfImageTransformPlugin.

Pour installer le helper rien de plus simple, vous créez le répertoire lib/helper, et vous placez le fichier dedans.
lors de l’appel il faut penser à le loader avec la fonction suivante dans une action sfProjectConfiguration::getActive()->loadHelpers(‘Thumb’);
ou

<?php use_helper('Thumb');?>

dans la vue.

il y a deux fonctions:

une pour générer le thumb:
doThumb($image_name, $folder, $options = array(), $resize = ‘scale’, $default = ‘default.jpg’)
@param $image_name : le nom de l’image donc généralement le $object->getImage(), pas de répertoire
@param $folder : le nom du répertoire dans uploads où est stocké l’image : uploads/object/source => $folder = object
@param $options : la taille de l’image: width et height
@param $resize : l’opération sur le thumb: « scale » pour garder les proportions, « center » pour tronquer l’image
@param $default : l’image par défaut si image_name n’existe pas
le thumb est créé dans uploads/object/thumb/
le réslutat retourné est le lien vers l’image : /uploads/object/thumb/mon-image.jpg

une autre fonction :
showThumb($image_name, $folder, $options = array(), $resize = ‘scale’, $default = ‘default.jpg’)
elle appelle la précédente avec les même paramètres.
elle retourne l’image tag directement. donc un seul paramètre change:
@param $options : les parametres à passer à l’image: width, height, alt, title, class, id…

Vous pouvez télécharger le helper ici: thumbhelper

Merci de me contacter en cas de soucis.

Pour uploader un fichier rien de plus simple, et tout est expliqué ici: http://www.symfony-project.org/jobeet/1_2/Doctrine/en/10 le schema.yml

Image:
  tableName: table_image
  columns:
    name: { type: string(255), notnull: true }
    image: { type: string(255) }

dans le fichier ImageForm.class.php, on modifie le widget pour lui dire que c’est un input File, et le validator qui correspond

class ImageForm extends BaseImageForm
{
  public function configure()
  {
    $this->widgetSchema['image'] = new sfWidgetFormInputFile(array(
                                        'label' => 'Image',
                                         ));
 
    $this->validatorSchema['image'] = new sfValidatorFile(array(
                                        'required' => true,
                                        'path' => sfConfig::get('sf_upload_dir').'/images',
                                        'mime_types' => 'web_images',
                               ));
 
  }
}

Donc à partir de maintenant dans mon backend, je peux uploader les images MAIS elles sont renommées en md5.extension, ce qui est bien, mais pas top. Pour y remedier, je vais dans le model Image.class.php

class Image extends BaseImage
{
  public function generateImageFilename(sfValidatedFile $file)
  {
    return Sanitize::stripText($this->name).'_logo'.$file->getOriginalExtension();
  }
}

en créant une fonciton generateMonChampsFilename(), je peux choisir le nomdu me fichier uploadé, fichier qui passe en parametre de cette fonciton. Ici je lui donne la valeur de mon champs name. Pour l’API correspondante: http://www.symfony-project.org/api/1_2/sfValidatedFile