Bubble Sweat Bubble - développement

Dissimuler les liens mailto des pages html

Olivier — Sun, 11 Nov 2007 20:54:00 +0100

Vu sur http://www.alistapart.com/comments/gracefulemailobfuscation/ :

Une technique intéressante pour supprimer les liens mailto sur une page html et donc empêcher la détection des adresses emails par les robots des spameurs.... La technique n'est toute fois pas parfaite (elle ne permet pas de gérer le caractère '+' des adresses emails) mais l'idée est là...

Classe php5 pour l'API Fotolia utilisant le Zend Framework

Olivier — Fri, 09 Nov 2007 04:50:00 +0100

Dans la lignée de mon post précédent, voici le code d'une classe implémentant de façon simple l'API XML-RPC de Fotolia avec le Zend Framework.

Je précise à tout hasard que ce code est livré tel quel et que je ne suis pas responsable de tout problème pouvant survenir de son utilisation.
La licence du code est la licence BSD.
Pour ceux que ça intéresse, cette classe fait l'objet d'une proposition pour intégrer le framework.
Vous pouvez suivre son évolution ici : http://framework.zend.com/wiki/display/ZFPROP/Zend_Service_Fotolia

<?php
require_once 'Zend/Service/Exception.php';
require_once 'Zend/Http/Client.php';
require_once 'Zend/XmlRpc/Client.php';

class Zend_Service_Fotolia_Exception extends Zend_Service_Exception
{
}

class Zend_Service_Fotolia
{
    /**
     * Fotolia xml-rpc uri
     */
    const FOTOLIA_URI = 'http://www.fotolia.com/Xmlrpc/rpc';

    /**
     * API key
     *
     * @var $_key string
     */
    private $_key;

    /**
     * XML-RPC client
     *
     * @var $_client Zend_XmlRpc_Client
     */
    private $_client;

    /**
     * Proxy instances array
     *
     * @var $_proxies array
     */
    private $_proxies;

    /**
     * Current session id
     *
     * @var $_session_id string
     */
    private $_session_id;

    /**
     * Constructor
     *
     * @param  string $apiKey
     */
    public function __construct($apiKey)
    {
        $this->_key = $apiKey;
        $this->_session_id = NULL;
        $http = new Zend_Http_Client();
        $http->setCookieJar();
        $this->_client = new Zend_XmlRpc_Client(self::FOTOLIA_URI, $http);
    }

    /**
     * Returns current api key
     *
     * return string
     */
    public function getApiKey()
    {
        return $this->_key;
    }

    /**
     * This method makes possible to search media in fotolia image bank.
     * Full search capabilities are available through the API
     *
     * @param  array  $searchParams
     * @return array
     */
    public function getSearchResults($searchParams)
    {
        return $this->__call('getSearchResults',
                             array($this->_key,
                                   $searchParams));
    }

    /**
     * This method returns childs of a parent category in fotolia representative category system.
     * This method could be used to display a part of the category system or the all tree.
     * Fotolia categories system counts three levels.
     *
     * @param  int    $language_id
     * @param  int    $id
     * @param  int    $category_type_id
     * @return array
     */
    public function getCategories1($language_id = 2, $id = 0, $category_type_id = 1)
    {
        return $this->__call('getCategories1',
                             array($this->_key,
                                   $language_id,
                                   $id,
                                   $category_type_id));
    }

    /**
     * This method returns childs of a parent category in fotolia conceptual category system.
     * This method could be used to display a part of the category system or the all tree.
     * Fotolia categories system counts three levels.
     *
     * @param  int    $language_id
     * @param  int    $id
     * @return array
     */
    public function getCategories2($language_id = 2, $id = 0)
    {
        return $this->__call('getCategories2',
                             array($this->_key, $language_id, $id));
    }

    /**
     * This method returns most searched tag and most used tag on fotolia website.
     * This method may help you to create a tags cloud.
     *
     * @param  int    $language_id
     * @param  string $type
     * @return array
     */
    public function getTags($language_id = 2, $type = 'Used')
    {
        return $this->_call('getTags',
                            array($this->_key, $language_id, $type));
    }

    /**
     * This method returns public galleries for a defined language
     *
     * @param  int    $language_id
     * @return array
     */
    public function getGalleries($language_id = 2)
    {
        return $this->__call('getGalleries',
                             array($this->_key, $language_id));
    }

    /**
     * This method returns childs of a parent colors in the Fotolia color scheme.
     * If no parent is provided first level colors are returned.
     * This method can be used to display color and subcolors for color search queries.
     *
     * @param  int    $id
     * @return array
     */
    public function getColors($id = 0)
    {
        return $this->__call('getColors', array($this->_key, $id));
    }

    /**
     * This method returns Fotolia list of countries.
     *
     * @param  int    $language_id
     * @return array
     */
    public function getCountries($language_id = 2)
    {
        return $this->__call('getCountries',
                             array($this->_key, $language_id));
    }

    /**
     * This method returns fotolia data
     *
     * @return array
     */
    public function getData()
    {
        return $this->__call('getData', array($this->_key));
    }

    /**
     * This method is a test method which returns success if connexion is valid
     *
     * @return array
     */
    public function test()
    {
        return $this->__call('test', array($this->_key));
    }

    /**
     * This method return all information about a media
     *
     * @param  int    $id
     * @param  int    $thumbnail_size
     * @param  int    $language_id
     * @return array
     */
    public function getMediaData($id, $thumbnail_size = 110, $language_id = 2)
    {
        return $this->__call('getMediaData',
                             array($this->_key,
                                   $id,
                                   $thumbnail_size,
                                   $language_id));
    }

    /**
     * This method return private galleries for logged user
     *
     * @param  int    $id
     * @param  int    $language_id
     * @param  int    $thumbnail_size
     * @return array
     */
    public function getMediaGalleries($id, $language_id = 2, $thumbnail_size = 110)
    {
        return $this->__call('getMediaData',
                             array($this->_key,
                                   $id,
                                   $language_id,
                                   $thumbnail_size));
    }

    /**
     * This method allows to purchase a media and returns url to the purchased file
     *
     * @param  int    $id
     * @param  string $license_name
     * @return array
     */
    public function getMedia($id, $license_name)
    {
        return $this->__call('getMedia',
                             array($this->_key,
                                   $this->_getSessionId(),
                                   $id,
                                   $license_name));
    }

    /**
     * This method returns comp images. Comp images can ONLY be used to evaluate the image
     * as to suitability for a project, obtain client or internal company approvals,
     * or experiment with layout alternatives.
     *
     * @param  int    $id
     * @return array
     */
    public function getMediaComp($id)
    {
        return $this->__call('getMediaComp',
                             array($this->_key, $id));
    }

    /**
     * Authenticate an user
     *
     * @param  string $login User login
     * @param  string $pass User password
     */
    public function loginUser($login, $pass)
    {
        $res = $this->__call('loginUser',
                             array($this->_key,
                                   $login,
                                   $pass));
        $this->_session_id = $res['session_id'];
    }

    /**
     * Log out an user
     */
    public function logoutUser()
    {
        $this->__call('logoutUser',
                      array($this->key,
                            $this->_getSessionId()));
        $this->_session_id = NULL;
    }

    /**
     * This method returns data for logged user.
     *
     * @return array
     */
    public function getUserData()
    {
        return $this->__call('getUserData',
                             array($this->_key,
                                   $this->_getSessionId()));
    }

    /**
     * This method allows you to get sales/views/income statistics from your account.
     *
     * @param  string $type
     * @param  string $time_range
     * @param  string $easy_date_period
     * @param  string $start_date
     * @param  string $end_date
     * @return array
     */
    public function getUserAdvancedStats($type,
                                         $time_range,
                                         $easy_date_period=NULL,
                                         $start_date=NULL,
                                         $end_date=NULL)
    {
        return $this->__call('getUserAdvancedStats',
                             array($this->_key,
                                   $this->_getSessionId(),
                                   $type,
                                   $time_range,
                                   $easy_date_period,
                                   $start_date,
                                   $end_date));
    }

    /**
     * This methods returns statistics for logged user
     *
     * @return array
     */
    public function getUserStats()
    {
        return $this->__call('getUserStats',
                             array($this->_key,
                                   $this->_getSessionId()));
    }

    /**
     * Delete a user's gallery
     *
     * @param  string $id
     */
    public function deleteUserGallery($id)
    {
        $this->__call('deleteUserGallery',
                      array($this->_key,
                            $this->_getSessionId(),
                            $id));
    }

    /**
     * This method allows you to create a new gallery in your account.
     *
     * @param  string $name
     * @return array
     */
    public function createUserGallery($name)
    {
        return $this->__call('createUserGallery',
                             array($this->_key,
                                   $this->_getSessionId(),
                                   $name));
    }

    /**
     * This method allows you to add a content to your default lightbox or any of your existing galleries
     *
     * @param  int    $content_id
     * @param  string $id
     * @return array
     */
    public function addToUserGallery($content_id, $id = '')
    {
        return $this->__call('addToUserGallery',
                             array($this->_key,
                                   $this->_getSessionId(),
                                   $content_id,
                                   $id));
    }

    /**
     * This method allows you to remove a content from your default lightbox or any of your existing galleries
     *
     * @param  int    $content_id
     * @param  string $id
     * @return array
     */
    public function removeFromUserGallery($content_id, $id = '')
    {
        return $this->__call('removeFromUserGallery',
                             array($this->_key,
                                   $this->_getSessionId(),
                                   $content_id,
                                   $id));
    }

    /**
     * This method allows to search media in logged user galleries or lightbox.
     *
     * @param  int    $page
     * @param  int    $per_page
     * @param  int    $thumbnail_size
     * @param  string $id
     * @return array
     */
    public function getUserGalleryMedias($page = 0,
                                         $per_page = 32,
                                         $thumbnail_size = 110,
                                         $id = '')
    {
        return $this->__call('getUserGalleryMedias',
                             array($this->_key,
                                   $this->_getSessionId(),
                                   $page,
                                   $per_page,
                                   $thumbnail_size,
                                   $id));
    }

    /**
     * This method returns private galleries for logged user.
     *
     * @return array
     */
    public function getUserGalleries()
    {
        return $this->__call('getUserGalleries',
                             array($this->_key,
                                   $this->_getSessionId()));
    }

    /**
     * Magic method used to call fotolia xml-rpc functions
     *
     * @param  string $method
     * @param  array  $args
     * @return array
     * @throws Zend_Service_Fotolia_Exception
     */
    public function __call($method, $args)
    {
        $obj = $this->_getProxy($this->_getNamespace($method));
        try {
            return $obj->__call($method, $args);
        } catch (Zend_XmlRpc_Client_Exception $e) {
            throw new Zend_Service_Fotolia_Exception($e->getMessage(),
                                                     $e->getCode());
        }
    }

    /**
     * Returns xml-rpc client
     *
     * @return Zend_XmlRpc_Client
     */
    public function getClient()
    {
        return $this->_client;
    }

    /**
     * Returns namespace associated to given method name
     *
     * @param  string $method
     * @return string
     */
    protected function _getNamespace($method)
    {
        switch ($method) {
        case 'getSearchResults':
        case 'getCategories1':
        case 'getCategories2':
        case 'getTags':
        case 'getGalleries':
        case 'getColors':
        case 'getCountries':
            return 'search';
        case 'getMediaData':
        case 'getMediaGalleries':
        case 'getMedia':
        case 'getMediaComp':
            return 'media';
        case 'loginUSer':
        case 'logoutUser':
        case 'getUserData':
        case 'getUserGalleries':
        case 'getUserGalleryMedias':
        case 'deleteUserGallery':
        case 'createUserGallery':
        case 'addToUserGallery':
        case 'removeFromUserGallery':
        case 'getUSerAdvancedStats':
            return 'user';
        case 'getData':
        case 'test':
            return 'main';
        default:
            return 'xmlrpc';
        }
    }

    /**
     * Returns a xml-rpc proxy instance from a namespace
     *
     * @param  string $namespace
     * @return Zend_xmlRpc_Client_ServerProxy
     * @throws Zend_Service_Fotolia_Exception
     */
    protected function _getProxy($namespace)
    {
        if (!isset($this->_proxies[$namespace])) {
            $valid = array('xmlrpc', 'search', 'media', 'user', 'main');
            if (!in_array($namespace, $valid)) {
                throw new Zend_Service_Fotolia_Exception('invalid namespace');
            }

            $this->_proxies[$namespace] = $this->_client->getProxy($namespace);
        }

        return $this->_proxies[$namespace];
    }

    /**
     * Returns current session id
     *
     * @return string
     * @throws Zend_Service_Fotolia_Exception
     */
    protected function _getSessionId()
    {
        if ($this->_session_id === NULL) {
            throw new Zend_Service_Fotolia_Exception('session id not set, please use loginUser method before');
        }

        return $this->_session_id;
    }
}

Utiliser l'API XML-RPC Fotolia en php5

Olivier — Thu, 08 Nov 2007 11:17:00 +0100

Afin d'utiliser l'api de Fotolia il est nécessaire d'obtenir une clé API.
Si vous n'en avez pas déjà une, il suffit d'aller dans votre compte, section "outils" puis de cliquer sur l'onglet "api".
Une fois que votre clé API aura été validée par l'équipe Fotolia vous pourrez commencer à utiliser leur service xml-rpc.
Lire la documentation sera bien sûr bienvenue !

Voici un exemple de recherche sur Fotolia via le composant Zend_XmlRpc_Client du Zend Framework.

require_once 'Zend/Loader.php';

Zend_Loader::registerAutoload();
$client = new Zend_XmlRpc_Client('http://www.fotolia.com/Xmlrpc/rpc');

// on récupère l'objet correspondant à l'espace de noms 'system'
$system = $client->getProxy('system');

// on affiche la liste des méthodes supportées par le serveur
echo "Méthodes disponibles :\n";
print_r($system->listMethods());

// on affiche l'aide xml-rpc de la méthode search.getSearchResults
echo "Aide du serveur :\n";
echo $system->methodHelp('search.getSearchResults');

// clé API fotolia
$api_key = 'ma clé api fotolia';

// on récupère l'objet correspondant à l'espace de noms 'search'
$search = $client->getProxy('search');

// on recherche toutes les photos de bulldog anglais sur le site US
$results = $search->getSearchResults($api_key,
                                     array('words' => 'bulldog anglais'));

// on recherche toutes les photos de bulldog anglais sur le site français
$results = $search->getSearchResults($api_key,
                                     array('words' => 'bulldog anglais',
                                           'language_id' => 1));

// on recherche les 10 première photos de bulldog anglais sur le site français
$results = $search->getSearchResults($api_key,
                                     array('words' => 'bulldog anglais',
                                           'language_id' => 1,
                                           'limit' => 10));

// on affiche les résultats de la recherche
foreach ($results as $result) {
    echo 'Photo #' . $result['id'] . "\\n";
    echo 'Titre : ' . $result['title'] . "\\n";
    echo 'Auteur : ' . $result['creator_name'] . "\\n";
    echo 'Miniature de la photo : ' . $result['thumbnail_url'] . "\\n";
    echo 'Tag html à utiliser : ' . $result['thumbnail_html_tag'] . "\\n";
    echo "\\n";
}

Exemple de requête nécessitant une identification préalable :

require_once 'Zend/Loader.php';

Zend_Loader::registerAutoload();

// on utilise un client http avec le support des cookies activé
$http_client = new Zend_Http_Client();
$http_client->setCookieJar();
$client = new Zend_XmlRpc_Client('http://www.fotolia.com/Xmlrpc/rpc',
                                 $http_client);

// clé API fotolia
$api_key = 'ma clé api fotolia';

// on récupère l'objet correspondant à l'espace de noms 'user'
$user = $client->getProxy('user');

// on s'identifie
$res = $user->loginUser($api_key, 'identifiant', 'mot de passe');
$sess_id = $res['session_id'];

// on récupère les statistiques du compte
$stats = $user->getUserStats($api_key, $sess_id);

echo 'Nombre de médias envoyés : ' . $stats['nb_media_uploaded'] . "\\n";
echo 'Nombre de médias validés : ' . $stats['nb_media_accepted'] . "\\n";
echo 'Nombre de médias achetés : ' . $stats['nb_media_purchased'] . "\\n";
echo 'Nombre de médias vendus : ' . $stats['nb_media_sold'] . "\\n";
echo 'Classement du compte : ' . $stats['ranking_absolute'] . "\\n";
echo 'Classement du compte sur les 7 derniers jours : ' . $stats['ranking_relative'] . "\\n";

Comme vous le voyez, il est très simple d'accéder à toute la puissance de Fotolia grâce au Zend Framework !

sprintf en Javascript

Olivier — Thu, 07 Jun 2007 10:54:00 +0200

Javascript ne propose pas en standard de fonction sprintf pourtant si pratique.... Voilà le code de cette fonction trouvée sur http://jan.moesen.nu/ :

// This code is in the public domain. Feel free to link back to http://jan.moesen.nu/
function sprintf() {
    if (!arguments || arguments.length < 1 || !RegExp) {
        return;
    }

    var str = arguments[0];
    var re = /([^%]*)%('.|0|\x20)?(-)?(\d+)?(\.\d+)?(%|b|c|d|u|f|o|s|x|X)(.*)/;
    var a = b = [], numSubstitutions = 0, numMatches = 0;
    while (a = re.exec(str)) {
        var leftpart = a[1], pPad = a[2], pJustify = a[3], pMinLength = a[4];
        var pPrecision = a[5], pType = a[6], rightPart = a[7];

        numMatches++;

        if (pType == '%') {
            subst = '%';
        } else {
            numSubstitutions++;
            if (numSubstitutions >= arguments.length) {
                alert('Error! Not enough function arguments (' + (arguments.length - 1) + ', excluding the string)\nfor the number of substitution parameters in string (' + numSubstitutions + ' so far).');
            }

            var param = arguments[numSubstitutions];
            var pad = '';
            if (pPad && pPad.substr(0,1) == "'") {
                pad = leftpart.substr(1,1);
            } else if (pPad) {
                pad = pPad;
            }

            var justifyRight = true;
            if (pJustify && pJustify === "-") {
                justifyRight = false;
            }

            var minLength = -1;
            if (pMinLength) {
                minLength = parseInt(pMinLength);
            }

            var precision = -1;
            if (pPrecision && pType == 'f') {
                precision = parseInt(pPrecision.substring(1));
            }

            var subst = param;
            if (pType == 'b') {
                subst = parseInt(param).toString(2);
            } else if (pType == 'c') {
                subst = String.fromCharCode(parseInt(param));
            } else if (pType == 'd') {
                subst = parseInt(param) ? parseInt(param) : 0;
            } else if (pType == 'u') {
                subst = Math.abs(param);
            } else if (pType == 'f') {
                subst = (precision > -1) ? Math.round(parseFloat(param) * Math.pow(10, precision)) / Math.pow(10, precision): parseFloat(param);
            } else if (pType == 'o') {
                subst = parseInt(param).toString(8);
            } else if (pType == 's') {
                subst = param;
            } else if (pType == 'x') {
                subst = ('' + parseInt(param).toString(16)).toLowerCase();
            } else if (pType == 'X') {
                subst = ('' + parseInt(param).toString(16)).toUpperCase();
            }
        }

        str = leftpart + subst + rightPart;
    }

    return str;
}

Lightbox ou comment attirer l'attention

Olivier — Wed, 16 Aug 2006 20:23:00 +0200

Pour ceux qui se demande comment réaliser un effet de boîte de dialogue rendant inaccessible ce qui est derrière lui, autrement dit un comportement basique de n'importe quel système de fenêtres, une solution en javascript se nomme Lightbox.

Il s'agit d'une bibliothèque javascript qui permet d'afficher une boîte de dialogue de façon élégante et rapide de façon très simple. On peut l'utiliser en lui donnant une url ou charger ses données ou alors les lui donner directement.
Pour ceux qui ont déjà fait de jolis formulaires on peut aussi très facilement les relier au système lightbox.
Seul bémol en ce qui me concerne : le code n'est pas écrit en objet.

Zend Framework

Olivier — Tue, 15 Aug 2006 16:03:00 +0200

J'ai longtemps cherché un framework intéressant à utiliser en php.

Tous les framework que j'avais pu trouvé ne me plaisaient pas : ils étaient ou trop lourd ou trop simple et dans les deux cas compliqués à mettre en oeuvre dans un projet industriel.

Mais voilà que Zend a répondu à mon besoin !
Ce framework est conçu sur le modèle MVC et est très modulaire.
Le fait qu'il soit supporté par Zend lui donne un côté pérenne qui n'est pas fait pour me déplaire !

Travailler avec des fichiers .po

Olivier — Thu, 26 Jan 2006 23:47:00 +0100

Les fichiers .po sont les fichiers utilisés par les systèmes de traduction utilisant gettext. Un exemple de fichier .po pourrait être :


# message à traduire
msgid "Hello world!"
# message traduit
msgstr "Bonjour monde !"

Ce n'est pas les fichiers .po qui sont utilisés à proprement parler par gettext mais une version binaire du fichier en extension .mo.

Un tel fichier est généré par une commande du type : msgfmt -o mon_fichier.mo mon_fichier.po

Comme d'habitude, se réferer à la page de manuel de la commande msgfmt pour de plus amples informations sur ses possibilités.