Serveur

Développement du backend et de l'API.

Dossier du serveur

Le dossier 📂 server contient un ensemble de fichiers et de dossiers qui forment le backend de l'application.

Tout ce qui se trouve dans le dossier 📂 server est utilisé dans le traitement du serveur backend, comme les intégrations, l'API, la base de données, la sécurité et l'authentification, les Cron Jobs, entre autres.

Structure du dossier

Dans le dossier 📂 server se trouve la structure suivante :

./server/
 ├─ ./actions/
 ├─ ./components/
 ├─ ./core/
 │   ├─ ./_config.js
 │   ├─ ./_init.js
 │   ├─ ./_request_close.js
 │   ├─ ./_request_end.js
 │   ├─ ./_request_error.js
 │   ├─ ./_request_start.js
 │   ├─ ./_request_url.js
 │   ├─ ./_service_config.js
 │   ├─ ./_service_end.js
 │   ├─ ./_service_error.js
 │   └─ ./_service_start.js
 ├─ ./reports/
 ├─ ./services/
 ├─ ./setup/
 │   ├─ ./_end.js
 │   └─ ./_start.js
 └─ ./templates/
     ├─ ./_/
     ├─ ./dev/
     │   └─ ./dashboard.html
     ├─ ./dashboard.html
     ├─ ./scripts.html
     ├─ ./scripts_dev.html
     ├─ ./scripts_login.html
     ├─ ./styles.html
     ├─ ./styles_dev.html
     └─ ./styles_login.html

Actions

Dans 📂 actions, on peut ajouter des actions personnalisées sur mesure (hooks) dans les opérations CRUD des formulaires générés automatiquement pour le backoffice ; en fonction de la structure des données, de nombreuses interventions sur les données peuvent être effectuées ici.

Par exemple, lors de la suppression d'un client, il est nécessaire de supprimer toutes ses commandes, ou lors de la création d'un nouveau produit, il doit être intégré à un autre système. Enfin, tout développement directement lié aux données peut être effectué ici.

Les actions sont inspirées des triggers de base de données, mais au niveau de l'exécution du code.

Ainsi, des opérations spécifiques peuvent être programmées lors de la création, de la modification et de la suppression de données.

Composants

Les 📂 components sont utilisés pour définir des types de champs personnalisés dans les formulaires de backoffice, qui peuvent effectuer leur propre manipulation de données.

Des composants peuvent être créés via des scripts pour fournir un nouveau type de champ spécifique dans l'application.

Core

Le dossier 📂 core permet l'injection de code dans le flux de traitement des requêtes HTTP.

Il est également utilisé pour partager du code entre les différents services et autres.

Le fichier _config.js est exécuté après le chargement de la configuration à chaque requête HTTP ; il est exécuté après le script de configuration de l'environnement qui se trouve dans le dossier 📂 config de l'application.

Le fichier _init.js sert à injecter des instructions lors de la première initialisation de l'application.

Traitement des requêtes HTTP

Dans le flux de traitement des requêtes HTTP pour toute URL de l'application, les scripts respectifs sont exécutés :

• _request_start.js est exécuté lorsque la requête HTTP arrive au serveur Netuno.
• _request_url.js est exécuté lorsque l'URL est traitée par Netuno, l'URL peut être modifiée pour une autre destination.
• _request_close.js est exécuté lorsque la réponse à la requête HTTP est fermée.
• _request_end.js est exécuté lorsque la requête HTTP est définitivement terminée.
• _request_error.js est exécuté lorsqu'une erreur se produit lors du traitement de la requête HTTP.

Traitement des services API

Dans le flux de traitement de tout service API de l'application, les scripts suivants sont exécutés :

• _service_config.js est exécuté avant de démarrer l'exécution du service, il sert à définir les configurations d'exécution du service entre autres choses. On peut définir si le service peut ou non être exécuté, c'est-à-dire un contrôle de sécurité sur l'accès au service API.
• _service_start.js est exécuté dès qu'un service commence à être traité.
• _service_end.js est exécuté après la fin du traitement d'un service.
• _service_error.js est exécuté lorsqu'une erreur se produit lors du traitement d'un service.

Services - API

C'est dans le dossier 📂 services que sont créés les services qui forment l'API applicative.

Les services peuvent être écrits dans différents langages : JavaScript, Python, Java, Kotlin, Ruby ou Groovy.

Comme Netuno est polyglotte, tout fichier de script peut être changé pour un autre langage de programmation pris en charge, il suffit d'avoir l'extension des fichiers en fonction du langage.

Aucune configuration supplémentaire n'est nécessaire en fonction du langage de programmation utilisé, il suffit de créer le fichier du service avec l'extension correcte correspondant au langage de programmation.

Setup

Dans le dossier 📂 setup se trouve le code généré automatiquement par le moteur de Netuno qui définit les schémas de base de données, et c'est aussi là que nous pouvons placer le chargement de données essentiel au fonctionnement de l'application.

Le script _start.js est exécuté avant de commencer le traitement de construction de la base de données.

Le script _end.js est exécuté après la fin du traitement de construction de la base de données.

En fonction de la construction de la structure de données, Netuno crée ici dans le dossier 📂 setup automatiquement le code nécessaire pour que toute la structure de données soit recréée dans une nouvelle base de données, ou pour recréer ce qui manque dans une autre base de données où l'application serait éventuellement exécutée.

Templates

Le dossier 📂 templates contient le contenu HTML des pages de backoffice de l'application, qui sont générées par le serveur Netuno.

Dans le dossier 📂 dev se trouve le fichier dashboard.html qui permet la modification de l'espace de travail en mode construction du développeur.

Le fichier dashboard.html qui se trouve à la racine des templates contient le HTML de l'espace de travail général du backoffice.

Templates natifs

Dans le dossier 📂 _, tout template général peut être remplacé, c'est-à-dire que les templates par défaut de Netuno peuvent être modifiés.

• Ici se trouvent les templates natifs de Netuno.

Si le nom des dossiers et/ou des fichiers correspond à ceux des templates natifs dans ce dossier, alors le template qui se trouve dans ce dossier est utilisé à la place du template natif.

C'est-à-dire qu'il suffit de répliquer la même structure du template natif dans le dossier 📂 _ pour le remplacer.

Scripts

Les templates de scripts injectent des fichiers de code JavaScript à la fin des pages dans le but suivant :

1. scripts.html ajouter du code JavaScript à la fin de la page de backoffice.
2. scripts_dev.html ajouter du code JavaScript à la fin de la page de la zone de construction du développeur.
3. scripts_login.html ajouter du code JavaScript à la fin de la page de connexion.

Styles

Les templates de styles injectent des fichiers de styles au début des pages dans le but suivant :

1. styles.html ajouter du code CSS au début de la page de backoffice.
2. styles_dev.html ajouter du code CSS au début de la page de la zone de construction du développeur.
3. styles_login.html ajouter du code CSS au début de la page de connexion.