700 lines
31 KiB
Python
700 lines
31 KiB
Python
"""
|
||
Génère le rapport de PFE ERP Rayhan en format DOCX professionnel.
|
||
Usage : python3 generate_report.py
|
||
"""
|
||
|
||
from docx import Document
|
||
from docx.shared import Pt, Cm, RGBColor, Inches
|
||
from docx.enum.text import WD_ALIGN_PARAGRAPH
|
||
from docx.enum.table import WD_TABLE_ALIGNMENT, WD_ALIGN_VERTICAL
|
||
from docx.oxml.ns import qn
|
||
from docx.oxml import OxmlElement
|
||
import copy
|
||
|
||
# ── Palette de couleurs ──────────────────────────────────────────────────────
|
||
BLEU_FONCE = RGBColor(0x1F, 0x38, 0x64) # Titres principaux
|
||
BLEU_MOYEN = RGBColor(0x2E, 0x74, 0xB5) # Titres secondaires
|
||
BLEU_CLAIR = RGBColor(0xBD, 0xD7, 0xEE) # Fond en-têtes tableau
|
||
GRIS_TEXTE = RGBColor(0x26, 0x26, 0x26) # Corps de texte
|
||
BLANC = RGBColor(0xFF, 0xFF, 0xFF)
|
||
|
||
# ── Helpers ──────────────────────────────────────────────────────────────────
|
||
|
||
def set_cell_bg(cell, color_hex):
|
||
tc = cell._tc
|
||
tcPr = tc.get_or_add_tcPr()
|
||
shd = OxmlElement('w:shd')
|
||
shd.set(qn('w:val'), 'clear')
|
||
shd.set(qn('w:color'), 'auto')
|
||
shd.set(qn('w:fill'), color_hex)
|
||
tcPr.append(shd)
|
||
|
||
def add_page_number(paragraph):
|
||
run = paragraph.add_run()
|
||
fldChar1 = OxmlElement('w:fldChar')
|
||
fldChar1.set(qn('w:fldCharType'), 'begin')
|
||
instrText = OxmlElement('w:instrText')
|
||
instrText.text = 'PAGE'
|
||
fldChar2 = OxmlElement('w:fldChar')
|
||
fldChar2.set(qn('w:fldCharType'), 'end')
|
||
run._r.append(fldChar1)
|
||
run._r.append(instrText)
|
||
run._r.append(fldChar2)
|
||
|
||
def set_col_width(table, col_idx, width_cm):
|
||
for row in table.rows:
|
||
row.cells[col_idx].width = Cm(width_cm)
|
||
|
||
def styled_heading(doc, text, level, color=None):
|
||
p = doc.add_paragraph(style=f'Heading {level}')
|
||
run = p.add_run(text)
|
||
run.font.name = 'Calibri'
|
||
run.font.bold = True
|
||
if level == 1:
|
||
run.font.size = Pt(16)
|
||
run.font.color.rgb = color or BLEU_FONCE
|
||
p.paragraph_format.space_before = Pt(24)
|
||
p.paragraph_format.space_after = Pt(8)
|
||
elif level == 2:
|
||
run.font.size = Pt(13)
|
||
run.font.color.rgb = color or BLEU_MOYEN
|
||
p.paragraph_format.space_before = Pt(16)
|
||
p.paragraph_format.space_after = Pt(6)
|
||
else:
|
||
run.font.size = Pt(11)
|
||
run.font.color.rgb = color or BLEU_MOYEN
|
||
run.font.italic = True
|
||
p.paragraph_format.space_before = Pt(10)
|
||
p.paragraph_format.space_after = Pt(4)
|
||
return p
|
||
|
||
def body(doc, text, space_after=6):
|
||
p = doc.add_paragraph()
|
||
run = p.add_run(text)
|
||
run.font.name = 'Calibri'
|
||
run.font.size = Pt(11)
|
||
run.font.color.rgb = GRIS_TEXTE
|
||
p.paragraph_format.space_after = Pt(space_after)
|
||
p.paragraph_format.line_spacing = Pt(16)
|
||
return p
|
||
|
||
def bullet(doc, text):
|
||
p = doc.add_paragraph(style='List Bullet')
|
||
run = p.add_run(text)
|
||
run.font.name = 'Calibri'
|
||
run.font.size = Pt(11)
|
||
run.font.color.rgb = GRIS_TEXTE
|
||
p.paragraph_format.space_after = Pt(3)
|
||
return p
|
||
|
||
def add_table(doc, headers, rows, col_widths=None):
|
||
table = doc.add_table(rows=1 + len(rows), cols=len(headers))
|
||
table.style = 'Table Grid'
|
||
table.alignment = WD_TABLE_ALIGNMENT.CENTER
|
||
|
||
# En-tête
|
||
hdr = table.rows[0]
|
||
for i, h in enumerate(headers):
|
||
cell = hdr.cells[i]
|
||
set_cell_bg(cell, '2E74B5')
|
||
p = cell.paragraphs[0]
|
||
p.alignment = WD_ALIGN_PARAGRAPH.CENTER
|
||
run = p.add_run(h)
|
||
run.font.name = 'Calibri'
|
||
run.font.bold = True
|
||
run.font.size = Pt(10)
|
||
run.font.color.rgb = BLANC
|
||
cell.vertical_alignment = WD_ALIGN_VERTICAL.CENTER
|
||
|
||
# Données
|
||
for r_idx, row_data in enumerate(rows):
|
||
row = table.rows[r_idx + 1]
|
||
bg = 'F2F7FC' if r_idx % 2 == 0 else 'FFFFFF'
|
||
for c_idx, val in enumerate(row_data):
|
||
cell = row.cells[c_idx]
|
||
set_cell_bg(cell, bg)
|
||
p = cell.paragraphs[0]
|
||
run = p.add_run(val)
|
||
run.font.name = 'Calibri'
|
||
run.font.size = Pt(10)
|
||
run.font.color.rgb = GRIS_TEXTE
|
||
cell.vertical_alignment = WD_ALIGN_VERTICAL.CENTER
|
||
|
||
if col_widths:
|
||
for i, w in enumerate(col_widths):
|
||
set_col_width(table, i, w)
|
||
|
||
doc.add_paragraph()
|
||
return table
|
||
|
||
def add_code_block(doc, code_text):
|
||
p = doc.add_paragraph()
|
||
run = p.add_run(code_text)
|
||
run.font.name = 'Courier New'
|
||
run.font.size = Pt(9)
|
||
run.font.color.rgb = RGBColor(0x1E, 0x1E, 0x1E)
|
||
p.paragraph_format.left_indent = Cm(1)
|
||
shading = OxmlElement('w:shd')
|
||
shading.set(qn('w:val'), 'clear')
|
||
shading.set(qn('w:color'), 'auto')
|
||
shading.set(qn('w:fill'), 'F4F4F4')
|
||
p._p.get_or_add_pPr().append(shading)
|
||
p.paragraph_format.space_after = Pt(8)
|
||
|
||
def separator(doc):
|
||
p = doc.add_paragraph()
|
||
p.paragraph_format.space_before = Pt(4)
|
||
p.paragraph_format.space_after = Pt(4)
|
||
pPr = p._p.get_or_add_pPr()
|
||
pBdr = OxmlElement('w:pBdr')
|
||
bottom = OxmlElement('w:bottom')
|
||
bottom.set(qn('w:val'), 'single')
|
||
bottom.set(qn('w:sz'), '6')
|
||
bottom.set(qn('w:space'), '1')
|
||
bottom.set(qn('w:color'), '2E74B5')
|
||
pBdr.append(bottom)
|
||
pPr.append(pBdr)
|
||
|
||
|
||
# ── Document ─────────────────────────────────────────────────────────────────
|
||
|
||
doc = Document()
|
||
|
||
# Marges
|
||
for section in doc.sections:
|
||
section.top_margin = Cm(2.5)
|
||
section.bottom_margin = Cm(2.5)
|
||
section.left_margin = Cm(3.0)
|
||
section.right_margin = Cm(2.5)
|
||
|
||
# Pied de page avec numéros de page
|
||
for section in doc.sections:
|
||
footer = section.footer
|
||
fp = footer.paragraphs[0]
|
||
fp.alignment = WD_ALIGN_PARAGRAPH.CENTER
|
||
fp.add_run('ERP SUARL Rayhan — PFE Ali Guennari | Page ').font.name = 'Calibri'
|
||
fp.runs[0].font.size = Pt(9)
|
||
fp.runs[0].font.color.rgb = RGBColor(0x80, 0x80, 0x80)
|
||
add_page_number(fp)
|
||
|
||
# ════════════════════════════════════════════════════════════════════════════
|
||
# PAGE DE GARDE
|
||
# ════════════════════════════════════════════════════════════════════════════
|
||
|
||
# Espacement haut
|
||
for _ in range(4):
|
||
doc.add_paragraph()
|
||
|
||
# Titre principal
|
||
p = doc.add_paragraph()
|
||
p.alignment = WD_ALIGN_PARAGRAPH.CENTER
|
||
run = p.add_run('ERP SUR MESURE')
|
||
run.font.name = 'Calibri'
|
||
run.font.size = Pt(28)
|
||
run.font.bold = True
|
||
run.font.color.rgb = BLEU_FONCE
|
||
|
||
p2 = doc.add_paragraph()
|
||
p2.alignment = WD_ALIGN_PARAGRAPH.CENTER
|
||
run2 = p2.add_run('SUARL Rayhan')
|
||
run2.font.name = 'Calibri'
|
||
run2.font.size = Pt(22)
|
||
run2.font.bold = True
|
||
run2.font.color.rgb = BLEU_MOYEN
|
||
|
||
separator(doc)
|
||
|
||
for _ in range(2):
|
||
doc.add_paragraph()
|
||
|
||
# Sous-titre
|
||
p3 = doc.add_paragraph()
|
||
p3.alignment = WD_ALIGN_PARAGRAPH.CENTER
|
||
run3 = p3.add_run('Rapport de Projet de Fin d\'Études')
|
||
run3.font.name = 'Calibri'
|
||
run3.font.size = Pt(14)
|
||
run3.font.italic = True
|
||
run3.font.color.rgb = GRIS_TEXTE
|
||
|
||
for _ in range(3):
|
||
doc.add_paragraph()
|
||
|
||
# Infos
|
||
infos = [
|
||
('Étudiant', 'Ali Guennari'),
|
||
('Entreprise d\'accueil', 'SUARL Rayhan — Plasturgie, Tataouine, Tunisie'),
|
||
('Encadrant académique', 'À compléter'),
|
||
('Encadrant professionnel', 'À compléter'),
|
||
('Année universitaire', '2025 / 2026'),
|
||
]
|
||
for label, val in infos:
|
||
p = doc.add_paragraph()
|
||
p.alignment = WD_ALIGN_PARAGRAPH.CENTER
|
||
r1 = p.add_run(f'{label} : ')
|
||
r1.font.name = 'Calibri'
|
||
r1.font.size = Pt(12)
|
||
r1.font.bold = True
|
||
r1.font.color.rgb = BLEU_FONCE
|
||
r2 = p.add_run(val)
|
||
r2.font.name = 'Calibri'
|
||
r2.font.size = Pt(12)
|
||
r2.font.color.rgb = GRIS_TEXTE
|
||
p.paragraph_format.space_after = Pt(6)
|
||
|
||
for _ in range(2):
|
||
doc.add_paragraph()
|
||
|
||
p_date = doc.add_paragraph()
|
||
p_date.alignment = WD_ALIGN_PARAGRAPH.CENTER
|
||
r_date = p_date.add_run('Avril 2026')
|
||
r_date.font.name = 'Calibri'
|
||
r_date.font.size = Pt(12)
|
||
r_date.font.color.rgb = RGBColor(0x70, 0x70, 0x70)
|
||
|
||
# Saut de page
|
||
doc.add_page_break()
|
||
|
||
|
||
# ════════════════════════════════════════════════════════════════════════════
|
||
# CHAPITRE 1 — PRÉSENTATION DU PROJET
|
||
# ════════════════════════════════════════════════════════════════════════════
|
||
|
||
styled_heading(doc, 'Chapitre 1 — Présentation du Projet', 1)
|
||
separator(doc)
|
||
|
||
styled_heading(doc, '1.1 Contexte', 2)
|
||
body(doc,
|
||
'SUARL Rayhan est une entreprise tunisienne spécialisée dans la fabrication d\'emballages '
|
||
'plastiques implantée à Tataouine. Son catalogue comprend quatre produits finis : sacs Bertel, '
|
||
'sacs poubelles, sacs alimentaires et film rétractable, produits à partir de matières premières '
|
||
'telles que le HDPE (Polyéthylène Haute Densité) et le LDPE (Polyéthylène Basse Densité).')
|
||
body(doc,
|
||
'Face à une gestion encore manuelle de ses processus métier — achats, ventes, production et stock — '
|
||
'la direction a exprimé le besoin d\'un système d\'information intégré permettant de centraliser '
|
||
'et d\'automatiser l\'ensemble de ces opérations.')
|
||
|
||
styled_heading(doc, '1.2 Objectif du Projet', 2)
|
||
body(doc,
|
||
'Ce projet de fin d\'études consiste à concevoir et développer un ERP (Enterprise Resource '
|
||
'Planning) sur mesure, adapté aux spécificités de SUARL Rayhan, couvrant les domaines suivants :')
|
||
for item in [
|
||
'Gestion du référentiel articles (matières premières, produits semi-finis, produits finis)',
|
||
'Cycle d\'achat complet : commandes fournisseurs → bons de réception → mise à jour du stock',
|
||
'Cycle de vente complet : commandes clients → bons de livraison → sortie de stock',
|
||
'Gestion de la production : nomenclatures BOM, ordres de fabrication avec suivi de statut',
|
||
'Suivi des stocks en temps réel avec alertes de seuil minimum',
|
||
'Tableau de bord KPI pour la direction (PDG)',
|
||
]:
|
||
bullet(doc, item)
|
||
|
||
styled_heading(doc, '1.3 Périmètre Fonctionnel', 2)
|
||
add_table(doc,
|
||
['Module', 'Description'],
|
||
[
|
||
['Authentification', 'Connexion sécurisée avec rôles différenciés (6 rôles)'],
|
||
['Articles', 'Gestion du catalogue : MP, Produits Semi-Finis, Produits Finis'],
|
||
['Clients & Fournisseurs', 'Annuaire des tiers commerciaux'],
|
||
['Cycle Achat', 'Commande fournisseur → Réception → Entrée en stock automatique'],
|
||
['Cycle Vente', 'Commande client → Livraison → Sortie de stock automatique'],
|
||
['Production', 'Nomenclatures BOM + Ordres de Fabrication (planif./lancement/clôture)'],
|
||
['Stock', 'Mouvements horodatés, historique complet, alertes seuil minimum'],
|
||
['Tableau de bord', 'KPIs temps réel réservés au PDG'],
|
||
],
|
||
col_widths=[5, 12]
|
||
)
|
||
|
||
doc.add_page_break()
|
||
|
||
|
||
# ════════════════════════════════════════════════════════════════════════════
|
||
# CHAPITRE 2 — ARCHITECTURE TECHNIQUE
|
||
# ════════════════════════════════════════════════════════════════════════════
|
||
|
||
styled_heading(doc, 'Chapitre 2 — Architecture Technique', 1)
|
||
separator(doc)
|
||
|
||
styled_heading(doc, '2.1 Stack Technologique', 2)
|
||
add_table(doc,
|
||
['Couche', 'Technologie', 'Version'],
|
||
[
|
||
['Backend API', 'Spring Boot', '3.2.5'],
|
||
['Langage', 'Java', '17 LTS'],
|
||
['Sécurité', 'Spring Security + JWT', 'JJWT 0.12.5'],
|
||
['Persistance', 'Spring Data JPA / Hibernate','6.4.4'],
|
||
['Base de données','MySQL', '8.0'],
|
||
['Conteneurisation','Docker + Docker Compose', '—'],
|
||
['Frontend', 'Flutter Web', '3.x'],
|
||
],
|
||
col_widths=[5, 8, 4]
|
||
)
|
||
|
||
styled_heading(doc, '2.2 Architecture N-Tiers', 2)
|
||
body(doc,
|
||
'L\'API suit rigoureusement le patron d\'architecture Controller → Service → Repository → Model. '
|
||
'Chaque couche a une responsabilité unique et clairement définie :')
|
||
add_table(doc,
|
||
['Couche', 'Rôle', 'Exemple'],
|
||
[
|
||
['Controller', 'Reçoit la requête HTTP, valide, délègue au service, retourne la réponse', 'ArticleController.java'],
|
||
['Service', 'Contient la logique métier : règles, validations, transactions', 'StockService.java'],
|
||
['Repository', 'Abstraction d\'accès à la base de données (Spring Data JPA)', 'ArticleRepository.java'],
|
||
['Model', 'Entités JPA mappées sur les tables MySQL', 'Article.java'],
|
||
],
|
||
col_widths=[4, 10, 5]
|
||
)
|
||
|
||
styled_heading(doc, '2.3 Sécurité — Authentification JWT', 2)
|
||
body(doc,
|
||
'Le système utilise une authentification stateless basée sur les JSON Web Tokens (RFC 7519). '
|
||
'Le flux d\'authentification est le suivant :')
|
||
steps = [
|
||
'1. Le client envoie ses identifiants à POST /api/auth/signin',
|
||
'2. Le serveur valide les credentials et retourne un JWT signé (valable 24 heures)',
|
||
'3. Le client inclut Authorization: Bearer <token> dans chaque requête suivante',
|
||
'4. Le filtre AuthTokenFilter intercepte et valide le token avant chaque endpoint sécurisé',
|
||
]
|
||
for s in steps:
|
||
body(doc, s, space_after=4)
|
||
|
||
doc.add_paragraph()
|
||
styled_heading(doc, '2.4 Rôles et Contrôle d\'Accès', 2)
|
||
add_table(doc,
|
||
['Rôle', 'Périmètre d\'accès'],
|
||
[
|
||
['ROLE_PDG', 'Accès complet à tous les modules + tableau de bord'],
|
||
['ROLE_RESPONSABLE_VENTE', 'Commandes clients, bons de livraison, clients'],
|
||
['ROLE_RESPONSABLE_ACHAT', 'Commandes fournisseurs, bons de réception, fournisseurs'],
|
||
['ROLE_RESPONSABLE_PRODUCTION', 'Nomenclatures BOM, ordres de fabrication'],
|
||
['ROLE_MAGASINIER', 'Mouvements de stock, ajustements, historique'],
|
||
['ROLE_RH', 'Ressources humaines (module à venir)'],
|
||
],
|
||
col_widths=[6, 11]
|
||
)
|
||
|
||
doc.add_page_break()
|
||
|
||
|
||
# ════════════════════════════════════════════════════════════════════════════
|
||
# CHAPITRE 3 — ENDPOINTS DE L'API
|
||
# ════════════════════════════════════════════════════════════════════════════
|
||
|
||
styled_heading(doc, 'Chapitre 3 — Endpoints de l\'API REST', 1)
|
||
separator(doc)
|
||
|
||
styled_heading(doc, '3.1 Authentification', 2)
|
||
add_table(doc,
|
||
['Méthode', 'URL', 'Description'],
|
||
[
|
||
['POST', '/api/auth/signin', 'Connexion — retourne un JWT Bearer'],
|
||
['POST', '/api/auth/signup', 'Créer un nouvel utilisateur'],
|
||
],
|
||
col_widths=[3, 6, 9]
|
||
)
|
||
|
||
styled_heading(doc, '3.2 Articles', 2)
|
||
add_table(doc,
|
||
['Méthode', 'URL', 'Rôles autorisés'],
|
||
[
|
||
['GET', '/api/articles', 'Tous'],
|
||
['GET', '/api/articles/{id}', 'Tous'],
|
||
['GET', '/api/articles/type/{type}', 'Tous — types : MP, PSF, PF'],
|
||
['GET', '/api/articles/alertes-stock', 'PDG, Magasinier, Production'],
|
||
['POST', '/api/articles', 'PDG, Production, Magasinier'],
|
||
['PUT', '/api/articles/{id}', 'PDG, Production'],
|
||
['DELETE', '/api/articles/{id}', 'PDG (désactivation logique)'],
|
||
],
|
||
col_widths=[3, 6.5, 7.5]
|
||
)
|
||
|
||
styled_heading(doc, '3.3 Clients & Fournisseurs', 2)
|
||
add_table(doc,
|
||
['Méthode', 'URL', 'Rôles autorisés'],
|
||
[
|
||
['GET', '/api/clients', 'PDG, Vente'],
|
||
['POST', '/api/clients', 'PDG, Vente'],
|
||
['PUT', '/api/clients/{id}', 'PDG, Vente'],
|
||
['GET', '/api/fournisseurs', 'PDG, Achat'],
|
||
['POST', '/api/fournisseurs', 'PDG, Achat'],
|
||
['PUT', '/api/fournisseurs/{id}', 'PDG, Achat'],
|
||
],
|
||
col_widths=[3, 6.5, 7.5]
|
||
)
|
||
|
||
styled_heading(doc, '3.4 Cycle d\'Achat', 2)
|
||
add_table(doc,
|
||
['Méthode', 'URL', 'Description'],
|
||
[
|
||
['GET', '/api/purchase-orders', 'Liste des commandes fournisseurs'],
|
||
['POST', '/api/purchase-orders', 'Créer une commande fournisseur'],
|
||
['POST', '/api/purchase-orders/{id}/receive', 'Réceptionner → crée BR + entre en stock'],
|
||
],
|
||
col_widths=[3, 7, 8]
|
||
)
|
||
|
||
styled_heading(doc, '3.5 Cycle de Vente', 2)
|
||
add_table(doc,
|
||
['Méthode', 'URL', 'Description'],
|
||
[
|
||
['GET', '/api/sales-orders', 'Liste des commandes clients'],
|
||
['POST', '/api/sales-orders', 'Créer une commande client'],
|
||
['POST', '/api/sales-orders/{id}/deliver', 'Livrer → crée BL + sort du stock'],
|
||
],
|
||
col_widths=[3, 7, 8]
|
||
)
|
||
|
||
styled_heading(doc, '3.6 Production', 2)
|
||
add_table(doc,
|
||
['Méthode', 'URL', 'Description'],
|
||
[
|
||
['GET', '/api/production/bom/{produitId}', 'Nomenclature d\'un produit fini'],
|
||
['POST', '/api/production/bom', 'Définir une ligne de nomenclature'],
|
||
['DELETE', '/api/production/bom/{id}', 'Supprimer une ligne BOM'],
|
||
['GET', '/api/production/orders', 'Liste des ordres de fabrication'],
|
||
['POST', '/api/production/orders/plan', 'Planifier un OF'],
|
||
['POST', '/api/production/orders/{id}/launch', 'Lancer un OF → consomme les MP'],
|
||
['POST', '/api/production/orders/{id}/complete','Clôturer un OF → entre les PF en stock'],
|
||
],
|
||
col_widths=[3, 8, 7]
|
||
)
|
||
|
||
styled_heading(doc, '3.7 Stock & Tableau de Bord', 2)
|
||
add_table(doc,
|
||
['Méthode', 'URL', 'Description'],
|
||
[
|
||
['GET', '/api/stock/historique/{articleId}', 'Historique des mouvements d\'un article'],
|
||
['POST', '/api/stock/adjust', 'Ajustement manuel du stock'],
|
||
['GET', '/api/dashboard', 'KPIs consolidés (PDG uniquement)'],
|
||
],
|
||
col_widths=[3, 7.5, 7.5]
|
||
)
|
||
|
||
doc.add_page_break()
|
||
|
||
|
||
# ════════════════════════════════════════════════════════════════════════════
|
||
# CHAPITRE 4 — DÉPLOIEMENT
|
||
# ════════════════════════════════════════════════════════════════════════════
|
||
|
||
styled_heading(doc, 'Chapitre 4 — Déploiement', 1)
|
||
separator(doc)
|
||
|
||
styled_heading(doc, '4.1 Infrastructure Docker', 2)
|
||
body(doc,
|
||
'L\'application est containerisée via Docker Compose. Deux conteneurs coexistent '
|
||
'dans un réseau Docker privé (rayhan-net) :')
|
||
add_table(doc,
|
||
['Conteneur', 'Image', 'Rôle'],
|
||
[
|
||
['rayhan-mysql', 'mysql:8.0', 'Base de données — rayhan_erp_db'],
|
||
['rayhan-backend', 'Build local Maven', 'API REST Spring Boot — port 8080 interne'],
|
||
],
|
||
col_widths=[4, 5, 9]
|
||
)
|
||
|
||
styled_heading(doc, '4.2 Build Multi-Étapes (Dockerfile)', 2)
|
||
body(doc,
|
||
'Le Dockerfile utilise un build multi-étapes pour minimiser la taille de l\'image finale. '
|
||
'L\'étape de build (Maven + JDK 17) produit le JAR exécutable ; l\'étape d\'exécution '
|
||
'utilise uniquement le JRE Alpine (image légère) :')
|
||
add_code_block(doc,
|
||
'# Étape 1 : Compilation Maven\n'
|
||
'FROM maven:3.9.6-eclipse-temurin-17 AS build\n'
|
||
'WORKDIR /app\n'
|
||
'COPY pom.xml .\n'
|
||
'RUN mvn dependency:go-offline\n'
|
||
'COPY src ./src\n'
|
||
'RUN mvn clean package -DskipTests\n\n'
|
||
'# Étape 2 : Image d\'exécution légère\n'
|
||
'FROM eclipse-temurin:17-jre-alpine\n'
|
||
'WORKDIR /app\n'
|
||
'COPY --from=build /app/target/erp-1.0.0-SNAPSHOT.jar app.jar\n'
|
||
'EXPOSE 8080\n'
|
||
'ENTRYPOINT ["java", "-jar", "app.jar"]'
|
||
)
|
||
|
||
styled_heading(doc, '4.3 Reverse Proxy HTTPS', 2)
|
||
body(doc,
|
||
'En production, un reverse proxy (Nginx ou Traefik) se place devant le conteneur backend. '
|
||
'Il prend en charge le certificat TLS et transmet les requêtes au port interne 8080. '
|
||
'Spring Boot est configuré pour reconnaître les headers X-Forwarded-Proto et X-Forwarded-For '
|
||
'via la propriété server.forward-headers-strategy=framework.')
|
||
add_table(doc,
|
||
['Environnement', 'URL d\'accès'],
|
||
[
|
||
['Production (HTTPS)', 'https://rayhan-erp.bolbol.tn'],
|
||
['Développement local', 'http://localhost:8090'],
|
||
['Documentation API', 'https://rayhan-erp.bolbol.tn/swagger-ui/index.html'],
|
||
],
|
||
col_widths=[5, 12]
|
||
)
|
||
|
||
doc.add_page_break()
|
||
|
||
|
||
# ════════════════════════════════════════════════════════════════════════════
|
||
# CHAPITRE 5 — TESTS ET VALIDATION
|
||
# ════════════════════════════════════════════════════════════════════════════
|
||
|
||
styled_heading(doc, 'Chapitre 5 — Tests et Validation', 1)
|
||
separator(doc)
|
||
|
||
styled_heading(doc, '5.1 Interface Swagger UI', 2)
|
||
body(doc,
|
||
'L\'API intègre Swagger UI (SpringDoc OpenAPI 2.5.0), une interface web interactive accessible '
|
||
'depuis n\'importe quel navigateur sans installation. Elle permet de visualiser tous les endpoints, '
|
||
'de s\'authentifier avec le JWT et de tester chaque fonctionnalité en un clic.')
|
||
body(doc, 'Procédure de connexion via Swagger UI :')
|
||
for s in [
|
||
'1. Ouvrir https://rayhan-erp.bolbol.tn/swagger-ui/index.html',
|
||
'2. Exécuter POST /api/auth/signin avec {"username":"admin","password":"Rayhan2024!"}',
|
||
'3. Copier la valeur du champ token dans la réponse JSON',
|
||
'4. Cliquer sur le bouton Authorize (cadenas) en haut de la page',
|
||
'5. Coller le token et cliquer Authorize — tous les endpoints sont maintenant accessibles',
|
||
]:
|
||
body(doc, s, space_after=3)
|
||
|
||
styled_heading(doc, '5.2 Scénario de Test Complet', 2)
|
||
body(doc, 'Le tableau suivant décrit le scénario de test de bout en bout validant les quatre cycles métier :')
|
||
add_table(doc,
|
||
['Étape', 'Action', 'Résultat attendu'],
|
||
[
|
||
['1', 'Connexion admin', 'Token JWT retourné'],
|
||
['2', 'Créer article MP-HDPE', 'Article créé, stock = 0'],
|
||
['3', 'Créer article PF-Sac Bertel', 'Article créé, stock = 0'],
|
||
['4', 'Créer commande fournisseur (1000 kg)', 'Statut CONFIRMEE, totalTTC calculé'],
|
||
['5', 'Réceptionner la commande', 'Stock HDPE = 1 000 kg'],
|
||
['6', 'Définir nomenclature BOM', '0,015 kg HDPE par Sac Bertel'],
|
||
['7', 'Planifier OF (10 000 unités)', 'Stock HDPE suffisant : 150 kg requis'],
|
||
['8', 'Lancer l\'OF', 'Stock HDPE = 850 kg (−150 kg consommés)'],
|
||
['9', 'Clôturer l\'OF', 'Stock Sac Bertel = 9 800 unités'],
|
||
['10', 'Créer commande client (5 000 unités)', 'Statut CONFIRMEE'],
|
||
['11', 'Livrer la commande', 'Stock Sac Bertel = 4 800 unités'],
|
||
['12', 'Consulter le tableau de bord', 'KPIs mis à jour en temps réel'],
|
||
],
|
||
col_widths=[1.5, 6, 9.5]
|
||
)
|
||
|
||
doc.add_page_break()
|
||
|
||
|
||
# ════════════════════════════════════════════════════════════════════════════
|
||
# CHAPITRE 6 — FRONTEND FLUTTER WEB
|
||
# ════════════════════════════════════════════════════════════════════════════
|
||
|
||
styled_heading(doc, 'Chapitre 6 — Frontend Flutter Web', 1)
|
||
separator(doc)
|
||
|
||
styled_heading(doc, '6.1 Choix Technologique', 2)
|
||
body(doc,
|
||
'Le frontend est développé avec Flutter Web, ce qui permet de produire une application web '
|
||
'moderne à partir d\'une unique base de code. L\'application sera containerisée dans Docker '
|
||
'et servie via Nginx, exactement comme le backend.')
|
||
|
||
styled_heading(doc, '6.2 Architecture Flutter', 2)
|
||
add_table(doc,
|
||
['Composant', 'Technologie', 'Rôle'],
|
||
[
|
||
['State management', 'Provider 6.x', 'Gestion de l\'état global (token, données chargées)'],
|
||
['HTTP client', 'Dio 5.x', 'Appels API avec intercepteur JWT automatique'],
|
||
['Stockage local', 'shared_preferences', 'Persistance du token JWT entre sessions'],
|
||
['Navigation', 'go_router 13.x', 'Routing déclaratif avec garde d\'authentification'],
|
||
['Graphiques', 'fl_chart', 'Graphiques pour le tableau de bord KPI'],
|
||
['Formatage', 'intl', 'Formatage des devises (TND) et des dates en français'],
|
||
],
|
||
col_widths=[4, 4, 9]
|
||
)
|
||
|
||
styled_heading(doc, '6.3 Écrans Réalisés', 2)
|
||
add_table(doc,
|
||
['Écran', 'Statut', 'Endpoints utilisés'],
|
||
[
|
||
['Login', '✅ Terminé', 'POST /api/auth/signin'],
|
||
['Tableau de bord', '✅ Terminé', 'GET /api/dashboard'],
|
||
['Articles', '✅ Terminé', 'GET/POST/PUT/DELETE /api/articles'],
|
||
['Commandes vente', '✅ Terminé', 'GET/POST /api/sales-orders + /deliver'],
|
||
['Commandes achat', '✅ Terminé', 'GET/POST /api/purchase-orders + /receive'],
|
||
['Production', '✅ Terminé', 'GET/POST /api/production/bom + /orders'],
|
||
['Stock & Historique', '✅ Terminé', 'GET /api/stock/historique + POST /adjust'],
|
||
],
|
||
col_widths=[4, 2.5, 10.5]
|
||
)
|
||
|
||
styled_heading(doc, '6.4 Fonctionnalités Clés du Frontend', 2)
|
||
for item in [
|
||
'Intercepteur JWT automatique : le token est injecté dans chaque requête HTTP sans code répétitif',
|
||
'Routing sécurisé : GoRouter redirige automatiquement vers /login si non authentifié',
|
||
'Calcul en temps réel HT/TVA/TTC dans les formulaires de commande',
|
||
'Vérification du stock disponible avant planification d\'un ordre de fabrication',
|
||
'Affichage dynamique de la nomenclature BOM lors de la sélection du produit',
|
||
'Ajustement manuel du stock avec traçabilité complète (motif, date, opérateur)',
|
||
'Barre de progression visuelle dans l\'écran stock (vert → rouge selon le niveau)',
|
||
'Pull-to-refresh sur toutes les listes pour actualiser les données',
|
||
]:
|
||
bullet(doc, item)
|
||
|
||
doc.add_page_break()
|
||
|
||
|
||
# ════════════════════════════════════════════════════════════════════════════
|
||
# ANNEXES
|
||
# ════════════════════════════════════════════════════════════════════════════
|
||
|
||
styled_heading(doc, 'Annexes', 1)
|
||
separator(doc)
|
||
|
||
styled_heading(doc, 'A — Modèle de Données Relationnel', 2)
|
||
body(doc, 'La base de données rayhan_erp_db contient les tables suivantes :')
|
||
add_table(doc,
|
||
['Table', 'Description'],
|
||
[
|
||
['users / roles / user_roles', 'Authentification et droits d\'accès'],
|
||
['tiers', 'Table mère (héritage JOINED) — données communes clients/fournisseurs'],
|
||
['clients', 'Extension de tiers : plafond crédit, délai paiement'],
|
||
['fournisseurs', 'Extension de tiers : pays, catégorie produit, délai livraison'],
|
||
['articles', 'Catalogue : référence, type MP/PSF/PF, stock actuel/minimum'],
|
||
['bom_lines', 'Nomenclatures : lien produit fini ↔ composant + quantité'],
|
||
['production_orders', 'Ordres de fabrication : PLANIFIE → LANCE → TERMINE'],
|
||
['purchase_orders / purchase_order_lines', 'Commandes fournisseurs et leurs lignes'],
|
||
['goods_receipts / goods_receipt_lines', 'Bons de réception'],
|
||
['sales_orders / sales_order_lines', 'Commandes clients et leurs lignes'],
|
||
['delivery_notes / delivery_note_lines', 'Bons de livraison'],
|
||
['stock_movements', 'Historique complet IN/OUT avec stockAvant/stockAprès'],
|
||
],
|
||
col_widths=[6, 11]
|
||
)
|
||
|
||
styled_heading(doc, 'B — Initialisation Automatique', 2)
|
||
body(doc,
|
||
'Au premier démarrage, la classe DataInitializer (CommandLineRunner Spring) crée automatiquement '
|
||
'les 6 rôles dans la base de données ainsi que l\'utilisateur administrateur par défaut :')
|
||
add_table(doc,
|
||
['Paramètre', 'Valeur'],
|
||
[
|
||
['Nom d\'utilisateur', 'admin'],
|
||
['Mot de passe', 'Rayhan2024!'],
|
||
['Rôle', 'ROLE_PDG (accès complet)'],
|
||
['Email', 'admin@rayhan.tn'],
|
||
],
|
||
col_widths=[5, 12]
|
||
)
|
||
|
||
styled_heading(doc, 'C — Commandes Docker Essentielles', 2)
|
||
add_code_block(doc,
|
||
'# Démarrer l\'application (première fois ou après modification)\n'
|
||
'docker compose up -d --build\n\n'
|
||
'# Démarrer sans rebuild\n'
|
||
'docker compose up -d\n\n'
|
||
'# Arrêter sans supprimer les données\n'
|
||
'docker compose down\n\n'
|
||
'# Voir les logs de l\'API en temps réel\n'
|
||
'docker logs rayhan-backend -f\n\n'
|
||
'# Accéder directement à MySQL\n'
|
||
'docker exec -it rayhan-mysql mysql -u root -prayhan_erp_2024 rayhan_erp_db'
|
||
)
|
||
|
||
|
||
# ── Sauvegarde ───────────────────────────────────────────────────────────────
|
||
output_path = 'Livrables/Rapport-ERP-Rayhan-Ali-Guennari.docx'
|
||
doc.save(output_path)
|
||
print(f'Document généré : {output_path}')
|