Documentation Frappe Framework

Frappe Framework

Qu’est-ce que Frappe Framework ?

Frappe est un framework web full stack « batteries incluses », écrit en Python et JavaScript, qui motorise ERPNext. Cette page présente ses principes : métadonnées, interface d’administration, permissions, ORM, temps réel, tâches de fond, e-mail et impression.

4 min de lectureMis à jour le Source : docs.frappe.io

Un framework web full stack

Frappe est un framework web full stack, « batteries incluses » (batteries-included), écrit en Python et en JavaScript.

C’est le framework qui motorise ERPNext. Il reste pourtant très générique : il sert à construire n’importe quelle application pilotée par une base de données.

Piloté par les métadonnées

Dans Frappe, les métadonnées (meta-data) sont des citoyens de première classe. Elles servent à générer les tables de la base de données, à dessiner les formulaires et à configurer de nombreuses fonctionnalités. Les métadonnées sont stockées dans un modèle (Model) que Frappe appelle DocType.

Prenons l’exemple d’un DocType nommé ToDo. Il contient des champs comme status, date et description.

Voici à quoi peut ressembler son fichier todo.json :

json
{
 "name": "ToDo",
 "module": "Desk",
 "field_order": [
  "status",
  "date",
  "description"
 ],
 "fields": [
  {
   "default": "Open",
   "fieldname": "status",
   "fieldtype": "Select",
   "in_global_search": 1,
   "in_list_view": 1,
   "in_standard_filter": 1,
   "label": "Status",
   "options": "Open
Closed"
  },
  {
   "fieldname": "date",
   "fieldtype": "Date",
   "in_standard_filter": 1,
   "label": "Due Date"
  },
  {
   "fieldname": "description",
   "fieldtype": "Text Editor",
   "in_global_search": 1,
   "label": "Description",
   "reqd": 1
  }
 ]
}

Une configuration de ce type génère une table de base de données dont le schéma ressemble à ceci :

sql
MariaDB [_baa0f26509a564b6]> desc tabToDo;
+-----------------------+--------------+------+-----+---------+-------+
| Field                 | Type         | Null | Key | Default | Extra |
+-----------------------+--------------+------+-----+---------+-------+
| name                  | varchar(140) | NO   | PRI | NULL    |       |
| creation              | datetime(6)  | YES  |     | NULL    |       |
| modified              | datetime(6)  | YES  | MUL | NULL    |       |
| modified_by           | varchar(140) | YES  |     | NULL    |       |
| owner                 | varchar(140) | YES  |     | NULL    |       |
| docstatus             | int(1)       | NO   |     | 0       |       |
| idx                   | int(8)       | NO   |     | 0       |       |
| status                | varchar(140) | YES  |     | Open    |       |
| description           | longtext     | YES  |     | NULL    |       |
| date                  | date         | YES  |     | NULL    |       |
+-----------------------+--------------+------+-----+---------+-------+

Une interface d’administration riche

Frappe ne gère pas seulement le backend : il fournit aussi une interface d’administration complète, appelée le bureau (Desk). Quand vous créez un DocType, plusieurs vues sont générées automatiquement. En voici quelques-unes :

  • La vue liste (List View) prend en charge la pagination, le filtrage, le tri et la modification en masse des enregistrements.
  • La vue formulaire (Form View), utilisée pour modifier les enregistrements, gère aussi les pièces jointes, le format PDF, les commentaires, l’e-mail, etc.
  • Le générateur de rapports (Report Builder) permet d’ajouter des colonnes, de regrouper, de filtrer, de trier et d’enregistrer le tout comme configuration.

La documentation officielle illustre chacune de ces vues par une capture d’écran.

Utilisateurs, rôles et permissions

Frappe intègre d’origine la gestion des utilisateurs et des rôles. Un utilisateur (User) est une personne qui peut se connecter au système et effectuer les actions autorisées : créer, modifier ou supprimer des enregistrements. Un rôle (Role) associe des DocTypes aux actions permises sur chacun d’eux.

Python, JavaScript et MariaDB

Frappe Framework utilise Python côté serveur. Il fournit un ORM simple mais puissant qui abstrait les opérations CRUD. La base de données par défaut est MariaDB ; la prise en charge de Postgres est en bêta.

python
doc = frappe.new_doc('ToDo')
doc.description = 'Buy Eggs'
doc.insert()

Le front-end est une application monopage (SPA) écrite en JavaScript (jQuery).

Temps réel

Frappe prend aussi en charge des événements temps réel de type publication/abonnement (pub/sub) grâce à NodeJS et socket.io.

python
# server
frappe.publish_realtime('update_progress', {
    'progress': 42,
    'total': 100
})

# client
frappe.realtime.on('update_progress', (data) => {
    console.log(data)
});

Tâches de fond

Frappe gère également une file de tâches de fond (Background Jobs) basée sur Python RQ.

python
frappe.enqueue('frappe.job.run_job', arg1='Test', arg2='Test2')

E-mail

Frappe sait envoyer et recevoir des e-mails, qui peuvent être rattachés à des documents individuels.

Impression

Frappe génère des formats d’impression PDF à partir de templates Jinja. Il inclut aussi un constructeur de formats d’impression (Print Format Builder) en glisser-déposer.

Batteries incluses

Frappe propose une multitude de fonctionnalités indispensables pour construire une application moderne et complexe. Seules les fonctions de base sont présentées ici ; la suite de ce guide les détaille, ainsi que d’autres fonctions avancées. Lisez-le en entier.

Pages liées