Archives mensuelles : mars 2014

Bilan de la découverte Tryton

Après ces quelques semaines sur Tryton, j'ai choisi de revenir sur OpenERP pour les raisons suivantes :
 
- périmètre fonctionnel beaucoup plus étendu
 
- communauté plus importante
 
- ergonomie du produit plus satisfaisante
 
- moins de technicité (python ...) requise

même si ses qualités sont indéniables :
  - vision open-source plus engagée
  - migration automatisée de versions Tryton
  - socle technique robuste et plus pérenne (ex: python 3)

Installation de Tryton à partir des sources

Nous allons maintenant installer le client et le serveur Tryton (avec ses modules) directement à partir des sources.
Je vous invite à vous référer au wiki pour plus d'infos.

Environnement technique
- nouveau serveur virtualisé Debian 7.3 (wheezy)
- PC client sous Linux Mint 14

Description
- installer pip
sudo apt-get install python-pip

- installer la BD
sudo apt-get install postgresql
su - postgres -c "createuser --createdb --no-createrole --no-superuser --pwprompt tryton"

- installer les  prérequis "serveur Tryton"
sudo apt-get install python-psycopg2  python-lxml python-dateutil python-relatorio python-polib python-ldap python-webdav python-vobject python-tz python-stdnum python-vatnumber


sudo pip install python-sql

- installer mercurial et son extension "hgnested"
sudo apt-get install mercurial mercurial-nested

- activer "hgnested" en modifiant le fichier /etc/mercurial/hgrc.d/hgnested.rc
# To enable the hgnested extension system wide, uncomment the following lines
[extensions]
hgnested =

- installer la version en cours de développement de trytond (serveur Tryton) et tous les modules
hg nclone http://hg.tryton.org/trytond

... ou une version stable (ex: 3.0)
hg nclone -u 3.0 http://hg.tryton.org/trytond

- mettre à jour le fichier de configuration trytond/etc/trytond.conf en modifiant les lignes suivantes :
jsonrpc = <adresse ip ou nom dns du serveur debian >:8000
db_host = localhost
db_user = tryton
db_password = <mot de passe saisi à la création du user BD tryton>
language = fr_FR
timezone = Europe/Paris

- lancer le serveur tryton
trytond/bin/trytond -c trytond/etc/trytond.conf

- installer le client Tryton sur le PC client
hg clone http://hg.tryton.org/tryton

- lancer le client Tryton
tryton/bin/tryton

- créer la base de données

... en saisissant les infos suivantes (attention, le mot de passe par défaut du serveur tryton est : admin)

- se connecter

On passe ensuite à l'étape de configuration ... voir article sur le sujet

Mise à jour des sources
Après s'être positionné dans le répertoire trytond, la mise à jour des sources se fait par :
hg npull -u

Tryton – tests unitaires d’un module

Tryton fournit un framework de tests unitaires reposant sur unittest.
Le wiki décrit très bien comment procéder pour les tests unitaires d'un module.

Pour l'illustrer, nous allons reprendre notre 1er exemple de création de module (module mylibrary).
Description
- ajouter dans le répertoire modules/mylibrary, le sous-répertoire tests et les 2 fichiers suivants :

 - créer le fichier __init__.py
#This file is part mylibrary module for Tryton.
#The COPYRIGHT file at the top level of this repository contains
#the full copyright notices and license terms.

from .test_mylibrary import suite

__all__ = ['suite']

- créer le fichier test_mylibrary.py
#!/usr/bin/env python
#This file is part mylibrary module for Tryton.
#The COPYRIGHT file at the top level of this repository contains
#the full copyright notices and license terms.
import sys
import os
DIR = os.path.abspath(os.path.normpath(os.path.join(__file__,
    '..', '..', '..', '..', '..', 'trytond')))
if os.path.isdir(DIR):
    sys.path.insert(0, os.path.dirname(DIR))

import unittest
import trytond.tests.test_tryton
from trytond.tests.test_tryton import test_view, test_depends

class MylibraryTestCase(unittest.TestCase):
    '''
    Test Mylibrary module.
    '''

    def setUp(self):
        trytond.tests.test_tryton.install_module('mylibrary')

    def test0005views(self):
        '''
        Test views.
        '''
        test_view('mylibrary')

    def test0006depends(self):
        '''
        Test depends.
        '''
        test_depends()

def suite():
    suite = trytond.tests.test_tryton.suite()
    suite.addTests(unittest.TestLoader().loadTestsFromTestCase(
            MylibraryTestCase))
    return suite

if __name__ == '__main__':
    unittest.TextTestRunner(verbosity=2).run(suite())

- exécuter les tests unitaires
python trytond/modules/mylibrary/tests/test_mylibrary.py

le résultat doit se terminer par :

Tryton – Traduction d’un module

Lors du développement d'un module, la règle est d'utiliser l'anglais puis de créer des fichiers de traduction par
langue.
La procédure de traduction est décrite dans le wiki.

Pour l'illustrer, nous allons reprendre notre 1er exemple de création de module (module mylibrary) pour le traduire en français.

Description
- se connecter "admin" sur le client Tryton
- vérifier que la langue française est bien "translatable"

- aller dans le menu "localization/Synchronize Translations", choisir "french" puis cliquer sur "update"

- aller dans le menu "localization/export translation", saisir la langue et le module puis cliquer sur "export"

- récupérer le fichier produit via l'icone

- le nommer fr_FR.po

extrait fichier fr_FR.po

- renseigner les lignes "msgstr" avec la traduction adéquate

- créer un sous-répertoire locale sous modules/mylibrary

- copier fr_FR.po sous modules/mylibrary/locale

- faire un update du module
/usr/bin/trytond -u mylibrary  -d <nom BD>

- sur le client Tryton, recharger le menu

... le module s'exécute en Français

Tryton – Installation du client web

Tryton sera accessible par un navigateur web dans une prochaine version.
Nous allons installer la version du client web en cours de développement.
Ce client Web s'appelle SAO.

La procédure qui suit, n'est quasiment qu'une traduction de celle-ci.
Environnement technique
- serveur Tryton 3.0 sur un serveur virtualisé Debian 7.3 (wheezy)
- client Tryton 3.0 sur PC Linux Mint 14

Description
- installer le compilateur g++
sudo apt-get install g++

- récupérer SAO et le mettre dans un répertoire <rep_sao> accessible au user linux tryton
hg clone http://hg.tryton.org/sandbox/sao

- installer la dernière version de Nodejs qui amène aussi npm

wget http://nodejs.org/dist/v0.10.26/node-v0.10.26.tar.gz

tar xvf node-v0.10.26.tar.gz

cd node-v0.10.26

make -j 4

sudo make install

sudo npm install -g grunt-cli

- aller dans le répertoire <rep_sao>
npm install grunt-contrib-concat

npm install grunt-contrib-uglify

npm install grunt-contrib-watch

npm install

grunt

- modifier le fichier /etc/trytond.conf
jsondata_path = <rep_sao>

- relancer le serveur Tryton
 /etc/init.d/tryton-server restart

- appeler Tryton dans votre navigateur par :
http://<adr ip du serveur tryton>:8000

Voici le résultat

Tryton – import de données avec Proteus

Proteus a été développé par l'équipe Tryton pour entre autre, réaliser des scripts d'import/export.
Dans mon cas, j'installe Proteus sur mon PC Linux Mint alors que le serveur Tryton est installé sur un serveur Debian.

Description
- télécharger Proteus ici
- l'installer avec la commande :
python setup.py install

- modifier le fichier /etc/trytond.conf pour autoriser l'accès xmlrpc
xmlrpc = *:8069
- relancer trytond
/etc/init.d/tryton-server restart
- développer un script python selon les exemples disponibles ici

Dans mon cas, le script est celui-ci :
from xmlrpclib import Fault
from proteus import config, Model, Wizard

# si script s'execute sur meme serveur que Tryton
# config = config.set_trytond(database_name='<nom BD>')
# sinon si acces a distance
config = config.set_xmlrpc('http://<user>:<pwd>@(adr ip srv tryton>:8069/<nom BD>')

# création d'un client
Party = Model.get('party.party')
party = Party(name='Client2')
party.save()

# vérification que le client a été créé
party = Party.find([('name', '=', 'Client2')])
for r in party :
   print r.name

Tryton – Import initial de données – exemple « client »

Je vais importer un exemple de données "client" à partir d'un fichier csv, en utilisant la méthode de base.
Les données "client" sont implémentées dans le modèle "party.party"

Voici l'exemple de fichier csv utilisé (avec 1 relation One2Many)

Nom,Adresses/Ville
Client1,Paris
,Toulon
Description
- dans le menu "Tiers", cliquer sur l'icône

- sélectionner "import de données"

- sélectionner le fichier, puis "détection automatique" et enfin "valider"

Pour plus d'infos se reporter au wiki

Tryton – gestion des droits d’accès

La gestion des droits d'accès aux modules Tryton repose sur :

  • les groupes
  • les ACL (Access Control List)
  • les "record rules"


Si rien de ce qui suit n'est configuré pour un module donné, un utilisateur a alors tous les droits sur ce module.

Groupe
Un groupe caractérise une
typologie d'utilisation d'un ou plusieurs modules (ex: vendeur, responsable  des ventes).

Un groupe est déclaré dans le fichier xml d'un module ou créé par l'écran d'administration.

extrait "sale.xml"

L'objet "Groupe" est implémenté dans le "model" res.group.

Un utilisateur est affecté à un ou plusieurs groupes lors de sa création ou de sa modification.

extrait écran "administration des utilisateurs"

Il est possible de restreindre à un ou plusieurs groupes :

  1- les droits d'accès aux objets ("model") et/ou champs via les ACL
      cf paragraphe suivant

   2- les accès à un menu

extrait "sale.xml"

   3- les accès à une action

extrait "sale/party.xml"

    4- les accès à un bouton

extrait "sale.xml"

   5- les accès à un "type de séquence"

extrait "sale.xml"

Il est possible d'affecter un groupe à un utilisateur (ex: "administrateur") lors de la livraison du module

extrait "sale.xml"

Il n'est par contre pas possible qu'un groupe hérite des droits d'un autre groupe.

ACL
Une ACL définit les droits d'accès au format "CRUD" (création, lecture, modification, suppression) sur un objet ("model") ou un champ.

Les ACL sont aussi utilisées dans les "record rules" (cf plus loin).

 - exemple d'ACL sur un "model"

extrait "sale.xml"

- une ACL peut être positionnée sur un champ par l'écran d'administration

Record Rule
Les "règles d'enregistrement" (i.e. "record rules") permettent de restreindre les accès de certaines données aux utilisateurs.

Dans l'exemple ci-dessous, seuls les enregistrements qui satisfont à la contrainte exprimée dans "domain", sont accédés (utilisation des ACL) :

extrait "sale.xml"