Aller au contenu principal

Structure modulaire APS

Organisation modulaire de la plateforme APS : découpage en modules fonctionnels, dépendances et responsabilités.

Vue d'ensemble​

L'architecture APS est organisée en modules distincts regroupés par domaine fonctionnel. Cette organisation modulaire apporte plusieurs avantages :

  • Séparation des responsabilités : Chaque module a un périmètre fonctionnel clair
  • Réutilisabilité : Les modules peuvent être utilisés dans différents contextes (Web, Studio, Agents)
  • Maintenabilité : Modifications isolées sans impact global
  • Testabilité : Tests unitaires ciblés par module

Modules principaux​

Kernel​

Namespace : Avanteam.Kernel.*
Dossier : /Kernel/

Le Kernel constitue le socle technique de l'application. Il ne contient aucune logique métier et fournit des services transversaux utilisés par tous les autres modules.

Sous-modules :

  • Kernel : Core du kernel (configuration, logging, mail)
  • Kernel.DependencyInjection : Infrastructure d'injection de dépendances
  • Kernel.Configuration : Lecture et gestion de la configuration
  • Kernel.Data : Abstraction d'accès aux données
  • Kernel.Parameters : Gestion des paramètres applicatifs
  • Kernel.AspNetCore : Extensions pour ASP.NET Core
  • Kernel.Web : Extensions pour ASP.NET Framework
  • Kernel.Office : Intégration Office (Word, Excel)
  • Kernel.MicrosoftGraph : Intégration Microsoft Graph

Dépendances : Aucune (module de base)

Responsabilités :

  • Configuration centralisée (fichiers .ini, appsettings.json)
  • Journalisation (NLog)
  • Envoi d'emails
  • Abstraction base de données
  • Services de fond (background tasks)

Directory​

Namespace : Avanteam.Directory.*
Dossier : /Directory/

Le module Directory gère tout ce qui concerne l'annuaire, les utilisateurs et l'authentification.

Sous-modules :

  • Directory : Core du module annuaire
  • Directory.Api : API publique du module
  • Directory.Identity : Modèle Identity (utilisateurs, rôles, ressources)
  • Directory.Authentication : Mécanismes d'authentification
    • Directory.Authentication.AspNetCore : Authentification ASP.NET Core
    • Directory.Authentication.Cookies : Authentification par cookies
    • Directory.Authentication.Saml2 : Authentification SAML
  • Directory.Authorization : Gestion des autorisations
  • Directory.Synchronization : Synchronisation Active Directory / LDAP
  • Directory.Repository : Accès aux données annuaire
  • Directory.Web : Extensions web pour l'annuaire
  • Directory.UI : Composants UI pour l'annuaire

Dépendances : Kernel

Responsabilités :

  • Gestion des utilisateurs, groupes, ressources
  • Authentification (Forms, Windows, SAML, OAuth)
  • Autorisation et politiques de sécurité
  • Synchronisation avec annuaires externes (AD, LDAP)
  • Gestion des délégations

Application​

Namespace : Avanteam.Application.*
Dossier : /Application/

Le module Application contient la logique métier centrale de la plateforme.

Sous-modules :

  • Application : Core du module applicatif
  • Application.Api : API publique du module
  • Application.Agents : Système d'agents (tâches planifiées)
  • Application.Archives : Gestion de l'archivage
  • Application.Log : Journalisation métier
  • Application.Modules : Modules métier spécifiques
  • Application.Repository : Accès aux données métier
    • Application.Repository.EFCore : Implémentation Entity Framework Core
    • Application.Repository.EFCore.SqlServer : Provider SQL Server
    • Application.Repository.EFCore.Oracle : Provider Oracle
  • Application.Web : Extensions web
  • Application.WebControls : Contrôles web réutilisables

Dépendances : Kernel, Directory

Responsabilités :

  • Gestion des documents et métadonnées
  • Gestion des formulaires et schémas
  • Gestion des vues et requêtes
  • Agents et tâches planifiées
  • Archivage documentaire
  • Logs métier et audit

ApplicationPool​

Namespace : Avanteam.Application.Pool.*
Dossier : /ApplicationPool/

Le module ApplicationPool gère le concept de pool d'applications et le multi-tenant.

Sous-modules :

  • ApplicationPool : Core du pool
  • ApplicationPool.Api : API du pool
  • ApplicationPool.Repository : Accès aux données du pool

Dépendances : Kernel, Directory, Application

Responsabilités :

  • Gestion des profils d'applications
  • Configuration multi-tenant
  • Isolation des données par application

Workflow​

Namespace : Avanteam.Workflow.*
Dossier : /Workflow/

Le module Workflow fournit le moteur de workflow de la plateforme.

Sous-modules :

  • Workflow : Core du moteur de workflow
  • Workflow.ComponentModel : Modèle de composants workflow
  • Workflow.Runtime : Exécution des workflows
  • Workflow.DataSource : Accès aux données workflow

Dépendances : Kernel, Directory, Documents

Responsabilités :

  • Définition des processus métier
  • Exécution des instances de workflow
  • Gestion des états et transitions
  • Actions automatiques et notifications

Formulars​

Namespace : Avanteam.Formulars.*
Dossier : /Formulars/

Le module Formulars gère la conception et le rendu des formulaires.

Sous-modules :

  • Formulars : Core des formulaires
  • Formulars.Designer : Éditeur de formulaires
  • Formulars.Schema : Schémas de formulaires
  • Formulars.UI : Rendu UI des formulaires

Dépendances : Kernel, Application

Responsabilités :

  • Définition des schémas de formulaires
  • Rendu dynamique des formulaires
  • Validation des données
  • Types de champs personnalisés

Views​

Namespace : Avanteam.Views.*
Dossier : /Views/

Le module Views gère l'affichage tabulaire des données et les requêtes.

Dépendances : Kernel, Application

Responsabilités :

  • Exécution de requêtes SQL/Entity
  • Filtrage et tri des données
  • Export vers Excel/CSV
  • Vues personnalisées par utilisateur

Documents​

Namespace : Avanteam.Documents.*
Dossier : /Documents/

Le module Documents gère les documents et pièces jointes.

Dépendances : Kernel

Responsabilités :

  • Stockage des fichiers
  • Gestion des versions
  • Conversion PDF
  • Check-in/Check-out

Studio​

Namespace : Avanteam.Studio.*
Dossier : /Studio/

Le module Studio contient l'outil de configuration desktop (WinForms).

Sous-modules :

  • Studio.Main : Application principale
  • Studio.Core : Core du studio
  • Studio.Security : Sécurité du studio
  • Studio.Modules.* : Modules de configuration
    • Studio.Modules.Formulars : Configuration des formulaires
    • Studio.Modules.Parameters : Configuration des paramètres
    • Studio.Modules.Views : Configuration des vues
    • Studio.Modules.Workflow : Configuration des workflows

Dépendances : Kernel, Directory, Application, tous les modules métier

Responsabilités :

  • Modélisation des formulaires
  • Édition des workflows
  • Configuration des vues
  • Gestion des paramètres applicatifs

Web​

Namespace : Avanteam.Web.*
Dossier : /Web/

Le module Web contient les applications web.

Sous-modules :

  • Web.Model : Application web principale (ASP.NET Framework 4.8)
  • Web.Root : Nouvelle application (ASP.NET Core - en développement)

Dépendances : Tous les modules

Responsabilités :

  • Interface utilisateur web
  • API REST
  • SignalR (temps réel)
  • Gestion de session

Modules complémentaires​

Localisation : Gestion multilingue
Remoting : Communication inter-process
Reporting : Génération de rapports
Search : Recherche plein texte
SharePoint : Intégration SharePoint
Exchange : Intégration Exchange
GraphBuilder : Construction de graphes visuels
Navigators : Navigation visuelle

Organisation des projets​

Chaque module suit une structure standardisée :

Module/
├── Abstractions/      # Interfaces et abstractions
├── Api/               # API publique du module
├── DependencyInjection/  # Configuration DI
├── Repository/        # Accès aux données
├── Src/               # Implémentation principale
├── UnitTests/         # Tests unitaires
└── Web/               # Extensions web (si applicable)

Pattern de nommage​

  • Projet : {Module}.{SubModule}
  • Namespace : Avanteam.{Module}.{SubModule}
  • Assembly : Avanteam.{Module}.{SubModule}.dll

Exemple : Application.Repository.EFCore.SqlServer

Graphe de dépendances​

┌─────────────────────────────────────────────┐
│                   Studio                    │
│              (Configuration)                │
└──────────────────┬──────────────────────────┘
                   │
┌──────────────────▼──────────────────────────┐
│                Web.Model                    │
│            (Application Web)                │
└──────────────────┬──────────────────────────┘
                   │
        ┌──────────┼──────────┐
        │          │          │
┌───────▼────┐ ┌──▼────────┐ ┌▼──────────────┐
│ Workflow   │ │Application│ │ApplicationPool│
└──────┬─────┘ └──┬────────┘ └┬──────────────┘
       │          │            │
       └──────┬───┴────────────┘
              │
       ┌──────▼──────┐
       │  Directory  │
       └──────┬──────┘
              │
       ┌──────▼──────┐
       │   Kernel    │
       └─────────────┘

Stratégie de versionnage​

  • Tous les projets partagent le même numéro de version
  • Version définie dans Directory.Build.props à la racine
  • Format : {Année}.{Mois}.{Build}.{Revision}
  • Exemple : 2023.1.0.0
<PropertyGroup>
  <Version Condition="'$(VERSION)' == ''">1.0.0.0</Version>
  <AssemblyVersion>1.0.0.0</AssemblyVersion>
</PropertyGroup>

Gestion des dépendances​

Dépendances internes​

Les dépendances entre modules APS s'effectuent via ProjectReference :

<ItemGroup>
  <ProjectReference Include="..\..\Kernel\Src\Kernel.csproj" />
  <ProjectReference Include="..\..\Directory\Src\Directory.csproj" />
</ItemGroup>

Dépendances externes​

Les packages NuGet externes sont centralisés et gérés de manière cohérente :

  • Entity Framework Core
  • AutoMapper
  • NLog
  • DevExpress (composants UI)
  • Microsoft.Extensions.*

Règles de dépendances​

  1. Kernel ne dépend de rien : Module de base autonome
  2. Pas de dépendances circulaires : Graphe acyclique
  3. Abstractions séparées : Interfaces dans modules *.Abstractions
  4. API publique isolée : Contrats dans modules *.Api

Extension et personnalisation​

Système de plugins​

L'architecture supporte l'extension via le système AddStartupExtensions :

apsAppBuilder.AddStartupExtensions("MonModule");

Cette méthode recherche et exécute automatiquement toutes les classes implémentant IStartupExtension dans les assemblies du module.

Modules personnalisés​

Pour créer un module personnalisé :

  1. Créer la structure de dossiers standard
  2. Implémenter une classe Startup avec méthode d'extension
  3. Enregistrer les services via IServiceCollection
  4. Référencer les modules dépendants
  5. Appeler la méthode d'extension dans le point d'entrée

Compilation et build​

Configuration globale​

Le fichier Directory.Build.props à la racine définit les paramètres communs :

  • Target Framework (.NET Framework 4.8)
  • Chemins de sortie (Build/Debug ou Build/Release)
  • Warnings et analyses de code
  • Métadonnées d'assembly

Scripts de build​

  • npm scripts : Compilation frontend (webpack, gulp)
  • MSBuild : Compilation .NET
  • Publish : Publication vers serveur IIS

Bonnes pratiques​

Organisation du code​

  • Un fichier par classe
  • Namespaces cohérents avec la structure de dossiers
  • Interfaces dans projets Abstractions
  • Implémentation dans projets Src

Enregistrement des services​

Chaque module expose une méthode d'extension fluide :

public static IApsAppBuilder AddMonModule(
    this IApsAppBuilder builder)
{
    AddServices(builder.Services);
    return builder.AddStartupExtensions("MonModule");
}

Tests unitaires​

Chaque module a son projet UnitTests correspondant avec la même structure.

Références​