Après avoir…
– passé le site en https, https://www.ergofip.com,
– travaillé jour et nuit sur les photos
– travaillé plusieurs week ends sur le tournage
…
il est sur le point de sortir !
Clavier mécanique, entièrement configurable, international et LEDs RGBs.
Merci à mes étudiants qui ont accepté ces photos :
Licence Pro / IUT Aix en Provence :
Et Ecole d’ingénieur ISEN Toulon :
Je n’avais pas bien compris l’utilité de « annotate » dans les queries Django jusqu’à maintenant…
Voici quel était mon problème :
J’avais un modèle de base, Activite. Une activité contenait des choses concernant… une activité. Si si je vous jure !
Par exemple, une activité consistait à ajouter un voyage. Ou avoir une nouvelle relation. Ou faire un témoignage comme quoi on aimait bien le site. Etc.
Je voulais que ces activités soient « partageables » entre les amis.
J’ai crée un modèles ActiviteShare. Facile jusque là.
Mais lorsque je demandais à récupérer toutes les activités, il fallait que je les trie en me basant sur le fait de savoir si elles étaient partagées. Pour exagérer, imaginons une activité qui était faite en 2010. Vous étiez parti à Malibu. Génial ! Et maintenant, en 2016, un ami s’inscrit, devient votre ami, et vous voulez partager cette activité avec lui. Il faut qu’elle s’affiche dans votre mur, comme activité « partagée récemment », mais qu’elle garde sa date de 2010, ok ?
Donc je devais trier d’abord en fonction de la date de ActiviteShare puis seulement après par la date de création de l’Activite.
Seul hic : si vous aviez partagé cette activité avec 10 contacts, au moment du tri, Django renvoyait dix fois le même enregistrement.
Mon tri était super basique, du genre :
Activite.objects.filter(
# blabla
).order_by(
'-activiteshared__date_last_modif',
'-date_last_modif',
'-date_publication',)
Mais ça ne marchait pas. 🙁
La solution ? Annotate.
Pour vous expliquer avant de mettre le code : je lui demande, lors de la requête, de garder la date maximale parmi toutes les dates partagées, et de l’appeler « mx ». Ensuite, je demande de trier simplement d’abord par « mx », puis par la date de dernière modification de l’activité.
Activite.objects.filter(
# blabla
).annotate(mx=Max('activiteshared__date_last_modif')).order_by(
'-mx',
'-date_last_modif',
'-date_publication',)
Django vient tout faire pour l’internationalisation de pages HTML, mais saviez-vous qu’il est aussi possible et de manière très simple d’internationaliser vos échanges AJAX ?
Vous avez un tutoriel ici.
Seul point noir : ils ont oublié deux éléments essentiels, je vais donc faire une explication courte ici, puis ajouter un résumé dans ma cheatsheet Django.
Dans l’ordre :
urls.py :app » pour qu’il soit tout en haut des dossiers racine. Donc ici :
js_info_dict = {
'packages': ('app',)
}
urls.py :jsi18n. Attention ! L’aide ne précise pas du tout où la mettre et c’est là où j’ai perdu énormément de temps, faites attention : il faut le mettre dans les patterns traduits, soit ici :
urlpatterns += i18n_patterns( url(r'^jsi18n/$', javascript_catalog, js_info_dict, name='javascript_catalog'), # blabla... }
js dans les pages :<script src="{% url 'javascript_catalog' %}"></script>
js dans les pages :<script src="{% static 'js/globals.js' %}"></script>
function _(a) {
return gettext(a);
}
djangojs :third_party (où je mets les outils externes que je ne veux pas toucher) :
makemessages -d djangojs -i third_party --locale fr --locale en
djangojs.po qu’il faut modifier, pas le classique django.po (sans strong>js).
Et à partir de là, tout fonctionne : dans tous les fichiers JavaScript qui suivent, je peux traduire à la fois ce qui arrive en AJAX, ou bien tout simplement afficher un message via _(). Exemple :
$('#menu').empty().append(
$('<h5 />').html(_('Waiting...'))
);
Tiens, un blog d’un geek qui explique pourquoi il est passé de python à NodeJS.
Why I’m switching from Python to NodeJS
Ah j’oubliais le plus important : un an après avoir utilisé nodejs en production :
After a year of nodejs in production: back to Python
Au moins ça vient d’un développeur talentueux qui a bossé jour et nuit sur du NodeJS pendant toute une année et il sait bien de quoi il parle.
Spoiler :
Traduction de ce qui importe le plus : votre client devra payer le double pour le même projet : développement + autant de temps pour déboguer.
Je vous laisse faire votre propre expérience, moi j’ai la mienne qui se rapproche assez de ces billets de blog.
Saviez vous qu’il était impossible de créer un élément svg dynamiquement comme ceci :
var $('<svg />'); ?
Moi non. Après avoir cherché pendant pas mal de temps j’ai enfin réussi à faire un code qui génère un svg et ça fonctionne :
var mySvg = document.createElementNS("http://www.w3.org/2000/svg", "svg"),
div_svg = $('#mondiv');
mySvg.setAttribute("version", "1.2");
mySvg.setAttribute("baseProfile", "tiny");
mySvg.setAttribute('viewBox', '0 0 100 100');
mySvg.setAttribute('preserveAspectRatio', 'xMinYMin');
div_svg[0].appendChild(mySvg); /* (!) [0] = élément DOM "pur" */
var c = document.createElementNS("http://www.w3.org/2000/svg", "polygon");
c.setAttribute('points', '0,45 25,1 75,1 99,45 75,90 25,90');
c.setAttribute('style', 'fill:blue;stroke:red;stroke-width:1');
$(mySvg).append(c);
Et voilà vous avez enfin un exemple qui fonctionne !
Je me sers de cet habillage ici.
C’est, en gros, une « surcharge » de bootstrap avec quelques composants en plus.
Seulement j’aurais aimé avoir une sélection de plusieurs choix = cases à cocher qui soit « compatible » avec cet habillage.
Je n’aurais jamais cru que c’était aussi simple.
En fait Django a généralisé plein d’affichages HTML à tel point qu’il suffit de faire du pas à pas et de regarder ce qu’il fait pour comprendre.
Même le rendu par « item » de chaque « Renderer » est surchargeable. Donc voici le code qui prend… 10 lignes, et qui réhabille totalement le rendu des cases à cocher :
from django.forms import CheckboxSelectMultiple
from django.forms.widgets import ChoiceFieldRenderer, \
CheckboxChoiceInput
class BootstrapChoiceFieldRenderer(ChoiceFieldRenderer):
choice_input_class = CheckboxChoiceInput
outer_html = '<div{id_attr}>{content}</div>'
inner_html = '<div class="checkbox">'
'{choice_value}{sub_widgets}'
'</div>'
class CheckboxSelectMultipleBootstrap(CheckboxSelectMultiple):
renderer = BootstrapChoiceFieldRenderer
Voici ma classe :
class GameAdmin(admin.ModelAdmin):
fieldsets = (
(None, {
'fields': (('name', 'number_of_players'), )
}),
(_(u'Validity'), {
'classes': ('collapse',),
'fields': ('date_v_debut', 'date_v_fin')
}),
)
inlines = (GamePersonsInline,)
Mon problème est que je voulais changer dynamiquement 'Validity' afin de montrer soit, si le jeu n’était plus valide, soit s’il était toujours en cours.
L’idée est que s’il a une date de fin de validité, c’est que le jeu n’est plus en cours.
Voici la solution complète, extrêmement simple, et qui me permet sans avoir à déplier le groupe « dates de validité », de voir si la partie n’est plus en cours :
class GameAdmin(admin.ModelAdmin):
def get_fieldsets(self, request, obj=None):
fieldsets = super(GameAdmin, self).get_fieldsets(
request, obj)
retour = [list(x) for x in fieldsets]
if obj.date_v_fin:
retour[1][0] = _(u'Expired: {}').format(
obj.date_v_fin.strftime('%Y-%m-%d %H:%M:%S'))
else:
retour[1][0] = _(u'Running!')
return retour
fieldsets = (
(None, {
'fields': (('name', 'number_of_players'), )
}),
(_(u'Validity'), {
'classes': ('collapse',),
'fields': ('date_v_debut', 'date_v_fin')
}),
)
Après c’est vrai, il y a une chose de codée en dur, le [1][0], mais je ne voyais pas d’autre solution.
Django a une manière de gérer la date et l’heure de façon très pratique… encore faut-il la comprendre !
Il y a la date et l’heure qui prend en compte le fuseau horaire.
Imaginez qu’un type en Chine envoie une date et une heure avec le fuseau horaire de Chine sur votre serveur, via un formulaire Web.
Le plus pratique est donc d’enregistrer au format UTC = 0 décalage horaire en se souvenant que l’heure est basée sur le fuseau de Chine.
Comme ça, si un Français demande cette heure, hop, il voit que c’est pour un fuseau +1 (ou +2 selon la saison) et fait le calcul tout seul.
Génial non ?
Seule chose à laquelle il faut faire attention : Python a son package datetime, et il y a une fonction now() qui n’est pas la même que la fonction now() de Django !
Donc si vous voulez enregistrer une date « style Django », il faut faire cet import :
from django.utils.timezone import now
Ensuite, vous pourrez, par exemple, faire des différences de secondes qui fonctionneront :
def is_expired(self, nb_seconds):
return (now()-self.date_last_update).total_seconds() > nb_seconds
(Attention au code précédent : deux choses : le now() qui doit être importé comme je l’ai dit, et total_seconds() auquel il faut faire attention, car il y a une propriété seconds qui ne fait pas du tout la même chose….)
et surtout ne pas faire from datetime import datetime
Si vous faites comme moi et faites le mauvais import, l’heure ne sera pas « recentrée » à fuseau + 0 afin que tout le monde puisse la lire !
La documentation est ici, elle est très claire :
docs.djangoproject.com/translation
Enfin très claire.. jusqu’à un certain point….
Disons qu’ils oublient de préciser une chose :
Lorsqu’il faut créer la liste des messages à traduire, ils ont codé en dur deux listes à générer :
djangodjangojsDonc si vous voulez que manage.py crée correctement les fichiers JavaScript, il faut obligatoirement passer le paramètre djangojs. L’ordre à donner est donc :
manage.py makemessages -d djangojs --locale=fr_FR --locale=en_US
Je vous explique, et c’est bien plus facile en français en fait 😉
Je voulais mettre en place une relation style facebook mais en plus évolué : une personne peut avoir une ou plusieurs personnes ami(e)(s). Seulement, on ne gère qu’un seul type de relation par personne. Par exemple, Olivier est ami proche avec Elsa. Déjà, cela implique qu’Elsa est amie proche avec Olivier. Donc, il faut imaginer une table qui aura une relation qui va s’auto-référencer, via une table intermédiaire dans laquelle on précisera le type de relation.
Ce n’est pas très dur à imaginer :
Personne <-> PersonneRelation.
Déclaration de Personne :
class Personne(BaseModel):
user = models.ForeignKey(User)
relations = models.ManyToManyField('self',
through='PersonneRelation',
symmetrical=False)
Maintenant, là où le problème se pose c’est qu’au moment de l’ajout d’une relation dans un sens, par exemple mari femme, il faut que la relation soit aussi ajoutée dans l’autre sens, à la fois pour des questions de performance, mais aussi pour des questions d’affichage (« Simon est le mari de Arlette » mais dans l’autre sens, « Arlette est la femme de Simon », on constate que les phrases sont totalement différentes… et quand c’est mari femme, on peut imaginer ne pas se compliquer l’existence en regardant dans si la personne est un homme ou une femme et en déduire le sens, mais si jamais c’est une relation maître – élève ? HEIN ? COMMENT ON FAIT ? Si c’est un formateur qui forme des adultes ? HEIN ? ON DIT QUOI LA ? On fait moins le malin d’un coup HEIN ! Oui bon ok il faut que je décompresse un peu…). Donc l’idée est (1) de définir les relations possibles en dur (vous pourrez très facilement faire évoluer cela en une relation supplémentaire vers une table qui définit le type de relation et vous n’aurez plus de limites en termes de types de relations possibles, mais ce qui suit est déjà assez long à expliquer, je ne vais pas en plus l’alourdir avec du code supplémentaire) et de (2) gérer au moment où on insère un nouvel enregistrement : si jamais la relation opposée n’est pas encore présente, on l’ajoute. Ah. J’oubliais le (3) modifications = appliquer la même de l’autre côté et suppression : supprimer l’autre côté aussi.
Stop bullshit, du code :
@python_2_unicode_compatible
class PersonneRelation(BaseModel):
TYPE_AMI = u'0'
TYPE_CONNAISSANCE = u'1'
TYPE_PARENT_ENFANT = u'2'
TYPE_MARI_FEMME = u'3'
TYPE_PROFESSEUR_ELEVE = u'4'
TAB_TYPES = {
TYPE_AMI: _(u'friend'),
TYPE_CONNAISSANCE: _(u'relationship'),
TYPE_PARENT_ENFANT: _(u'parent > child'),
TYPE_MARI_FEMME: _(u'husband <> wife'),
TYPE_PROFESSEUR_ELEVE: _(u'teacher > student'),
}
TAB_TYPES_REVERSE = {
TYPE_AMI: _(u'friend'),
TYPE_CONNAISSANCE: _(u'relationship'),
TYPE_PARENT_ENFANT: _(u'child > parent'),
TYPE_MARI_FEMME: _(u'wife <> husband'),
TYPE_PROFESSEUR_ELEVE: _(u'student > teacher'),
}
type_relation = models.CharField(max_length=1,
choices=[(a, b) for a, b in
list(TAB_TYPES.items())],
default=TYPE_AMI)
src = models.ForeignKey('Personne', related_name='src')
dst = models.ForeignKey('Personne', related_name='dst')
opposite = models.ForeignKey('PersonneRelation',
null=True, blank=True, default=None)
is_reverse = models.BooleanField(default=False)
def __str__(self):
return _(u'n.{} {} --> {}').format(
str(self.pk),
self.TAB_TYPES[self.type_relation] if not self.is_reverse
else self.TAB_TYPES_REVERSE[self.type_relation],
str(self.dst))
class Meta:
verbose_name = _(u'Relation')
verbose_name_plural = _(u'Relations')
@receiver(post_save, sender=PersonneRelation)
def signal_receiver(sender, **kwargs):
created = kwargs['created']
obj = kwargs['instance']
if created and not obj.opposite:
opposite = PersonneRelation(
src=obj.dst, dst=obj.src, opposite=obj,
type_relation=obj.type_relation, is_reverse=True)
opposite.save()
obj.opposite = opposite
obj.save()
elif not created and obj.type_relation != obj.opposite.type_relation:
obj.opposite.type_relation = obj.type_relation
obj.opposite.save()
Vous remarquerez que j’ai vraiment réindenté le code pour qu’il reste lisible ici !
J’espère qu’il vous servira !
Python : batteries included.
Django : La Plateforme de développement Web pour les perfectionnistes sous pression.