Les derniers articles sur valentinbourgoin.net

Projets Django à l'IMAC (2012)

Fri, 16 Dec 2011 18:40:50 +0100

Tout au long du premier semestre, la promo 2012 de l'école d'ingénieur IMAC à qui je donne cours (intitulé largement "programmation web") a travaillé, en équipes de 3 à 6 imposées, sur un projet. Seule contrainte : le site ou l'application rendu(e) devait être développé en Python, à l'aide du framework Django.

Voici le fruit de leur travail.

Internsheep

Adresse : http://internsheep.alwaysdata.net/

Pitch : Réseau social de notations de stages.

Membres de l'agence : Adrien Bruneliere, Jérémy Busset, Jérémy Cornilleau, Benjamin Liger, Julien Michot.

Crewm8

Adresse : http://www.crewm8.com/

Pitch : Mise en relation de partenaires autour de projets multimédias.

Membres de l'agence : Aurélie Fruitière, Alice Loeser, Stéphanie Luu, Thomas Sebire.

JustDoThat

Adresse : http://justdothat.alwaysdata.net/

Pitch : Plateforme de défis entre amis.

Membres de l'agence : Jean-François Biondi, Quentin Cassagnavère, Vincent Jubault, Florian Lamy, Timothée Roldao, Marlène Vieillescazes.

404answers

Adresse : http://404answers.com/

Pitch : Plateforme de partage de besoins (geeks).

Vidéo de présentation : http://vimeo.com/33806754

Membres de l'agence : Odile Bellerose, Caroline Campan, Nicolas Gouard, Pierre Gouthéraud, Gabriel Peyrot.

RainArt

Adresse : http://rainart.alwaysdata.net/

Pitch : Galerie de présentation d'oeuvres graphiques. (Et je viens seulement de comprendre le jeu de mot).

Membres de l'agence : Fiona charbonnier, Manon Perrin, Arthur Muchir, Sébastien Poyer, Virgile Marin.

Jawa

Adresse : http://jawa-esiee-imac.alwaysdata.net/

Pitch : Refonte du site Internet de l'ESIEE.

Membres de l'agence : Martin Dautry, Matthieu De Canteloube, Nicolas Samir.

ArtSightWorld

Adresse : http://artsightworld.alwaysdata.net/

Pitch : Site communautaire autour de la photographie géolocalisée.

Membres de l'agence : Eléonore Delau, Imane Hachemaoui, Marjory Gaillot, Sanaa Belkouch.

Merci évidemment encore une fois à Alwaysdata pour l'hébergement Django de qualité et à Venceslas Biri pour m'avoir assisté lors des présentations finales.

Auto-entrepreneur : et après ?

Thu, 21 Jul 2011 21:28:03 +0200

Le statut d'auto-entrepreneur permet de se lancer dans une nouvelle activité indépendante sans trop de risque. Mais, une fois que cette activité évolue, comment évoluer avec elle ? Quels sont les limites du statut, et les démarches à faire pour ne pas se laisser surprendre ?

Les limites du statut d'auto-entrepreneur

En tant qu'auto-entrepreneur, vous pouvez être rapidement confronté à plusieurs problématiques : un chiffre d'affaire qui flirte avec le plafond, un besoin d'embaucher ou de s'associer ou encore des dépenses trop élevées... Faisons le point !

Le chiffre d'affaire

Comme vous le savez, le chiffre d'affaire d'une auto-entreprise ne peut dépasser un certain plafond annuel. Celui-ci s'élève à 32 600 € pour les activités de service et 81 500 € pour les activités commerciales de revente. Il existe bien un seuil de tolérance (respectivement 34 et 89 600 €), mais cela reste assez négligeable si les clients commencent à se bousculer et que votre boite mail explose.

Petite parenthèse sur le prorata temporis qui sera par ailleurs actif en 2011, pour la première fois. Si vous débutez votre activité en cours d'année, votre plafond sera calculé au prorata. Pour une entreprise de services lancée le 1er juillet, comptez un CA maximal à 17 000 € !

Travailler à plusieurs

Vous vous dites, à juste titre, qu'un statut d'auto-entrepreneur est réservé à une personne seule. Vous avez raison, mais ce n'est pas juste une question etymologique... En effet, en AE, le paiement des charges est calculé en fonction du chiffre d'affaire... qui vous servirait à payer un employé. Difficile dans ces conditions de rester sous le plafond de CA.

Ce statut n'est donc pas adapté pour embaucher, il ne l'est pas non plus pour s'associer. Pourtant, partager (et s'échanger !) des compétences, des ressources (local, matériel...) peut être très intéressant une fois une activité bien lancée. Hélas, il est très dangereux pour plusieurs auto-entrepreneurs de s'unir sans appui juridique. En effet, le fisc pourrait vite requalifier leur activité comme société à part entière, et du coup recalculer toutes leurs charges en fonction. A éviter, donc !

Vous pouvez néanmoins noter qu'il existe une alternative intéressante avec le GIE (Groupement d'Interêt Economique) qui permet à plusieurs professions libérales de mutualiser leurs moyens. J'y reviendrai sûrement très prochainement.

La TVA et les charges

En tant qu'auto-entrepreneur, vous ne facturez pas la TVA... mais vous ne la récupérez pas non plus. Vous ne pouvez donc en aucun cas faire passer un achat comme "professionnel" (ce qui pourtant être pratique pour du matériel informatique nécessaire à votre activité, un téléphone de fonction, etc.) et en économiser les 19,6% de TVA. Logique, puisque les prix que vous facturez sont Hors Taxe. Bien sûr, la comptabilité en est plus simple (pas de formulaires de TVA à remplir, moins de calculs), mais cela peut être un frein à l'investissement si vous avez besoin d'effectuer des achats professionels. Egalement, comme expliqué plus haut, les charges étant calculées sur le CA, l'achat de matériel en est d'autant plus difficile.

Quelles solutions ?

Conserver une Entreprise Individuelle

Il s'agit là de la suite logique du statut d'auto-entrepreneur (qui est déjà en lui même une EI). Les démarches restent assez souples, même s'il est nécessaire de tenir une comptabilité plus rigoureuse. Concernant le CA, plus de limitation mais une imposition plus importante, directement sur l'Impôts sur le Revenu Fini, donc, le versement libératoire auquel l'AE a, lui, le droit.

Au niveau du patrimoine de l'entrepreneur, celui-ci est entièrement confondu avec celui de la société. Vous avez donc une responsabilité illimitée sur la totalité de vos biens. Cependant, depuis janvier 2011, il existe l'EIRL qui permet de séparer patrimoines personnel et professionnel. A prendre tout de même avec des pincettes, car en cas de faute de gestion (ce qui arrive hélas facilement quand on est perdu dans cette nouvelle fiscalité), la résponsabilité n'est plus du tout limitée...

Créer une société

EURL ou SASU sont vos principales possiblités si vous souhaitez passer le pas et créer une société seul. Si vous souhaitez vous associer, vous pouvez opter pour la SARL ou la SAS. Dans tous les cas, les frais de constitutions sont plus élevés que pour une EI, et les démarches plus lourdes. Ne prenez pas cette création à la légère (encore moins qu'un statut d'AE !), et prenez contact avec votre CCI et / ou un juriste pour recevoir des conseils !

En pratique

Il faut savoir que, automatiquement, si vous dépassez le plafond de CA du statut d'auto-entrepreneur (32 600 € pour les activités de services) avant la fin de l'année, vous avez tout de même un seuil de tolérance situé à 34 000 €. A ce moment-là, vous avez tout de même le droit de rester AE pour l'année suivante. Cependant, si vous dépassez une seconde fois le plafond, vous n'aurez alors plus de joker : vous serez automatiquement transféré vers un statut d'EI classique.

De même, si vous dépassez directement le seuil de tolérance, votre statut d'AE s'arrêtera dès la somme supérieure encaissée (même la première année). Automatiquement, votre entreprise deviendra une EI, et vous serez assujeti en fonction. Si vous avez le droit à l'ACCRE, celle-ci s'arrêtera également instantanément pour toute recette supérieure au plafond.

Attention donc à ne pas vous faire surprendre ! Si vous sentez le plafond s'approcher, prenez les devants et choisissez quelle suite donner à votre activité : continuer sur la voie de l'AI, créer une structure ou... partir en vacances, tout simplement.

Auto-entrepreneur : impôts sur le revenu

Thu, 28 Apr 2011 00:49:39 +0200

La période des déclarations d'impôts sur le revenu approche à grands pas ! Vous devez avoir reçu un avis de votre Centre d'Impôts vous annonçant une date limite de paiement (au mois de juin pour les télé-déclarations)...

Voici la marche à suivre pour déclarer ses revenus en tant qu'auto-entrepreneur. Couplés ou non avec une autre activité (un CDI par exemple).

Pas de panique !

A priori, vous devez avoir opté pour le versement libératoire de l'impôt sur le revenu, lors du début d'activité. Dans ce cas-là, vos impôts ont déjà été payés. En effet, ils sont compris dans vos charges. Vous n'allez donc pas les payer une seconde fois...

Cependant, vous allez tout de même devoir remplir votre déclarations d'impôts. Vous devez avoir reçu un courrier de la part de l'URSSAF vous résumant le Chiffre d'Affaire que vous avez réalisé sur l'année. C'est simplement le montant que vous avez à déclarer... sans rien payer.

Mais les choses peuvent se compliquer. Si, au cours de l'année, vous avez exercé une autre activité que celle d'auto-entrepreneur, vous allez devoir déclarer ces revenus... et payer vos impôts.

Cas d'école : CDI + Pôle Emploi + AE + revenus annexes

Prenons, au hasard, mon cas. Au cours de l'année 2010, j'ai :

Eté en stage pendant un mois (janvier).
Eté en CDI pendant 6 mois (février - juillet).
Effectué quelques enseignements à l'Université, avec un statut de vacataire (mars).
Eté inscrit à Pôle Emploi suite à une rupture de contrat conventionnelle (juillet).
Bénéficié d'un statut d'auto-entrpreneur depuis le mois d'août.

Je vais donc devoir séparer mes différentes sources de revenus : le CDI, Pôle Emploi et l'Université d'une part (sur la déclaration principale) et les revenus en tant qu'auto-entrepreneur d'autre part (sur l'annexe à la déclaration).

Comment déclarer ?

Sur impots.gouv.fr, vous pouvez choisir les différents formulaires que vous allez remplir. Les auto-entrpreneurs doivent déclarer leurs revenus par le biais du formulaire 2042 C. Veillez donc bien à le sélectionner à la toute première étape de votre déclaration.

Votre déclaration principale

Vous allez commencer par remplir votre déclaration classique avec les revenus "principaux" (hors AE, donc) que vous avez touchés dans l'année. A priori, cette déclaration devra être pré-remplie. Si ce n'est pas le cas, reportez les valeurs de cumul "imposables" de votre dernière fiche de paie.

N'oubliez pas de déclarer vos revenus de vos différents employeurs. Pôle Emploi en fait partie !

Il vous sera également demandé de saisir vos revenus fonciers si vous en possédez.

2042C : Déclaration des revenus annexes

C'est dans ce formulaire annexe que vous allez devoir reporter votre revenu communiqué par l'URSSAF. Sur le courrier, ils vous ont même renseigné le code du cadre à remplir, pour éviter toute confusion.

Frais, TVA et prime pour l'emploi

Il est à noter qu'un auto-entrepreneur exemplté de TVA ne peut en aucun cas récupérer la TVA de ses achats professionnels. Pour la simple est bonne raison qu'il ne facture pas la taxe à ses clients. De même pour les frais ! Vous ne pouvez déduire aucun frais (loyer, essence, repas, etc.). Ce sont les limites du statut d'auto-entrepreneur...

Par contre, si vous n'avez travaillé en CDI / CDD que quelques mois sur l'année, n'oubliez pas de saisir le nombre d'heure travaillées (qui doit être présent sur votre dernière fiche de paie). Si vous êtes en-dessous d'un certain ratio revenus / temps de travail, vous pourrez récupérer une prime pour l'emploi de quelques centaines d'euros. Non négligeable !

Pour finir...

Enfin, ne vous fiez pas à l'estimation donné à la dernière étape du formulaire. Cette dernière combine vos différents revenus, sans prendre en compte du fait que vous avez déjà payé vos impôts sur les revenus en AE... Vous devez donc attendre le courier officiel de votre Centre d'Impôts pour être fixé !

Internationaliser son application Django

Tue, 08 Mar 2011 12:22:25 +0100

Voyons comment traduire efficacement une application Django, en plusieurs étapes. Les contenus génériques des modèles et des vues, tout d'abord, en utilisant gettext. Puis les templates en eux-même. Et enfin, le contenu de la base de données que nous allons rendre adaptables aux différentes traductions grâce à django-multilingual-ng. Nous verrons également comment Django permet d'adapter la langue affichée en fonction des options de l'utilisateur.

Configurer i18n

Le module générique de Django permettant la traduction s'appelle i18n, pour "Internationalisation". Dans votre fichier settings.py, ajouter / modifiez les lignes suivantes correspondant à vos différentes langues :

from django.utils.translation import gettext_lazy as _
TIME_ZONE = 'Europe/Paris'
LANGUAGE_CODE = 'fr'
SITE_ID = 1USE_I18N = True
USE_L10N = True
LANGUAGES = (
    ('fr', _('Français')),
    ('en', _('Anglais')),
)
DEFAULT_LANGUAGE = 1

Puis, au niveau des middlewares et des context processors :

MIDDLEWARE_CLASSES = ( 
    [...] 
    'django.middleware.locale.LocaleMiddleware', 
)
TEMPLATE_CONTEXT_PROCESSORS = (
    [...]
    "django.core.context_processors.i18n",
)

Utiliser gettext au sein des fichiers .py

Premiers termes que nous allons traduire : les contenus de vos fichiers .py (modèles essentiellement). C'est déjà ce que nous avons fait dans l'étape précédente pour les langues disponibles : dès qu'un mot sera écrit dans un fichier .py (description d'un champ d'un modèle par exemple), vous allez utiliser gettext pour permettre ça traduction (en mode paresseux). Importez donc gettext dans tous vos fichiers .py et attribuez lui l'alias _ pour l'implémenter plus facilement :

from django.utils.translation import gettext_lazy as _

Puis, pour chaque terme (ici la classe meta d'un model par exemple) :

class Meta:
    verbose_name = _('Image')
    verbose_name_plural = _('Images')

Traduire les templates

Pour ce qui est des templates, où vous devriez avoir plus de termes à traduire, le fonctionnement est le même. Commencez par permettre la traduction au sein de chaque template grâce au template_tag :

{% load i18n %}

Et, pour chaque phrase à traduire :

{% trans "Bienvenue sur mon site" %}

S'il s'agit d'un bloc de texte plus conséquent, vous pouvez utiliser :

{% blocktrans %}
[...]
{% endblocktrans %}

Si vos blocs contiennent des variables, je vous invite à consulter la documentation bien fournie !

Générer les traductions

Maintenant que vous avez permis l'internationalisation de tous vos termes, vous allez pouvoir en saisir la traduction. Si vous êtes déjà familier avec le système de wordpress, sachez qu'il s'agit du même principe (qui ressemblait déjà jusque là). Des fichiers de traductions (.po) vont être générés, contenant chaque phrase que vous aurez à traduire dans toutes les langues sélectionnées. Une fois la traduction effectuée, Django compilera ces données dans un fichier .mo.

Commencez par créer un nouveau répertoire à la racine de votre projet : locale/. C'est lui qui contiendra les différents fichiers de traductions.

Vous devez ensuite installer gettext, si vous ne l'avez pas encore. Voici la marche à suivre sous Windows et MacOS. Pour générer les fichiers de traductions, tapez la commande suivante (à la racine de votre application) :

django-admin.py makemessages --all

Un nouveau répertorie sera créé dans votre dossier locale/ par langue configurée. Editez LC_MESSAGES/django.po et traduisez chacun des termes... Puis, une fois la traduction effectuée, lancez la commande :

django-admin.py compilemessages

Changer de langue

Pour permettre à l'utilisateur de changer de langue, éditez votre fichier urls.py et ajoutez la règle suivante :

urlpatterns = patterns(
    [...],
    (r'^i18n/', include('django.conf.urls.i18n'))

Puis, dans un de vos templates, créez le formulaire suivant :

<form action="/i18n/setlang" method="post">
{% csrf_token %}
<select name="language">
{% for lang in LANGUAGES %}
    <option value="{{ lang.0 }}">{{ lang.1 }}</option>
{% endfor %}
</select> 
</form>

L'URL /i18n/setlang/ (que vous venez de configurer) permet de changer la langue courrante du site, qu'on lui passe en paramètre POST. La page est donc ré-actualisée... avec les templates traduits !

Notez que grâce au middleware Locale que vous avez inclus dans vos paramètres, Django détectera automatiquement les options du navigateur de l'utilisateur... et utilisera la bonne langue en conséquence !

Traduire le contenu de votre BDD : django-multilingual-ng

Seulement, vous l'aurez remarqué, seuls les contenus "statiques" sont modifiés. Comment faire pour traduire dynamiquement le contenu de votre base de données ? Le nom d'un post et son contenu, par exemple ? C'est là qu'entre en jeu django-multilingual-ng. Il vous permettra d'ajouter dynamiquement une table de traduction pour chacun des objets à internationaliser. Attention, les opérations suivantes vous feront perdre vos données déjà présentes dans la BDD. Pensez à les sauvegarder !

Installer django-multilingual-ng

Téléchargez le package et installez-le comme un plug-in classique. Editez ensuite settings.py :

TEMPLATE_CONTEXT_PROCESSORS = (
    [...], 
    'multilingual.context_processors.multilingual',
)
INSTALLED_APPS = ( 
    [...], 
    'multilingual', 
)

Modifier les modèles et l'intertface d'administration

Editez maintenant vos models.py. Vous allez devoir choisir les champs qui auront besoin d'une traduction et les placer dans une sous-classe, de la façon suivante :

from multilingual.translation import TranslationModel

class MyModel(models.Model):
    # Les champs qui ne seront pas traduits
    creation_date = models.DateTimeField()
    link = models.URLField(blank=True, null=True)

    # Les champs à traduire
    class Translation(TranslationModel):
        title = models.CharField(max_length=200)
        slug = models.CharField(max_length=200)
        description = models.TextField()
        overview = models.TextField()

Le champs compris dans cette classe Translation existeront donc pour chacune des langues configurées. Ici : title, slug, description et overview.

Modifiez également admin.py pour vous permettre de modifier ces champs dans l'interface d'administration. Vos classes d'admin devront juste hériter de "MultilingualModelAdmin" au lieu du traditionnel "ModelAdmin" :

from multilingual.admin import MultilingualModelAdmin

class MyModelAdmin(MultilingualModelAdmin):
    [...]
    use_prepopulated_fields = {'slug': ('title',)}

Attention, certaines méthodes ont été renomées dans le MultilingualModelAdmin. Par exemple, "prepolulated_fields" devient "use_prepopulated_fields". Notez également que vos classes "inlines" devront elles hériter de "MultilingualInlineAdmin", comme l'exemple suivant (couple classes Crea / Task) :

from multilingual.admin import MultilingualModelAdmin, MultilingualInlineAdmin

class TaskInline(MultilingualInlineAdmin):
    model = Task
    use_prepopulated_fields = {'slug': ('name',)}

class CreaAdmin(MultilingualModelAdmin):
    list_display = ('title', 'slug', 'creation_date', 'link')
    search_field = ('title', 'body')
    date_hierarchy = 'creation_date'
    use_prepopulated_fields = {'slug': ('title',)}
    inlines = [ TaskInline]

Vous devez lancer un syncdb pour re-synchroniser votre base. Vous allez donc perdre toutes vos anciennes données. N'hésitez pas à les exporter pour pouvoir ensuite les ré-importer. Mais je vous conseille surtout de faire cette opération d'internationalisation avant le déploiement de votre application...

$ manage.py syncdb

Si vous explorez votre nouvelle base (via phpMyAdmin par exemple), vous comprendrez le fonctionnement de django-multilingual-ng avec la création de tables de traductions supplémentaires...

Rendez-vous maintenant dans l'interface d'administration. Vous pourrez constater que vos modèles possédant des champs traduisibles sont désormais modifiables grâce à un onglet pour chaque langue !

Accéder aux données traduites

Dans votre application, suivant la langue courante, les champs seront automatiquement traduits. Mais vous pouvez tout de même accéder aux traductions des autres langues. Par exemple, au sein d'un template, si la langue courante est le français :

{{ obj.title }} <!-- Le titre en français -->
{{ obj.title_fr }} <!-- Idem -->
{{ obj.title_en }} <!-- Le titre en anglais -->

De même, dans vos Querysets (toujours avec le français en langue courante) :

# Les créations ordonnées par le titre français
objs = Crea.objects.order_by('title')

# Les créations ordonnées par le titre anglais
objs = Crea.objects.order_by('title_en')

Voilà pour l'utilisation de django-multilingual-ng. Vous pouvez également lire la documentation relativement peu fournie, ou simplement fouiller dans le code (ce qui est finalement le plus efficace)...

Optimisation

Une dernière chose à propose de l'optimisation. Si vous posséder la django-debug-toolbar (par exemple), vous allez constater que les requêtes SQL générés par django-multilingual-ng sont assez... généreuses. Effectivement, elles sont assez fournies en jointures (logique, avec les données réparties entre deux tables pour la traduction). N'hésitez pas, donc, à utiliser les moteurs de cache de Django pour décharger un peu votre base de données. Je reviendrai également dans un futur article sur une méthode de cache de fichiers HTML statiques (par langue) qui permettra un gain notable de performances.

jQuery mobile (et Django)

Sun, 06 Mar 2011 12:37:19 +0100

jQuery mobile est un framework Javascript orienté interface utilisateur permettant, suivant le fameux concept du "write less, do more", de mettre en place une version mobile pour son site web. L'ergonomie est au coeur de la problématique : comment proposer aux utilisateurs de terminaux mobiles une version de mon site rapide à charger et ergonomique sur petit écran ?

Dans cet article, vous verrez comment mettre en place jQuery mobile au sein d'une application Django, pour l'exemple. L'architecture de cette application n'a rien à voir avec jQuery mobile, donc n'hésitez pas à le suivre quel que soit votre framework préféré... La première partie sera plus généraliste et vous permettra de comprendre comment adapter jQuery mobile à n'importe quelle application.

Mise en place de jQuery mobile

jQuery mobile vous fournit toutes les données nécessaires (Javascript, AJAX et CSS) pour créer des interfaces orientées utilisateurs de terminaux mobiles. Pour un usage basique, vous n'aurez donc aucune ligne de code à écrire vous-même, simplement à copier / coller les exemples de la documentation.

Nous allons créer un nouveau set de templates, indépendant de notre application, qui sera dédié aux utilisateurs mobiles. L'utilisation du HTML5 est donc de rigueur ! Rendez-vous sur la documentation de jQuery mobile. Ce sera exactement le rendu que nous cherchons à avoir. Examinez donc le code source de la première page : vous devrez utiliser la même structure.

Template de base

Voici votre template de base :

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8" />
    <title>Mon site | Version mobile</title>
    <link rel="stylesheet" href="http://code.jquery.com/mobile/1.0a3/jquery.mobile-1.0a3.min.css" />
    <link rel="stylesheet" href="/media/css/mobile.css" />
    <script type="text/javascript" src="http://code.jquery.com/jquery-1.5.min.js"></script>
    <script type="text/javascript" src="http://code.jquery.com/mobile/1.0a3/jquery.mobile-1.0a3.min.js"></script>
</head>
<body>
    <div data-role="page" data-theme="b">
	<!-- Header, éventuellement -->
	<!-- Contenu -->
	<div data-role="content">
	</div>
    </div>
	</body>
	</html>

Vous constatez que vous n'avez aucun fichier à héberger sur votre serveur : nous chargeons le CSS et les images directement en ligne. En partant du principe que le serveur de jQuery est plus réactif que le votre (sans offense), cela vous permettra de gagner du temps sur la durée de chargement des médias.

Les listes

jQuery mobile fonctionne avec des listes HTML basiques. Là encore, vous n'avez qu'à copier coller le code de la documentation, et à tester pour voir le rendu.

Tout votre contenu devra se placer dans la div data-role "content". Créez une liste de la façon suivante :

<div data-role="content">
    <ul data-role="listview" data-insert="true" data-theme="b" data-dividertheme="b">
	<li data-role="list-divider">Titre de la liste</li>
	<li><a href="page2/">Page 2</a></li>
	<li><a href="page3/">Page 3</a></li>
    </ul>
	</div>

Vous aurez ainsi une liste déjà stylée grâce au CSS de jQuery mobile. Notez que vous pouvez modifier le thème de chaque élément possédant l'attribut "data-theme", en lui donnant une valeur de a à e. Voici la correspondance au niveau design.

Le fonctionnement

jQuery mobile va suivre les liens de votre templates en créant une requête AJAX afin de ne pas raffraîchir la page (= gain de performance), avec en prime une petite animation de slide (par défaut). Créez donc simpement les pages correspondant à vos liens, avec la même structure que votre template de base. Le contenu de la div data-role "content" sera ré-injecté dans votre page.

Vous pouvez également ajouter un header proposant un lien de retour :

<div data-role="header" data-theme="b">
    <h1>Portfolio</h1>
    <a href="../" data-icon="home" data-iconpos="notext" data-direction="reverse" class="ui-btn-right jqm-home">Accueil</a>
	</div>

Personnalisation

Voilà pour le fonctionnement de base. Vous pouvez évidememnt personnaliser les composants de vos listes en suivant la documentation. Il en existe beaucoup de génériques. Si vous souhaitez modifier le CSS pour une personnalisation totale, il est également très facile d'écraser les règles de base dans votre propre CSS (mobile.css, que nous avons lié). Exemple :

 .ui-li-divider  { 
    background-image: -webkit-gradient(linear,left top,left bottom,color-stop(0,#0091b6),color-stop(1,#0289ab)); 
}

Firebug vous aidera à trouver la classe des élements que vous souhaitez personnaliser ! Pour plus d'informations sur jQuery mobile, je vous invite à regarder cet excellent tutoriel vidéo par Grafikart.

L'application Django

Voyons maintenant comment utiliser jQuery mobile au sein d'une application Django existante. Pour cela, nous allons créer un module (views + templates) dédié.

Le module mobile

Pourquoi ne pas modifier seulement les templates existants ? Plusieurs réponses :

Les querysets effectuées dans le contrôleur d'une vue "non-mobile" ne seront pas forcément utilisées, vu qu'on n'affichera pas les mêmes données.
Comme on recherche avant tout la performance, on préferera supprimer toute requête inutile.
Pour avoir un code plus clair !

Créez donc le nouveau module :

$ manage.py startapp mobile

Comme d'habitude, ajoutez l'application à vos installations via settings.py :

INSTALLED_APPS = (
    [...]
    'myproject.mobile',
)

Et les URLs, dans urls.py :

urlpatterns = patterns('',
    [...],
    (r'^mobile/', include('myproject.mobile.urls')),
)

Les urls et vues

Dans mobile/views.py, créez une vue pour chacune des pages de votre application. Pour rester dans l'exemple : home, page1 et page2 :

from django.shortcuts import render_to_response

def home(request):
    return render_to_response(
        'mobile/home.html'
        {},
        context_instance=RequestContext(request)
    )
def page1(request):
     return render_to_response(
         'mobile/page1.html'
         {},
         context_instance=RequestContext(request)
     )  

def page2(request):
     return render_to_response(
         'mobile/page2.html'
         {},
         context_instance=RequestContext(request)
     )

Puis, reliez ces vues avec les URLs, dans mobile/urls.py :

from django.conf.urls.defaults import *
from myproject.apps.mobile.views import *

urlpatterns = patterns('',
    url(r'^$', home, name='home'),
    url(r'^page1/$', page1, name='page1'),
    url(r'^page2/$', page2, name='page2'),
)

Les templates

Pour les templates, vous pouvez réutiliser la structure donnée au-dessus. Par exemple, templates/layout/base_mobile.html :

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8" />
    <title>{% block title %}Mon site | Version mobile{% endblock title %}</title>
    <link rel="stylesheet" href="http://code.jquery.com/mobile/1.0a3/jquery.mobile-1.0a3.min.css" />
    <link rel="stylesheet" href="/media/css/mobile.css" />
    <script type="text/javascript" src="http://code.jquery.com/jquery-1.5.min.js"></script>
    <script type="text/javascript" src="http://code.jquery.com/mobile/1.0a3/jquery.mobile-1.0a3.min.js"></script>
</head>
<body>
    <div data-role="page" data-theme="b">
	{% block header %}{% endblock header %}
	<div data-role="content">
	{% block content %}{% endblock content %}
	</div>
    </div>
	</body>
	</html>

Et le template de la home (templates/mobile/home.html) :

{% extends "layout/base_mobile.html" %}
{% block header %}
<div data-role="header" data-theme="b">
    <h1>Portfolio</h1>
    <a href="../" data-icon="home" data-iconpos="notext" data-direction="reverse" class="ui-btn-right jqm-home">Accueil</a>
</div> 
{% endblock header %}

{% block content %}
<ul data-role="listview" data-insert="true" data-theme="b" data-dividertheme="b">
        <li data-role="list-divider">Titre de la liste</li>
        <li><a href="page2/">Page 2</a></li>
        <li><a href="page3/">Page 3</a></li>
    </ul>
{% endblock content %}

Faites de même pour les différentes pages.

Rediriger l'utilisateur mobile

Vous devez maintenant pouvoir naviguer sur votre version mobile à l'adresse mobile/. Maintenant, on voudrait que l'utilisateur d'un terminal mobile soit automatiquement rédirigé vers cette URL. Pour cela, on va utiliser (et adapter) django-mobile.

Installer django-mobile

Téléchargez et installez l'archive en suivant la documentation. Vous devrez :

Installer le package.
Ajouter django-mobile à vos INSTALLED_APPS.
Ajouter les middlewares dans le bon ordre.
Ajouter le template loader et le context processor.

Utiliser un décorateur

Pour finir, nous allons décorer chacune des vues de l'application (non-mobile) pour rediriger automatiquement les utilisateurs mobiles. Pour ce faire, placez dans le répertoire mobile/ un nouveau fichier decorators.py :

from django.http import HttpResponseRedirect
from functools import wraps
from django_mobile import get_flavour

def mobile_redirection(url):
    def decorator(func):
        def inner_decorator(request, *args, **kwargs)
            flavour = get_flavour()
            if flavour == 'mobile':
                return HttpResponseRedirect('mobile%s' % url)
            else:
                return func(request, *args, **kwargs)
        return wraps(func)(inner_decorator)
    return decorator

Ce décorateur s'utilise de la façon suivante. Dans les vues de votre application :

@mobile_redirection('/')
def home_page(request):
[...]

L'utilisateur mobile sera alors automatiquement redirigé vers /mobile/. Pour modifier cette URL, passez-le en paramètre du décorateur. Par exemple '/page1/' redirigera vers mobile/page1/.

Testez en appelant votre URL depuis un terminal mobile. Vous devriez être redirigé automatiquement (comme sur http://www.valentinbourgoin.net) !

Changer de version manuellement

Enfin, si vous souhaitez proposer un lien pour changer de version manuellement, il vous suffit d'utiliser une spécificité de django-mobile en appelant les URLs suivantes :

/?flavour=mobile pour la version mobile.
/?flavour=full pour la version complète.

Disqus : plateforme de commentaires

Fri, 25 Feb 2011 17:29:07 +0100

Submergé par les spams, j'ai décidé d'abandonner mon bon vieux systèmes de commentaires codé à la mano au sein de mon application Django pour un module plus souple. Disqus semblait répondre à mes besoins. Voici la marche à suivre pour l'installer sur un blog (ou un site). Avec, en prime, la méthode pour importer vos anciens commentaires...

Disqus

Disqus est donc un systèmes de gestion de commentaires externalisé qui comporte, en plus des classiques, un certain nombre de fonctionnalités intéressantes. Par exemple, il propose l'identification par le biais d'un service tiers (Facebook, Twitter, OpenID, etc.), le suivi de conversation par RSS ou e-mail, le classement de commentaires par popularité (likes)... De plus, son mode de fonctionnement est assez original, puisque les discussions sont organisées par "threads" de questions / réponses, comme sur un forum.

Disqus est utilisé sur des sites à fort traffic comme Techcrunch (exemple ci-dessus), CNN, ou encore Fox news. Le tout propulsé... par Django !

Quelques détails désacréables tout de même :

Disqus charge les commentaires en Javascript. Le contenu de ceux-ci ne sera donc pas référencé.
Il faut être prêt à confier son systèmes de commentaires (et ses données) à une plateforme externe. Mais Disqus permet un import/export relativement facile (nous y reviendrons), donc on peut tout de même récupérer ses commentaires si on décide d'abandonner le système.

Installation

Commencez par créer un compte Disqus ainsi qu'un site. Vous êtes maintenant prêt à installer le module. Vous allez voir qu'il est possible de l'installer sur des plateformes de blogs basiques, sous Django ou encore à la main...

Plateformes de blog

Un des gros avantages de Disqus, c'est qu'il est directement installable sur les plateformes de blogs les plus courantes, sous la forme d'un plug-in. Pas besoin de mettre les mains dans le cambouis, donc ; juste à le configurer. Sont compatibles : Wordpress, Blogger, Tumblr, Drupal, Joomla... Vous trouverez la liste sur la page d'installation de l'interface d'administration de Disqus.

Sous Django

Django-disqus, comme son nom l'indique, permet d'utiliser disqus au sein d'un projet Django. Commencez par télécharger le package est l'installer. Vous devez ensuite l'importer dans les paramètres de votre application. Ainsi, dans settings.py :

INSTALLED_APPS = (
     ...
     'disqus',
 )

 DISQUS_API_KEY = 'FOOBARFOOBARFOOBARFOOBARFOOBARF'
 DISQUS_WEBSITE_SHORTNAME = 'foobar'

Note : pour récupérer votre clé d'API, il vous être loggé sous Disqus et consulter la page suivante : http://disqus.com/api/get_my_key/.

Ensuite, c'est très simple. Django-disqus permet, par l'utilisation de templatetags, de charger le module de commentaire en une ligne. En haut de votre template concerné, il vous suffit d'écrire :

{% load disqus_tags %}
{% disqus_dev %} <!-- Si vous êtes en local -->

Puis, à l'endroit où vous voulez afficher les commentaires et le formulaire :

{% disqus_show_comments %}

Le code Javascript sera alors généré... et les commentaires affichés ! Vous pourrez alors le personnaliser depuis votre interface d'administration Disqus. Plus d'informations sur les templatetags dans la documentation du plug-in.

A la main

Pour les non-djangonautes, pas de panique, l'installation à la main est presque aussi facile. Il vous suffit d'utiliser ce code Javascript pour afficher les commentaires et leur formulaire :

<div id="disqus_thread"></div>
<script type="text/javascript">
    /* * * CONFIGURATION VARIABLES: EDIT BEFORE PASTING INTO YOUR WEBPAGE * * */
    var disqus_shortname = 'example'; // required: replace example with your forum shortname

    // The following are highly recommended additional parameters. Remove the slashes in front to use.
    // var disqus_identifier = 'unique_dynamic_id_1234';
    // var disqus_url = 'http://example.com/permalink-to-page.html';

    /* * * DON'T EDIT BELOW THIS LINE * * */
    (function() {
        var dsq = document.createElement('script'); dsq.type = 'text/javascript'; dsq.async = true;
        dsq.src = 'http://' + disqus_shortname + '.disqus.com/embed.js';
        (document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(dsq);
    })();
</script>
<noscript>Please enable JavaScript to view the <a href="http://disqus.com/?ref_noscript">comments powered by Disqus.</a></noscript>
<a href="http://disqus.com" class="dsq-brlink">blog comments powered by <span class="logo-disqus">Disqus</span></a>

C'est tout ! Les autres fonctionnalités sont expliquées sur cette page.

Personnalisation

Une fois Disqus installé, vous pouvez personnaliser l'affichage de vos commentaires comme bon vous semble. Vous pouvez choisir un thème via l'interface d'administration, ouvrir ou fermer certaines fonctionnalités (likes, permaliens...), ou même modifier vous-même le CSS.

Les possibilités sont donc quasi-infinies, et vous pourrez avoir très facilement un design moins générique et se mariant parfaitement avec le thème de votre blog (hm, chose que je n'ai pas forcément faite).

Import des anciens commentaires

Enfin, si votre blog comportait d'anciens commentaires avant l'implémentation de Disqs, vous ne voulez pas forcément vous en séparer... Si vous possédez une plateforme de blog (Wordpress, Blogger), il existe un plug-in vous permettant d'exporter vos commentaires. Dans l'interface d'administration, allez dans "Tools", puis "Import / Export". Vous verrez les plateformes compatibles.

Si ce n'est pas le cas et que votre appli Django utilise django-comments, vous allez pouvoir exporter vos données gâce à Django-disqus. En effet, le package comporte les commandes nécessaires our générer l'export au bon format. Vous pouvez suivre la marche à suivre ici.

Enfin, si vous devez exporter vos commentaires à la main, vous pouvez utiliser le format WXR de Wordpress, pris en charge par Disqus. Il vous suffit d'écrire un petit script générant un fichier XML conforme aux spécifications de WXR, et en l'uploadant dans l'interface. Par exemple, voici le template que j'ai utilisé (attention, pensez bien à l'encodage du fichier) :

<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:excerpt="http://wordpress.org/export/1.0/excerpt/" 
   xmlns:content="http://purl.org/rss/1.0/modules/content/" 
   xmlns:wfw="http://wellformedweb.org/CommentAPI/" 
   xmlns:dc="http://purl.org/dc/elements/1.1/" 
   xmlns:wp="http://wordpress.org/export/1.0/">

<channel> 
   <title>{{ site.title }}</title> 
   <link>{{ site.url }}</link> 
   <description>{{ site.description }}</description> 
   <pubDate>{% now|date:"D, d M Y H:i:s" %}</pubDate> 
   <generator>http://wordpress.org/?v=3.0.4</generator> 
   <language>fr</language> 
   <wp:wxr_version>1.0</wp:wxr_version> 
   <wp:base_site_url>{{ site.url }}</wp:base_site_url> 
   <wp:base_blog_url>{{ site.url }}</wp:base_blog_url>  
   <generator>http://wordpress.org/?v=3.0.4</generator> 

   {% for entry in entries %}    
     <item> <title>{{ entry.title }}</title> 
     <link>{{ site_url }}{{ entry.get_absolute_url }}</link> 
     <pubDate>{{ entry.publication_date|date:"D, d M Y H:i:s" }}</pubDate> 
     <dc:creator><![CDATA[{{ entry.user }}]]></dc:creator>  
     <guid isPermaLink="false">{{ site_url }}{{ entry.get_absolute_url }}</guid> 
     <description></description> 
     <content:encoded><![CDATA[{{ entry.body }}]]></content:encoded> 
     <wp:post_id>{{ entry.id }}</wp:post_id> 
     <wp:post_date>{{ entry.publication_date|date:"D, d M Y H:i:s" }}</wp:post_date> 
     <wp:post_date_gmt>{{ entry.publication_date|date:"D, d M Y H:i:s" }}</wp:post_date_gmt> 
     <wp:comment_status>open</wp:comment_status> <wp:ping_status>open</wp:ping_status> 
     <wp:post_name>{{ entry.slug }}</wp:post_name> 
     <wp:status>publish</wp:status> 
     <wp:post_parent>0</wp:post_parent> 
     <wp:menu_order>0</wp:menu_order> 
     <wp:post_type>post</wp:post_type> 
     <wp:is_sticky>0</wp:is_sticky>
 
     {% for com in entry.entrycomment_set.all %} 
     <wp:comment> 
          <wp:comment_id>{{ com.id }}</wp:comment_id>          
          <wp:comment_author><![CDATA[{{ com.author }}]]></wp:comment_author> 
          <wp:comment_author_email>{{ com.email }}</wp:comment_author_email> 
          <wp:comment_author_url>{{ com.website }}</wp:comment_author_url> 
          <wp:comment_author_IP>{{ com.ip }}</wp:comment_author_IP> 
          <wp:comment_date>{{ com.publication_date|date:"D, d M Y H:i:s" }}</wp:comment_date> 
          <wp:comment_date_gmt>{{ com.publication_date|date:"D, d M Y H:i:s" }}</wp:comment_date_gmt> 
          <wp:comment_content><![CDATA[{{ com.content }}]]></wp:comment_content> 
          <wp:comment_approved>1</wp:comment_approved> 
          <wp:comment_parent>0</wp:comment_parent>
     </wp:comment>
   {% endfor %}
</item> 
{% endfor %}  
</channel>
</rss>

Combien facturer en freelance ?

Mon, 07 Feb 2011 10:02:27 +0100

Une fois lancé en freelance, vous vous retrouvez devant une grave problématique : comment fixer votre tarif journalier ? Vous devez garder en vue la concurrence, évidemment, et définir un prix concurrentiel sans pour autant vous solder.

Je vous propose un calcul simple, facile à mettre en oeuvre.

Commencez par réfléchir à combien vous voudriez gagner par mois. Sans l'ACCRE, vous devrez payer environ 30% de charge + impôts sur le revenu. Je vous conseille également de conserver 20% de chaque facture pour les frais professionnels annexes basiques. Par exemple, donc, pour avoir 1500 € net dans votre poche à la fin du mois :

Total de 3000 € à facturer.
900 € de charges.
600 € de frais annexes (ou de secours).

Vous pouvez partir sur 3 jours de travail facturés par semaine. Pourquoi seulement 3 ? Car votre temps passé en comptabilité, devis, rendez-vous clients, etc. ne seront eux pas facturés. Vous devrez donc réaliser votre chiffre d'affaire mensuel sur... 12 jours. Si on divise 3000 € par 12, on obtient votre tarif journalier moyen : 250 €.

Pensez également à différencier vos prix en fonction de vos taches afin de donner une réelle valeur à vos compétences. Typiquement, de l'intégration HTML ne sera pas facturée au même prix que du développement Python. Cela permet également de réfléchir sur la gestion de votre temps, et ce dès l'étape du devis.

Voici, d'après mon expérience, des taux journaliers honnêtes pour un autoentrepreneur débutant en région parisienne.

Intégration HTML : 350 €.
Développement front / back : 400 €.
Suivi de projet / conception : 450 €.

Autoentrepreneur : premier bilan

Fri, 04 Feb 2011 18:10:02 +0100

Il y a tout juste 6 mois, je me lançais dans l'aventure de l'(auto-)entrepreneuriat. Aujourd'hui, c'est l'heure d'en dresser le premier bilan. Humain, tout d'abord, mais aussi financier !

"En étant développeur web freelance, combien on gagne ? Comment on vit ? Un CDI, c'est pas mieux ?"

Je vais tenter de répondre à toutes ces questions en partageant mon expérience !

Mon cas

Tout d'abord, petit préambule sur mon cas. On peut être autoentrepreneur en parallèle de ses études ou d'un autre travail, mais on peut aussi l'être à temps plein. C'est mon cas, depuis cet été. Je possédais un statut de travailleur indépendant depuis 2006, qui m'a permis de me familiariser avec le concept de devis et de facturation pendant mes études.

Puis, après mon diplôme d'ingénieur et un an de CDI, j'ai décidé de me lancer. Un sacré pari, puisque ce qui n'était alors qu'une entrée d'argent d'appoint allait devoir devenir mon unique source de revenus.

Avec "seulement" un gros loyer en région parisienne - mais pas de labrador à charge - cela semblait être le bon moment pour limiter la prise de risques qu'implique toute création d'activité.

La vie de freelance

La vie de freelance - ou plus généralement de télé-travailleur - est à double-tranchant. Effectivement, on gagne beaucoup de temps à ne pas se déplacer jusqu'à son lieu de travail (puisqu'on y dort). Oui, on est libre dans les horaires. Mais... il y a un "mais".

Quand on passe tes journées chez soi, le plus souvent devant son ordinateur, il faut faire attention à plusieurs choses. Tout d'abord, à instaurer des règles, voire une routine. Sinon, on va rapidement se retrouver à pratiquer des horaires complètement décalés : travailler la nuit, se lever tard... Donc, comme au bureau, se donner des horaires : 9h - 18h30 par exemple, avec une pause déjeuner... loin de l'ordinateur, de préférence !

Ca parait bête, mais il faut aussi... s'habiller ! C'est tentant de coder en caleçon, mais ça n'est pas très professionnel. Donc, même si l'ordinateur est à 5 mètres du lit, éviter la solution de facilité : se laver, s'habiller, et seulement après, travailler.

Il faut aussi braver courageusement les blagues des copains. "Oh, t'es chez toi toute la journée, tu fous rien de toutes façons..." ou autre "Et ça va, le chômage ?". Ils sont juste jaloux car pendant qu'eux, ils sont dans le métro, nous, on maximise notre productivité.

Les aides

Lorsqu'on débute une activité indépendante, on continue d'avoir le droit au chômage. Pour ma part, j'ai eu la chance de bénéficier d'une rupture de contrat conventionnelle, donc j'avais quelques mois de chômage devant moi. Dans ce cas là, Pôle Emploi propose deux formules :

Continuer de toucher ses droits en complément à ses revenus déclarés chaque mois.
Bénéficier d'un capital, avec le versement de 50% de tous ses droits.

J'avais le droit à environ 1200 € de chômage, pendant 9 mois (ma période cotisée). J'avais donc le choix :

Soit avoir 1200 € assurés chaque mois (exemple : je gagne 500 € un mois, on m'en verse 700 pour compléter).
Soit avoir 50% des 10 800 € de mes droits.

J'ai opté pour la seconde solution. Je n'avais pas besoin d'un capital de départ (aucun achat de matériel à faire, aucun investissement pour mon activité), mais il me semblait que 1200 € mensuels seraient vite atteints. Le capital est versé en deux fois : une partie immédiatement, l'autre 6 mois après.

Seconde aide très importante pour les chômeurs ou jeunes autoentrepreneurs : l'ACCRE. Il s'agit d'une Aide à la Création d'Entreprise pour les moins de 26 ans, qui peuvent bénéficier d'une réduction des charges de façon dégressive pendant trois ans. Ainsi, au lieu de payer 20,3% de mon chiffre d'affaire, je commençais le premier trimestre avec environ 7%. Non négligeable, donc !

Les clients

Se lancer en freelance, c'est bien... Mais encore faut-il avoir des clients ! De mon début d'activité, je retiens que cela fonctionne beaucoup par contacts. Il faut donc privilégier au maximum son carnet d'adresses : anciens élèves, stages, collègues de promo... Mes premiers contrats sont venus à moi sans que je n'aie besoin de prospecter !

De plus, il faut penser à avoir une bonne visibilité sur les réseaux sociaux. Un compte twitter actif plus ou moins sérieux qu'on arrose de news, un facebook pour l'auto-promotion, un viadeo, linkedin, etc. Sans être non plus un pro du marketing, pensez à votre référencement. Google offre 50 € d'Adwords pour les auto-entrepreneurs, profitez-en pour vous essayer à la pub !

La facturation

Une fois que vous possédez vos premiers clients vient l'étape la plus critique : le devis / facturation. Quelle démarche adopter ? Baisser les prix pour être très concurrentiel ? Conserver des prix normaux mais miser sur la présentation et la qualité technique de la livraison ?

A mon avis, baisser les prix pour se faire une place sur le marché n'est vraiment pas la bonne solution. Bien sûr, vous pourrez décrocher des contrats plus facilement. Mais à travailler en-dessous de votre vraie valeur, vous courrez à votre perte. Il faut vous fixer un prix de Jour-Homme conforme à votre niveau et à votre activité, et vous y tenir. A vous de savoir l'expliquer... et le mériter.

Je reviendrai plus en détail dans un prochain billet sur le meilleur moyen de fixer efficacement son tarif journalier.

Bilan financier et humain

Enfin, je vais conclure en dressant un rapide bilan financier et humain de ces 6 mois d'activité. Entre août 2010 et janvier 2011, j'ai facturé exactement 11 600 € (bruts). La grande majorité des contrats ont été signés à la fin de cette période, puisque le mois de décembre représente 75% de ces revenus.

Alors, est-ce rentable, par rapport à un CDI ? Il est encore trop tôt pour répondre, car ces 6 premiers mois ont été assez longs à se lancer. Toutefois, le plafond annuel de revenus d'un autoentrepreneur étant à 32 000 € bruts, si on s'en tient au calcul de la partie précédente (où 50% de ses revenus finissent réellement dans nos poches), on peut vite voir que non, ce n'est pas forcément "rentable".

Seulement, en terme de qualité de vie, même s'il faut s'habituer à ce mode de vie un peu spécial (un emploi du temps très flexible et pas de salaire fixe), je suis plutôt séduit. Une fois les règles établies, même si ça arrive de devoir finir un livrable en urgence de nuit ou que plusieurs projets nous tombent dessus en même-temps, le télétravail est vraiment appréciable. Tout comme le fait de passer de projet en projet et de les suivre de A à Z, en relation directe avec le client !

Il ne faut pas se voiler la face et voir ce statut, ce mode de vie, comme ce qu'il est réellement : un tremplin vers l'entrepreneuriat. Un essai de création d'entreprise, mais pas une fin en soi.

Projets Django à l'école IMAC

Tue, 14 Dec 2010 02:03:35 +0100

Pour terminer le semestre en beauté, les étudiants de l'école d'ingénieur IMAC auxquels je donne cours avaient à réaliser un projet en utilisant le framework Django par équipes de 5 à 7. Le sujet était relativement libre : un site institutionnel, communautaire ou d'e-commerce. Voici le fruit de leurs 5 semaines de travail. Bravo à eux !

Fac by car

Adresse : http://facbycar.alwaysdata.net

Pitch : Site de co-voiturage réservé aux étudiants de l'Université de Marne-la-Vallée.

Membres de l'agence : Yacine Arhaliass, Floriane Brin, Camille Dutrouilh, Paul Hillereau, Samuel Maillot, Virginie Rallière, Clément Robein.

MyApps5

Adresse : http://myapps5.pandaco.net/

Pitch : Galerie d'applications HTML5.

Membres de l'agence : Adrien Benoist, Alexandre Huynh, Aurore Jard, Sophie Linh, Thi Thanh Trang Phan.

IMAC Center

Adresse : http://imaccenter.alwaysdata.net/

Pitch : Réseau social réservé aux étudiants de l'IMAC (futurs, actuels et anciens).

Membres de l'agence : Lionel Augé, Julien Issartel, Yoann Gobert, Ikram Naciri, Jordan Valnet.

BuyBioFrance

Adresse : http://buybiofrance.alwaysdata.net

Pitch : Site d'e-commerce de produits bio en relation directe avec les producteurs.

Membres de l'agence : Karine Chor, Ludivine Clémenceau, Vincent Hurbourque, Nicolas Martino, Mathieu Taillandier.

MyGroupies

Adresse : http://mygroupies.alwaysdata.net

Pitch : Site communautaire à l'attention de musiciens et organisateurs d'évènements.

Membres de l'agence : Camille Bossoutrot, Nassim Khiter, Arnaud Casella, Solèle Le Borgne, Sébastien Margheriti.

Ciné-court

Adresse : http://cinecourt.alwaysdata.net

Pitch : Site communautaire de partage de courts métrages.

Membres de l'agence : Laetitia Cunin, Julie Escoffier, Thibaut Fluteaux, Maxime Pasquali, Yann Nivet, Julie Trang.

Cinémac

Adresse : http://geocoucou.alwaysdata.net

Pitch : Site d’e-learning communautaire destiné aux étudiants en audiovisuel de l'école IMAC.

Membres de l'agence : Mélanie Charbonnier, Lucie Cordina, Arnaud Dabouis, Quentin Dangles, Eric Hauchecorne, Raphaël Vandon.

Merci également à Alwaysdata pour l'hébergement Django de qualité et à Florian Thirion et Fabien Kapala pour m'avoir assisté lors des présentations finales.

Enseignements web à l'IMAC

Mon, 01 Nov 2010 02:16:00 +0100

Je donne depuis le mois d'avril dernier des cours en Master 1 Informatique à l'Université de Marne-la-Vallée et depuis octobre à l'école d'ingénieur IMAC (1ère et 3ème années).

Pour que mes étudiants retrouvent chaque semaine le bon TD, j'ai développé, en Django, une plateforme dédiée.

Rien de très compliqué, beaucoup de copiés collés de ce blog, un rafraîchissement du CSS et le tour est joué. Si vous souhaitez y faire un tour, c'est par ici que ça se passe : http://cours.valentinbourgoin.net. J'y parle d'intégration HTML, de jQuery, de PHP et un peu de Django. Forcément.

Django - l'interface d'administration

Wed, 15 Sep 2010 15:52:19 +0200

Dans les articles précédents, nous avons conçu la structure d'un futur portfolio Django et en avons développé les modèles. Maintenant, nous allons lancer l'interface d'administration générique proposée par Django afin d'avoir la possibilité d'ajouter des données à notre application.

Cette dernière nous permettra d'ajouter / éditer / supprimer (CRUD) tous les objets que nous aurons décidé de rendre personnalisable.

Activer l'interface d'administration

Avant toute chose, il faut activer l'interface d'administration. Pour cela, dans votre fichier urls.py (celui de la racine, correspondant à votre projet), décommentez les deux lignes pour avoir un résultat de la forme suivante :

from django.conf.urls.defaults import *
# Uncomment the next two lines to enable the admin:
from django.contrib import admin
admin.autodiscover()
urlpatterns = patterns('',
    # Example:
    # (r'^mysite/', include('mysite.foo.urls')),

    # Uncomment the admin/doc line below and add 'django.contrib.admindocs'
    # to INSTALLED_APPS to enable admin documentation:
    # (r'^admin/doc/', include('django.contrib.admindocs.urls')),

    # Uncomment the next line to enable the admin:
    (r'^admin/', include(admin.site.urls)),
)

Puis, dans settings.py, ajoutez l'interface d'administration dans les applications installées (si ce n'est pas déjà le cas) :

INSTALLED_APPS = (
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.sites',
    'django.contrib.messages',
    'django.contrib.admin',
    'website.apps.portfolio',
)

Vous devez maintenant synchroniser la base de données pour ajouter les tables correspondant à l'admin :

$ manage.py syncdb

Relancez votre serveur de développement

$ manage.py runserver

et rendez-vous sur

http://localhost:8000/admin/

Bienvenue sur l'interface d'administration de Django !

Personnaliser l'interface

Vous pouvez maintenant personnaliser les informations (ou plutôt les modèles) que vous voudrez modifier grâce à cette interface. Typiquement, pour notre portfolio, il s'agit :

Des créations.
De leurs images respectives.
Des tags qui les définissent.

Vous allez donc éditer le fichier admin.py de votre application (apps/portfolio/admin.py) et définir une classe pour l'administration des créations, que vous allez relier au modèle Crea :

from django.contrib import admin
from website.apps.portfolio.models import Crea, Tag, Pict

class CreaAdmin(admin.ModelAdmin):
    list_display = ('title', 'slug', 'creation_date', 'link')
    search_field = ('title', 'description')
    date_hierarchy = 'creation_date'
    prepopulated_fields = {'slug': ('title',)}

admin.site.register(Crea, CreaAdmin)

Si vous retournez sur la page de l'interface, vous verrez que vous pouvez maintenant ajouter et modifier vos objets Crea. Nous allons maintenant faire de même avec les images et les tags. Seulement, vu qu'il s'agit-là d'objets liés entre eux (une ForeignKey), nous allons les ajouter directement à la gestion des créations. Ainsi, quand vous voudrez ajouter une création, vous pourrez gérer ses images et ses tags sur la même page. Pour cela, nous alons utiliser très simplement TabularInline :

class PictInline(admin.TabularInline):
    model = Pict

class TagInline(admin.TabularInline):
    model = Crea.tags.through

Ici, on mappe directement la classe d'administration avec le modèle. Concernant les tags, on utilise le mot clé through pour récupérer la relation en elle-même (il s'agit d'une ManyToMany). Vous n'aurez plus qu'à ajouter ces classes Tabular à la classe CreaAdmin :

class CreaAdmin(admin.ModelAdmin):
    [...]
    inlines = [PictInline, TaskInline]

Désormais, dans l'interface d'administration, vous pourrez gérer vos créations, les images et les tags sur la même page !

Dans le prochain article, nous aborderons le côté front et nous concentrerons sur les vues. Révisez votre MVC !

Créer un portfolio avec Django - Les modèles

Tue, 10 Aug 2010 02:21:41 +0200

Dans l'article précédent, nous avons conçu la structure de notre futur portfolio. Aujourd'hui, nous allons démarrer le projet django et y modéliser cette structure grâce aux modèles.

Previously on this blog

Nous avons réflechi sur le schéma conceptuel de notre application. Après avoir listé toutes les données à stocker et les relations entre elles, nous nouss sommes arrêtés sur ce diagramme :

Créer un projet django

Maintenant que nous avons conçu l'architecture de notre application, les choses sérieuses peuvent commencer. Nous allons créer notre projet django. Pour cette étape, vous devez posséder quelques bases en python et avoir un environnement de développement django opérationnel. Si ce n'est pas le cas, je vous invite à installer django en suivant ce tutoriel (windows) ou celui-ci (officiel, en anglais).

La première étape consiste à créer la base de données (on utilisera mySQL) et l'utilisateur avec laquelle django communiquera. Vous pouvez le faire par le biais de phpmyadmin. Nommons-la "website".

Puis, dans le projet dédié à vos projets django, nous allons créer notre application (website) et son unique module (portfolio).

$ django-admin.py startproject website
$ cd website
$ django-admin startapp portfolio

A la racine du projet (website), nous allons créer deux répertoires :

templates/, qui accueuillera les pages HTML dont on aura besoin plus tard.
media/, où seront placés les images, css, javascript...

Enfin, toujours à la racine, créez un répertoire apps/ qui renfermera les différents modules. Ici, nous n'avons qu'un seul module, mais cela permettra de faire évoluer notre application plus simplement si vous voulez ajouter un nouveau module par la suite (Un blog par exemple !). Déplacez le répertoire portfolio/ dans ce répertoire apps/, dans lequel vous aurez pris soin de créer un fichier __init__.py vide (vous pouvez copier / coller ce fichier depuis un autre répertoire).

Vous devez alors avoir l'architecture suivante :

.
|-- __init__.py
|-- apps
|   |-- __init__.py
|   `-- portfolio
|       |-- __init__.py
|       |-- models.py
|       `-- views.py
|-- manage.py
|-- media
|-- settings.py
|-- templates
`-- urls.py

Vérifions que le projet fonctionne bien. Tapez la commande suivante pour démarrer le serveur de développement :

$ manage.py runserver

Et, à l'aide de votre navigateur, allezà l'adresse

$ http://localhost:8000

Tout fonctionne ? Parfait !

Paramétrer l'application

Maintenant, paramétrons correctement l'application en éditant le fichier settings.py.

Nous allons tout d'abord créer, en haut du fichier, une constante PROJECT_PATH qui contiendra le path global du projet.

import os.path
PROJECT_PATH = os.path.dirname(os.path.abspath(__file__))

Editez les lignes suivantes pour ajuster la langue et le fuseau horraire :

TIME_ZONE = 'Europe/Paris'
LANGUAGE_CODE = 'fr-fr'

On ajoute notre répertoire média (path et url) ainsi que celui de la future interface d'administration :

MEDIA_ROOT = os.path.join(PROJECT_PATH, 'media/')
MEDIA_URL = '/media/'
ADMIN_MEDIA_PREFIX = '/media/admin/'

On ajoute notre répertoire de templates :

TEMPLATE_DIRS = (
os.path.join(PROJECT_PATH, 'templates'),
)

Et enfin, on ajoute notre module à la liste des applications installées :

INSTALLED_APPS = ('django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.sites',
    'django.contrib.messages',
    'django.contrib.admin',
    'website.apps.portfolio',
)

Les modèles

Maintenant, éditons le fichier models.py de notre application afin d'y introduire le schéma que nous avons défini. Chaque table correspond à une classe possédant des attributs.

Commençons par la création en elle-même :

class Crea(models.Model):
    title = models.CharField(max_length=200)
    slug = models.CharField(max_length=200)
    overview = models.TextField()
    description = models.TextField()

    thumb = models.ImageField(upload_to='img/crea/thumb/')
    creation_date = models.DateTimeField()
    link = models.URLField()
    tags = models.ManyToManyField('Tag')
    picts = models.OneToManyField('Pict')

    class Meta:
        verbose_name = _('Creation')
        verbose_name_plural = _('Creations')<

    def __unicode__(self):
        return self.title

Nous avons ajouté deux champs qui n'étaient pas dans le diagramme. Il s'agit des relations. Une ManyToMany pour les tags (un tag peut être lié à plusieurs créations) et un OneToMany pour les images (une image n'est liée qu'à une seule création). C'est django qui générera tout seul la table de relation nécessaire (pour le many to many).

Passons aux tags :

class Tag(models.Model):
    name = models.CharField(max_length=200)
    slug = models.SlugField(max_length=200)

    def __unicode__(self):
        return self.tag

Et enfin, les images :

class Pict(models.Model):
    pict = models.ImageField(upload_to='creas/')
    rank = models.IntegerField()
    crea = models.ForeignKey('Crea')

    class Meta:
        verbose_name = _('Image')
        verbose_name_plural = _('Images')

    def __unicode__(self)
        return self.get_absolute_url()

Pour en savoir plus sur les différents champs utilisés dans ces modèles, je vous invite à consulter la documentation qui recence toutes les possibilités d'attributs.

Une fois que le fichier models.py a été édité, vérifions que nous n'avons pas commis d'erreur :

$ manage.py validate

Puis, synchronisons le tout avec la base de données. Django va alors créer une table par classe (plus une pour la relation entre tags et créations, donc).

$ manage.py syncdb

Les modèles sont prêts ! Dans le prochain article, nous installerons l'interface d'administration qui nous permettra d'y insérer nos premières données !

Créer un portfolio avec Django - Conception

Mon, 09 Aug 2010 23:44:48 +0200

Les articles qui vont suivre seront dédiés à la création d'un simple portfolio en utilisant python et django. La saga s'ouvre avec la première étape, la plus importante : la conception de l'application. Ici, pas de code, simplement de la réflexion...

Le but de ce futur portfolio sera bien évidement de présenter ses créations et de les caractériser par des mots clés et des images (captures d'écran ou autre). Chaque réalisation possédera un certain nombre de paramètres pour les illustrer. Ce sont ces paramètres que nous allons devoir définir.

L'application sera donc composée de trois entitées. Tout d'abord, la création : la réalisation en elle-même, puis le tag : le mot clé caractérisant la création et enfin l'image d'illustration. Chaque création pourra être reliée à un ou plusieurs tags et à une ou plusieurs images.

Détaillons maintenant les paramètres de chacune de ces entités :

Création :

Nom de la création.
Slug : identifiant unique sous forme de chaîne de caractère.
Description courte : texte court décrivant en quelques mots la référence.
Description longue : texte décrivant les tâches réalisées, etc.
Vignette : petite image illustrant la création.
Date de la création.
URL (externe) où est visible la création.

Tag :

Le mot clé en lui-même.
Slug : identifiant unique permettant d'accéder au mot-clé.

Image :

L'URL de l'image.
Son ordre d'affichage.

Si l'on met ces données en page sous la forme d'un MCD (Modèle Conceptuel de Données), cela donne le schéma suivant :

A noter que nous avons affaire ici à deux types de relations. Un tag peut être relié à plusieurs créations, alors qu'une image n'est liée qu'à une seule création. Les créations, quant à elles, peuvent faire appel à plusieurs tags et plusieurs images.

C'est tout pour la phase de conception ! La prochaine étape sera de modéliser ces données dans un projet django ! Donc d'ici-là, profitez-en pour réviser votre python ou pour installer Django...

Nouvelle architecture : Django

Thu, 05 Aug 2010 00:53:18 +0200

Depuis le début de ma nouvelle activité, j'ai eu, comme j'en avais parlé dans le billet précédent, le temps de m'autoformer sur des technologies qui me tenaient à coeur. J'ai commencé par le framework Django.

Pour apprendre, il n'y a rien de mieux que de se jeter à l'eau sur un nouveau projet. J'ai donc décidé de refaire entièrement le moteur de mon porfolio / blog en utilisant Django. Et j'ai été vraiment séduit.

Comme vous avez pu le constater, il n'y a pas eu de gros chamboulement graphique (j'aurais du y passer des mois avant d'être presque satisfait), mais le moteur a vraiment été refait à neuf.

Dans la version précédente, qui datait de deux ans, le tout tournait autour d'un schéma MVC maison en PHP, sans mySQL mais avec les informations stockés dans des fichiers XML (à l'époque, c'était pour faire joujou avec simplexml). Le côté blog, quant à lui, était un simple wordpress. Alors, oui, je sais, pourquoi ne pas garder wordpress, pourquoi réinventer la roue, nianiania ? Simplement pour me familiariser avec ce framework. Un moteur de blog est une chose simple et facilement adaptable. Cela me semblait un bon point de départ pour (re)découvrir Django !

J'ai été impressioné par la rapidité de développement. Malgré le nouveau langage pour moi (python), on n'est pas perdus et les modules front / back se déploient en quelques lignes. Après quelques bons tutos, on est vite capable de se débrouiller ! J'en ai aussi profité pour déserter OVH au profit d'alwaysdata !

D'ailleurs, en parlant de tutos, mes prochains articles seront dédiés au développement d'un portfolio en Django. Si ça vous intéresse, repassez par là :)

Free-lance, le grand saut

Tue, 03 Aug 2010 14:31:55 +0200

Et voilà. C'est le grand saut.

Après plus d'un an chez e-citizen, j'ai décidé de me mettre à mon compte. Avec pour l'instant mon ancien statut de "travailleur indépendant", mais très bientôt en tant qu'autoentrepreneur ou entrepreneur individuel.

Je vais profiter de cette période de liberté pour, tout en prospectant des clients et en répondant à des appels d'offre, m'intéresser à des technologies que je n'avais jamais eu le temps (ou trop peu) d'aborder :

Django, pour changer un peu du PHP, et re-découvrir ce framework complet.
Développement Android pour avoir un aperçu sur le mobile.
Administration système pour me familiariser d'avantage avec des problématiques de serveurs.
Joomla / Drupal / Wordpress ou autre CMS pour avoir la possibilité de monter très rapidement des sites complets.

Vous l'aurez compris, une période sous le signe de l'auto-formation. Et de la formation aussi, d'ailleurs, puisque je continuerai de donner des cours à l'Université de Marne la Vallée. Mais je reste bien évidemment à la recherche de tout projet me permettant de mettre en place ces technologies. Ou d'autres ! N'hésitez pas à me contacter !

Source de l'image : alexiadelfino / flickR

Travaux Dirigés - web 2.0

Sun, 27 Jun 2010 19:32:29 +0200

J'ai été, le semestre dernier, chargé de TD en Master 1 Informatique à l'Université de Marne-la-Vallée. J'ai décidé d'axer le cours, intitulé par la formation web 2.0 autour des technologies suivantes :

xHTML / CSS
jQuery
AJAX
PHP5 (MVC).

Voici la liste des sujets :

L'année prochaine, je serai à priori chargé des TDs de web à l'école d'ingénieur IMAC !

Concevoir une application Ruby on Rails

Sun, 03 May 2009 19:32:29 +0200

Ruby on Rails (RoR) est un framework web dont nous allons illustrer la puissance en créant une simple application de gestion de vidéothèque, en minimisant les lignes de code. Nous utiliserons sa version 2.0, sortie le 7 décembre 2008, et qui possède plusieurs différences avec la précédente, notamment au niveau de la génération du code (Scaffold).

Nous verrons tout d'abord comment installer Ruby on Rails en local ou le lancer depuis un serveur distant. Puis, nous présenterons les concepts de base de développement en créant nos modèles de données et en personnalisant les vues.

Installer Ruby on Rails

En local

Sous debian / ubuntu, mettez vous en superutilisateur pour installer ruby :

apt-get install ruby irb ri rdoc build-essantial

Puis, la gem rails :

gem install rails --include-dependencies

Vérifions la version de rails installée :

rails –v

Sur un serveur distant

Si vous utilisez un serveur supportant ruby avec rails préinstallé, comme c'est le cas chez alwaysdata par exemple, vous n'avez rien à faire. Vous pouvez vous passer du serveur de développement intégré à RoR. Par contre, vous devrez effectuer toutes les commandes suivantes via un connexion ssh.

Utiliser Rails

Créer l'application

Pour créer une nouvelle application, placez-vous dans votre dossier personnel. Une simple commande vous permettra de générer toutes l'arborescence du futur projet, que nous nommerons myMovies.

rails myMovies

Lancer le serveur

Si vous travaillez en local, vous devrez lancer le serveur de développement intégré à RoR, WEBrick, pour que votre application soit accessible. Pour ce faire, tapez simplement :

ruby script/server

Une fois le serveur lancé, votre site sera accessible à l'adresse :

http://localhost:3000

Si vous travaillez sur un serveur distant, vous pourrez normalement visualiser directement votre application sans passer par le lancement manuel de WEBrick.

Créer et configurer la base

Par le biais de votre SGBD, commencez par créer une base de données pour votre projet, nommée - par exemple - myMovies.

Configurons maintenant l'accès à cette base, en éditant le fichier /myMovies/config/database.yml en renseignant le moteur (ici mySQL) l'hôte, l'utilisateur mySQL et le mot de passe. Note : il est possible de différencier les bases de développement et de production.

Une fois l'application configurée, on pourra simplement créer la base grâce à la commande :

rake db:create:all

Créer un modèle

Cette étape est cruciale car elle détermine toute l'architecture des données de notre application. Vous devrez déterminer toutes les entités qu'il vous sera nécessaire de stocker. D'une mauvaise conception découlerait une application bancale. Dans notre cas, la question ne se pose pas car nous avons choisi un cas de figure particulièrement simple. Nous n'avons à travailler que sur un seul modèle : movie. Bien sûr, il sera possible d'ajouter des entités plus tard (des commentaires, par exemple), mais faisons simple pour commencer.

Maintenant, réfléchissons sur le données que nous avons besoin de stocker pour chaque modèle : le titre du film, son réalisateur, l'année de sortie, une brève description et une url permettant d'en savoir plus (un lien imdb par exemple). Pour cela, lançons la commande :

ruby script/generate scaffold Movie title:string director:string year:string decription:text url:string

Nous lançons ainsi le scaffold qui va générer tout le code lié à ce modèle, de la table dans la base de donnée aux vues génériques destinées à son affichage. Nous avons juste à mettre à jour la base de données :

rake db:migrate

L'interface générée

Voyons maintenant ce que nous avons généré avec cette simple commande. Après avoir lancé le serveur, allez sur

http://localhost:3000/movies

Nous avons maintenant une veritable interface CRUD pour l’ajout et l’édition de films. Essayez d’ajouter un nouveau film ; il apparaitra dans la liste et vous pourrez l’éditez ou le supprimer.

Validation du modèle

On peut aller plus loin dans la création du modèle. Si certaines des données sont obligatoire au bon fonctionnement de l'application, comment empêcher la saisie d'entrées incorrectes et mal formées ? C'est là qu'intervient la validation du modèle. Pour cela, ouvrez le modèle proprement dit, stocké dans le fichier /myMovies/app/models/movies.rb. Pour l'instant, le fichier est quasiment vide, et c'est normal. C'est ici que nous allons renseigner les informations relatives à la validation. Au sein de la classe, tapez (attention à la place des espaces) :

validates_presence of :title, :director, :year

C'est tout ! Dans l'application, essayez de saisir un film sans réalisateur ou sans date ; l'enregistrement échouera. Finis, les tests bancaux : tout est automatisé grâce RoR !

Personnaliser l'application

Comme vous pouvez le voir, sans que nous n'ayons besoin d'écrire la moindre véritable ligne de code, RoR nous a généré une interface complète CRUD (Create, Read, Update, Delete) pour notre modèle. On peut aisément ajouter des nouveaux films, éditer ou supprimer les existants, et visualiser le tout en détails. Libre à nous de personnaliser les vues grâce au système de templates que nous allons voir maintenant.
Vous l'avez vu, l'habillage de l'interface est très sommaire. A nous de l'adapter et de l'intégrer dans un design complet. Pour cela, rien de compliqué ; il ne s'agit que de XHTML / CSS standard. Regardez dans le dossier /myMovies/app/views/movie/ : c'est ici que sont cachés les templates correspondant aux vues pour notre modèle. On y retrouve les différentes actions possibles : l'affichage détaillé (show.html.erb), l'édition (edit.html.erb), l'ajout (new.html.erb) et enfin la liste en page d'accueil (index.html.erb).

Ces templates sont incorporés dans une mise en page globale, définie elle par le ficher myMovies/app/views/layouts/movies.html.erb par le biais de la ligne <%= yield>. Vous pouvez ainsi modifier vos différentes vues, de la structure HTML au CSS (stocké dans /public/stylesheets) en mettant les mains dans le cambouis un minimum...

Aller plus loin

Voici une application de test mise en place à partir de ce tutoriel : myMovies.

Si vous souhaitez en savoir plus sur Ruby on Rails, vous pouvez consulter ce dossier, rédigé par Mathieu Thibault, Vincent Navetat et moi-même pour un cours de l'IMAC.

Statut d'autoentrepreneur, l'arnaque ?

Tue, 03 Feb 2009 15:32:29 +0100

En vigueur depuis le 1er janvier 2009, le statut d'autoentrepreneur permet - sur le papier - de simplifier la création d'une activité économique indépendante. Cependant, qu'apporte-t-il de nouveau par rapport aux précédents régimes de freelance, en particulier celui "d'artiste-auteur" ? Faut-il changer de statut, pour une activité occasionnelle tout du moins ?

Le régime des artistes-auteurs

Je possède depuis octobre 2007 un statut de travailleur indépendant, dit "artiste-auteur" qui me permet d'exercer légalement - en parallèle de mes études - une activité de développeur web / designer en freelance. Après quelques déboires avec les impôts dûs à mon inexpérience, j'ai fini par être en règle et peux éditer des factures à ma guise, du moment que je reste sous un certain seuil de chiffre d'affaire annuel : 27 000 €. Autant dire inaccessible, vu le caractère occasionnel de mon activité.

Autre avantage, ce genre d'activité peut être dispensé de TVA pendant les trois premières années. C'est-à-dire qu'il n'y aucune déclaration de taxe à faire, pour peu qu'on se soit bien débrouillé lors de la création de l'entreprise. Il n'y a qu'une seule déclaration à faire par an, en même temps que la déclaration de revenus. Et la somme déclarée étant en général faible, elle en est imposable. (Note : si vous n'êtes pas détaché du foyer fiscal de vos parents, vous devrez joindre un formulaire à leur déclaration d'impôts. En espérant que cela ne les fasse pas changer de palier...)

Pour résumer :

Micro BNC (régime spécial)
Exempté de TVA selon l'article 293B du CGI
Plafond annuel max : 27 000 €

Le statut d'autoentrepreneur

Qu'en est-il de ce nouveau statut ? D'après le site qui lui est dédié, celui-ci possède quatre grandes lignes :

1 - Simplifier la création ou la cessassion d'une activité économique indépendante
Mise en place d'un kit de l'auto entrepreneur, un formulaire de seulement 3 pages, devrait proposer les outils pour en une heure, créer, interrompre, reprendre et cesser une activité indépendante.

2 - Prélèvement à la source des prélèvements sociaux et fiscaux
Instaurer sur option le prélèvement à la source pour le travail indépendant.
Christine Lagarde, Ministre de l'économie : "Je veux que l'entrepreneur puisse payer ses impôts quand il touche son chiffre d'affaires, n'en paye pas quand il n'a pas de revenus et arrête d'en payer dès qu'il arrête son activité".
L'entrepreneur aura un prélèvement forfaitaire "charges sociales plus impôts" égal à 13% du chiffre d'affaires pour les activités d'achat-revente et à 23% pour les activités de service.

3 - Protection du patrimoine personnel de l’auto-entrepreneur
Sortir de leur vulnérabilité les plus petits entrepreneurs en créant un patrimoine de l’entreprise individuelle, réceptacle à des capitaux propres dédiés.

4 - Instaurer un droit à l'échec
Trop souvent, notre droit positif fait obstacle à la réinsertion professionnelle de celui qui a été victime d'un échec économique ou qui a subi une condamnation pénale. "Il faut savoir créer en France, à la fois cette culture de l’échec qui nous manque, mais aussi savoir reconnaître à celui qui a eu le courage d’entreprendre le droit de pouvoir le refaire en profitant évidemment de son expérience".

Depuis le lancement de ce nouveau statut, l'accent est mis sur "pas de chiffre d'affaire = pas de charge". Seulement, cela reste flou car c'était déjà le cas avec le précédent régime. Par contre, les charges (désormais en indemnités forfaitaires) restent fixe et assez élevées : 21,3% dans mon cas. Payable par mois, trimestre ou année. En contrepartie, les autoentrepreneurs bénéficient d'un net avantage pratique : toutes leurs déclarations / documentation sont accessibles en ligne depuis le site officiel. Plus besoin donc de correspondre avec le contrôleur de son centre d'impôts. Intéressant, mais reste à savoir si ce service suffit à gérer entièrement son activité...

Au final, que choisir ?

Il est clair que pour une activité peu régulière, l'ancien statut de travailleur indépendant paraît plus rentable. Même s'il est plus compliqué à prendre en main, notamment au niveau des déclarations, il réclame beaucoup moins de charges. Après, la question reste en suspend pour une activité à temps complet, ou lorsqu'on dépasse le seuil de chiffre d'affaire annuel.

Quelques liens

Commencer une activité d'artiste auteur.
En savoir plus sur les micro entreprises.
Le site officiel du statut d'autoentrepreneur, pour s'informer et faire toutes ses déclarations en ligne.

Installer Django sous Windows

Wed, 10 Dec 2008 23:32:29 +0100

Django, qu'est ce que c'est ?

Django est un framework web basé sur le langage Python qui permet un développement simple et ultra-rapide. A l'instar de Symfony ou Ruby on Rails, il suit le modèle de conception Modèle-Vue-Contrôleur ; toute la gesion de la structure des données est assurée par des classes de Modèles, les Vues permettent l'affichage des informations et enfin les Contrôleurs répondent au requêtes des utilisateurs. Ainsi, grâce à ces trois entités, le framework sera capable de générer toute une application web, en back et frontoffice.

Installation

La plupart des informations glanées sur Internet concernant l'installation de Django se fait souvent sous environnement Linux. Voici la marche à suivre pour permettre aux utilisateurs de Windows d'utiliser Django. Celle-ci est assez simple. Je met à votre disposition une archive contenant tous les installateurs dont j'ai eu besoin. Ceux-ci datent du mois de juillet 2008, et ne seront peut être plus d'actualité dans quelques mois.

Installer Python

Tout d'abord, vous devez avoir la dernière version de Python. Vous pouvez la télécharger sur le site officiel. Une fois l'installateur lancé, conservez les options par défaut ; le dossier d'installation sera C:\Python25 (pour la version 2.5).

Installer PostgreSQL et psycopg

Django gère plusieurs types de SGBD. Néanmoins, je vous conseille d'installer postgreSQL, accompagné de psycopg (qui permettra à Python de communiquer avec la base). Une fois récupéré le .msi d'installation sur le site, conservez là-encore les options par défaut, jusqu'à l'écran de configuration ("Initialise database cluster"). Là, choisissez un login (postgres par exemple) et un mot de passe permettant d'accèder à la future base de données.
Une fois l'installation terminée, lancez le programme pgAdmin III depuis le menu démarrer. Vous pourrez vous y connecter grâce au mot de passe préalablement choisi. L'installation s'est donc bien déroulée ! Vous n'avez plus qu'à installer psycopg, très simplement en téléchargeant l'exécutable windows.

Installer Apache et mod_python

Téléchargez simplement la denière version d'Apache et éxecutez l'installateur. Choisissez bien de lancer Apache sur le port 80. Pour vérifier que l'installation s'est bien déroulée, lancez votre navigateur sur l'url http://127.0.0.1. Vous devriez avoir une page générée par le serveur : "It works". En installant Apache, vous avez aussi accès au moniteur du service, dans la barre de taches. C'est là que vous pourrez relancer ou arrêter le serveur.
Maintenant, au tour de mod_python qui permettra à Apache d'interpréter le code Python. Suivez simplement l'assistant d'installation. Puis, éditez le fichier httpd.conf d'Apache, situé dans son répertoire d'installation : C:\Program Files\Apache Software Foundation\Apache 2.X\conf\httpd.conf. Ajoutez le chargement de mod_python à l'endroit où sont regroupés tous les "LoadModule" (au début du fichier) de la façon suivante :

LoadModule python_module modules/mod_python.so

Relancez Apache par le moniteur de services. Si le serveur refuse de se réinitialisez, vous avez commis une erreur en éditant le fichier httpd.conf. Recommencez (il existe un fichier de backup dans le même répertoire conf).

Installer Subversion

Pour récupérer la dernière version de développement de Django, nous allons utiliser subversion. Vous pouvez le télécharger ici. Pour les adeptes des interfaces graphiques, il existe aussi TurtoiseSVN (que je déconseille néanmoins). Cela vous permettra, entre autres, de mettre à jour automatiquement votre version de Django en lançant un simple update depuis votre répertoire d'installation. Plus d'informations sur Subversion.

Installer Django

Enfin nous y arrivons ! Grâce à SVN, nous allons faire un commit depuis le site officiel du framework. Pour cela, lancez l'invite de commande et tapez

C:\>cd C:\python25\Lib\sites-package
C:\python25\Lib\sites-package>svn co http://code.djangoproject.com/svn/django/trunk/ django

Djanjo va alors s'installer dans le répertoire de Python. Pour un usage ultérieur plus facile, vous pouvez faire une copie du fichier django-admin.py de Django\bin vers C:\Python25\Scripts. De plus, vous pouvez aussi changer vos variables d'environnement. Pour celà, faites un clic droit sur le poste de travail > Propriétés. Puis, dans l'onglet Avancé, cliquez sur "Variables d'environnement". A la suite de la chaine de caractères du PATH, rajoutez les chemins ci-dessous :

C:\Python25;C:\Python25\Scripts\;C:\Program Files\Subversion\bin;

Configurer Apache

Revenons à Apache. Nous allons configurer votre espace de développement local. Rééditez votre fichier httpd.conf et placez vous tout en bas. Copiez collez les lignes suivantes, permettant de créer un alias de votre répertoire de développement Django. (C:\Django ici)


     SetHandler python-program
     PythonPath "['C:/django'] + sys.path"
     PythonHandler django.core.handlers.modpython
     SetEnv DJANGO_SETTINGS_MODULE testproject.settings
     PythonDebug On


     SetHandler None


     SetHandler None

La configuration est donc terminée ! Vous trouverez tous les exécutables nécessaire à cette installation ici. Nous pouvons donc entrer dans le vif du sujet.

Démarrer avec Django

Pour vérifier que l'installation s'est correctement déroulée, nous allons commencer un nouveau projet Django. Pour en savoir plus sur les commandes que nous allons utiliser, je vous invite à consulter la doc du framework, très bien faite (ou les futurs articles de ce blog !)
Commençons à créer notre dossier Django.

C:\>mkdir Django
C:\>cd Django

Puis, nous allons créer un nouveau projet Django

C:\Django\>django-admin.py startproject monprojet
C:\Django\>cd monprojet

Le squelette du projet Django est donc initialisé. Pour pouvoir le tester, nous devons effectuer un runserver qui lancera le serveur de développement en local (par défaut sur le port 8000) en validant vos modèles (vides pour l'instant, donc ça devrait aller).

C:\Django\monprojet\>python manage.py runserver

Ainsi, en lançant votre navigateur sur l'url http://127.0.0.1:8000/monprojet/, vous verrez la page par défaut du projet Django vide.

Maintenant, à vous de jouer ! Pour découvrir Django (et python !), je vous conseille le tutorial du site officiel : Rédaction de votre première application (en quatre parties, traduites en plus !).

PHPSESSID squatteur d'URL

Tue, 11 Nov 2008 23:32:29 +0100

Lors de l'utilisation de variables de session, il arrive qu'une session_id vienne pourrir notre jolie URL fraichement rewritée. La solution, en une seule ligne. Dans le .htaccess :

php_flag session.use_trans_sid off