Cela fait quelque temps que j'ai commencé ce blog et j'avais encore des doutes et des questions sur la licence à utiliser. Je traite essentiellement de logiciels libre et open source donc je trouve plus cohérent d'utiliser une licence libre pour partager le contenu de ce blog.

Pourquoi choisir une licence ? Si aucune licence n'est définit, le droit d'auteur s'applique automatiquement et limite l'utilisation de l’œuvre sans l'autorisation de l'auteur. Une licence permet simplement d'accorder certains droits supplémentaires (reproduction, adaptation,...) à l'utilisateur.

Faire le choix d'une distribution GNU/Linux peut sembler compliqué mais le choix d'une licence n'est pas plus facile et c'est un peu comme une expédition avec Bear Grylls mais dans le domaine du droit. Ici, il n'est pas possible de tester pour se décider, la licence est définitive sans véritable retour en arrière possible. Si la licence est disponible en français, je peux éventuellement la lire (ce que j'ai fait) mais je n'ai pas les connaissances suffisantes pour comprendre la portée réelle de ce choix. Pour couronner le tout, c'est vraiment chiant à lire et faut vraiment s'accrocher pendant la lecture.

Il faut pourtant faire un choix parmi les différentes licences disponibles.

En suivant les conseils de Bendia (de DF) j'ai commencé par lire Le libre à la française. Un article véritablement instructif et je recommande sa lecture pour comprendre certaines notions essentielles du droit.

Suite à cette lecture, j'ai pensé adopter une licence BiPu qui me semble plutôt bonne (concise et compréhensible). Malheureusement elle n'est pas assez répandue et pourrait limiter certaines personnes dans certains pays d'autant qu'elle n'est disponible qu'en français.

Il y a le choix en matière de licences mais finalement peu qui correspondent à mes besoins :

• une licence en français (parce que le contenu publié est en français et touche un public francophone).
• une licence suffisamment universelle (traduction disponible dans différentes langue et connue dans d'autres pays).
• une licence compréhensible pour faciliter le partage (enfin presque).

Après réflexion, je préfère utiliser une licence plus populaire comme Creative Commons.

Les conditions de la licence

La licence est un contrat qui réglemente et définit clairement les droits et obligations des utilisateurs concédés par l'auteur sur son œuvre. Elle s'intègre au droit d'auteur qui est automatiquement appliqué pour lui ajouter certaines conditions d'utilisations. L'objectif est de diffuser plus facilement une œuvre, il faut donc définir les autorisations accordées à l'utilisateur.

Les points ci-dessous reprennent les principales conditions que l'on peut inclure dans une licence.

Paternité

La paternité est le point le plus simple à comprendre, il faut simplement citer le nom de l'auteur et de l'œuvre.

Il y a une seule chose que je trouve important pour le choix de la licence, c'est l'attribution de l’œuvre à l'auteur. Je n'ai pas envie que l'on s'approprie mon travail illégitimement.

La paternité ne limite pas l'utilisation d'une œuvre mais définit uniquement la condition de son utilisation et ne représente pas de véritable contrainte. Il suffit simplement de faire référence à la source et de sa licence.

Utilisation commerciale

Il est possible de limiter l'utilisation de son œuvre à une exploitation non-commerciale.

Sur l'exploitation de mon travail pour faire de l'argent, j'étais réticent au début (comme beaucoup de personnes) mais de nombreux articles traitant de ce sujet expliquent et argumentent sur cette contrainte et de son application dans les faits. On peut légitimement penser que prohiber l'utilisation commerciale permet de ne pas avoir d'utilisation "parasite" de son œuvre. Évidemment, c'est un peu plus compliqué dans la réalité et qu'en l'état, cela restreint surtout certaines pratiques même s'il n'y a aucun profit derrière. Les explications de Dominus Carnufex dans son article sur la limite de la mention non-commercial et de la distinction entre onéreux et commercial a finit par me convaincre. Pour reprendre son exemple, il serait impossible de revendre la compilation des articles de Wikipédia sur une clé USB a prix coûtant.

Au final, je doute qu'on puisse monnayer mes articles même si j'arrive à publier tout ce qui est encore en cours de rédaction. Si quelqu'un arrive à tirer un quelconque profit uniquement à partir de mon travail, il est plutôt bon.

D'un autre côté, c'est aussi contribuer à l'utilisation du logiciel libre même si je n'en tire aucun revenu. Du coup, je ne vois plus de raison d'interdire une utilisation commerciale.

Adaptation / Pas de modification

Il est possible d'interdire la réalisation d'œuvres dérivées (traduction, mise à jour, adaptation, ...).

Dans mon cas, ne pas autoriser les adaptions n'a pas de sens. Je publie principalement des tutos/astuces de logiciels qui risquent d'être obsolètes dans le temps. Si quelqu'un décide d'en faire une mise à jour sur son site cela ne serait pas possible, de même si quelqu'un souhaite en faire une traduction.

Entre garder de mon côté des articles périmés et voir une documentation à jour mais indépendante, ou d'avoir des traductions dans différentes langues, mon choix va vers la réutilisation et l'adaptation de mon travail.

Pour des articles qui concerneraient des opinions ou des réflexions personnelles, cela pourrait se discuter et se justifier mais ce n'est pas le cas.

Partage à l'identique / Clause de contamination

Rien que le nom clause de contamination génère une certaine méfiance. C'est une obligation où toutes les œuvres dérivées devront être publiées sous une licence équivalente. L'œuvre dérivée devra être disponible selon les mêmes conditions que l'œuvre originale, donc avec les mêmes autorisations et interdictions d'utilisation.

L'objectif de continuer à partager le contenu dans les mêmes conditions est plutôt favorable à la diffusion du libre et louable dans un sens. Dans les faits, c'est relativement contraignant et pas forcément justifié. C'est en quelque sorte le prosélytisme dans le droit d'auteur. Au final, on impose à un auteur de ce qu'il doit faire de son œuvre même si elle n'est pas complètement originale, mais qui l'est réellement ?

Si un travail reprend différents travaux avec des clauses de contaminations cela pourrait devenir vraiment difficile de trouver une licence compatible. Il faudrait redéfinir à chaque fois une licence en fonction de ses sources. Si on ne connaît pas le droit, cela devient tout simplement impossible.

Pour moi, cela se rapproche de l'interdiction d'utilisation commerciale et ne me parait pas plus favorable à la diffusion de la culture et du libre.

L'utilisation de la licence et son application dans la réalité

Je ne me fais pas d'illusion, entre la licence que l'on décide d'appliquer et ce que les gens font de votre travail est assez différent.

À mon niveau je n'aurai pas la possibilité de vérifier si quelqu'un réutilise mon travail et en tire avantage. Du coup, autant faciliter son utilisation et la faire circuler facilement les différents contenus avec une licence libre.

Au final, ça donne quoi comme licence ?

Après une longue réflexion, je me suis décidé de la licence à utiliser. Au final, j'ai fait le choix une licence beaucoup plus permissive que ce que j'envisageai avec une licence CC-BY (attribution).

Le choix a été difficile mais correspond à ma vision du libre et du contenu que je publie. J'ai remplacé la mention en bas de page "Tous droits réservés" par "Licence Creative Commons Attribution" avec un lien vers la licence complète et les explications.

J'ai noté que le résumé de la licence CC-BY n'était pas entièrement traduit, du coup je rapatrie toute la licence sur le site pour éviter des problèmes dans le futur et qu'on dispose tous de la même référence.

Résumé de la licence CC-BY Le titulaire des droits autorise toute exploitation de l’œuvre, y compris à des fins commerciales, ainsi que la création d’œuvres dérivées, dont la distribution est également autorisée sans restriction, à condition de l’attribuer à son l’auteur en citant son nom.

N'hésitez pas à me laisser un message si vous avez repris du contenu ici, cela me permet de savoir ce qui vous intéresse.

Si vous n’êtes pas encore décidé et vous devez choisir une licence, je vous invite à vous documenter et prendre le temps choisir en accord avec vos besoins et vos convictions. Quelle que soit la licence choisie, c'est quelque chose d'important et nécessitera une réflexion de votre part. Après tout, chacun dispose de son travail / œuvre comme il l'entend et on doit le respecter pour ça.

Ressources

• Zeste de Savoir - Le libre à la française
• Zeste de Savoir - Le droit d'auteur, Creative Commons et les licences sur Zeste de Savoir
• Creative Commons - Choisir une licence
• Creative Commons - Attribution 3.0 France (CC BY 3.0 FR)

Original post of nIQnutn.Votez pour ce billet sur Planet Libre.

En matière de classement des photos, comme dans bien d'autres domaines, j'ai le sentiment de ramer à contre courant. L'heure est à l'utilisation de logiciels graphiques sophistiqués, prenant en charge depuis l'insertion de la carte SD (ou la connexion de l'APN) jusqu'au téléversement sur l'album en ligne. Digikam fait, paraît-il, cela très bien, mais je le trouve trop lourd et d'un emploi mal aisé. Je fondais quelques espoir sur oqapy, malheureusement je ne le trouve plus sur les dépôts Archlinux, même pas dans AUR... J'aime assez gthumb mais il ne sait pas faire tout ça.

Bref, je continue à travailler à la mimine selon un processus bien établi :

• Créer un répertoire au nom significatif tant du point de vue chronologique que géographique (aaaammjj_Localisation)
• Y copier les fichiers JPG et les renommer selon un shéma analogue (aaaammjj_hhmmss_Localisation_NomOriginel.JPG)
• Y copier le ou les éventuel(s) fichiers gpx associés et géolocaliser les images
• Sélectionner, recadrer et éventuellement retoucher les meilleurs clichés avant de les transférer vers notre album Piwigo

Pour renommer les photos j'utilise exiv2 de la manière suivante :

exiv2 -r %Y%m%d_%H%M%S_Localisation_:basename: mv *.JPG

Pour géolocaliser j’utilise Gpscorrelate, que j'ai présenté ici, qui est malheureusement abandonné par son créateur mais a l'avantage de disposer à la fois d'une version graphique et d'une version en ligne de commande.

gpscorrelate -g monFichierTrace.gpx -z [valeur] *.JPG

La valeur à associer à l'option -z est le décalage du fuseau horaire, par exemple +1:00 pour l’heure normale d’Europe centrale (CET : Paris, Bruxelles, Genève…) et +2:00 pour l’heure d’été d’Europe centrale (CEST). Ceci dans la mesure ou l’horodatage des photos est faite en heure locale et celle du GPS en UTC, ce qui est en principe le cas. Il y a d'autres options possible, voir la  documentation.

Bon, ce n'est pas trop compliqué, mais il faut se souvenir des options, tout ça.... Pourquoi ne pas automatiser le processus dans un petit script ?

#! /bin/bash 

#######################
##     photoman      ##
## interface à exiv2 ##
## et à gpscorrelate ##
#######################


declare -i nbRep=0
declare -i nbPhotos=0
declare -A DateTab

# chemin du répertoire photo
photoRep="/media/NAS/Public/Photos/"
# chemin du GPS
GPS="/run/media/vincent/GARMIN/Garmin/GPX"

IFS=$'\\n'
shopt -s nullglob

# détection du GPS
if [ -d $GPS ]; then
    find $GPS -iname "*.gpx" > /tmp/tracesGPS
    if [ $(wc -l /tmp/tracesGPS | cut -d " " -f 1) != 0 ]; then        
        echo
        read -n 1 -s -p "un ou plusieurs fichiers gpx ont été trouvé dans le GPS. Les copier dans le(s) répertoire(s) photos [O/n] ? " copieTrace
        copieTrace="${copieTrace:=o}"
        case $copieTrace in
            o|O|y|Y ) Geolocalisation=true;;
            * ) Geolocalisation=false;;
        esac
    fi
else
    read -n 1 -s -p "Le GPS n'a pas été détecté : continuer quand même [o/N] ? " question
    question="${question:=n}"
    case $question in
            o|O|y|Y ) Geolocalisation=false ;;
            * ) exit;;
    esac
fi
echo

#traitement des photos
for fichier in *
do
    if [ ! -f $fichier ]; then continue; fi
    MimeType=$(file --mime-type $fichier)
    if [[ ${MimeType:(-10)} != "image/jpeg" ]]; then continue; fi
    datePhoto=$(exiv2 -g Exif.Photo.DateTimeOriginal $fichier | sed -r 's/^ *//;s/ {1,}/ /g'| cut -d " " -f 4 | sed 's/://g')
    repertoire=$photoRep${datePhoto:0:4}"/"
    if [ -z ${DateTab[$datePhoto]} ]; then 
        echo
        read -p "Veuillez indiquer une localisation correspondant à la journée du $datePhoto puis appuyez sur [Entrée] : " localisation
        echo
        DateTab[$datePhoto]="_"$(echo $localisation | sed 's/ /-/g')
        mkdir $repertoire$datePhoto${DateTab[$datePhoto]} 2> /dev/null
        ((nbRep++))
        # copier les fichiers gpx        
        if $Geolocalisation; then
            while read line  
                do   
                cp $line $repertoire$datePhoto${DateTab[$datePhoto]}
            done < /tmp/tracesGPS
        fi
    fi 
    fichierRenomme=$repertoire$datePhoto${DateTab[$datePhoto]}"/"$(echo $fichier | sed 's/ /-/g')
    cp $fichier $fichierRenomme
    ((nbPhotos++))
    exiv2 "-r%Y%m%d_%H%M%S"${DateTab[$datePhoto]}"_:basename:" mv $fichierRenomme
done

#Bilan
if [ $nbPhotos -eq 0 ]; then 
    echo
    echo "Il n'y a aucune photo à transférer dans ce répertoire"
    echo "+++++++++++++++++++++++++++++++++++++++++++++++++++++"
    echo
    exit
fi
echo "$nbPhotos photos ont été transférées dans $nbRep répertoire(s)."
printf '\\033[7m'
read -n 1 -s -p "===> Supprimer toutes les photos dans le répertoire d'origine [o/N] ? " question
question="${question:=n}"
printf '\\033[0m'
echo
case $question in
        o|O|y|Y ) rm -rf *.[jJ][pP][gG] ;;
        * ) : ;;
esac

#Géolocalisation
if ! $Geolocalisation; then exit; fi
read -n 1 -s -p "Géolocaliser les photos transférées [O/n] ? " question
question="${question:=o}"
case $question in
        o|O|y|Y ) : ;;
        * ) exit;;
esac
for i in "${!DateTab[@]}"
    do 
    cd $photoRep${i:0:4}"/"$i${DateTab[$i]}
    for f in "*.[gG][pP][xX]"
        do
        gpxFileDate=$(xml_grep 'trkpt' $f --nb_results 1 | xml_grep 'time' --text_only)
        UTCHour=$(date -d $(echo $gpxFileDate | sed "s/T/ /g" | sed "s/Z//g") +%k | sed "s/ //g")
        LocalHour=$(date -d $gpxFileDate +%k)
        TimeZone=$(( $LocalHour  - $UTCHour ))
        gpscorrelate -g $f -z $TimeZone *.[jJ][pP][gG]
    done
done

Quelques explications :

Les premières lignes servent de fichier ini : emplacement du répertoire photo et point de montage du GPS

Ensuite je détecte si le GPS est connecté et je vérifie (find -iname *.gpx) et s'il y a une (ou plusieurs) traces. On y reviendra plus tard

• je teste s'il est de type image jpg,
• j'extrais la date de prise de vue grace à exiv2
• s'il n'existe pas je crée un répertoire correspondant à cette date (localisation demandée), j'y copier les éventuelles traces du GPS et j'incrémente un compteur (les noms des répertoires sont stockés dans un tableau associatif date => _localisation )
• J'y copie le fichier photo, le renomme (aaaammjj_hhmmss_localisation_nomOririnel.JPG) et incrémenter un compteur

J'appelle enfin gpscorrelate pour chaque fichier gpx, avec le décalage horaire calculé, et je l'applique à toutes les photos. En principe une photo n'est concernée que par une seule trace mais s'il arrivait que le fichier JPG contienne déjà des données exif gps elles ne seraient pas écrasées et un message d'erreur serait affiché.

Original post of Vincent Gay.Votez pour ce billet sur Planet Libre.

Je ne sais pas vous mais personnellement, j’ai toujours pensé que la Russie était plus grande que le continent Africain. Cette croyance était due à la représentation du monde à plat la plus courante que ce soit dans les manuels d’histoire géographie ou en poster dans mes toilettes. Il s’agit de la projection de Mercator. Cette projection est très pratique pour naviguer mais peut-être pas la meilleure pour se représenter le monde… En fait la Russie à une superficie de 17 millions de km² et l’Afrique 30 millions km²… C’est seulement à mes 28 ans & à la suite de la conférence gesticulée d’Alexis Lecointe que j’ai découvert cette nouvelle vision du monde (qui me semble plus juste) :

Le planisphère “Planète terre” de Gérad Onesta

Les grosses différences avec Mercator :

• Projection : conserve les rapports de surface entre les masses continentales (mais ne garde pas les formes, ce qui donne un aspect allongé, étiré en hauteur) ;
• Limites : zones naturelles (formations végétales) et non frontières étatiques ;
• Humains : nom des peuples et non des états même si c’est incomplet : la richesse humaine dans ce domaine ne pouvant être représentée sur un morceau de papier, d’autant que les peuples se mélangent, voyagent, et l’imbrication des humains rend presque impossible la définition de limites claires et figées ;
• Rose des vents : Sud vers le haut. Le Nord n’est ni en haut ni en bas, il est au Nord…  Il n’est donc pas à l’envers ça n’est qu’une convention ;

La page Wikipedia de “Planisphère” nous indique :

Les planisphères ne représentent pas uniquement une surface physique mais sont souvent au centre d’enjeux géostratégiques. Ils représentent la vision de l’auteur et ne sont donc pas seulement issus d’une technique de représentation géométrique ; ils peuvent alimenter autant les intérêts de la représentation politique et peuvent être des moyens de propagande

Le planisphère alternatif de Gérard Onesta nous invite, par ses conventions inhabituelles, à faire un pas de côté pour voir quelles mécaniques et logiques de domination peut véhiculer quelque chose d’aussi habituel et apparemment inoffensif qu’un planisphère. La domination de l’Afrique par l’Europe par exemple, en choisissant une représentation où elle se trouve plus petite et “sous” nous.

Et c’est libre ?

Non

Alexis Lecointe qui a relancé l’édition de ce planisphère avec l’accord de son auteur Gérad Onesta a émis la demande de libérer ce planisphère, mais sans succès dans ce texte (p4) il nous relate son dialogue avec l’auteur :

j’ai compris les besoins de G. Onesta en termes d’éthique, et je suis garant du respect de celle-ci. En gros il faut surtout éviter que ce planisphère serve à faire du “green washing”, soit récupéré pour des motifs mercantiles par des entreprises privées, ou utilisé par des partis politiques ou individus clairement adversaires des valeurs écologistes. Pour l’instant, il ne sera pas en licences libres Creative Commons http://creativecommons.fr/), par exemple, mais j’espère qu’à l’avenir nous en rediscuterons:

Moi aussi je l’espère ! J’ai quand même choisie d’appuyer ce planisphère parce que c’est une œuvre renversante et je ne désespère pas, un jour, croiser Gérard Onesta et lui en causer deux mots. Parce que vraiment Gérard, si tu me lis, je penses que ton travail serait encore plus beau & pertinent dans le domaine public ou sous licence libre (Licence CC0). Ne serait-ce que pour faciliter sa diffusion. De plus, je ne suis pas certain qu’un Copyright garantisse une utilisation éthique de ce beau planisphère

S’en procurer

Je ne sais pas vous mais je compte bien retapisser tous les planisphères de mes proches avec celui-ci qui me semble “plus juste”.

Pour le moment seul des points de dépôts sont disponible à travers la France :

• NANTES (44) – David – david [arobase] mercereau [point] info – 06.63.69.16.04
• GOUTEVERNISSE (31) – Loïc – zgalki [arobase] filibert [point] fr – 06 01 88 89 17
• TOULOUSE (31) – Librairie Terra Nova (8,5 € l’unité) – 18 rue Gambetta – 05 61 21 17 47
• SAINT-MOREIL (23) – Alexis – lecointe.alexis [arobase] gmail [point] com – 07 82 26 04 56
• CHARENTON (94) – Hélène – h.fougerol [arobase] orange [point] fr – 06 71 48 53 27
• CALAIS – Benjamin – benjamin [arobase] sphax3d [point] org – 06 65 26 69 81

Alexi s’organise en ce moment pour proposer un envoi postal : Plus d’info sa page

Le mot de la fin

“la critique c’est nécessaire, mais l’invention c’est vital, car dans toute invention il y a une critique de la convention” (Gustave Parking)

Original post of David Mercereau.Votez pour ce billet sur Planet Libre.

Et voila ! Enfin. Nous venons de publier la première alpha de wallabag v2. Vous pouvez aller le billet complet sur le blog du projet.

Merci énormément à Jérémy Benoist pour tout le travail qu'il accomplit sur cette version, merci énorménent à Thomas Citharel pour tout ce qu'il fait également pour le projet.

Si vous voulez tester / installer, c'est ici :

git clone https://github.com/wallabag/wallabag.git -b v2
cd wallabag
composer install
php app/console wallabag:install
php app/console server:run

N'hésitez pas à tester et à nous remonter les bugs, y'en a forcément. À vos claviers, bons tests !

Original post of Nicolas Lœuillet.Votez pour ce billet sur Planet Libre.

Un souci de synchronisation du calendrier entre Owncloud et mon téléphone a été le prétexte à bidouiller une fonctionnalité de rappel des événements par e-mail. Pourquoi des e-mail ? Parce que je suis un fana de ce moyen de communication, la preuve ici et là.

Donc ce que je veux c'est un joli e-mail le lundi matin qui résume mes rendez- vous de la semaine (description, date et heure) et puis chaque matin au réveil un e-mail par événement avec le fichier ICS en pièce jointe. ICS késako ? Un vieux mais très actuel standard de description d'un événement reconnu par la plupart des calendriers. L'intérêt d'avoir le fichier ICS c'est de pouvoir l'ajouter au calendrier local du téléphone en un clic et de paramétrer le rappel en connaissance de cause (le matin on a une petite idée de comment va se profiler sa journée).

Plutôt que de coder dans un langage évolué, je me suis amusé à réaliser cela avec les outils présent en standard sur GNU/Linux (Awk et Bash) pour le backend MySQL d'Owncloud. C'est didactique car il est toujours préférable de privilégier l'accès aux données par une API qui sera plus ou moins bien maintenue dans le temps par les développeurs que d'attaquer directement la base de données. D'abord jetons un oeil à structure de la base de donnée Owncloud.

La table oc_clndr_calendars permet de retrouver l'id de calendrier de notre utilisateur.

mysql> SELECT * FROM oc_clndr_calendars;
+----+------------+-------------+-----------+--------+------+---------------+---------------+----------+-----------------------+
| id | userid     | displayname | uri       | active | ctag | calendarorder | calendarcolor | timezone | components            |
+----+------------+-------------+-----------+--------+------+---------------+---------------+----------+-----------------------+
|  1 | yax        | Personnel   | personnel |      1 |  196 |             0 | NULL          | NULL     | VEVENT,VTODO,VJOURNAL |
+----+------------+-------------+-----------+--------+------+---------------+---------------+----------+-----------------------+

Et la table oc_clndr_objects contient les évènements :

mysql> DESC oc_clndr_objects;
+--------------+------------------+------+-----+---------------------+----------------+
| Field        | Type             | Null | Key | Default             | Extra          |
+--------------+------------------+------+-----+---------------------+----------------+
| id           | int(10) unsigned | NO   | PRI | NULL                | auto_increment |
| calendarid   | int(10) unsigned | NO   |     | 0                   |                |
| objecttype   | varchar(40)      | NO   |     |                     |                |
| startdate    | datetime         | YES  |     | 1970-01-01 00:00:00 |                |
| enddate      | datetime         | YES  |     | 1970-01-01 00:00:00 |                |
| repeating    | int(11)          | YES  |     | 0                   |                |
| summary      | varchar(255)     | YES  |     | NULL                |                |
| calendardata | longtext         | YES  |     | NULL                |                |
| uri          | varchar(255)     | YES  |     | NULL                |                |
| lastmodified | int(11)          | YES  |     | 0                   |                |
+--------------+------------------+------+-----+---------------------+----------------+

On peut récupérer les évènements du jour courant avec la requête suivante :

mysql> SELECT startdate,summary,calendardata FROM oc_clndr_objects WHERE calendarid = 1 AND DATE(startdate) = DATE(NOW()) ORDER by startdate \\G;
*************************** 1. row ***************************
   startdate: 2015-09-14 10:30:00
     summary: Déjeuner avec M.
calendardata: BEGIN:VCALENDAR
VERSION:2.0
PRODID:ownCloud Calendar
CALSCALE:GREGORIAN
BEGIN:VEVENT
UID:95d9221d97
DTSTAMP:20150914T103206Z
CREATED:20150913T170426Z
LAST-MODIFIED:20150914T103206Z
SUMMARY:Déjeuner avec M.
DTSTART;TZID=Europe/Paris:20150914T123000
DTEND;TZID=Europe/Paris:20150914T140000
LOCATION:
DESCRIPTION:
CATEGORIES:
CLASS:PUBLIC
END:VEVENT
END:VCALENDAR
*************************** 2. row ***************************
   startdate: 2015-09-14 16:15:00
     summary: RV dentiste
calendardata: BEGIN:VCALENDAR
VERSION:2.0
PRODID:ownCloud Calendar
CALSCALE:GREGORIAN
BEGIN:VEVENT
UID:1958bfe4a9
DTSTAMP:20150914T103134Z
CREATED:20150914T103134Z
LAST-MODIFIED:20150914T103134Z
SUMMARY:RV dentiste
DTSTART;TZID=Europe/Paris:20150914T181500
DTEND;TZID=Europe/Paris:20150914T183000
LOCATION:
DESCRIPTION:
CATEGORIES:
END:VEVENT
END:VCALENDAR

Les colonnes intéressantes sont :

• calendarid pour filtrer les évènements de notre utilisateur Owncloud
• summary : le libellé de l'évènement
• startdate : la date de début de l'évènement
• calendardata : l'évènement au format iCalendar

Ce qu'on veut c'est générer un shell script qui récupère les informations du jour et envoie un e-mail par évènement avec le fichier ICS en pièce jointe. L'envoi est réalisé par l'utilitaire mpack. Le résultat final espéré pour notre exemple est ce script :

#!/bin/sh
# 
STARTDATE="`date -d '2015-09-14 10:30:00-000' '+%a %e %b %R'`"
SUMMARY="Déjeuner avec M."
echo "BEGIN:VCALENDAR" >event.ics
echo "VERSION:2.0" >> event.ics
echo "PRODID:ownCloud Calendar" >> event.ics
echo "CALSCALE:GREGORIAN" >> event.ics
echo "BEGIN:VEVENT" >> event.ics
echo "UID:95d9221d97" >> event.ics
echo "DTSTAMP:20150914T103206Z" >> event.ics
echo "CREATED:20150913T170426Z" >> event.ics
echo "LAST-MODIFIED:20150914T103206Z" >> event.ics
echo "SUMMARY:Déjeuner avec M." >> event.ics
echo "DTSTART;TZID=Europe/Paris:20150914T123000" >> event.ics
echo "DTEND;TZID=Europe/Paris:20150914T140000" >> event.ics
echo "LOCATION:" >> event.ics
echo "DESCRIPTION:" >> event.ics
echo "CATEGORIES:" >> event.ics
echo "CLASS:PUBLIC" >> event.ics
echo "END:VEVENT" >> event.ics
echo "END:VCALENDAR" >>event.ics
mpack -s "$SUMMARY - $STARTDATE" event.ics $1
#
STARTDATE="`date -d '2015-09-14 16:15:00-000' '+%a %e %b %R'`"
SUMMARY="RV dentiste"
echo "BEGIN:VCALENDAR" >event.ics
echo "VERSION:2.0" >> event.ics
echo "PRODID:ownCloud Calendar" >> event.ics
echo "CALSCALE:GREGORIAN" >> event.ics
echo "BEGIN:VEVENT" >> event.ics
echo "UID:1958bfe4a9" >> event.ics
echo "DTSTAMP:20150914T103134Z" >> event.ics
echo "CREATED:20150914T103134Z" >> event.ics
echo "LAST-MODIFIED:20150914T103134Z" >> event.ics
echo "SUMMARY:RV dentiste" >> event.ics
echo "DTSTART;TZID=Europe/Paris:20150914T181500" >> event.ics
echo "DTEND;TZID=Europe/Paris:20150914T183000" >> event.ics
echo "LOCATION:" >> event.ics
echo "DESCRIPTION:" >> event.ics
echo "CATEGORIES:" >> event.ics
echo "END:VEVENT" >> event.ics
echo "END:VCALENDAR" >>event.ics
mpack -s "$SUMMARY - $STARTDATE" event.ics $1

Comment fait-on ? On exécute la requête SQL et on la donne à manger à un script awk qui a pour objectif de générer le shell script ci-dessus. Awk a été inventé pour ce genre de tâche : prendre un fichier en entrée et le modifier pour créer un fichier en sortie. Le script est assez opaque si on n'a jamais pratiqué mais l'idée c'est de décrire la structure du document en entrée (comment distinguer les enregistrements) et de faire correspondre des traitements à certains enregistrements qu'on identifie par une expression régulière.

Voci le script awk complet :

BEGIN { 
    FS="\\n"    
    OFS=""
    ORS="\\n"
    print "#!/bin/sh"
    print " " 
}
# blank lines
/^$/ { next }
# record header
$1 ~ /^\\*\\*\\*\\*/ { 
    next
}
# summary field
$1 ~ /^[ ]*summary\\:/ {
    idx = match($1, /summary\\:(.*)/)
    print "SUMMARY=\\"" substr($1, idx + 9) "\\""
    next
}
# startdate field
$1 ~ /^[ ]*startdate\\: / {
    match($1, /startdate\\: /)
    print "STARTDATE=\\"`date -d '" substr($1, RSTART + RLENGTH) "-000' '+%a %e %b %R'`\\""
    next
}
# vcalendar start tag
$1 ~ /^[ ]*calendardata\\: / {
    match($1, /calendardata\\: /)
    print "echo \\"" substr($1, RSTART + RLENGTH) "\\" >event.ics"
    next
}
# vcalendar end tag
$1 ~ /^END\\:VCALENDAR/ {
    print "echo \\"" $1 "\\" >>event.ics"   
    print "mpack -s \\"$SUMMARY - $STARTDATE\\" event.ics $1"
    print ""     
    next
}
# vcalendar body
{            
    print "echo \\"" $0 "\\" >> event.ics"
}

Il ne reste plus qu'à orchestrer tout cela dans un shell script et de l'appeler par une tâche cron. Le script complet gère les rappels du jour et les rappels pour la semaine à venir. Il est disponible sur mon compte GitHub.

Original post of Yannic Arnoux.Votez pour ce billet sur Planet Libre.