Suite à tous mes posts de ce matin, j’ai cherché une façon de générer un titre à mes notes, que je publie généralement via la Web app quill.p3k.io développée par Aaron Pareki.

Il existe de nombreux filtres pour agir sur le contenu d’un post ou d’une page, mais la plupart sont exécutés à l’affichage comme the_title ou the_content, ou encore à la modification comme le filtre save_post.

On pourrait très bien générer notre titre après l’enregistrement dans la base de données, mais dans mon cas je souhaitais définir le titre et le permalien avant, simplement pour éviter que le partage sur Mastodon se fasse sans titre défini dans les metadonnées utilisées par OpenGraph.

Heureusement, il existe un filtre sur lequel agir pour ça : wp_insert_post_data.

Voici comment j’ai reussi :

function generate_post_title($data)
{
    if (empty($data['post_title'])) {

        $content = $data['post_content'];

        $pieces = explode(" ", $content);
        $first_part = implode(" ", array_splice($pieces, 0, 5));

        $data['post_title'] = $first_part; // Defines post title
        $data['post_name'] = sanitize_title($first_part); // Defines post slug
    }
    return $data; // Returns the modified data.
}
add_filter('wp_insert_post_data', 'generate_post_title', '99', 1);

Je pourrais toujours l’améliorer par la suite, par exemple :

• en prenant la première phrase de mon contenu, plutôt que les cinq premiers mots actuellement,
• en ajoutant des points de suspensions lorsque la première phrase dépasse les six mots.

J’espère que ce petit morceau de code vous aidera.

Minute papillon !

Qu’est-ce qu’on va faire exactement?

Voilà comment ça va se passer : d’abord on va modifier notre fichier de configuration Apache pour activer et utiliser des hôtes virtuels. Une fois ceci fait, on pourra définir des URLs personnalisés que l’on attribuera aux différents dossiers présents dans notre dossier Repositories.

Une fois qu’on aura fait ça, on va nettoyer un peu le bazard en séparant nos vhosts dans plusieurs fichiers pour que tout ça soit le plus facile possible à maintenir.

Aller, go !

Un peu de préparation

D’abord, on va ouvrir les quelques fichiers dont on va avoir besoin pour configurer nos hôtes virtuels. Ouvrez les fichiers suivants dans votre éditeur :

• /usr/local/etc/httpd/httpd.conf
• /usr/local/etc/httpd/extra/httpd-vhosts.conf
• /etc/hosts

Attention ! Si vous avez un Mac avec un processeur Apple (M1, M2, etc.) les fichiers dans lesquels on travaillera seront ceux-ci :

• /opt/homebrew/etc/httpd/httpd.conf
• /opt/homebrew/etc/httpd/extra/httpd-vhosts.conf
• /private/etc/hosts

Si vous n’avez pas déjà des projets dans votre dossier Repositories, créez en quelques uns :

Repositories/
|_ nighcrawl/
|  |_ html/
|  |_ logs/
|
|_ cv/
   |_ html/
   |_ logs/

Nos premiers virtual hosts

Nous allons maintenant créer nos tout premiers hôtes virtuels. Ils auront chacun une URL et un “document root” (le dossier dans lequel l’URL pointera) qui leur seront propres. L’URL http://nighcrawl.local pointera sur le dossier ~/Repositories/nighcrawl/html/ tandis que http://cv.local pointera sur ~/Repositories/cv/html/.

Dans httpd.conf

Trouvez la ligne suivante et décommentez la (il suffit de supprimer le # devant la ligne) :

#LoadModule vhost_alias_module lib/httpd/modules/mod_vhost_alias.so

Faites de même pour la ligne suivante :

#Include /usr/local/etc/httpd/extra/httpd-vhosts.conf

Attention ! Pour les processeurs Apple, la ligne à décommenter sera celle-ci :

#Include /opt/homebrew/etc/httpd/extra/httpd-vhosts.conf

Dans le fichier httpd-vhosts.conf

Si votre fichier contient déjà des configs, vous pouvez les supprimer si vous êtes certain qu’elles ne vous servent pas. On peut ajouter les configs suivantes pour déclarer nos virtual hosts http://nighcrawl.local et http://cv.local :

    DocumentRoot "/Users/YOUR_USERNAME/Repositories/nighcrawl/html"
    ServerName nighcrawl.local
    ErrorLog "/Users/YOUR_USERNAME/Repositories/nighcrawl/logs/error_log"
    CustomLog "/Users/YOUR_USERNAME/Repositories/nighcrawl/logs/access_log" common



    DocumentRoot "/Users/YOUR_USERNAME/Repositories/cv/html"
    ServerName bar.lo
    ErrorLog "/Users/YOUR_USERNAME/Repositories/cv/logs/error_log"
    CustomLog "/Users/YOUR_USERNAME/Repositories/cv/logs/access_log" common

Modification du fichier hosts

Pour que vos nouvelles URLs personnalisées soient reconnues, il va falloir leur dire sur quelle adresse IP elles devront pointer. Comme ces deux sites Web sont en local sur votre machine, leur adresse IP sera donc 127.0.0.1. Il faut alors ajouter ces deux ligne à la fin de votre fichier :

127.0.0.1   nighcrawl.local
127.0.0.1   cv.local

Après avoir effectué tout ces changements, on relancera Apache avec la commande suivante dans un Terminal :

$ brew services restart httpd

Vous devriez alors voir un beau message “Index of /” si vous ouvrez http://nighcrawl.local et http://cv.local dans votre navigateur.

Ça fonctionne ! Vous n’avez plus qu’à mettre les fichiers HTML/PHP/JS/etc.. dans chaque projet .

Ranger le bazard

Maintenant que nos vhosts fonctionnent, il est temps de prévoir le futur et de faire quelques ajustements afin qu’il soit beaucoup plus facile de créer ou modifier des vhosts sans risquer de se perdre.

Moi par exemple, j’ai plus de 50 virtual hosts configurés sur ma machine… Un peu chaud de s’y retrouver si il faut modifier un vhost.

C’est pourquoi on va créer un fichier par virtual host plutôt que de les avoir tous dans un seul fichier, ce sera beaucoup plus maintenable.

Un fichier par virtual host

J’ai l’habitude de rassembler tous mes fichiers de vhosts dans un dossier sites-available/ dans le dossier /usr/local/etc/httpd/ ( /opt/homebrew/etc/httpd/ pour les processeurs Apple).

Du coup on va déplacer nos configs pour http://nighcrawl.local dans un fichier /usr/local/etc/httpd/sites-available/nighcrawl.conf

# nighcrawl.conf

    DocumentRoot "/Users/YOUR_USERNAME/Repositories/nighcrawl/html"
    ServerName nighcrawl.local
    ErrorLog "/Users/YOUR_USERNAME/Repositories/nighcrawl/logs/error_log"
    CustomLog "/Users/YOUR_USERNAME/Repositories/nighcrawl/logs/access_log" common

et celle pour http://cv.local dans un fichier /usr/local/etc/httpd/sites-available/cv.conf.

# cv.conf

    DocumentRoot "/Users/YOUR_USERNAME/Repositories/cv/html"
    ServerName bar.lo
    ErrorLog "/Users/YOUR_USERNAME/Repositories/cv/logs/error_log"
    CustomLog "/Users/YOUR_USERNAME/Repositories/cv/logs/access_log" common

Attention à adapter si vous avez un processeur Apple .

Mettre à jour httpd-vhosts.conf

Maintenant que nos hôtes virtuels ont leur propre fichier de config, on peu les supprimer du fichier httpd-vhosts.conf.

Après ça, on va simplement inclure chaque fichier .confprésent dans notre dossier sites-available/ grâce à cette ligne :

# Pour les processeurs Intel
Include /usr/local/etc/httpd/sites-available/*.conf

# Pour les processeurs Apple
Include /opt/homebrew/etc/httpd/sites-available/*.conf

On redémarre à nouveau le services Apache avec brew services restart httpd et tout devrait rouler comme avant, mais en mieux.

Aller encore plus loin

Pour aller plus loin et gagner du temps lors de la création d’un nouvel hôte virtuel, j’utilise un script bash qui me permet de faire tout ceci en une seule ligne de commande.

Voici une version édulcorée de mon script vhost.sh :

#!/bin/bash
USER="achierchia"
CONF_FOLDER="/opt/homebrew/etc/httpd/sites-available/"
SITES_FOLDER="Repositories"

if [ "$USER" == "" ] || [ "$CONF_FOLDER" == "" ] || [ "$SITES_FOLDER" == "" ]; then
	echo "You must set the variables USER, CONF_FOLDER and SITES_FOLDER in the script!"
	echo ""
	exit
fi

if [ "$(whoami)" != "root" ]; then
    echo -ne "e[0;101m You must be root to use this script! e[0;49m "
    echo ""
    exit
fi

domain=""
createFolder="N"

while getopts d:f: flag 
do
	case "${flag}" in
		d) domain=${OPTARG};;
		f) createFolder=${OPTARG};;
	esac
done

if [[ "$createFolder" =~ ^[Yy]$ ]]; 
then
    echo "Création du dossier ${domain} dans ${SITES_FOLDER}..."
    cd /Users/${USER}/${SITES_FOLDER}/
	mkdir $domain
	cd /Users/${USER}/${SITES_FOLDER}/${domain}/
	mkdir logs
fi

accessLog="${domain}_access"
errorLog="${domain}_error"

echo "Création du fichier de config..."
cd $CONF_FOLDER
sudo -u $USER -i -- cat >> ${domain}.conf << EOF

	ServerName ${domain}.local

	DocumentRoot /Users/${USER}/${SITES_FOLDER}/${domain}
	DirectoryIndex index.php index.html
	
		Options -Indexes +FollowSymLinks +MultiViews
		AllowOverride All
		Require all granted
	

	LogLevel warn

	ErrorLog /Users/${USER}/${SITES_FOLDER}/${domain}/logs/${errorLog}.log
	CustomLog /Users/${USER}/${SITES_FOLDER}/${domain}/logs/${accessLog}.log combined

EOF

echo "Mise à jour du fichier hosts..."
HOSTURL=$domain".local"
HOSTCONF="127.0.0.1t"$HOSTURL"twww."$HOSTURL
sed -i -- "s/# local end/"$HOSTCONF"n# local end/g" /etc/hosts

echo "Modification des privileges du fichier conf"
cd ${CONF_FOLDER}
sudo chown $USER "${domain}.conf"
cd /Users/${USER}/${SITES_FOLDER}/${domain}/logs/
sudo chown $USER "${accessLog}.log" "${errorLog}.log"

echo "Redémarrage du serveur Apache..."
sudo -u $USER -i -- brew services restart httpd

Pour l’utiliser il suffit d’executer cette commande :

$ sudo sh vhost.sh -d monsiteweb -f Y

Ce script permet de :

• Créer un dossier monsiteweb/ dans le dossier $SITES_FOLDER paramétré.
• Créer le fichier de config vhost monsiteweb.conf dans le dossier $CONF_FOLDER.
• Déclarer monsiteweb.local dans le fichier hosts
• Relancer le serveur Apache

Si on ne souhaite pas créer le dossier du projet, par exemple parce qu’il existe déjà, on peux lancer cette commande :

$ sudo sh vhost.sh -d monsiteweb -f N

Lorsque je travaillais chez Ibakus Europe, on développait des projets Symfony, du coup on n’avait pas besoin d’un MAMP pour faire tourner le projet, compiler les fichiers Sass et/ou JavaScript. Webpack s’en chargeait.

En arrivant chez Concept Factory, MAMP Pro était déjà bien utilisé dans l’équipe Front. Parfois lorsqu’on travaille avec l’équipe Symfony sur un projet, on démarre Vagrant ou Docker dans lequel tout est déjà installé pour faire tourner le projet, seulement voilà, il faut arrêter MAMP pour pouvoir ensuite démarrer la machine virtuelle, va savoir pourquoi… Probablement une histoire de ports utilisés

Un moment donné je me suis dit “Et si j’abandonnais complètement MAMP et que j’installais un serveur local qui tournerai non-stop sur ma machine, ça me ferai gagner du temps, non ?”. Du coup, on va maintenant voir comment j’ai configuré mon serveur local.

Pré-requis

Avant de se lancer dans ce gros projet, il va falloir décider de l’emplacement où seront stockés les fichiers des différents sites Web que l’on créera sur notre serveur de développement. Ça n’est pas une étape très compliquée, mais c’est l’une des plus importante.

Choisir où placer nos fichiers PHP et HTML

Personnellement, j’ai un dossier Repositories à la racine de mon dossier utilisateur, dans lequel se trouvent les différents projets sur lesquels je travail. Puis dans ce dossier se trouve un fichier ìndex.html avec le message “Hello World!” dedans afin de vérifier que ma configuration Apache fonctionne. Je vous invite à faire de même, ou d’adapter en conséquences :

$ mkdir ~/Repositories
$ echo "Hello World!" > ~/Repositories/index.html

L’autre information importante qu’il nous faut, c’est notre nom d’utilisateur (en général, le nom de votre dossier dans /Users). Pour le connaitre, la commande $ whoami fera le boulot. Pour moi, par exemple c’est achierchia

Installer Homebrew

Tout d’abord, il nous faut Homebrew pour aller plus loin. Cette étape est super simple, dans l’application Terminal on lance cette commande :

$ /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Si tout se passe bien, la commande brew --version devrait afficher quelque chose comme ça :

$ brew --version
Homebrew 3.3.1
Homebrew/homebrew-core (git revision b97b0465deb; last commit 2021-10-26)
Homebrew/homebrew-cask (git revision f2232d8993; last commit 2021-10-26)

On est prêt à installer notre serveur local ! Passons à l’installation d’Apache.

Installer Apache

Par défaut, chaque version de macOS est fournie avec Apache et PHP préinstallés, mais pour des raisons pratique on préfèrera désactiver celles-ci et gérer nous même l’installation et la configuration des versions que l’on souhaite pour notre environement de développement.

Stopper et décharger la version d’Apache pré-installée

Afin de pouvoir installer notre propre serveur Apache, il faut d’abord arrêter celui qui tourne actuellement. Pour cela, rien de plus simple, il suffit d’exécuter les deux commandes suivantes dans votre Terminal :

$ sudo apachectl stop

Cette commande permet de stopper le serveur Apache, la suivante permettra de ne plus le démarrer la tâche de fond à l’ouverture de session :

$ sudo launchctl unload -w /Systems/Library/LaunchDaemons/org.apache.httpd.plist

Installation du paquet httpd via Homebrew

Maintenant qu’on a désactivé la version préinstallée d’Apache, on peut installer celle qu’on souhaite via la commande suivante :

brew install httpd

Cette commande installera la version courante d’Apache (v2.4.51 au moment où j’écris ces lignes).

Il faudra ensuite démarrer Apache en tâche de fond (gérée maintenant via Homebrew) grâce à cette commande :

$ brew services start httpd

Si vous allez maintenant sur http://localhost:8080/ via votre navigateur Web préféré vous devriez voir un superbe “It works!”.

Bravo Apache est installé et fonctionne, on va pouvoir adapter la configuration et lui dire où aller chercher nos fichiers !

Configurer Apache

Ici on va devoir modifier pas mal de petites choses, et c’est en général à ce moment là que ça pète si on ne fait pas bien attention.

On va donc ouvrir le fichier de configuration d’Apache dans l’éditeur de texte de notre choix, pour moi c’est VSCode :).

Si vous avez un Mac avec un processeur Intel, le fichier se trouvera à cet endroit : /usr/local/etc/httpd/httpd.conf. Pour les Mac avec un processeur Apple (M1, M1 Pro, M1 Max), il faudra ouvrir ce fichier /opt/homebrew/etc/httpd/httpd.conf.

Il faudra remplacer les choses suivantes :

• Listen 8080 Listen 80
• DocumentRoot "/usr/local/var/www" DocumentRoot "/Users/VOTRE_USERNAME/Repositories"
• <Directory "/usr/local/var/www"> <Directory "/Users/VOTRE_USERNAME/Repositories">
• Dans la section qu’on a modifié à l’instant : AllowOverride None AllowOverride All
• #LoadModule rewrite_module lib/httpd/modules/mod_rewrite.so LoadModule rewrite_module lib/httpd/modules/mod_rewrite.so
• User _www User VOTRE_USERNAME
• Group _www Group staff
• #ServerName www.example.com:8080 ServerName localhost:80

Et voilà, Apache est installé et configuré ! Pour que ces changements soient pris en compte, enregistrerez le fichier httpd.conf puis relancez le service :

$ brew services restart httpd

Si vous vous rendez maintenant sur http://localhost/ vous devriez voir votre “Hello World!”, confirmation que tout fonctionne comme vous l’aviez souhaité !

Installation du paquet php

Installer PHP

Maintenant que notre serveur Apache fonctionne comme on le souhaite, il nous reste à installer PHP. Pour cela une commande suffit :

$ brew install php

Cette commande installera la version courante de PHP (v8.0.12). Si vous souhaitez installer une version différente, vous trouverez les anciennes versions qu’il est possible d’installer ici : https://formulae.brew.sh/formula/php. Moi, par exemple j’ai installé PHP 7.4.x, plutôt que PHP 8.x. J’ai donc exécuté cette commande :

$ brew install php@7.4

Une fois que PHP est installé, démarrons la tâche de fond :

$ brew services start php
# ou pour PHP 7.4
$ brew services start php@7.4

Configurer PHP

Attention, là ça va aller pas mal vite !

Ouvrez à nouveau votre fichier de configuration Apache (/usr/local/etc/httpd/httpd.conf ou /opt/homebrew/etc/httpd/httpd.conf pour les processeurs M1).

Cherchez la dernière ligne LoadModule (ce sera probablement celle du mod_rewrite.so) et ajouter cette ligne juste après :

# Si vous avez installé PHP 8 sur processeur Intel
LoadModule php_module /usr/local/opt/php/lib/httpd/modules/libphp.so
# Sinon pour PHP 7.4 
LoadModule php7_module /usr/local/opt/php@7.4/lib/httpd/modules/libphp7.so

# Pour les processeurs M1, PHP 8
LoadModule php_module /opt/homebrew/opt/php/lib/httpd/modules/libphp.so
# ou PHP 7.4
LoadModule php7_module /opt/homebrew/opt/php@7.4/lib/httpd/modules/libphp7.so

Recherchez ensuite la ligne DirectoryIndex index.html et remplacez-la par DirectoryIndex index.html index.php.

Après le DirectoryIndex que l’on vient de modifier et juste avant la section concernant les fichiers htaccess, ajoutez cette section :

    SetHandler application/x-httpd-php

Et enfin, relancez le serveur Apache avec un magnifique $ brew services restart httpd

Youpi ! PHP est installé et prêt à être utilisé. Pour vérifier que le serveur interprète bien les fichiers PHP, créez un fichier ìnfo.php dans votre dossier Repositories contenant la ligne suivante :

Rendez-vous à l’adresse http://localhost/info.php dans votre navigateur. Si vous voyez le logo PHP ainsi qu’un enorme tableau de données concernant votre version de PHP, c’est gagné, vous avez votre propre serveur de développement !

Et ensuite ?

Dans un prochain article, je partagerai ici ma méthode pour créer des virtual hosts rapidement et simplement, pour par exemple visiter l’URL http://monsiteweb.local/ et quand même voir le site web stocké dans le dossier Repositories/monsiteweb. ]]> https://chierchia.fr/2021/10/configurer-un-serveur-local-avec-homebrew/feed/ 0 https://chierchia.fr/2017/11/scraper-web-avec-python/ https://chierchia.fr/2017/11/scraper-web-avec-python/#respond Ange Chierchia]]> Fri, 17 Nov 2017 11:49:38 +0000 https://nighcrawl.com/blog/2017/11/scraper-web-avec-python Aujourd’hui on va voir comment utiliser Python afin de scraper une page ou un site Web afin de récupérer les informations qui nous intéressent et ainsi se constituer une base de données.

Le scraping de sites Web fait partie de mon quotidien chez Ibakus Europe ces derniers mois, dans le cadre du développement d’une fonctionnalité de notre application dédiée à la lutte contre le blanchiment d’argent et le financement du terrorisme.
Le scraping de différentes sources nous a permit de constituer une base de données des sociétés européennes, permettant à nos utilisateurs de compléter leur fichier KYC avec les informations publiques dont on dispose sur leurs clients, en plus des informations qu’ils ont en leur possession.

Assez parlé d’Ibakus, passons au vif du sujet : la création d’un scraper web.

Création du scraper

Le but du scraper que l’on va écrire ici sera de récupérer les informations concernant les nouvelles sociétés luxembourgeoises créées. Nous allons donc faire un scraping du site du RCSL.

Pour cela nous allons utiliser la librairie Splinter, qui permettra à notre script de parcourir les pages comme si on le faisait nous même. Je vous invite à lire la documentation de la librairie pour ce qui concerne son installation et les différentes fonctions disponibles.

Nous allons enregistrer le code source de notre scraper dans un fichier scraper.py en déclarant que nous voulons utiliser l’encodage UTF-8 et utiliser la fonction Browser() de la librairie Splinter. Notre fichier débutera alors comme ça :

# coding: utf8
from splinter import browser

Tout ce qui va se passer ensuite sera executer comme si on naviguait vraiment depuis une fenêtre de navigateur Web. On appelle alors la fonction Browser() puis on se rend sur le site Web à scraper comme suit :

with Browser() as browser:
    url = "https://www.rcsl.lu"
    browser.visit(url)

Attention, il est important de bien faire attention à l’indentation du code. Ici, si on avait appellé la méthode visit() de l’objet browser sans l’indenter, ça n’aurait pas fonctionné car browser ne serait pas définit.
On aurait par contre pu écrire ceci :

browser = Browser()
browser.visit(url)

Notre scraper se trouve maintenant sur la page d’accueil du site Web du RCSL. Pour récupérer la liste des sociétés consituées aujourd’hui, il faut que l’on clique sur le lien “Journal des publications” que l’on peut trouver au bas de la page. La librairie Splinter dispose de plusieurs fonctions permettant de retrouver un élément dans le DOM et d’intéragir avec. Dans notre cas nous aurons besoin des fonctions is_element_present_by_css(), find_by_css() et click_link_by_partial_href().

Le lien que l’on cherche à cliquer contient la chaîne DisplayOfficialJournalAction dans son attribut href, nous allons donc cliquer dessus en faisant appelle à click_link_by_partial_href() ce qui nous amènera sur la page voulue :

browser.click_link_by_partial_href('mjrcs/jsp/DisplayOfficialJournalAction')

Dans cette nouvelle page on veut cliquer sur l’icône de téléchargement du fichier XML le plus récent (en haut de la liste).
Pour être certain qu’il y a bien une liste de fichiers disponibles présente sur la page, on vérifie qu’un élément table ayant la classe commonTable existe dans le DOM. Si il existe, on récupère alors le quatrième élément a qu’il contient puis on visite l’URL contenue dans son attribut href

if browser.is_element_present_by_css('table.commonTable'):
    # Récupère l'URL vers le fichier XML des publications du jour
    xmlfile = browser.find_by_css('table.commonTable')
                    .find_by_css('tbody')
                    .find_by_css('a')[3]
    browser.visit(xmlfile['href'])

On enregistre ensuite le contenu du fichier en local.

response = browser.html.encode('utf8', 'xmlcharrefreplace')
with open('notices.xml', 'w') as fh:
    fh.write(response)

Une fois le fichier récupéré en local, on peut imaginer un script Python ou PHP qui traiterai le contenu du fichier XML pour l’enregistrer dans une base de données.

Voilà le code source complet de notre scraper en Python :

# coding: utf8
from splinter import Browser # importe l'objet Browser de la librairie

with Browser() as browser:
    url = "https://www.rcsl.lu"
    browser.visit(url)
    # Effectue un clic sur le lien vers les publications du journal officiel
    browser.click_link_by_partial_href('mjrcs/jsp/DisplayOfficialJournalAction')
    # Vérifie que le tableau ayant la classe `commonTable` existe avant de passer à la suite
    if browser.is_element_present_by_css('table.commonTable'):
        # Récupère l'URL vers le fichier XML des publications du jour
        xmlfile = browser.find_by_css('table.commonTable')
                        .find_by_css('tbody')
                        .find_by_css('a')[3]
        browser.visit(xmlfile['href'])
        response = browser.html.encode('utf8', 'xmlcharrefreplace')
        # Enregistre le contenu du fichier XML dans un fichier en local
        with open('notices.xml', 'w') as fh:
            fh.write(response)

J’espère que cet article vous aura appris quelque chose et comme toujours, si vous avez des remarques ou des conseils pour l’améliorer, n’hésitez pas à m’en faire part sur Twitter ou dans les commentaires.

Pour la faire courte, la réponse est : non, pour l’instant.

Pourquoi GitHub Pages ne me convient pas ?

La plateforme est géniale, la mise à jour du blog sous Jekyll est instantanée à chaque git push origin master, plus besoin de lancer un jekyll build pour générer le site mis à jour, GitHub Pages s’occupe de tout !

Malheureusement, même si il est possible de forcer le HTTPS sur les pages du site, celui-ci doit obligatoirement avoir une URL du style https://username.github.io/repository. Impossible de forcer HTTPS si on veut utiliser son propre nom de domaine. Et comme j’avais déjà passé mon site en HTTPS il était hors de question de revenir en arrière, par principe.

Et puis, comme ça l’air de rien une petite newsletter OVH tombe dans ma boîte mail, proposant un nom de domaine en .me à -70%, du coup je me laisse tenter et puis une chose en entrainant une autre, je décide de prendre un petit VPS à pas cher…

Déployer Jekyll via GitHub

J’aime beaucoup GitHub, je m’en sert principalement pour sauvegarder quelques projets et ça m’évite de garder une copie sur un disque externe, je souhaitais donc pouvoir l’utiliser comme relai entre ma machine et le serveur, comme ça si il me prend l’envie de tout remettre à zéro, j’ai mes projets sauvés sur GitHub, un git clone et on en parle plus.

N’ayant jamais vraiment utilisé Linux, je me suis dit que c’était l’occasion. J’ai donc choisi de configurer mon VPS en distribution nue sous Debian 8 pour pouvoir installer uniquement ce dont j’avais besoin et laisser le plus de place possible pour mon site sur le disque dur. En gros : Apache, Git, Ruby et Let’s Encrypt.

Ici je n’expliquerai pas comment j’ai installé Apache, Git, Ruby et Let’s Encrypt. Je me contenterai de partager ma méthode pour déployer Jekyll.

Créer le dépôt Git distant

La première étape de ma méthode a consistée à créer un dépôt Git à la racine du VPS avec la commande suivante :

# connexion au VPS
ssh git@mon.vps
# création du dépôt distant
git clone --bare https://github.com/nighcrawl/jekyll-blog.git blog.git

Avec cette commande on clone le dépôt GitHub nu sur le VPS, c’est à dire en ne gardant que les fichiers normalement contenus dans .git/ dans le dossier blog.git/. Le dossier blog.git ressemble alors à ceci :

blog.git/
|_ HEAD/
|_ branches/
|_ config/
|_ description/
|_ hooks/
|  |_ post-receive
|  |_ post-update
|  |_ ...
|_ infos/
|_ objects/
|_ refs/

Le fichier intéressant ici est post-receive du dossier hooks/ car il va nous permettre d’executer un script bash à chaque fois qu’un git push sur le dépôt aura été complété.

Pour nous, il faudra lancer la génération du site avec Jekyll à chaque nouveau git push, le fichier post-receive contiendra alors le script suivant :

GIT_REPO=$HOME/blog.git
TMP_GIT_CLONE=$HOME/tmp/blog
PUBLIC_WWW=/var/www/blog

git clone $GIT_REPO $TMP_GIT_CLONE
bundle exec jekyll build -s $TMP_GIT_CLONE -d $PUBLIC_WWW
rm -Rf $TMP_GIT_CLONE
exit

Ici on déclare plusieurs variable en début de script:

• GIT_REPO contient le chemin vers le dépôt Git,
• TMP_GIT_CLONE permet de définir où sera cloné le dépôt
• PUBLIC_WWW contiendra les fichiers du site une fois compilés avec Jekyll

Une fois le dépôt Git cloné dans $TMP_GIT_CLONE, on lance la commande de compilation des fichier bundle exec jekyll build en spécifiant le dossier $TMP_GIT_CLONE comme étant la source et $PUBLIC_WWW comme destination, puis on supprime le dossier $TMP_GIT_CLONE avec la commande rm -Rf $TMP_GIT_CLONE.

Créer le dépôt Git local

Une fois le dépôt distant créé et le fichier post-receive modifié, il ne reste plus qu’à cloné le dépôt sur l’ordinateur avec la commande

git clone https://github.com/nighcrawl/jekyll-blog.git

puis d’y ajouter votre dépôt distant comme remote supplémentaire avec la commande

git remote add deploy ssh://git@mon.vps:/blog.git

Déployer en production

Pour pousser les mises à jour vers le VPS il suffira alors de faire un git push en spécifiant le dépôt distant dans lequel vous souhaitez envoyer vos commits.

Ici le dépôt GitHub s’appelle origin et mon dépôt de production (sur le VPS) s’appelle deploy. La commande de mise à jour du VPS sera alors

git push deploy master

Fin

La méthode de déploiement que j’utilise ici est assez basique et pourra probablement être améliorée, alors n’hésitez pas à la partager, ou mieux me donner votre avis et/ou vos conseils sur Twitter.

Bien que très simple à mettre en place dans les faits, quand vient l’heure de nettoyer une chaîne de caractères pleine d’accents, de signes de ponctuation et autres caractères spéciaux, c’est la galère.

Voici la fonction que j’utilise pour nettoyer mes chaînes de caractères et les utiliser comme permalien

function clean($string) {
	$string = html_entity_decode(preg_replace('/&([a-zA-Z]{1,2})(?:acute|cedil|circ|grave|lig|orn|ring|slash|th|tilde|uml);/i', '$1', htmlentities($string, ENT_QUOTES, 'UTF-8')), ENT_QUOTES, 'UTF-8');
	$string = strtolower(trim(preg_replace('/[^0-9a-z]+/i', '-', $string), '-'));

	return $string;
}

Le principe ici est très simple. D’abord on converti tout les caractères qui peuvent l’être en entités HTML à l’aide de la fonction htmlentities(), ensuite on remplace chaque caractère par son équivalent sans accent, cédille, etc.

preg_replace('/&([a-zA-Z]{1,2})(?:acute|cedil|circ|grave|lig|orn|ring|slash|th|tilde|uml);/i', '$1', htmlentities($string, ENT_QUOTES, 'UTF-8')), ENT_QUOTES, 'UTF-8');

En appliquant la fonction html_entity_decode() sur la chaîne nettoyée de tout caractère accentué, on transforme à nouveau les entités HTML restantes en caractères normaux.

Enfin, on remplace tous les caractères n’étant pas des lettres ou des chiffres par un tiret, puis on supprime les tirets en trop à l’aide de la fonction trim().

J’espère que ce petit morceau de code vous aura été utile :).

N’hésitez pas à partager votre solution, ou vos remarques dans les commentaires.

Tchô !

L’intérêt d’un tel dispositif est de pouvoir « tracker » ce qu’un visiteur fait lorsqu’il parcours votre site Web, ou encore de savoir si une campagne emailing a bien été ouverte.

Pixel de suivi

Le code partagé ici est un exemple basique est ne reflète pas exactement la solution que j’ai utilisé pour tracker les visiteurs de nos sites Internet, mais le principe reste le même.

<?php
// On récupère d'abord l'adresse IP du visiteur
$ip = !empty($_SERVER['HTTP_CLIENT_IP']) ? $_SERVER['HTTP_CLIENT_IP'] : (!empty($_SERVER['HTTP_X_FORWARDED_FOR']) ? $_SERVER['HTTP_X_FORWARDED_FOR'] : $_SERVER['REMOTE_ADDR']);

// Navigateur utilisé
$browser = $_SERVER['HTTP_USER_AGENT'];

// URL de la page visité
$url = $_SERVER['REQUEST_URI'];

// Enregistrement dans un fichier de log
$handle = fopen('log.txt', 'a+');
$log_data = date('Y-m-d H:i:s') . ' -- ' . $ip . ' -- ' . $brower . ' -- '. $url . "\r\n";
fwrite($handle, $log_data);
fclose($handle);

// Création du pixel de suivi
$pixel = imagecreate(1,1);
$pixel = imagecolorallocatealpha($pixel, 255, 255, 255, 0);

// Enfin, on affiche le pixel de suivi
header('Content-Type: image/png');
imagepng($pixel);
imagedestroy($pixel)
?>

Intégrer le pixel de suivi

Maintenant que notre image de 1 pixel sur 1 pixel est créée, il ne reste plus qu’à l’insérer dans le code HTML des pages que l’on souhaite suivre. Une simple balise img juste avant la balise </body> suffira !

<img src="pixel.php" width="1" height="1" />

Eh voilà ! J’espère que ce petit bout de code vous aura plu. Si vous avez d’autres solutions, n’hésitez pas à les partager dans les commentaires.

Tchô !

Lorsque je travaillais encore chez CBC Informatique, nous n’utilisions pas les principes de la programmation orientée Objet et nous préférions développer nous même les sites Web de nos clients plutôt que de s’appuyer sur des solutions toutes faites, afin de garder la maitrise de notre code. C’est dans cette optique que j’avais développé notre mini-framework/CMS.

Depuis presque 1 an maintenant,  je travaille chez Ibakus Europe et à nouvelle équipe nouvelle façon de travailler. Pour concevoir les nouvelles applications Web IBAKUS, nous utilisons la programmation orientée Objet et les principes du MVC. Nos applications gérant des données plutôt sensibles, il a été décidé de développer notre propre framework PHP Objet, afin de garder au maximum la main sur le code et pouvoir le modifier plus facilement.

Les bases du framework PHP Objet

D’abord, nous avons écrit une classe maîtresse que l’on a appelée Container. Elle nous permet entre autre d’initialiser le framework avec un fichier de configuration, de définir les différentes routes et de charger les différents Modèles et Contrôleurs.

Une classe abstraite Model définit les méthodes utilisées pour agir sur la base de données puis chacun de nos modèles étendent cette classe afin de gérer les spécificités qui leur sont propres.

Mon but n’étant pas de publier le code source de notre framework, je m’intéresserai uniquement aux méthodes CRUD de notre classe abstraite Model.

Structure de la classe abstraite Model

La classe abstraite Model est définie par deux propriétés $db et $table et cinq méthodes : get(), getDatas(), set(), delete() et save().

La propriété $db est une instance de la classe PDO établissant la connexion à notre base de données, $table quand à elle contient le nom de la table sur laquelle les opérations des méthodes save() et delete() vont être faites. Voici la structure de notre classe :

abstract class Model {
  protected $db;
  protected $table;
  
  public function __construct() {
    $this -> db = Container::getDb();
    $this -> table = $this; 
  }
  
  /**
   * Un echo de $this retournera le nom de la table associée au modèle.
   * Par exemple 'pages' pour le modèle 'PagesModel'
   */
  public function __toString() {
    return strtolower(substr(get_class($this), 0, -5));
  }
  
  // GETTERS
  public function get($attr) {
    return $this -> $attr;
  }
  
  /**
   * Retourne tous les attributs de l'objet
   */
  public function getDatas() {
    $datas = array();
    foreach (get_object_vars($this) as $key => $value)
        $datas[$key] = $value;
    
    return $datas;
  }
  
  // SETTER
  public function set($attr, $data) {
    if (property_exists($this, $attr)
        $this -> $attr = $data;
  }
  
  // METHODES
  public function delete() {}
  
  public function save() {}
}

La méthode save()

cette méthode permet d’enregistrer l’objet dans la base de données, que ce soit pour son insertion ou lors de sa modification. Pour définir si l’on va faire un INSERT ou un UPDATE, on testera la valeur de l’attribut id de l’objet courant. Si elle n’est pas nulle on souhaite modifier l’objet, sinon on crée une nouvelle entrée dans la base.

public function save($type = null) {
  if ($this -> get('id') == null) {
    $query = 'INSERT INTO ' . $this -> get('table') . ' SET';
    $nbDatas = count($this -> getDatas());

    $i = 0;
    foreach ($this -> getDatas() as $key => $value) {
      $i++;
      $query .= ' ' . $key . ' = :' . $key;
      if ($i < $nbDatas) $query .= ','; else $query .= ';'; } } else { $query = 'UPDATE ' . $this -> get('table') . ' SET';
    $nbDatas = count($this -> getDatas());

    $i = 0;
    foreach ($this -> getDatas() as $key => $value) {
      $i++;
      if ($key != 'id') {
        $query .= ' ' . $key . ' = :' . $key;
        if ($i < $nbDatas) $query .= ','; } } $query .= ' WHERE id = :id;'; } $query = $this -> get('db') -> prepare($query);

  foreach ($this -> getDatas() as $key => $value)
    $query -> bindValue(':' . $key, $value);

  $executed = $query -> execute();

  if ($executed && $this -> get('id') == null)
    $this -> set('id', $this -> get('db') -> lastInsertId());

  return $executed;
}

La méthode delete()

Pour supprimer les données de l’objet enregistré, rien de vraiment compliqué, on execute simplement une requête préparée avec la classe PDO et on supprime l’enregistrement dont id correspond à l’attribut id de l’objet courant.

public function delete() {
  $query = $this -> get('db') -> prepare('DELETE FROM ' . $this -> get('table') . ' WHERE id = :id;');
  $query -> bindValue(':id', $this -> get('id'));
  
  return $query -> execute();
}

Pour finir : construire un CMS

Construire un CMS sur base d’une classe abstraite comme celle-ci permet d’écrire très simplement les différents modules dont on aura besoin.

Si l’on souhaite gérer des pages de contenu, il suffira d’écrire un modèle héritant de la classe Model, par exemple pagesModel et d’y définir les attributs de l’objet en regard de la structure de la table pages de la base de données.

Cette classe héritant de la classe abstraite, nous n’auront pas besoin de réécrire nos méthodes save() et delete() et l’on pourra se concentrer sur des méthodes permettant par exemple, de retourner un menu de navigation, des méta-tags pour le référencement naturel, etc.

Bien sûr, il faudra écrire un contrôleur permettant de traiter les données à passer au modèle, qui se chargera ensuite de les enregistrer en base de données, mais ça se fait rapidement  .

Là dessus, bonne semaine (et bonne année) !

Une fois le client satisfait, il nous donne le « Go » pour la mise en ligne, nous transférons alors les fichiers et la base de données sur le domaine final. Parfois, les URLs générées dans le contenu des pages sont erronées suite au transfert sur le domaine définitif, et bien entendu les liens foirent… En PHP, on pourrait faire un bête str_replace(), ou un preg_match_all(). Mais en MySQL ? C’est là que la requête qui suit va nous sauver :

UPDATE pages SET contenu = REPLACE(contenu, 'http://ancienne.url', 'http://nouvelle.url') WHERE contenu LIKE '%ancienne.url%';

C’est bidon, mais j’ai toujours du mal à m’en souvenir. Le publier ici me permettra de retrouver ça facilement. Après tout, ce blog est avant tout pour moi et si ça peut aider quelqu’un d’autre… 

Personnellement j’aime passer du temps à peaufiner un design. je déteste réécrire les mêmes fonctions pour chaque projet. Alors oui, il des frameworks PHP, mais pourquoi utiliser un bazooka lorsqu’on doit abattre une mouche ?

MAJ 11/01/2016 : Si le PHP Objet vous parle, vous pouvez lire Créer son framework PHP Objet qui est un peu plus récent 

Attention, l’article est un chouilla trop long (beaucoup de lignes de code).

Oui utiliser une CMS déjà tout fait c’est bien, oui utiliser un framework en PHP Objet c’est bien. Seulement parfois, utiliser une arme de destruction massive n’est pas la bonne méthode à appliquer pour régler les choses les plus simples.

Ces dernier mois, au fil des projets qui le permettaient, j’ai pu me construire ma propre bibliothèque de fonctions, en essayant de l’améliorer à chaque itérations, tout en restant le plus générique possible pour permettre une très bonne portabilité de projet en projet. Bien sûr je n’ai pas hésité à piquer des idées dans les frameworks PHP, mais plutôt que de me trimballer toute la clique, j’ai maintenant un petit « framework » qui me permet de faire juste ce dont j’ai besoin. Cela m’a aussi permis de monter facilement notre propre CMS, lui aussi très basique.

Aujourd’hui j’ai donc envie de partager avec vous quelques unes de mes fonctions, car ça fait un petit moment que je n’ai pas publié un peut de code PHP dans mes pages.

Mes fonctions de CRUD

Etape obligatoire lorsqu’on souhaite agir sur des informations stockées en base de données, les célèbres fonctions INSERT, SELECT, UPDATE et DELETE. Après plusieurs itérations je suis arrivé à des fonctions quasiment utilisable par n’importe quel projet, même si je pense qu’elles ne sont pas encore parfaites, pour le moment elles me suffisent. Cependant, si vous avez de quoi les améliorer n’hésitez pas à me donner votre avis !

Ajouter un enregistrement dans une table

Après pas mal de projet dans lesquels j’avais une fonction d’ajout pour chaque type de contenu (page, article, etc.) enregistrés dans des tables différentes, j’ai essayé de trouver un moyen simple d’ajouter n’importe quelle données dans n’importe quelle table. Je suis donc passé de plusieurs fonction plus ou moins lourde à une bête fonction d’une quinzaine de ligne avec laquelle je peux faire ce que je veux, simplement en lui passant un tableau des données à ajouter, et le nom de la table dans laquelle faire cet INSERT.

/***
 *  insert des données dans la table en paramètre
 *  @datas  tableau des données à insérer dont la clé et le nom du champs dans la table
 *  @table  table dans laquelle insérer les données
 */
function add($datas, $table){
  $bdd = db(); //on ouvre la connexion à la base de données

  foreach($datas as $key => $value){
    $keys[] = $key;
    $values[] = $value;
  }

  $strSQL = "INSERT INTO ".$table." (";
  foreach($keys as $ky => $k){ $strSQL .= $k . ","; }

  $strSQL = substr($strSQL,0,-1) . ") VALUES(";
  foreach($values as $vl => $v){ $strSQL .= "?,"; }

  $strSQL = substr($strSQL,0,-1) . ")";

  $query = $bdd->prepare($strSQL);
  if($query->execute($values)) return $bdd->lastInsertId();
  else return false;
}

Comment utiliser la fonction ?

Après avoir vérifiées, échappées, etc., les informations soumisent à mon formulaire, il me suffit de créer un tableau dont les clés seront les noms des champs que je veux renseigner pendant mon INSERT.

Exemple : je veux renseigner le nom, l’adresse email et le commentaire dans la table « comments ».

$datas = array(
  'nom' => $nom,
  'email' => $email,
  'commentaire' => $commentaire
);

if(add($datas,'comments')) {
  return "cool";
} else return "pas cool";

Si tout c’est bien passé, la fonction add() me renvoie l’ID de l’enregistrement créé.

Mettre à jour les informations d’un enregistrement

Là aussi, c’est une fonction vraiment très simple. comme ma fonction add(), ma fonction update() requiert un tableau des données et le nom de la table à modifier. Seul petit changement, on doit aussi fournir l’ID de l’enregistrement à modifier.

/***
 *  met à jour les données de l'ID dans la table en paramètre
 *  @id identifiant de la ligne à modifier
 *  @datas  tableau des données à insérer dont la clé et le nom du champs dans la table
 *  @table  table dans laquelle insérer les données
 */
function update($id, $datas, $table){
  $bdd = db();
  foreach($datas as $key => $value){
    $keys[] = $key;
    $values[] = $value;
  }

  $strSQL = "UPDATE ".$table." SET ";
  foreach($datas as $key => $value){
    $strSQL .= $key . " = ?,";
  } $strSQL = substr($strSQL,0,-1) . " WHERE id = ?";
  $values[] = $id;
  $query = $bdd->prepare($strSQL);
  if($query->execute($values)) return true;
  else return false;
}

Supprimer un enregistrement

Rien de bien compliqué là non plus, on supprime l’enregistrement dont l’ID est passé en paramètre dans la table elle aussi en paramètre.

/***
 *  supprime les données correspondant à l'ID dans la table en paramètre
 *  @id   identifiant de la ligne à supprimer
 *  @table  table sur laquelle on applique la suppression
 */
function delete($id, $table){
  $bdd = db();
  $strSQL = "DELETE FROM ".$table." WHERE id = ?";
  $query = $bdd->prepare($strSQL);
  //print_r(array($id));

  if($query->execute(array($id))) return true;
  else return false;
}

Retourner une liste d’enregistrements

Cette dernière est l’une des fonctions que j’ai eu le plus de mal à rendre générique tout en me permettant de faire beaucoup de choses avec, comme par exemple préparer le terrain pour l’utiliser dans le cadre des données scindées sur plusieurs pages.

Ici ma fonction me permet de récupérer à la fois les enregistrements de ma requête, le total d’enregistrements que retournerai ma requête si aucun paramètre LIMIT n’était renseigné, la requête exécutée (pour les tests en phase de développement) ou les erreurs possibles quant à l’exécution de cette requête.

/***
 *  retourne le resultat d'un select
 *  @columns  colonnes à selectionner pour la requête (ex: array('champ1','champ2') ou '*')
 *  @table    nom de la table sur laquelle faire la requête
 *  @where    champs sur lequels appliquer des conditions ( ex: array( 'champ1 =' => 'valeur', 'champ2 LIKE' => 'valeur%') )
 *  @concats  [ AND | OR ]
 *  @order    champs sur lequels appliquer le tri, et l'ordre pour chaque champs (ex: array('champ1' => 'ASC','champ2' => 'DESC') )
 *  @limit    limit[0] => debut de la liste, limit[1] => nombre d'éléments dans la liste retournée (ex: array('0','20') )
 *
 *  return @retour  : tableau contenant la requête executée, les éventuelles erreurs et le resultat de la requête
 */
function get($columns = null, $table = null, $where = null, $concats = "AND", $order = null, $limit = null){
  $bdd = db();
  $retour = array(); //variable de type tableau, retournée par la fonction
  $rows = "";
  $clause = "";
  $sort = "";
  $limitStr = "";

  if(!is_null($columns) && !is_null($table)){

    // si $rows est un tableau ou égale à * tout va bien.
    if(is_array($columns)){
      foreach($columns as $column) { $rows .= $column .', '; }
      $rows = substr($rows,0,-2);
    } elseif($columns == '*'){
      $rows = '*';
    } else {
      $retour['erreur'] = "Les champs selectionné doivent être appelé depuis une variable Tableau";
    }

    if(!in_array(strtolower($concats),array('and','or'))){
      $retour['erreur'] = "<strong>".$concats."</strong> n'est pas une valeur autorisée pour concaténer des conditions. Utilisez 'OR' ou 'AND'.";
    }

    /*
    si @where est renseigné, on filtre les résultats grâce au tableau @where construit comme suit :
      array ('colname operateur' => 'valeur');
      ex: array('page_id =' => 5);
    sinon, on ne filtre pas les résultats
    */
    if(!is_null($where) && is_array($where)){
      foreach($where as $k => $v){
        $clause .= $k." ? ".$concats." ";
        $values[] = $v;
      }
      $clause = " WHERE ".substr($clause,0,(-(strlen($concats)+2)));
    } elseif(!is_null($where) && !is_array($where)){
      $retour['erreur'] = "La clause WHERE doit être construite via une variable Tableau";
    } else {
      $clause = "";
    }

    //si $order est un tableau et n'est pas null
    if(!is_null($order) && is_array($order)){
      foreach($order as $k => $v){ $sort .= $k." ".$v.", "; }
      $sort = " ORDER BY ".substr($sort,0,-2);
    } elseif(!is_null($order) && !is_array($order)) {
      $retour['erreur'] = "ORDER BY doit être construit via une variable Tableau";
    } else {
      $sort = "";
    }

    if(!is_null($limit) && is_array($limit) && is_numeric($limit[0]) && is_numeric($limit[1])){
      $debut = $limit[0];
      $nbRows = $limit[1];
      $limitStr = " LIMIT " . $debut . "," . $nbRows;
    } elseif(!is_null($limit) && !is_array($limit)){
      $retour['erreur'] = "LIMIT doit être construit via un tableau de deux entiers";
    } else {
      $limitStr = "";
    }

    // on construit la requête
    $strSQL = "SELECT ".$rows." FROM ".$table.$clause.$sort.$limitStr;
    if(empty($retour['erreur'])){
      $query = $bdd->prepare($strSQL);
      $query->execute(@$values);
      $retour['requete'] = $strSQL;
      $retour['reponse'] = $query->fetchAll(PDO::FETCH_ASSOC);

      $sqlTotal = "SELECT COUNT(*) as total FROM ".$table.$clause.$sort;
      $q = $bdd->prepare($sqlTotal);
      $q->execute(@$values);
      $tot = $q->fetchAll(PDO::FETCH_ASSOC);
      $retour['total'] = $tot[0]['total'];
    }

  } else {
    $retour['erreur'] = "Impossible de créer la requete, les champs à selectionner et la table sont vide";
  }

  return $retour;
}

Comment utiliser la fonction ?

Exemple : Je veux récupérer les cinq articles les plus récents écrits par nighcrawl dont le titre contient le mot « framework » publié depuis la date à laquelle la requête est exécutée.

$champs = array('id','titre','nom','contenu');
$conditions = array(
  'nom =' => 'nighcrawl',
  'date < =' => date('Y-m-d H:i:s'),
  'titre LIKE' => '%framework%'
);
$trier = array('date' => 'DESC');
$limite = array(0, 5);

$resultat = get($champs,'articles',$conditions,"AND",$trier,$limite);
if(isset($resultat['reponse'])){
  foreach($resultat['reponse'] as $row){
    echo "<article>
    <header>
      <h1>".$row['titre']."</h1>
    </header>
    <div>".$row['contenu']."</div>
    <footer>Auteur : ".$row['nom']."</footer>
    </article>";
  }
}
else echo $resultat['erreur'];

Mettre en place un système de pagination

Je m’arrêterai ici parce que l’article est déjà pas mal long, et si vous êtes arrivé jusqu’ici je vous dis chapeau. Personnellement je me serai déjà arrêté :). On fini donc avec une fonction très utile pour générer rapidement des liens de pagination afin de répartir les données d’une requête sur plusieurs pages. Voici donc la belle fonction :

/***
 *  génère des liens de pagination : numeros de pages, 'suivants', 'précédents'
 *  @total  nombre total d'enregistremnts à paginer
 *  @nbpp nombre d'enregistrements à afficher par page
 *  @link chaine qui servira à construire les liens vers les différentes pages
 */
function pagination($total, $nbpp, $link){
  echo"<div class='pagination'>";
    /** Pagination **/
    //calcul du nombre de pages
    $nbLiens = ceil($total/$nbpp);

    if($nbLiens > 1){
      /** précédents **/
      if(isset($_GET['d']) && $_GET['d'] > 0){
        echo "<a href='".$link.($_GET['d']-$nbpp)."'>« Précédents</a>";
      } else {
        echo "<span>« Précédents</span>";
      }
      /** pages ***/
      for($i = 0; $i < $nbLiens; $i++){
        if($_GET['d'] == ($i*$nbpp)){
          echo "<span class='active_pagi'>".($i+1)."";
        } else {
          echo "<a href='".$link.($i*$nbpp)."'>".($i+1)."</a>";
        }
      }

      /** suivants **/
      if(isset($_GET['d']) && $_GET['d'] >= 0 && $_GET['d'] < ($total-$nbpp)){
        echo "<a href='".$link.($_GET['d']+$nbpp)."'>Suivants »</a>";
      } else {
        echo "<span>Suivants »</span>";
      }
    }
  echo "</div>";
}

La pagination va s’effectuée en deux temps, d’abord l’appel de la fonction get(), puis l’appel de la fonction pagination(). Si on réutilise l’exemple précédent :

$nbpp = 5; //5 articles par page
$limite = array(intval($_GET['d']),$nbpp);
$resultat = get($champs,'articles',$conditions,"AND",$trier,$limite);

if(isset($resultat['reponse'])){
  foreach ($resultat as $row) {
    //affichage des articles
    ...
  }
  pagination($resultat['total'],$nbpp,'index.php?parametre=valeur&d=');
} else echo $resultat['erreur'];

Fin !

Merci de m’avoir lu jusqu’au bout. Je vous libère ici ! En espérant que ces quelques fonctions puissent vous être utiles. Elles ne sont pas parfaites et certaines pourraient être encore améliorées, alors si vous avez des idées, n’hésitez pas à les partager dans les commentaires.