Spécifications Techniques

Guide complet pour créer des spécifications fonctionnelles avec UML, Merise et RBAC

Spécifications Techniques

Les spécifications techniques constituent le socle de tout projet de développement. Elles permettent de formaliser les besoins fonctionnels et techniques avant le démarrage du développement.

1. Règles de Gestion

Définition et Importance

Les règles de gestion définissent les contraintes métier que le système doit respecter. Elles guident l'implémentation et garantissent la cohérence fonctionnelle.

Structure d'une Règle de Gestion

RG001 - Authentification utilisateur

  • Domaine : Sécurité
  • Description : Un utilisateur doit s'authentifier pour accéder à l'application
  • Condition : Si l'utilisateur n'est pas connecté
  • Action : Redirection vers la page de connexion
  • Exception : Pages publiques (accueil, contact)

Exemples de Règles de Gestion

E-commerce

RG002 - Validation de commande

  • Un panier ne peut être validé que s'il contient au moins un article
  • Le stock doit être suffisant pour tous les articles
  • L'adresse de livraison doit être renseignée

RG003 - Calcul de prix

  • Le prix total = prix articles + frais de port - réductions
  • Les réductions ne peuvent excéder 50% du montant total
  • Les frais de port sont gratuits à partir de 50€

Gestion RH

RG004 - Gestion des congés

  • Un employé ne peut poser que 5 semaines de congés par an
  • Une demande doit être faite 15 jours avant la date souhaitée
  • Un manager ne peut refuser plus de 2 demandes consécutives

2. Modélisation UML

Diagrammes Essentiels

Diagramme d'Activité

Représente les flux de traitement et les processus métier.

@startuml
title Processus de Commande E-commerce

start
:Sélection produits;
:Ajout au panier;
if (Utilisateur connecté?) then (non)
  :Création compte/Connexion;
endif
:Validation panier;
:Saisie adresse livraison;
:Choix mode paiement;
if (Paiement réussi?) then (oui)
  :Confirmation commande;
  :Envoi email confirmation;
else (non)
  :Affichage erreur;
  :Retour au panier;
endif
stop
@enduml

Diagramme de Cas d'Usage (Use Case)

Identifie les interactions entre les acteurs et le système.

@startuml
title Système de Gestion de Bibliothèque

left to right direction

actor "Lecteur" as lecteur
actor "Bibliothécaire" as biblio
actor "Administrateur" as admin

rectangle "Système Bibliothèque" {
  usecase "Consulter catalogue" as consultation
  usecase "Emprunter livre" as emprunt
  usecase "Restituer livre" as retour
  usecase "Gérer utilisateurs" as gestion_users
  usecase "Gérer catalogue" as gestion_catalogue
  usecase "Générer rapports" as rapports
}

lecteur --> consultation
lecteur --> emprunt
lecteur --> retour

biblio --> consultation
biblio --> emprunt
biblio --> retour
biblio --> gestion_catalogue

admin --> gestion_users
admin --> rapports
@enduml

Diagramme de Séquence

Décrit les interactions entre objets dans le temps.

@startuml
title Authentification Utilisateur

participant "Utilisateur" as user
participant "Interface" as ui
participant "Controller" as ctrl
participant "Service Auth" as auth
participant "Base de Données" as db

user -> ui : Saisit identifiants
ui -> ctrl : POST /login
ctrl -> auth : validate(email, password)
auth -> db : findUser(email)
db --> auth : userData
auth -> auth : checkPassword(password, hash)
auth --> ctrl : token JWT
ctrl --> ui : Response 200 + token
ui --> user : Redirection dashboard
@enduml

Diagramme de Classes

Représente la structure statique du système.

@startuml
title Modèle de Classes E-learning

class User {
  -id: Long
  -email: String
  -password: String
  -firstName: String
  -lastName: String
  -createdAt: Date
  +authenticate(): boolean
  +updateProfile(): void
}

class Course {
  -id: Long
  -title: String
  -description: Text
  -duration: Integer
  -level: Enum
  -createdAt: Date
  +addLesson(): void
  +updateContent(): void
}

class Lesson {
  -id: Long
  -title: String
  -content: Text
  -videoUrl: String
  -order: Integer
  +markAsCompleted(): void
}

class Enrollment {
  -enrollmentDate: Date
  -completionRate: Float
  -lastAccessDate: Date
  +calculateProgress(): Float
}

User ||--o{ Enrollment
Course ||--o{ Enrollment
Course ||--|| Lesson

@enduml

3. Méthode Merise

MCD (Modèle Conceptuel de Données)

Le MCD représente les données métier sans considération technique.

Règles de Construction

  • Entité : Objet du monde réel (CLIENT, COMMANDE)
  • Propriété : Caractéristique d'une entité (nom, âge)
  • Association : Lien entre entités (PASSER entre CLIENT et COMMANDE)
  • Cardinalité : Nombre d'occurrences possibles (0,n - 1,1)

Exemple MCD E-commerce

CLIENT (id_client, nom, prenom, email, date_creation)
  |
  | PASSER (0,n - 1,n) - date_commande
  |
COMMANDE (id_commande, date_commande, statut, montant_total)
  |
  | CONTENIR (1,n - 1,n) - quantite, prix_unitaire
  |
PRODUIT (id_produit, nom, description, prix, stock)
  |
  | APPARTENIR (1,n - 1,n)
  |
CATEGORIE (id_categorie, nom, description)

MLD (Modèle Logique de Données)

Le MLD transforme le MCD en structure relationnelle.

Règles de Transformation

  • Chaque entité devient une table
  • Les associations deviennent des tables ou des clés étrangères selon les cardinalités
  • Les propriétés deviennent des colonnes

Exemple MLD

CLIENT (id_client, nom, prenom, email, date_creation)
COMMANDE (id_commande, date_commande, statut, montant_total, #id_client)
PRODUIT (id_produit, nom, description, prix, stock, #id_categorie)
CATEGORIE (id_categorie, nom, description)
LIGNE_COMMANDE (id_ligne, #id_commande, #id_produit, quantite, prix_unitaire)

MPD (Modèle Physique de Données)

Le MPD précise l'implémentation technique dans un SGBD spécifique.

CREATE TABLE client (
    id_client SERIAL PRIMARY KEY,
    nom VARCHAR(100) NOT NULL,
    prenom VARCHAR(100) NOT NULL,
    email VARCHAR(255) UNIQUE NOT NULL,
    date_creation TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

CREATE TABLE categorie (
    id_categorie SERIAL PRIMARY KEY,
    nom VARCHAR(100) NOT NULL,
    description TEXT
);

CREATE TABLE produit (
    id_produit SERIAL PRIMARY KEY,
    nom VARCHAR(200) NOT NULL,
    description TEXT,
    prix DECIMAL(10,2) NOT NULL CHECK (prix > 0),
    stock INTEGER NOT NULL DEFAULT 0,
    id_categorie INTEGER REFERENCES categorie(id_categorie)
);

CREATE TABLE commande (
    id_commande SERIAL PRIMARY KEY,
    date_commande TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    statut VARCHAR(20) DEFAULT 'en_attente',
    montant_total DECIMAL(10,2) NOT NULL,
    id_client INTEGER REFERENCES client(id_client)
);

CREATE TABLE ligne_commande (
    id_ligne SERIAL PRIMARY KEY,
    id_commande INTEGER REFERENCES commande(id_commande),
    id_produit INTEGER REFERENCES produit(id_produit),
    quantite INTEGER NOT NULL CHECK (quantite > 0),
    prix_unitaire DECIMAL(10,2) NOT NULL
);

4. RBAC (Role-Based Access Control)

Principe du RBAC

Le RBAC organise les autorisations autour de rôles attribués aux utilisateurs.

Composants RBAC

  • Utilisateur : Personne physique utilisant le système
  • Rôle : Ensemble cohérent de permissions
  • Permission : Autorisation d'effectuer une action sur une ressource
  • Ressource : Objet ou donnée protégée

Modélisation RBAC

@startuml
title Modèle RBAC

class User {
  +id: Long
  +username: String
  +email: String
  +isActive: Boolean
}

class Role {
  +id: Long
  +name: String
  +description: String
  +level: Integer
}

class Permission {
  +id: Long
  +action: String
  +resource: String
  +description: String
}

class UserRole {
  +userId: Long
  +roleId: Long
  +assignedAt: Date
  +assignedBy: Long
}

class RolePermission {
  +roleId: Long
  +permissionId: Long
}

User ||--o{ UserRole
Role ||--o{ UserRole
Role ||--o{ RolePermission
Permission ||--o{ RolePermission
@enduml

Exemple d'Implémentation

Définition des Rôles

{
  "roles": [
    {
      "name": "admin",
      "description": "Administrateur système",
      "permissions": ["*"]
    },
    {
      "name": "manager",
      "description": "Gestionnaire métier",
      "permissions": [
        "users.read",
        "users.create",
        "users.update",
        "reports.read",
        "products.read",
        "products.create",
        "products.update"
      ]
    },
    {
      "name": "user",
      "description": "Utilisateur standard",
      "permissions": [
        "profile.read",
        "profile.update",
        "products.read",
        "orders.read",
        "orders.create"
      ]
    }
  ]
}

Middleware d'Autorisation

// middleware/rbac.js
function requirePermission(permission) {
  return async (req, res, next) => {
    const user = req.user;
    
    if (!user) {
      return res.status(401).json({ error: 'Non authentifié' });
    }
    
    const hasPermission = await checkUserPermission(user.id, permission);
    
    if (!hasPermission) {
      return res.status(403).json({ error: 'Permission insuffisante' });
    }
    
    next();
  };
}

// Utilisation
app.get('/api/users', 
  authenticate, 
  requirePermission('users.read'), 
  getUsersController
);

5. Benchmark de la Concurrence

Méthodologie d'Analyse

Critères d'Évaluation

  • Fonctionnalités : Couverture des besoins métier
  • UX/UI : Ergonomie et design
  • Performance : Temps de réponse, scalabilité
  • Prix : Modèle économique et tarification
  • Support : Documentation, assistance

Grille d'Analyse

ConcurrentFonctionnalitésUX/UIPerformancePrixSupportTotal
Solution A8/107/109/106/108/1038/50
Solution B9/109/107/108/107/1040/50
Notre App8/109/108/109/108/1042/50

Exemple Concret : CRM

Analyse Concurrentielle - CRM PME

Salesforce

Points forts :

  • Écosystème complet d'applications
  • Intégrations nombreuses
  • Fonctionnalités avancées (IA, automatisation)

Points faibles :

  • Complexité de configuration
  • Prix élevé pour les PME
  • Courbe d'apprentissage importante

HubSpot

Points forts :

  • Interface intuitive
  • Version gratuite disponible
  • Excellent marketing automation

Points faibles :

  • Limitations en version gratuite
  • Fonctionnalités avancées payantes
  • Personnalisation limitée

Notre Solution

Positionnement :

  • CRM spécialisé PME française
  • Interface en français
  • Prix compétitif
  • Support local

Outils et Ressources

Outils de Modélisation

  • PlantUML : Diagrammes UML en code
  • Lucidchart : Modélisation collaborative
  • Draw.io : Gratuit et open source
  • StarUML : Outil UML professionnel

Templates et Checklists

  • Règles de gestion documentées
  • Diagrammes UML créés
  • MCD/MLD/MPD validés
  • RBAC défini et testé
  • Benchmark concurrentiel réalisé
  • Spécifications validées par le client

Ressources Complémentaires

Des spécifications techniques bien conçues sont la garantie d'un développement efficace et d'un produit qui répond aux attentes. Elles constituent le référentiel partagé entre toutes les parties prenantes du projet.