My Developpement Blog

Juste une petite réflexion en passant.

1ere hypothèse

Aucune gronde concernant la candidature de J. Sarkozy au poste de président de l’EPAD => Un beau poste de prestige pour un jeune de 23 ans commençant la politique.

2ème hypothèse

Gronde de la population (politique ou non) => retrait de la candidature et un J. Sarkozy magnanime et un regain de popularité.

Dans tout les cas, il ressortait gagnant. Je pense que rien n’a été laissé au hasard dans cette affaire et l’UMP prépare la route au dauphin.

Edit

Je me sens moins seul

Morale

La communication, le développement, même combat : il ne faut pas prendre les gens pour des cons mais ne pas oublier qu’ils le sont. Et apparement, c’est plus facile pour la communication

ND_Template est un moteur de gabarit ou template engine pour les anglophones. Ce développement avait pour contrainte d’être fonctionnel et avoir un code court et clair.

Je n’ai pas encore tester le code en production donc il peut y avoir des problèmes d’utilisabilité ou de performance.

Je rajouterai un How to dès que j’aurais un peu plus de temps pour le rédiger

Le Module User

Ce module doit permettre la création/modification/suppression de comptes utilisateurs ainsi que leur identification. Personnellement, je pense que ce module ne doit gérer que peu de données : - Login (doit être unique) - Mot de passe (enregistré sous forme de Hash) - Date de création - Date d’activation - Email (doit être unique)

Pourquoi ces choix

Email + Login

J’ai décidé de ne pas prendre l’email en tant qu’identifiant du compte, car cela permet à l’utilisateur de choisir son propre identifiant qui peut être plus court que son email.

Mot de passe hashé

Pourquoi choisir de hasher le mot de passe.

Pour 2 raisons :

• le système n’a pas besoin de connaître le mot de passe de l’utilisateur, il doit simplement savoir si le mot de passe est le valide. Cela évite une faille de sécurité en cas d’intrusion dans la base. Le mot n’étant pas “en clair”, celui-ci n’a que peu d’intérêt.
• pour sécuriser les utilisateurs, beaucoup de gens gardent le même mot de passe, quelque soit l’application qu’ils utilisent.

Comment sera hashé le mot de passe.

Le hashage sera obligatoire mais l’administrateur de l’application aura la possibilité de choisir la manière dont il veut gérer cela.

Le grain de sel sera paramétrable

• choix du champs permettant de faire le générer ( Login / Date de création / email )
• choix de la méthode de hash ( md5 / sha1 / autre ) du champ
• choix dans la taille du grain de sel

Le hash se fera ensuite

• position du grain de sel (avant ou après le mot de passe)
• choix de la méthode de hash ( md5 / sha1 / autre )

Ce système empêche qu’un même mot de passe est le même hash.

Pourquoi avoir une date de création et une date de validation

Ce choix se justifie par le simple fait de purge de la base, un compte n’ayant pas été validé X jours après sa création est probablement un compte mort, donc un espace perdu.

Comment gérer les autres données

A ce système d’identification peut se greffer 2 autres tables permettant de gérer un nombre infini de données utilisateurs supplémentaires. Cela permet une malléabilité a l’administrateur d’une instance du CMS dans le choix des données utilisateurs qu’il souhaite. Le système n’ayant besoin à la base que de pouvoir identifier l’utilisateur

la table User_Field

Cette table permet à l’administrateur de choisir les informations de l’utilisateur qu’il souhaite La table contiendrait 3 voire 4 champs hors identifiant.

• name, nom pour l’administrateur
• i18n_name, variable que remplacera le système d’internationalisation
• required, permet de rendre obligatoire un champ
• validator, devrait permettre de valider ou non l’information saisie (Peut être externaliser cela dans un autre table afin de pré créer des règles de validation)

la table User_Data

Cette table permet d’associer un utilisateur, une donnée et sa valeur.

Voilà, je pense que tout est dit, si vous avez des remarques à faire, n’hésitez pas

Voila ce que donne Microsoft quand celui ci s’adonne à l’open source

Quelques liens qui peuvent être utiles :

* http://www.tripwiremagazine.com/tools/design/40-must-have-cheat-sheets-for-effective-web-designers.html
* http://www.tripwiremagazine.com/design/css-techniques/20-css-data-visualization-techniques.html

Si vous utilisez le Zend Framework et que vous cherchez à représenter une arborescence type Menu, Organigramme, …

C’est juste une simple mise en forme de cet article concernant la représentation intervallaire d’une arborescence

Il me reste la gestion des niveaux à prendre en compte, histoire de faire des filtres supplémentaire. Mais bon, chaque chose en son temps.

Comme toujours, je suis tout ouïe aux remarques voire même aux critiques

Appel de la classe

<?php
 
class Kernel_Models_Data_Role_Table extends ND_Db_Table_Hierarchical_Table{
 
   protected $_name      = 'role';
   protected $_rowClass = 'Kernel_Models_Data_Role_Row';
   protected $_left          = 'bg'; // defini la borne gauche (obligatoire)
   protected $_right        = 'bd'; // defini la borne droite (obligatoire) 
   protected $_level        = 'level' // defini la profondeur de l'arborescence (obligatoire) 
 
 
}

Et pour ceux qui ont la flemme de télécharger le fichier

<?php
/**
 * 
 * @author ndesaleux
 * @package ND
 * @subpackage Db
 * 
 */
 
class ND_Db_Table_Hierarchical_Table extends Zend_Db_Table{
 
   protected $_left   = null ;
   protected $_right  = null ;
   protected $_level  = null ;   
 
   /**
    * 
    * @param (array) $config 
    * @return null
    */
   public function __construct($config = array()){
      parent::__construct($config);
      if (null == $this->_left)   throw new ND_Db_Table_Hierarchical_Exception(ND_Db_Table_Hierarchical_Exception::NO_LEFT_BORDER_FIELD_DEFINED);
      if (null == $this->_right)  throw new ND_Db_Table_Hierarchical_Exception(ND_Db_Table_Hierarchical_Exception::NO_RIGHT_BORDER_FIELD_DEFINED);
      if (null == $this->_level)  throw new ND_Db_Table_Hierarchical_Exception(ND_Db_Table_Hierarchical_Exception::NO_LEVEL_FIELD_DEFINED);      
   }
 
   /**
    * 
    * @param (int) $id
    * @return (mixed) false|Zend_Db_Table_Row_Abstract
    */
   public function getById($id) {
      $rows = $this->find($id);
      if ($rows) {
         return $rows->current();
      }
      return false;
   }
 
   /**
    * Delete an element get by id (this delete also node and leaf)
    * Update bor
    * @param (int) $id
    * @return (boolean)
    */
   public function deleteById($id){
 
       $elt = $this->getById($id)    ;    
       if ($elt instanceof Zend_Db_Table_Row_Abstract ){
 
           $left  = $this->_left;
           $right = $this->_right;           
           $dif   = $elt->$right- $elt->$left + 1; 
           // on supprime les elements noeuds et feuilles
           $dlElt = 'DELETE FROM '.$this->_name.' 
           		      WHERE '.$this->_left.' >= '.$elt->$left.'
           		        AND '.$this->_right.' <= '.$elt->$right ;            
           // MAJ des bornes droites 
           $upRb = 'UPDATE '.$this->_name.' 
                       SET '.$this->_right.' = '.$this->_right.' - '.$dif.' 
                     WHERE '.$this->_right.' >= '.$elt->$left ;
           // MAj des bornes gauches
           $upLb = 'UPDATE '.$this->_name.' 
                       SET '.$this->_left.' = '.$this->_left.' - '.$dif.' 
                     WHERE '.$this->_left.' > '.$elt->$left ;
 
           try{
               $this->_db->beginTransaction();
               $this->_db->prepare($dlElt)->execute();
               $this->_db->prepare($upRb)->execute();
               $this->_db->prepare($upLb)->execute();
               $this->_db->commit();
               return true;
           }catch(Exception $e){
                $this->_db->rollBack();
                return false ;
           }                  
       }
 
 
   }
 
   /**
    * Add a leaf at the node $id 
    * 
    * @param (array) $data
    * @param (int) $id
    * @return (mixed) false|int
    */
   public function insertByParent(array $data, $id){
       $elt = $this->getById($id);
       if ($elt instanceof Zend_Db_Table_Row_Abstract ){
           $right = $this->_right;
           $level = $this->_level;     
 
           // MAJ des bornes droites 
           $upRb = 'UPDATE '.$this->_name.' 
                       SET '.$this->_right.' = '.$this->_right.' + 2 
                     WHERE '.$this->_right.' >= '.$elt->$right ;
           // MAj des bornes gauches
           $upLb = 'UPDATE '.$this->_name.' 
                       SET '.$this->_left.' = '.$this->_left.' + 2 
                     WHERE '.$this->_left.' >= '.$elt->$right ;           
 
           $inElt = 'INSERT INTO '.$this->_name.' 
                      ( '.$this->_left.', '.$this->_right.', '.$this->_level.' ) 
                     VALUES ( '.$elt->$right.', '.($elt->$right+1).', '.($elt->$level+1).' ) ';
 
           try{
               $this->_db->beginTransaction();
               $this->_db->prepare($upRb)->execute();
               $this->_db->prepare($upLb)->execute();
               $this->_db->prepare($inElt)->execute();
               $this->_db->commit();
 
               $oElt = $this->fetchRow($this->_left.' = '.$elt->$right.' AND '.$this->_right.' = '.($elt->$right+1));
 
               // clean data
               foreach( $this->_primary as $primaryK ){
                   unset( $data[$primaryK] );
               }
               unset( $data[$this->_left] );
               unset( $data[$this->_right] );
               unset( $data[$this->_level] );
               $oElt->setFromArray($data);
               Zend_Debug::dump($data);                              
               return $oElt->save();
 
           }catch(Exception $e){
               $this->_db->rollBack();
           }            
       }
       return false ; 
   }
 
   /**
    * Update a node or a leaf, left and right border can not be update
    * 
    * @param (array) $data
    * @param (int) $id
    * @return boolean
    */
   public function updateById(array $data, $id){
       unset( $data[$this->_left] );
       unset( $data[$this->_right] );
       unset( $data[$this->_level] );
       $elt = $this->getById($id);
       if ( $elt instanceof Zend_Db_Table_Row_Abstract ){           
           try{
               $elt->setFromArray($data);
               $elt->save();
               return true;  
           }catch(Zend_Db_Exception $e){
               //@todo
           }
       }
       return false;
   }
 
 
   /**
    * Get node and leaf come from node identified by $id
    * @param (int) $id
    * @param (int) $level optional
    * @return (mixed) array|false
    */
   public function getChildren($id, $lvl = null){
      $elt = $this->getById($id);
      if ( $elt instanceof Zend_Db_Table_Row_Abstract ){
          $left  = $this->_left;
          $right = $this->_right;        
          $select = $this->select()->from($this->_name)  
                                   ->where($this->_left.' > ? ', $elt->$left )
                                   ->where($this->_right.' < ? ', $elt->$right );
          if ( $lvl !== null && (int) $lvl > 0 ){
              $level = $this->_level ;
              $select->where($this->_level.' <= ? ', $elt->$level + (int) $lvl );
          }
          return $select->query()->fetchAll();          
      }else{
          return false;
      }   
   }
 
 
   /**
    * get parent of the element 
    * @param (int) $id
    * @return (mixed) Zend_Db_Table_Row_Abstract|false
    */
   public function getParent($id){
       $elt = $this->getById($id);
       if ( $elt instanceof Zend_Db_Table_Row_Abstract ){
           $left  = $this->_left  ;
           $level = $this->_level ;
           $select = $this->select()->from($this->_name)
                                    ->where($this->_left.' < ?',$elt->$left )
                                    ->where($this->_level.' = ?',$elt->$level-1)
                                     ->order($this->_left.' DESC' )
                                    ->limit(1);
           return $select->query()->fetchAll(); 
       }else{
           return false;
       }
   }
 
 
   /**
    * count children of an element 
    * @param $id
    * @return (mixed) false|int
    */
   public function countChildren($id){
       $return = $this->getChildren($id) ;
       return $return === false  ? false : count($return) ;
   }
 
   /**
    * return number of node of the element $id
    * @param (int) $id
    * @return (mixed) false|int
    */
   public function countNode($id){
       $oElt = $this->getById($id);
       if ( $oElt instanceof Zend_Db_Table_Row_Abstract ){
           $left   = $this->_left  ;
           $right  = $this->_right ;     
           $select = $this->select()
                          ->from($this->_name, array('count(id) as nb') )  
                          ->where($this->_right.' - '.$this->_left.' <> 1 ')
                          ->where($this->_left.' > ? ' , $oElt->$left )
                          ->where($this->_right.' < ? ', $oElt->$right );
           return $select->query()->fetchColumn(0);
       }
       return false ;
   }
 
   /**
    * 
    * @param (int) $id
    * @return (mixed) false|int 
    */
   public function countLeaf($id){
       $oElt = $this->getById($id);
       if ( $oElt instanceof Zend_Db_Table_Row_Abstract ){
           $left   = $this->_left  ;
           $right  = $this->_right ;
           $select = $this->select()
                          ->from($this->_name, array('count(id) as nb') )  
                          ->where($this->_right.' - '.$this->_left.' = 1 ')
                          ->where($this->_left.' > ? ' , $oElt->$left )
                          ->where($this->_right.' < ? ', $oElt->$right );
           return $select->query()->fetchColumn(0);           
       }
       return false ;       
   }
 
   /**
    * Move a subtree (node or leaf are allowed to move)
    * 
    * @param (int) $id
    * @param (int) $newParentId
    * @return (boolean)
    */
 
   public function moveTree($id, $newParentId){       
       $oEltToMove    = $this->getById($id);
       $oEltToReceive = $this->getById($newParentId);
 
       if ( $oEltToMove    instanceof Zend_Db_Table_Row_Abstract &&
            $oEltToReceive instanceof Zend_Db_Table_Row_Abstract ){
           $left   = $this->_left  ;
           $right  = $this->_right ;
 
           if ( $this->countChildren($id) >= 0 ){
               $data = $oEltToMove->toArray();
               $newId = $this->insertByParent($data, $newParentId);              
               $children = $this->getChildren($id, 1);
               foreach( $children as $child ){
                   $this->moveTree($child['id'], $newId );
               }
               $this->deleteById($id);
           }
 
      }
      return false;
 
   }
 
}

NB: moveTree est une fonction récursive elle fonctionne de manière atomique mais il peut potentiellement avoir des données orphelines si la procédure est interrompue pour X raisons :’(. Il faut que je regardes comment je pourrais gérer ca de manière transactionnelle, histoire qu’une interruption ne cause aucun soucis.

Je mettrai ici les différentes articles ne semblant pas être de la propagande pro/anti Hadopi mais me semblant être neutre

http://www.smashingmagazine.com/2009/03/02/40-stand-alone-javascript-libraries-for-specific-purposes/

Il me reste plus qu’a les analyser et faire un petit point dessus

Utilitaire JS http://www.smashingmagazine.com/2009/02/08/50-extremely-useful-javascript-tools/

Subversion http://www.simpleentrepreneur.com/2009/03/18/les-operations-de-base-dans-subversion/