4317 lines
164 KiB
Python
4317 lines
164 KiB
Python
from fastapi import FastAPI, HTTPException, Header, Depends, Query
|
||
from fastapi.middleware.cors import CORSMiddleware
|
||
from pydantic import BaseModel, Field
|
||
from typing import Optional, List, Dict
|
||
from datetime import datetime, date
|
||
from enum import Enum
|
||
import uvicorn
|
||
import logging
|
||
import win32com.client
|
||
from config import settings, validate_settings
|
||
from sage_connector import SageConnector
|
||
|
||
# =====================================================
|
||
# LOGGING
|
||
# =====================================================
|
||
logging.basicConfig(
|
||
level=logging.INFO,
|
||
format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
|
||
handlers=[logging.FileHandler("sage_gateway.log"), logging.StreamHandler()],
|
||
)
|
||
logger = logging.getLogger(__name__)
|
||
|
||
|
||
# =====================================================
|
||
# ENUMS
|
||
# =====================================================
|
||
class TypeDocument(int, Enum):
|
||
DEVIS = 0
|
||
BON_LIVRAISON = 1
|
||
BON_RETOUR = 2
|
||
COMMANDE = 3
|
||
PREPARATION = 4
|
||
FACTURE = 5
|
||
|
||
|
||
# =====================================================
|
||
# MODÈLES
|
||
# =====================================================
|
||
|
||
|
||
class DocumentGetRequest(BaseModel):
|
||
numero: str
|
||
type_doc: int
|
||
|
||
|
||
class FiltreRequest(BaseModel):
|
||
filtre: Optional[str] = ""
|
||
|
||
|
||
class CodeRequest(BaseModel):
|
||
code: str
|
||
|
||
|
||
class ChampLibreRequest(BaseModel):
|
||
doc_id: str
|
||
type_doc: int
|
||
nom_champ: str
|
||
valeur: str
|
||
|
||
|
||
class DevisRequest(BaseModel):
|
||
client_id: str
|
||
date_devis: Optional[date] = None
|
||
lignes: List[
|
||
Dict
|
||
] # Format: {article_code, quantite, prix_unitaire_ht, remise_pourcentage}
|
||
|
||
|
||
class TransformationRequest(BaseModel):
|
||
numero_source: str
|
||
type_source: int
|
||
type_cible: int
|
||
|
||
|
||
class StatutRequest(BaseModel):
|
||
nouveau_statut: int
|
||
|
||
|
||
class ClientCreateRequest(BaseModel):
|
||
intitule: str = Field(..., description="Nom du client (CT_Intitule)")
|
||
compte_collectif: str = Field("411000", description="Compte général rattaché")
|
||
num: Optional[str] = Field(None, description="Laisser vide pour numérotation auto")
|
||
adresse: Optional[str] = None
|
||
code_postal: Optional[str] = None
|
||
ville: Optional[str] = None
|
||
pays: Optional[str] = None
|
||
email: Optional[str] = None
|
||
telephone: Optional[str] = None
|
||
siret: Optional[str] = None
|
||
tva_intra: Optional[str] = None
|
||
|
||
class ClientUpdateGatewayRequest(BaseModel):
|
||
"""Modèle pour modification client côté gateway"""
|
||
code: str
|
||
client_data: Dict
|
||
|
||
class FournisseurCreateRequest(BaseModel):
|
||
intitule: str = Field(..., description="Raison sociale du fournisseur")
|
||
compte_collectif: str = Field("401000", description="Compte général rattaché")
|
||
num: Optional[str] = Field(None, description="Code fournisseur (auto si vide)")
|
||
adresse: Optional[str] = None
|
||
code_postal: Optional[str] = None
|
||
ville: Optional[str] = None
|
||
pays: Optional[str] = None
|
||
email: Optional[str] = None
|
||
telephone: Optional[str] = None
|
||
siret: Optional[str] = None
|
||
tva_intra: Optional[str] = None
|
||
|
||
|
||
class FournisseurCreateRequest(BaseModel):
|
||
intitule: str = Field(..., description="Raison sociale du fournisseur")
|
||
compte_collectif: str = Field("401000", description="Compte général rattaché")
|
||
num: Optional[str] = Field(None, description="Code fournisseur (auto si vide)")
|
||
adresse: Optional[str] = None
|
||
code_postal: Optional[str] = None
|
||
ville: Optional[str] = None
|
||
pays: Optional[str] = None
|
||
email: Optional[str] = None
|
||
telephone: Optional[str] = None
|
||
siret: Optional[str] = None
|
||
tva_intra: Optional[str] = None
|
||
|
||
|
||
class FournisseurUpdateGatewayRequest(BaseModel):
|
||
"""Modèle pour modification fournisseur côté gateway"""
|
||
code: str
|
||
fournisseur_data: Dict
|
||
|
||
class DevisUpdateGatewayRequest(BaseModel):
|
||
"""Modèle pour modification devis côté gateway"""
|
||
numero: str
|
||
devis_data: Dict
|
||
|
||
|
||
class CommandeCreateRequest(BaseModel):
|
||
"""Création d'une commande"""
|
||
client_id: str
|
||
date_commande: Optional[date] = None
|
||
reference: Optional[str] = None
|
||
lignes: List[Dict]
|
||
|
||
|
||
class CommandeUpdateGatewayRequest(BaseModel):
|
||
"""Modèle pour modification commande côté gateway"""
|
||
numero: str
|
||
commande_data: Dict
|
||
|
||
|
||
# =====================================================
|
||
# SÉCURITÉ
|
||
# =====================================================
|
||
def verify_token(x_sage_token: str = Header(...)):
|
||
"""Vérification du token d'authentification"""
|
||
if x_sage_token != settings.sage_gateway_token:
|
||
logger.warning(f"❌ Token invalide reçu: {x_sage_token[:20]}...")
|
||
raise HTTPException(401, "Token invalide")
|
||
return True
|
||
|
||
|
||
# =====================================================
|
||
# APPLICATION
|
||
# =====================================================
|
||
app = FastAPI(
|
||
title="Sage Gateway - Windows Server",
|
||
version="1.0.0",
|
||
description="Passerelle d'accès à Sage 100c pour VPS Linux",
|
||
)
|
||
|
||
app.add_middleware(
|
||
CORSMiddleware,
|
||
allow_origins=settings.cors_origins,
|
||
allow_methods=["*"],
|
||
allow_headers=["*"],
|
||
allow_credentials=True,
|
||
)
|
||
|
||
sage: Optional[SageConnector] = None
|
||
|
||
|
||
# =====================================================
|
||
# LIFECYCLE
|
||
# =====================================================
|
||
@app.on_event("startup")
|
||
def startup():
|
||
global sage
|
||
|
||
logger.info("🚀 Démarrage Sage Gateway Windows...")
|
||
|
||
# Validation config
|
||
try:
|
||
validate_settings()
|
||
logger.info("✅ Configuration validée")
|
||
except ValueError as e:
|
||
logger.error(f"❌ Configuration invalide: {e}")
|
||
raise
|
||
|
||
# Connexion Sage
|
||
sage = SageConnector(
|
||
settings.chemin_base, settings.utilisateur, settings.mot_de_passe
|
||
)
|
||
|
||
if not sage.connecter():
|
||
raise RuntimeError("❌ Impossible de se connecter à Sage 100c")
|
||
|
||
logger.info("✅ Sage Gateway démarré et connecté")
|
||
|
||
|
||
@app.on_event("shutdown")
|
||
def shutdown():
|
||
if sage:
|
||
sage.deconnecter()
|
||
logger.info("👋 Sage Gateway arrêté")
|
||
|
||
|
||
# =====================================================
|
||
# ENDPOINTS - SYSTÈME
|
||
# =====================================================
|
||
@app.get("/health")
|
||
def health():
|
||
"""Health check"""
|
||
return {
|
||
"status": "ok",
|
||
"sage_connected": sage is not None and sage.cial is not None,
|
||
"cache_info": sage.get_cache_info() if sage else None,
|
||
"timestamp": datetime.now().isoformat(),
|
||
}
|
||
|
||
|
||
# =====================================================
|
||
# ENDPOINTS - CLIENTS
|
||
# =====================================================
|
||
@app.post("/sage/clients/list", dependencies=[Depends(verify_token)])
|
||
def clients_list(req: FiltreRequest):
|
||
"""Liste des clients avec filtre optionnel"""
|
||
try:
|
||
clients = sage.lister_tous_clients(req.filtre)
|
||
return {"success": True, "data": clients}
|
||
except Exception as e:
|
||
logger.error(f"Erreur liste clients: {e}")
|
||
raise HTTPException(500, str(e))
|
||
|
||
@app.post("/sage/clients/update", dependencies=[Depends(verify_token)])
|
||
def modifier_client_endpoint(req: ClientUpdateGatewayRequest):
|
||
"""
|
||
✏️ Modification d'un client dans Sage
|
||
"""
|
||
try:
|
||
resultat = sage.modifier_client(req.code, req.client_data)
|
||
return {"success": True, "data": resultat}
|
||
|
||
except ValueError as e:
|
||
logger.warning(f"Erreur métier modification client: {e}")
|
||
raise HTTPException(404, str(e))
|
||
except Exception as e:
|
||
logger.error(f"Erreur technique modification client: {e}")
|
||
raise HTTPException(500, str(e))
|
||
|
||
@app.post("/sage/clients/get", dependencies=[Depends(verify_token)])
|
||
def client_get(req: CodeRequest):
|
||
"""Lecture d'un client par code"""
|
||
try:
|
||
client = sage.lire_client(req.code)
|
||
if not client:
|
||
raise HTTPException(404, f"Client {req.code} non trouvé")
|
||
return {"success": True, "data": client}
|
||
except HTTPException:
|
||
raise
|
||
except Exception as e:
|
||
logger.error(f"Erreur lecture client: {e}")
|
||
raise HTTPException(500, str(e))
|
||
|
||
|
||
# DANS main.py
|
||
@app.post("/sage/clients/create", dependencies=[Depends(verify_token)])
|
||
def create_client_endpoint(req: ClientCreateRequest):
|
||
"""Création d'un client dans Sage"""
|
||
try:
|
||
# L'appel au connecteur est fait ici
|
||
resultat = sage.creer_client(req.dict())
|
||
return {"success": True, "data": resultat}
|
||
except ValueError as e:
|
||
logger.warning(f"Erreur métier création client: {e}")
|
||
# Erreur métier (ex: doublon) -> 400 Bad Request
|
||
raise HTTPException(400, str(e))
|
||
except Exception as e:
|
||
logger.error(f"Erreur technique création client: {e}")
|
||
# Erreur technique (ex: COM) -> 500 Internal Server Error
|
||
raise HTTPException(500, str(e))
|
||
|
||
# =====================================================
|
||
# ENDPOINTS - ARTICLES
|
||
# =====================================================
|
||
@app.post("/sage/articles/list", dependencies=[Depends(verify_token)])
|
||
def articles_list(req: FiltreRequest):
|
||
"""Liste des articles avec filtre optionnel"""
|
||
try:
|
||
articles = sage.lister_tous_articles(req.filtre)
|
||
return {"success": True, "data": articles}
|
||
except Exception as e:
|
||
logger.error(f"Erreur liste articles: {e}")
|
||
raise HTTPException(500, str(e))
|
||
|
||
|
||
@app.post("/sage/articles/get", dependencies=[Depends(verify_token)])
|
||
def article_get(req: CodeRequest):
|
||
"""Lecture d'un article par référence"""
|
||
try:
|
||
article = sage.lire_article(req.code)
|
||
if not article:
|
||
raise HTTPException(404, f"Article {req.code} non trouvé")
|
||
return {"success": True, "data": article}
|
||
except HTTPException:
|
||
raise
|
||
except Exception as e:
|
||
logger.error(f"Erreur lecture article: {e}")
|
||
raise HTTPException(500, str(e))
|
||
|
||
|
||
# =====================================================
|
||
# ENDPOINTS - DEVIS
|
||
# =====================================================
|
||
@app.post("/sage/devis/create", dependencies=[Depends(verify_token)])
|
||
def creer_devis(req: DevisRequest):
|
||
"""Création d'un devis"""
|
||
try:
|
||
# Transformer en format attendu par sage_connector
|
||
devis_data = {
|
||
"client": {"code": req.client_id, "intitule": ""},
|
||
"date_devis": req.date_devis or date.today(),
|
||
"lignes": req.lignes,
|
||
}
|
||
|
||
resultat = sage.creer_devis_enrichi(devis_data)
|
||
return {"success": True, "data": resultat}
|
||
except Exception as e:
|
||
logger.error(f"Erreur création devis: {e}")
|
||
raise HTTPException(500, str(e))
|
||
|
||
|
||
@app.post("/sage/devis/get", dependencies=[Depends(verify_token)])
|
||
def lire_devis(req: CodeRequest):
|
||
"""Lecture d'un devis"""
|
||
try:
|
||
devis = sage.lire_devis(req.code)
|
||
if not devis:
|
||
raise HTTPException(404, f"Devis {req.code} non trouvé")
|
||
return {"success": True, "data": devis}
|
||
except HTTPException:
|
||
raise
|
||
except Exception as e:
|
||
logger.error(f"Erreur lecture devis: {e}")
|
||
raise HTTPException(500, str(e))
|
||
|
||
|
||
@app.post("/sage/devis/list", dependencies=[Depends(verify_token)])
|
||
def devis_list(
|
||
limit: int = 100, statut: Optional[int] = None, inclure_lignes: bool = Query(True)
|
||
):
|
||
"""
|
||
📋 Liste tous les devis avec filtres optionnels
|
||
|
||
Args:
|
||
limit: Nombre max de devis à retourner
|
||
statut: Filtre par statut (optionnel)
|
||
inclure_lignes: Si True, charge les lignes de chaque devis (par défaut: True)
|
||
|
||
✅ AMÉLIORATION: Charge maintenant les lignes de chaque devis
|
||
"""
|
||
try:
|
||
if not sage or not sage.cial:
|
||
raise HTTPException(503, "Service Sage indisponible")
|
||
|
||
with sage._com_context(), sage._lock_com:
|
||
factory = sage.cial.FactoryDocumentVente
|
||
devis_list = []
|
||
index = 1
|
||
max_iterations = limit * 3
|
||
erreurs_consecutives = 0
|
||
max_erreurs = 50
|
||
|
||
logger.info(
|
||
f"🔍 Recherche devis (limit={limit}, statut={statut}, inclure_lignes={inclure_lignes})"
|
||
)
|
||
|
||
while (
|
||
len(devis_list) < limit
|
||
and index < max_iterations
|
||
and erreurs_consecutives < max_erreurs
|
||
):
|
||
try:
|
||
persist = factory.List(index)
|
||
if persist is None:
|
||
logger.debug(f"Fin de liste à l'index {index}")
|
||
break
|
||
|
||
doc = win32com.client.CastTo(persist, "IBODocumentVente3")
|
||
doc.Read()
|
||
|
||
# Filtrer uniquement devis (type 0)
|
||
doc_type = getattr(doc, "DO_Type", -1)
|
||
if doc_type != 0:
|
||
index += 1
|
||
continue
|
||
|
||
doc_statut = getattr(doc, "DO_Statut", 0)
|
||
|
||
# Filtre statut
|
||
if statut is not None and doc_statut != statut:
|
||
index += 1
|
||
continue
|
||
|
||
# ✅ Charger client via .Client
|
||
client_code = ""
|
||
client_intitule = ""
|
||
|
||
try:
|
||
client_obj = getattr(doc, "Client", None)
|
||
if client_obj:
|
||
client_obj.Read()
|
||
client_code = getattr(client_obj, "CT_Num", "").strip()
|
||
client_intitule = getattr(
|
||
client_obj, "CT_Intitule", ""
|
||
).strip()
|
||
logger.debug(
|
||
f"✅ Client: {client_code} - {client_intitule}"
|
||
)
|
||
except Exception as e:
|
||
logger.debug(f"Erreur chargement client: {e}")
|
||
# Fallback sur cache si code disponible
|
||
if client_code:
|
||
client_cache = sage.lire_client(client_code)
|
||
if client_cache:
|
||
client_intitule = client_cache.get("intitule", "")
|
||
|
||
# ✅✅ NOUVEAU: Charger les lignes si demandé
|
||
lignes = []
|
||
if inclure_lignes:
|
||
try:
|
||
factory_lignes = getattr(doc, "FactoryDocumentLigne", None)
|
||
if not factory_lignes:
|
||
factory_lignes = getattr(
|
||
doc, "FactoryDocumentVenteLigne", None
|
||
)
|
||
|
||
if factory_lignes:
|
||
ligne_index = 1
|
||
while ligne_index <= 100: # Max 100 lignes par devis
|
||
try:
|
||
ligne_persist = factory_lignes.List(ligne_index)
|
||
if ligne_persist is None:
|
||
break
|
||
|
||
ligne = win32com.client.CastTo(
|
||
ligne_persist, "IBODocumentLigne3"
|
||
)
|
||
ligne.Read()
|
||
|
||
# Charger référence article
|
||
article_ref = ""
|
||
try:
|
||
article_ref = getattr(
|
||
ligne, "AR_Ref", ""
|
||
).strip()
|
||
if not article_ref:
|
||
article_obj = getattr(
|
||
ligne, "Article", None
|
||
)
|
||
if article_obj:
|
||
article_obj.Read()
|
||
article_ref = getattr(
|
||
article_obj, "AR_Ref", ""
|
||
).strip()
|
||
except:
|
||
pass
|
||
|
||
lignes.append(
|
||
{
|
||
"article": article_ref,
|
||
"designation": getattr(
|
||
ligne, "DL_Design", ""
|
||
),
|
||
"quantite": float(
|
||
getattr(ligne, "DL_Qte", 0.0)
|
||
),
|
||
"prix_unitaire": float(
|
||
getattr(
|
||
ligne, "DL_PrixUnitaire", 0.0
|
||
)
|
||
),
|
||
"montant_ht": float(
|
||
getattr(ligne, "DL_MontantHT", 0.0)
|
||
),
|
||
}
|
||
)
|
||
|
||
ligne_index += 1
|
||
except Exception as e:
|
||
logger.debug(f"Erreur ligne {ligne_index}: {e}")
|
||
break
|
||
except Exception as e:
|
||
logger.debug(f"Erreur chargement lignes: {e}")
|
||
|
||
devis_list.append(
|
||
{
|
||
"numero": getattr(doc, "DO_Piece", ""),
|
||
"date": str(getattr(doc, "DO_Date", "")),
|
||
"client_code": client_code,
|
||
"client_intitule": client_intitule,
|
||
"total_ht": float(getattr(doc, "DO_TotalHT", 0.0)),
|
||
"total_ttc": float(getattr(doc, "DO_TotalTTC", 0.0)),
|
||
"statut": doc_statut,
|
||
"lignes": lignes, # ✅ Lignes incluses
|
||
}
|
||
)
|
||
|
||
erreurs_consecutives = 0
|
||
index += 1
|
||
|
||
except Exception as e:
|
||
erreurs_consecutives += 1
|
||
logger.debug(f"⚠️ Erreur index {index}: {e}")
|
||
index += 1
|
||
|
||
if erreurs_consecutives >= max_erreurs:
|
||
logger.warning(
|
||
f"⚠️ Arrêt après {max_erreurs} erreurs consécutives"
|
||
)
|
||
break
|
||
|
||
nb_avec_client = sum(1 for d in devis_list if d["client_intitule"])
|
||
nb_avec_lignes = sum(1 for d in devis_list if d.get("lignes"))
|
||
logger.info(
|
||
f"✅ {len(devis_list)} devis retournés "
|
||
f"({nb_avec_client} avec client, {nb_avec_lignes} avec lignes)"
|
||
)
|
||
|
||
return {"success": True, "data": devis_list}
|
||
|
||
except HTTPException:
|
||
raise
|
||
except Exception as e:
|
||
logger.error(f"❌ Erreur liste devis: {e}", exc_info=True)
|
||
raise HTTPException(500, str(e))
|
||
|
||
|
||
@app.post("/sage/devis/statut", dependencies=[Depends(verify_token)])
|
||
def changer_statut_devis_endpoint(numero: str, nouveau_statut: int):
|
||
"""Change le statut d'un devis"""
|
||
try:
|
||
with sage._com_context(), sage._lock_com:
|
||
factory = sage.cial.FactoryDocumentVente
|
||
persist = factory.ReadPiece(0, numero)
|
||
|
||
if not persist:
|
||
raise HTTPException(404, f"Devis {numero} introuvable")
|
||
|
||
doc = win32com.client.CastTo(persist, "IBODocumentVente3")
|
||
doc.Read()
|
||
|
||
statut_actuel = getattr(doc, "DO_Statut", 0)
|
||
doc.DO_Statut = nouveau_statut
|
||
doc.Write()
|
||
|
||
logger.info(f"✅ Statut devis {numero}: {statut_actuel} → {nouveau_statut}")
|
||
|
||
return {
|
||
"success": True,
|
||
"data": {
|
||
"numero": numero,
|
||
"statut_ancien": statut_actuel,
|
||
"statut_nouveau": nouveau_statut,
|
||
},
|
||
}
|
||
except HTTPException:
|
||
raise
|
||
except Exception as e:
|
||
logger.error(f"Erreur changement statut: {e}")
|
||
raise HTTPException(500, str(e))
|
||
|
||
|
||
# =====================================================
|
||
# ENDPOINTS - DOCUMENTS
|
||
# =====================================================
|
||
@app.post("/sage/documents/get", dependencies=[Depends(verify_token)])
|
||
def lire_document(req: DocumentGetRequest):
|
||
"""Lecture d'un document (commande, facture, etc.)"""
|
||
try:
|
||
doc = sage.lire_document(req.numero, req.type_doc)
|
||
if not doc:
|
||
raise HTTPException(404, f"Document {req.numero} non trouvé")
|
||
return {"success": True, "data": doc}
|
||
except HTTPException:
|
||
raise
|
||
except Exception as e:
|
||
logger.error(f"Erreur lecture document: {e}")
|
||
raise HTTPException(500, str(e))
|
||
|
||
|
||
@app.post("/sage/documents/transform", dependencies=[Depends(verify_token)])
|
||
def transformer_document(
|
||
numero_source: str = Query(..., description="Numéro du document source"),
|
||
type_source: int = Query(..., description="Type document source"),
|
||
type_cible: int = Query(..., description="Type document cible"),
|
||
):
|
||
"""
|
||
🔧 Transformation de document
|
||
|
||
✅ CORRECTION : Utilise les VRAIS types Sage Dataven
|
||
|
||
Types valides :
|
||
- 0: Devis
|
||
- 10: Bon de commande
|
||
- 20: Préparation
|
||
- 30: Bon de livraison
|
||
- 40: Bon de retour
|
||
- 50: Bon d'avoir
|
||
- 60: Facture
|
||
|
||
Transformations autorisées :
|
||
- Devis (0) → Commande (10)
|
||
- Commande (10) → Bon livraison (30)
|
||
- Commande (10) → Facture (60)
|
||
- Bon livraison (30) → Facture (60)
|
||
"""
|
||
try:
|
||
logger.info(
|
||
f"🔄 Transformation demandée: {numero_source} "
|
||
f"(type {type_source}) → type {type_cible}"
|
||
)
|
||
|
||
# ✅ Matrice des transformations valides pour VOTRE Sage
|
||
transformations_valides = {
|
||
(0, 10), # Devis → Commande
|
||
(10, 30), # Commande → Bon de livraison
|
||
(10, 60), # Commande → Facture
|
||
(30, 60), # Bon de livraison → Facture
|
||
(0, 60), # Devis → Facture (si autorisé)
|
||
}
|
||
|
||
if (type_source, type_cible) not in transformations_valides:
|
||
logger.error(
|
||
f"❌ Transformation non autorisée: {type_source} → {type_cible}"
|
||
)
|
||
raise HTTPException(
|
||
400,
|
||
f"Transformation non autorisée: type {type_source} → type {type_cible}. "
|
||
f"Transformations valides: {transformations_valides}",
|
||
)
|
||
|
||
# Appel au connecteur Sage
|
||
resultat = sage.transformer_document(numero_source, type_source, type_cible)
|
||
|
||
logger.info(
|
||
f"✅ Transformation réussie: {numero_source} → "
|
||
f"{resultat.get('document_cible', '?')} "
|
||
f"({resultat.get('nb_lignes', 0)} lignes)"
|
||
)
|
||
|
||
return {"success": True, "data": resultat}
|
||
|
||
except HTTPException:
|
||
raise
|
||
except ValueError as e:
|
||
logger.error(f"❌ Erreur métier transformation: {e}")
|
||
raise HTTPException(400, str(e))
|
||
except Exception as e:
|
||
logger.error(f"❌ Erreur technique transformation: {e}", exc_info=True)
|
||
raise HTTPException(500, f"Erreur transformation: {str(e)}")
|
||
|
||
|
||
@app.post("/sage/documents/champ-libre", dependencies=[Depends(verify_token)])
|
||
def maj_champ_libre(req: ChampLibreRequest):
|
||
"""Mise à jour d'un champ libre"""
|
||
try:
|
||
success = sage.mettre_a_jour_champ_libre(
|
||
req.doc_id, req.type_doc, req.nom_champ, req.valeur
|
||
)
|
||
return {"success": success}
|
||
except Exception as e:
|
||
logger.error(f"Erreur MAJ champ libre: {e}")
|
||
raise HTTPException(500, str(e))
|
||
|
||
|
||
@app.post("/sage/documents/derniere-relance", dependencies=[Depends(verify_token)])
|
||
def maj_derniere_relance(doc_id: str, type_doc: int):
|
||
"""📅 Met à jour le champ 'Dernière relance' d'un document"""
|
||
try:
|
||
success = sage.mettre_a_jour_derniere_relance(doc_id, type_doc)
|
||
return {"success": success}
|
||
except Exception as e:
|
||
logger.error(f"Erreur MAJ dernière relance: {e}")
|
||
raise HTTPException(500, str(e))
|
||
|
||
|
||
# =====================================================
|
||
# ENDPOINTS - CONTACTS
|
||
# =====================================================
|
||
@app.post("/sage/contact/read", dependencies=[Depends(verify_token)])
|
||
def contact_read(req: CodeRequest):
|
||
"""Lecture du contact principal d'un client"""
|
||
try:
|
||
contact = sage.lire_contact_principal_client(req.code)
|
||
if not contact:
|
||
raise HTTPException(404, f"Contact non trouvé pour client {req.code}")
|
||
return {"success": True, "data": contact}
|
||
except HTTPException:
|
||
raise
|
||
except Exception as e:
|
||
logger.error(f"Erreur lecture contact: {e}")
|
||
raise HTTPException(500, str(e))
|
||
|
||
|
||
@app.post("/sage/commandes/list", dependencies=[Depends(verify_token)])
|
||
def commandes_list(limit: int = 100, statut: Optional[int] = None):
|
||
"""
|
||
📋 Liste toutes les commandes
|
||
✅ AJOUT: Retourne maintenant DO_Ref pour tracer les transformations
|
||
"""
|
||
try:
|
||
if not sage or not sage.cial:
|
||
raise HTTPException(503, "Service Sage indisponible")
|
||
|
||
with sage._com_context(), sage._lock_com:
|
||
factory = sage.cial.FactoryDocumentVente
|
||
commandes = []
|
||
index = 1
|
||
max_iterations = limit * 10
|
||
erreurs_consecutives = 0
|
||
max_erreurs = 100
|
||
|
||
logger.info(f"🔍 Recherche commandes (limit={limit}, statut={statut})")
|
||
|
||
while (
|
||
len(commandes) < limit
|
||
and index < max_iterations
|
||
and erreurs_consecutives < max_erreurs
|
||
):
|
||
try:
|
||
persist = factory.List(index)
|
||
if persist is None:
|
||
break
|
||
|
||
doc = win32com.client.CastTo(persist, "IBODocumentVente3")
|
||
doc.Read()
|
||
|
||
doc_type = getattr(doc, "DO_Type", -1)
|
||
|
||
# Filtrer sur type 10 (BON_COMMANDE)
|
||
if doc_type != settings.SAGE_TYPE_BON_COMMANDE:
|
||
index += 1
|
||
continue
|
||
|
||
doc_statut = getattr(doc, "DO_Statut", 0)
|
||
|
||
# Filtre statut
|
||
if statut is not None and doc_statut != statut:
|
||
index += 1
|
||
continue
|
||
|
||
# Charger client
|
||
client_code = ""
|
||
client_intitule = ""
|
||
|
||
try:
|
||
client_obj = getattr(doc, "Client", None)
|
||
if client_obj:
|
||
client_obj.Read()
|
||
client_code = getattr(client_obj, "CT_Num", "").strip()
|
||
client_intitule = getattr(
|
||
client_obj, "CT_Intitule", ""
|
||
).strip()
|
||
except Exception as e:
|
||
logger.debug(f"Erreur chargement client: {e}")
|
||
|
||
commande = {
|
||
"numero": getattr(doc, "DO_Piece", ""),
|
||
"reference": getattr(doc, "DO_Ref", ""), # ✅ AJOUT
|
||
"date": str(getattr(doc, "DO_Date", "")),
|
||
"client_code": client_code,
|
||
"client_intitule": client_intitule,
|
||
"total_ht": float(getattr(doc, "DO_TotalHT", 0.0)),
|
||
"total_ttc": float(getattr(doc, "DO_TotalTTC", 0.0)),
|
||
"statut": doc_statut,
|
||
}
|
||
|
||
commandes.append(commande)
|
||
erreurs_consecutives = 0
|
||
index += 1
|
||
|
||
except Exception as e:
|
||
erreurs_consecutives += 1
|
||
index += 1
|
||
|
||
if erreurs_consecutives >= max_erreurs:
|
||
break
|
||
|
||
logger.info(f"✅ {len(commandes)} commandes retournées")
|
||
|
||
return {"success": True, "data": commandes}
|
||
|
||
except HTTPException:
|
||
raise
|
||
except Exception as e:
|
||
logger.error(f"❌ Erreur liste commandes: {e}", exc_info=True)
|
||
raise HTTPException(500, str(e))
|
||
|
||
|
||
@app.post("/sage/factures/list", dependencies=[Depends(verify_token)])
|
||
def factures_list(limit: int = 100, statut: Optional[int] = None):
|
||
"""
|
||
📋 Liste toutes les factures avec leurs lignes
|
||
✅ AJOUT: Retourne maintenant DO_Ref pour tracer les transformations
|
||
"""
|
||
try:
|
||
with sage._com_context(), sage._lock_com:
|
||
factory = sage.cial.FactoryDocumentVente
|
||
factures = []
|
||
index = 1
|
||
max_iterations = limit * 3
|
||
|
||
while len(factures) < limit and index < max_iterations:
|
||
try:
|
||
persist = factory.List(index)
|
||
if persist is None:
|
||
break
|
||
|
||
doc = win32com.client.CastTo(persist, "IBODocumentVente3")
|
||
doc.Read()
|
||
|
||
# Filtrer factures (type 60)
|
||
if getattr(doc, "DO_Type", -1) != settings.SAGE_TYPE_FACTURE:
|
||
index += 1
|
||
continue
|
||
|
||
doc_statut = getattr(doc, "DO_Statut", 0)
|
||
|
||
if statut is None or doc_statut == statut:
|
||
# Charger client
|
||
client_code = ""
|
||
client_intitule = ""
|
||
|
||
try:
|
||
client_obj = getattr(doc, "Client", None)
|
||
if client_obj:
|
||
client_obj.Read()
|
||
client_code = getattr(client_obj, "CT_Num", "").strip()
|
||
client_intitule = getattr(client_obj, "CT_Intitule", "").strip()
|
||
except:
|
||
pass
|
||
|
||
# Charger les lignes
|
||
lignes = []
|
||
try:
|
||
factory_lignes = getattr(doc, "FactoryDocumentLigne", None)
|
||
if not factory_lignes:
|
||
factory_lignes = getattr(doc, "FactoryDocumentVenteLigne", None)
|
||
|
||
if factory_lignes:
|
||
ligne_index = 1
|
||
while ligne_index <= 100:
|
||
try:
|
||
ligne_persist = factory_lignes.List(ligne_index)
|
||
if ligne_persist is None:
|
||
break
|
||
|
||
ligne = win32com.client.CastTo(ligne_persist, "IBODocumentLigne3")
|
||
ligne.Read()
|
||
|
||
# Charger référence article
|
||
article_ref = ""
|
||
try:
|
||
article_ref = getattr(ligne, "AR_Ref", "").strip()
|
||
if not article_ref:
|
||
article_obj = getattr(ligne, "Article", None)
|
||
if article_obj:
|
||
article_obj.Read()
|
||
article_ref = getattr(article_obj, "AR_Ref", "").strip()
|
||
except:
|
||
pass
|
||
|
||
lignes.append({
|
||
"article": article_ref,
|
||
"designation": getattr(ligne, "DL_Design", ""),
|
||
"quantite": float(getattr(ligne, "DL_Qte", 0.0)),
|
||
"prix_unitaire": float(getattr(ligne, "DL_PrixUnitaire", 0.0)),
|
||
"montant_ht": float(getattr(ligne, "DL_MontantHT", 0.0))
|
||
})
|
||
|
||
ligne_index += 1
|
||
except Exception as e:
|
||
logger.debug(f"Erreur ligne {ligne_index}: {e}")
|
||
break
|
||
except Exception as e:
|
||
logger.debug(f"Erreur chargement lignes: {e}")
|
||
|
||
factures.append({
|
||
"numero": getattr(doc, "DO_Piece", ""),
|
||
"reference": getattr(doc, "DO_Ref", ""), # ✅ AJOUT
|
||
"date": str(getattr(doc, "DO_Date", "")),
|
||
"client_code": client_code,
|
||
"client_intitule": client_intitule,
|
||
"total_ht": float(getattr(doc, "DO_TotalHT", 0.0)),
|
||
"total_ttc": float(getattr(doc, "DO_TotalTTC", 0.0)),
|
||
"statut": doc_statut,
|
||
"lignes": lignes
|
||
})
|
||
|
||
index += 1
|
||
except:
|
||
index += 1
|
||
continue
|
||
|
||
logger.info(f"✅ {len(factures)} factures retournées")
|
||
return {"success": True, "data": factures}
|
||
|
||
except Exception as e:
|
||
logger.error(f"Erreur liste factures: {e}")
|
||
raise HTTPException(500, str(e))
|
||
|
||
@app.post("/sage/client/remise-max", dependencies=[Depends(verify_token)])
|
||
def lire_remise_max_client(code: str):
|
||
"""Récupère la remise max autorisée pour un client"""
|
||
try:
|
||
client_obj = sage._lire_client_obj(code)
|
||
|
||
if not client_obj:
|
||
raise HTTPException(404, f"Client {code} introuvable")
|
||
|
||
remise_max = 10.0 # Défaut
|
||
|
||
try:
|
||
remise_max = float(getattr(client_obj, "CT_RemiseMax", 10.0))
|
||
except:
|
||
pass
|
||
|
||
logger.info(f"✅ Remise max client {code}: {remise_max}%")
|
||
|
||
return {
|
||
"success": True,
|
||
"data": {"client_code": code, "remise_max": remise_max},
|
||
}
|
||
|
||
except HTTPException:
|
||
raise
|
||
except Exception as e:
|
||
logger.error(f"Erreur lecture remise: {e}")
|
||
raise HTTPException(500, str(e))
|
||
|
||
|
||
# =====================================================
|
||
# ENDPOINTS - ADMIN
|
||
# =====================================================
|
||
@app.post("/sage/cache/refresh", dependencies=[Depends(verify_token)])
|
||
def refresh_cache():
|
||
"""Force le rafraîchissement du cache"""
|
||
try:
|
||
sage.forcer_actualisation_cache()
|
||
return {
|
||
"success": True,
|
||
"message": "Cache actualisé",
|
||
"info": sage.get_cache_info(),
|
||
}
|
||
except Exception as e:
|
||
logger.error(f"Erreur refresh cache: {e}")
|
||
raise HTTPException(500, str(e))
|
||
|
||
|
||
@app.get("/sage/cache/info", dependencies=[Depends(verify_token)])
|
||
def cache_info_get():
|
||
"""Informations sur le cache (endpoint GET)"""
|
||
try:
|
||
return {"success": True, "data": sage.get_cache_info()}
|
||
except Exception as e:
|
||
logger.error(f"Erreur info cache: {e}")
|
||
raise HTTPException(500, str(e))
|
||
|
||
|
||
# Script à ajouter temporairement dans main.py pour diagnostiquer
|
||
|
||
|
||
@app.get("/sage/devis/{numero}/diagnostic", dependencies=[Depends(verify_token)])
|
||
def diagnostiquer_devis(numero: str):
|
||
"""
|
||
ENDPOINT DE DIAGNOSTIC: Affiche TOUTES les infos d'un devis
|
||
|
||
Permet de comprendre pourquoi un devis ne peut pas être transformé
|
||
"""
|
||
try:
|
||
if not sage or not sage.cial:
|
||
raise HTTPException(503, "Service Sage indisponible")
|
||
|
||
with sage._com_context(), sage._lock_com:
|
||
factory = sage.cial.FactoryDocumentVente
|
||
|
||
# Essayer ReadPiece
|
||
persist = factory.ReadPiece(0, numero)
|
||
|
||
# Si échec, chercher dans List()
|
||
if not persist:
|
||
logger.info(f"[DIAG] ReadPiece echoue, recherche dans List()...")
|
||
index = 1
|
||
while index < 10000:
|
||
try:
|
||
persist_test = factory.List(index)
|
||
if persist_test is None:
|
||
break
|
||
|
||
doc_test = win32com.client.CastTo(
|
||
persist_test, "IBODocumentVente3"
|
||
)
|
||
doc_test.Read()
|
||
|
||
if (
|
||
getattr(doc_test, "DO_Type", -1) == 0
|
||
and getattr(doc_test, "DO_Piece", "") == numero
|
||
):
|
||
persist = persist_test
|
||
logger.info(f"[DIAG] Trouve a l'index {index}")
|
||
break
|
||
|
||
index += 1
|
||
except:
|
||
index += 1
|
||
|
||
if not persist:
|
||
raise HTTPException(404, f"Devis {numero} introuvable")
|
||
|
||
doc = win32com.client.CastTo(persist, "IBODocumentVente3")
|
||
doc.Read()
|
||
|
||
# EXTRACTION COMPLÈTE
|
||
diagnostic = {
|
||
"numero": getattr(doc, "DO_Piece", ""),
|
||
"type": getattr(doc, "DO_Type", -1),
|
||
"statut": getattr(doc, "DO_Statut", -1),
|
||
"statut_libelle": {
|
||
0: "Brouillon",
|
||
1: "Soumis",
|
||
2: "Accepte",
|
||
3: "Realise partiellement",
|
||
4: "Realise totalement",
|
||
5: "Transforme",
|
||
6: "Annule",
|
||
}.get(getattr(doc, "DO_Statut", -1), "Inconnu"),
|
||
"date": str(getattr(doc, "DO_Date", "")),
|
||
"total_ht": float(getattr(doc, "DO_TotalHT", 0.0)),
|
||
"total_ttc": float(getattr(doc, "DO_TotalTTC", 0.0)),
|
||
"est_transformable": False,
|
||
"raison_blocage": None,
|
||
}
|
||
|
||
# Client
|
||
try:
|
||
client_obj = getattr(doc, "Client", None)
|
||
if client_obj:
|
||
client_obj.Read()
|
||
diagnostic["client_code"] = getattr(
|
||
client_obj, "CT_Num", ""
|
||
).strip()
|
||
diagnostic["client_intitule"] = getattr(
|
||
client_obj, "CT_Intitule", ""
|
||
).strip()
|
||
except Exception as e:
|
||
diagnostic["erreur_client"] = str(e)
|
||
|
||
# Lignes
|
||
try:
|
||
factory_lignes = doc.FactoryDocumentLigne
|
||
except:
|
||
factory_lignes = doc.FactoryDocumentVenteLigne
|
||
|
||
lignes = []
|
||
index = 1
|
||
while index <= 100:
|
||
try:
|
||
ligne_p = factory_lignes.List(index)
|
||
if ligne_p is None:
|
||
break
|
||
|
||
ligne = win32com.client.CastTo(ligne_p, "IBODocumentLigne3")
|
||
ligne.Read()
|
||
|
||
article_ref = ""
|
||
try:
|
||
article_ref = getattr(ligne, "AR_Ref", "").strip()
|
||
if not article_ref:
|
||
article_obj = getattr(ligne, "Article", None)
|
||
if article_obj:
|
||
article_obj.Read()
|
||
article_ref = getattr(article_obj, "AR_Ref", "").strip()
|
||
except:
|
||
pass
|
||
|
||
lignes.append(
|
||
{
|
||
"index": index,
|
||
"article": article_ref,
|
||
"designation": getattr(ligne, "DL_Design", ""),
|
||
"quantite": float(getattr(ligne, "DL_Qte", 0.0)),
|
||
"prix_unitaire": float(
|
||
getattr(ligne, "DL_PrixUnitaire", 0.0)
|
||
),
|
||
"montant_ht": float(getattr(ligne, "DL_MontantHT", 0.0)),
|
||
}
|
||
)
|
||
|
||
index += 1
|
||
except:
|
||
break
|
||
|
||
diagnostic["nb_lignes"] = len(lignes)
|
||
diagnostic["lignes"] = lignes
|
||
|
||
# ANALYSE TRANSFORMABILITÉ
|
||
statut = diagnostic["statut"]
|
||
|
||
if statut == 5:
|
||
diagnostic["raison_blocage"] = "Document deja transforme (statut=5)"
|
||
elif statut == 6:
|
||
diagnostic["raison_blocage"] = "Document annule (statut=6)"
|
||
elif statut in [3, 4]:
|
||
diagnostic["raison_blocage"] = (
|
||
f"Document deja realise partiellement ou totalement (statut={statut}). "
|
||
f"Une commande/BL/facture existe probablement deja."
|
||
)
|
||
diagnostic["suggestion"] = (
|
||
"Cherchez les documents lies a ce devis dans Sage. "
|
||
"Il a peut-etre deja ete transforme manuellement."
|
||
)
|
||
elif statut == 0:
|
||
diagnostic["est_transformable"] = True
|
||
diagnostic["action_requise"] = (
|
||
"Statut 'Brouillon'. Le systeme le passera automatiquement a 'Accepte' "
|
||
"avant transformation."
|
||
)
|
||
elif statut == 2:
|
||
diagnostic["est_transformable"] = True
|
||
diagnostic["action_requise"] = (
|
||
"Statut 'Accepte'. Transformation possible."
|
||
)
|
||
else:
|
||
diagnostic["raison_blocage"] = f"Statut inconnu ou non gere: {statut}"
|
||
|
||
# Champs libres (pour Universign, etc.)
|
||
champs_libres = {}
|
||
try:
|
||
for champ in ["UniversignID", "DerniereRelance", "DO_Ref"]:
|
||
try:
|
||
valeur = getattr(doc, f"DO_{champ}", None)
|
||
if valeur:
|
||
champs_libres[champ] = str(valeur)
|
||
except:
|
||
pass
|
||
except:
|
||
pass
|
||
|
||
if champs_libres:
|
||
diagnostic["champs_libres"] = champs_libres
|
||
|
||
logger.info(
|
||
f"[DIAG] Devis {numero}: statut={statut}, transformable={diagnostic['est_transformable']}"
|
||
)
|
||
|
||
return {"success": True, "diagnostic": diagnostic}
|
||
|
||
except HTTPException:
|
||
raise
|
||
except Exception as e:
|
||
logger.error(f"[DIAG] Erreur diagnostic: {e}", exc_info=True)
|
||
raise HTTPException(500, str(e))
|
||
|
||
|
||
@app.get("/sage/diagnostic/configuration", dependencies=[Depends(verify_token)])
|
||
def diagnostic_configuration():
|
||
"""
|
||
DIAGNOSTIC COMPLET de la configuration Sage
|
||
|
||
Teste:
|
||
- Quelles méthodes COM sont disponibles
|
||
- Quels types de documents sont autorisés
|
||
- Quelles permissions l'utilisateur a
|
||
- Version de Sage
|
||
"""
|
||
try:
|
||
if not sage or not sage.cial:
|
||
raise HTTPException(503, "Service Sage indisponible")
|
||
|
||
with sage._com_context(), sage._lock_com:
|
||
diagnostic = {
|
||
"connexion": "OK",
|
||
"chemin_base": sage.chemin_base,
|
||
"utilisateur": sage.utilisateur,
|
||
}
|
||
|
||
# Version Sage
|
||
try:
|
||
version = getattr(sage.cial, "Version", "Inconnue")
|
||
diagnostic["version_sage"] = str(version)
|
||
except:
|
||
diagnostic["version_sage"] = "Non disponible"
|
||
|
||
# Test des méthodes disponibles sur IBSCIALApplication3
|
||
methodes_disponibles = []
|
||
methodes_a_tester = [
|
||
"CreateProcess_Document",
|
||
"FactoryDocumentVente",
|
||
"FactoryArticle",
|
||
"CptaApplication",
|
||
"BeginTrans",
|
||
"CommitTrans",
|
||
"RollbackTrans",
|
||
]
|
||
|
||
for methode in methodes_a_tester:
|
||
try:
|
||
if hasattr(sage.cial, methode):
|
||
methodes_disponibles.append(methode)
|
||
except:
|
||
pass
|
||
|
||
diagnostic["methodes_cial_disponibles"] = methodes_disponibles
|
||
|
||
# Test des types de documents autorisés
|
||
types_autorises = []
|
||
types_bloques = []
|
||
|
||
for type_doc in range(6): # 0-5
|
||
try:
|
||
# Essayer de créer un process (sans le valider)
|
||
process = sage.cial.CreateProcess_Document(type_doc)
|
||
if process:
|
||
types_autorises.append(
|
||
{
|
||
"type": type_doc,
|
||
"libelle": {
|
||
0: "Devis",
|
||
1: "Bon de livraison",
|
||
2: "Bon de retour",
|
||
3: "Commande",
|
||
4: "Preparation",
|
||
5: "Facture",
|
||
}[type_doc],
|
||
}
|
||
)
|
||
# Ne pas valider, juste tester
|
||
del process
|
||
except Exception as e:
|
||
types_bloques.append(
|
||
{
|
||
"type": type_doc,
|
||
"libelle": {
|
||
0: "Devis",
|
||
1: "Bon de livraison",
|
||
2: "Bon de retour",
|
||
3: "Commande",
|
||
4: "Preparation",
|
||
5: "Facture",
|
||
}[type_doc],
|
||
"erreur": str(e)[:200],
|
||
}
|
||
)
|
||
|
||
diagnostic["types_documents_autorises"] = types_autorises
|
||
diagnostic["types_documents_bloques"] = types_bloques
|
||
|
||
# Test TransformInto() sur un devis test
|
||
try:
|
||
factory = sage.cial.FactoryDocumentVente
|
||
|
||
# Chercher n'importe quel devis
|
||
index = 1
|
||
devis_test = None
|
||
|
||
while index < 100:
|
||
try:
|
||
persist = factory.List(index)
|
||
if persist is None:
|
||
break
|
||
|
||
doc = win32com.client.CastTo(persist, "IBODocumentVente3")
|
||
doc.Read()
|
||
|
||
if getattr(doc, "DO_Type", -1) == 0: # Devis
|
||
devis_test = doc
|
||
break
|
||
|
||
index += 1
|
||
except:
|
||
index += 1
|
||
|
||
if devis_test:
|
||
# Tester si TransformInto existe
|
||
if hasattr(devis_test, "TransformInto"):
|
||
diagnostic["transforminto_disponible"] = True
|
||
diagnostic["transforminto_test"] = "Methode existe (non testee)"
|
||
else:
|
||
diagnostic["transforminto_disponible"] = False
|
||
diagnostic["transforminto_test"] = (
|
||
"Methode TransformInto() inexistante"
|
||
)
|
||
else:
|
||
diagnostic["transforminto_disponible"] = (
|
||
"Impossible de tester (aucun devis trouve)"
|
||
)
|
||
|
||
except Exception as e:
|
||
diagnostic["transforminto_disponible"] = False
|
||
diagnostic["transforminto_erreur"] = str(e)
|
||
|
||
# Modules Sage actifs
|
||
try:
|
||
# Tester l'accès aux différentes factories
|
||
modules = {}
|
||
|
||
try:
|
||
sage.cial.FactoryDocumentVente
|
||
modules["Ventes"] = "OK"
|
||
except:
|
||
modules["Ventes"] = "INACCESSIBLE"
|
||
|
||
try:
|
||
sage.cial.CptaApplication.FactoryClient
|
||
modules["Clients"] = "OK"
|
||
except:
|
||
modules["Clients"] = "INACCESSIBLE"
|
||
|
||
try:
|
||
sage.cial.FactoryArticle
|
||
modules["Articles"] = "OK"
|
||
except:
|
||
modules["Articles"] = "INACCESSIBLE"
|
||
|
||
diagnostic["modules_actifs"] = modules
|
||
except Exception as e:
|
||
diagnostic["modules_actifs_erreur"] = str(e)
|
||
|
||
# Compter documents existants
|
||
try:
|
||
counts = {}
|
||
factory = sage.cial.FactoryDocumentVente
|
||
|
||
for type_doc in range(6):
|
||
count = 0
|
||
index = 1
|
||
|
||
while index < 1000:
|
||
try:
|
||
persist = factory.List(index)
|
||
if persist is None:
|
||
break
|
||
|
||
doc = win32com.client.CastTo(persist, "IBODocumentVente3")
|
||
doc.Read()
|
||
|
||
if getattr(doc, "DO_Type", -1) == type_doc:
|
||
count += 1
|
||
|
||
index += 1
|
||
except:
|
||
index += 1
|
||
break
|
||
|
||
counts[
|
||
{
|
||
0: "Devis",
|
||
1: "Bons_livraison",
|
||
2: "Bons_retour",
|
||
3: "Commandes",
|
||
4: "Preparations",
|
||
5: "Factures",
|
||
}[type_doc]
|
||
] = count
|
||
|
||
diagnostic["documents_existants"] = counts
|
||
except Exception as e:
|
||
diagnostic["documents_existants_erreur"] = str(e)
|
||
|
||
logger.info("[DIAG] Configuration Sage analysee")
|
||
|
||
return {"success": True, "diagnostic": diagnostic}
|
||
|
||
except HTTPException:
|
||
raise
|
||
except Exception as e:
|
||
logger.error(f"[DIAG] Erreur diagnostic config: {e}", exc_info=True)
|
||
raise HTTPException(500, str(e))
|
||
|
||
|
||
@app.get("/sage/diagnostic/types-reels", dependencies=[Depends(verify_token)])
|
||
def decouvrir_types_reels():
|
||
"""
|
||
DIAGNOSTIC CRITIQUE: Découvre les VRAIS types de documents Sage
|
||
|
||
Au lieu de deviner les types (0-5), on va:
|
||
1. Créer manuellement un document de chaque type dans Sage
|
||
2. Les lister ici pour voir leurs vrais numéros de type
|
||
"""
|
||
try:
|
||
if not sage or not sage.cial:
|
||
raise HTTPException(503, "Service Sage indisponible")
|
||
|
||
with sage._com_context(), sage._lock_com:
|
||
factory = sage.cial.FactoryDocumentVente
|
||
|
||
# Parcourir TOUS les documents
|
||
documents_par_type = {}
|
||
index = 1
|
||
max_docs = 500 # Limiter pour ne pas bloquer
|
||
|
||
logger.info("[DIAG] Scan de tous les documents...")
|
||
|
||
while index < max_docs:
|
||
try:
|
||
persist = factory.List(index)
|
||
if persist is None:
|
||
break
|
||
|
||
doc = win32com.client.CastTo(persist, "IBODocumentVente3")
|
||
doc.Read()
|
||
|
||
# Récupérer le type ET le sous-type
|
||
type_doc = getattr(doc, "DO_Type", -1)
|
||
piece = getattr(doc, "DO_Piece", "")
|
||
statut = getattr(doc, "DO_Statut", -1)
|
||
|
||
# Essayer de récupérer le domaine (vente/achat)
|
||
domaine = "Inconnu"
|
||
try:
|
||
domaine_val = getattr(doc, "DO_Domaine", -1)
|
||
domaine = {0: "Vente", 1: "Achat"}.get(
|
||
domaine_val, f"Code {domaine_val}"
|
||
)
|
||
except:
|
||
pass
|
||
|
||
# Récupérer la catégorie
|
||
categorie = "Inconnue"
|
||
try:
|
||
cat_val = getattr(doc, "DO_Categorie", -1)
|
||
categorie = str(cat_val)
|
||
except:
|
||
pass
|
||
|
||
# Grouper par type
|
||
if type_doc not in documents_par_type:
|
||
documents_par_type[type_doc] = {
|
||
"count": 0,
|
||
"exemples": [],
|
||
"domaine": domaine,
|
||
"categorie": categorie,
|
||
}
|
||
|
||
documents_par_type[type_doc]["count"] += 1
|
||
|
||
# Garder quelques exemples
|
||
if len(documents_par_type[type_doc]["exemples"]) < 3:
|
||
documents_par_type[type_doc]["exemples"].append(
|
||
{
|
||
"numero": piece,
|
||
"statut": statut,
|
||
"domaine": domaine,
|
||
"categorie": categorie,
|
||
}
|
||
)
|
||
|
||
index += 1
|
||
|
||
except Exception as e:
|
||
logger.debug(f"Erreur index {index}: {e}")
|
||
index += 1
|
||
|
||
# Formater le résultat
|
||
types_trouves = []
|
||
|
||
for type_num, infos in sorted(documents_par_type.items()):
|
||
types_trouves.append(
|
||
{
|
||
"type_code": type_num,
|
||
"nombre_documents": infos["count"],
|
||
"domaine": infos["domaine"],
|
||
"categorie": infos["categorie"],
|
||
"exemples": infos["exemples"],
|
||
"suggestion_libelle": _deviner_libelle_type(
|
||
type_num, infos["exemples"]
|
||
),
|
||
}
|
||
)
|
||
|
||
logger.info(
|
||
f"[DIAG] {len(types_trouves)} types de documents distincts trouves"
|
||
)
|
||
|
||
return {
|
||
"success": True,
|
||
"types_documents_reels": types_trouves,
|
||
"instructions": (
|
||
"Pour identifier les types corrects:\n"
|
||
"1. Creez manuellement dans Sage: 1 Bon de commande, 1 BL, 1 Facture\n"
|
||
"2. Appelez de nouveau cet endpoint\n"
|
||
"3. Les nouveaux types apparaitront avec leurs numeros corrects"
|
||
),
|
||
"total_documents_scannes": index - 1,
|
||
}
|
||
|
||
except Exception as e:
|
||
logger.error(f"[DIAG] Erreur decouverte types: {e}", exc_info=True)
|
||
raise HTTPException(500, str(e))
|
||
|
||
|
||
def _deviner_libelle_type(type_num, exemples):
|
||
"""Devine le libellé d'un type basé sur les numéros de pièce"""
|
||
if not exemples:
|
||
return "Type inconnu"
|
||
|
||
# Analyser les préfixes des numéros
|
||
prefixes = [ex["numero"][:2] for ex in exemples if ex["numero"]]
|
||
prefix_commun = max(set(prefixes), key=prefixes.count) if prefixes else ""
|
||
|
||
# Deviner selon le type_num et les préfixes
|
||
suggestions = {
|
||
0: "Devis (DE)",
|
||
1: "Bon de livraison (BL)",
|
||
2: "Bon de retour (BR)",
|
||
3: "Bon de commande (BC)",
|
||
4: "Preparation de livraison (PL)",
|
||
5: "Facture (FA)",
|
||
6: "Facture d'avoir (AV)",
|
||
7: "Bon d'avoir financier (BA)",
|
||
}
|
||
|
||
libelle_base = suggestions.get(type_num, f"Type {type_num}")
|
||
|
||
if prefix_commun:
|
||
libelle_base += f" - Detecte: prefix '{prefix_commun}'"
|
||
|
||
return libelle_base
|
||
|
||
|
||
@app.post("/sage/test-creation-par-type", dependencies=[Depends(verify_token)])
|
||
def tester_creation_par_type(type_doc: int = Query(..., ge=0, le=20)):
|
||
"""
|
||
TEST: Essaie de créer un document d'un type spécifique
|
||
|
||
Permet de tester tous les types possibles (0-20) pour trouver
|
||
lesquels fonctionnent sur votre installation
|
||
"""
|
||
try:
|
||
if not sage or not sage.cial:
|
||
raise HTTPException(503, "Service Sage indisponible")
|
||
|
||
with sage._com_context(), sage._lock_com:
|
||
logger.info(f"[TEST] Tentative creation type {type_doc}...")
|
||
|
||
try:
|
||
# Essayer de créer un process
|
||
process = sage.cial.CreateProcess_Document(type_doc)
|
||
|
||
if not process:
|
||
return {
|
||
"success": False,
|
||
"type": type_doc,
|
||
"resultat": "Process NULL retourne",
|
||
}
|
||
|
||
# Si on arrive ici, le type est valide !
|
||
doc = process.Document
|
||
|
||
try:
|
||
doc = win32com.client.CastTo(doc, "IBODocumentVente3")
|
||
except:
|
||
pass
|
||
|
||
# Récupérer les infos du document créé
|
||
type_reel = getattr(doc, "DO_Type", -1)
|
||
domaine = getattr(doc, "DO_Domaine", -1)
|
||
|
||
# NE PAS VALIDER le document (pas de Write/Process)
|
||
# On veut juste savoir si la création est possible
|
||
|
||
del process
|
||
del doc
|
||
|
||
return {
|
||
"success": True,
|
||
"type_demande": type_doc,
|
||
"type_reel_doc": type_reel,
|
||
"domaine": {0: "Vente", 1: "Achat"}.get(domaine, domaine),
|
||
"resultat": "CREATION POSSIBLE",
|
||
"note": "Document non valide (test uniquement)",
|
||
}
|
||
|
||
except Exception as e:
|
||
return {
|
||
"success": False,
|
||
"type": type_doc,
|
||
"erreur": str(e),
|
||
"resultat": "CREATION IMPOSSIBLE",
|
||
}
|
||
|
||
except Exception as e:
|
||
logger.error(f"[TEST] Erreur test type {type_doc}: {e}")
|
||
raise HTTPException(500, str(e))
|
||
|
||
|
||
@app.get("/sage/diagnostic/facture-requirements", dependencies=[Depends(verify_token)])
|
||
def diagnostiquer_exigences_facture():
|
||
"""
|
||
DIAGNOSTIC: Découvre les champs obligatoires pour créer une facture
|
||
"""
|
||
try:
|
||
if not sage or not sage.cial:
|
||
raise HTTPException(503, "Service Sage indisponible")
|
||
|
||
with sage._com_context(), sage._lock_com:
|
||
# Créer un process facture de test
|
||
process = sage.cial.CreateProcess_Document(60)
|
||
doc_test = process.Document
|
||
|
||
try:
|
||
doc_test = win32com.client.CastTo(doc_test, "IBODocumentVente3")
|
||
except:
|
||
pass
|
||
|
||
# Tester tous les champs potentiellement obligatoires
|
||
champs_a_tester = [
|
||
"DO_ModeRegl",
|
||
"DO_CondRegl",
|
||
"DO_CodeJournal",
|
||
"DO_Souche",
|
||
"DO_TypeCalcul",
|
||
"DO_CodeTaxe1",
|
||
"CT_Num",
|
||
"DO_Date",
|
||
"DO_Statut",
|
||
]
|
||
|
||
resultats = {}
|
||
|
||
for champ in champs_a_tester:
|
||
try:
|
||
valeur = getattr(doc_test, champ, None)
|
||
resultats[champ] = {
|
||
"valeur_defaut": str(valeur) if valeur is not None else "None",
|
||
"accessible": True,
|
||
}
|
||
except Exception as e:
|
||
resultats[champ] = {
|
||
"valeur_defaut": "N/A",
|
||
"accessible": False,
|
||
"erreur": str(e)[:100],
|
||
}
|
||
|
||
# Ne pas valider le document de test
|
||
del process
|
||
del doc_test
|
||
|
||
return {
|
||
"success": True,
|
||
"champs_facture": resultats,
|
||
"conseil": "Les champs avec valeur_defaut=None ou 0 sont souvent obligatoires",
|
||
}
|
||
|
||
except Exception as e:
|
||
logger.error(f"[DIAG] Erreur: {e}", exc_info=True)
|
||
raise HTTPException(500, str(e))
|
||
|
||
|
||
@app.post("/sage/test/creer-facture-vide", dependencies=[Depends(verify_token)])
|
||
def tester_creation_facture_vide():
|
||
"""
|
||
🧪 TEST: Crée une facture vide pour identifier les champs obligatoires
|
||
|
||
Ce test permet de découvrir EXACTEMENT quels champs Sage exige
|
||
"""
|
||
try:
|
||
if not sage or not sage.cial:
|
||
raise HTTPException(503, "Service Sage indisponible")
|
||
|
||
with sage._com_context(), sage._lock_com:
|
||
logger.info("[TEST] Creation facture test...")
|
||
|
||
# 1. Créer le process
|
||
process = sage.cial.CreateProcess_Document(60)
|
||
doc = process.Document
|
||
|
||
try:
|
||
doc = win32com.client.CastTo(doc, "IBODocumentVente3")
|
||
except:
|
||
pass
|
||
|
||
# 2. Définir UNIQUEMENT les champs absolument critiques
|
||
import pywintypes
|
||
|
||
# Date (obligatoire)
|
||
doc.DO_Date = pywintypes.Time(datetime.now())
|
||
|
||
# Client (obligatoire) - Utiliser le premier client disponible
|
||
factory_client = sage.cial.CptaApplication.FactoryClient
|
||
persist_client = factory_client.List(1)
|
||
|
||
if persist_client:
|
||
client = sage._cast_client(persist_client)
|
||
if client:
|
||
doc.SetDefaultClient(client)
|
||
client_code = getattr(client, "CT_Num", "?")
|
||
logger.info(f"[TEST] Client test: {client_code}")
|
||
|
||
# 3. Écrire sans Process() pour voir les valeurs par défaut
|
||
doc.Write()
|
||
doc.Read()
|
||
|
||
# 4. Analyser tous les champs
|
||
champs_analyse = {}
|
||
|
||
for attr in dir(doc):
|
||
if attr.startswith("DO_") or attr.startswith("CT_"):
|
||
try:
|
||
valeur = getattr(doc, attr, None)
|
||
if valeur is not None:
|
||
champs_analyse[attr] = {
|
||
"valeur": str(valeur),
|
||
"type": type(valeur).__name__,
|
||
}
|
||
except:
|
||
pass
|
||
|
||
logger.info(f"[TEST] {len(champs_analyse)} champs analyses")
|
||
|
||
# 5. Tester Process() pour voir l'erreur exacte
|
||
erreur_process = None
|
||
try:
|
||
process.Process()
|
||
logger.info("[TEST] Process() reussi (inattendu!)")
|
||
except Exception as e:
|
||
erreur_process = str(e)
|
||
logger.info(f"[TEST] Process() echoue comme prevu: {e}")
|
||
|
||
# Ne pas commit - c'est juste un test
|
||
try:
|
||
sage.cial.CptaApplication.RollbackTrans()
|
||
except:
|
||
pass
|
||
|
||
return {
|
||
"success": True,
|
||
"champs_definis": champs_analyse,
|
||
"erreur_process": erreur_process,
|
||
"conseil": "Les champs manquants dans l'erreur sont probablement obligatoires",
|
||
}
|
||
|
||
except Exception as e:
|
||
logger.error(f"[TEST] Erreur: {e}", exc_info=True)
|
||
raise HTTPException(500, str(e))
|
||
|
||
|
||
@app.get("/sage/config/parametres-facture", dependencies=[Depends(verify_token)])
|
||
def verifier_parametres_facture():
|
||
"""
|
||
🔍 Vérifie les paramètres Sage pour la création de factures
|
||
"""
|
||
try:
|
||
if not sage or not sage.cial:
|
||
raise HTTPException(503, "Service Sage indisponible")
|
||
|
||
with sage._com_context(), sage._lock_com:
|
||
parametres = {}
|
||
|
||
# Paramètres société
|
||
try:
|
||
param_societe = sage.cial.CptaApplication.ParametreSociete
|
||
|
||
parametres["societe"] = {
|
||
"journal_vente_defaut": getattr(
|
||
param_societe, "P_CodeJournalVte", "N/A"
|
||
),
|
||
"mode_reglement_defaut": getattr(
|
||
param_societe, "P_ModeRegl", "N/A"
|
||
),
|
||
"souche_facture": getattr(param_societe, "P_SoucheFacture", "N/A"),
|
||
}
|
||
except Exception as e:
|
||
parametres["erreur_societe"] = str(e)
|
||
|
||
# Tester un client existant
|
||
try:
|
||
factory_client = sage.cial.CptaApplication.FactoryClient
|
||
persist = factory_client.List(1)
|
||
|
||
if persist:
|
||
client = sage._cast_client(persist)
|
||
if client:
|
||
parametres["exemple_client"] = {
|
||
"code": getattr(client, "CT_Num", "?"),
|
||
"mode_reglement": getattr(client, "CT_ModeRegl", "N/A"),
|
||
"conditions_reglement": getattr(
|
||
client, "CT_CondRegl", "N/A"
|
||
),
|
||
}
|
||
except Exception as e:
|
||
parametres["erreur_client"] = str(e)
|
||
|
||
# Journaux disponibles
|
||
try:
|
||
factory_journal = sage.cial.CptaApplication.FactoryJournal
|
||
journaux = []
|
||
|
||
index = 1
|
||
while index <= 20: # Max 20 journaux
|
||
try:
|
||
persist_journal = factory_journal.List(index)
|
||
if persist_journal is None:
|
||
break
|
||
|
||
# Cast en journal
|
||
journal = win32com.client.CastTo(persist_journal, "IBOJournal3")
|
||
journal.Read()
|
||
|
||
journaux.append(
|
||
{
|
||
"code": getattr(journal, "JO_Num", "?"),
|
||
"intitule": getattr(journal, "JO_Intitule", "?"),
|
||
"type": getattr(journal, "JO_Type", "?"),
|
||
}
|
||
)
|
||
|
||
index += 1
|
||
except:
|
||
index += 1
|
||
break
|
||
|
||
parametres["journaux_disponibles"] = journaux
|
||
|
||
except Exception as e:
|
||
parametres["erreur_journaux"] = str(e)
|
||
|
||
return {
|
||
"success": True,
|
||
"parametres": parametres,
|
||
"conseil": "Utilisez ces valeurs pour remplir les champs obligatoires des factures",
|
||
}
|
||
|
||
except Exception as e:
|
||
logger.error(f"Erreur verification config: {e}", exc_info=True)
|
||
raise HTTPException(500, str(e))
|
||
|
||
|
||
@app.get("/sage/diagnostic/statuts-globaux", dependencies=[Depends(verify_token)])
|
||
def diagnostiquer_statuts_globaux():
|
||
"""
|
||
📊 MATRICE COMPLÈTE DES STATUTS SAGE
|
||
|
||
Retourne pour CHAQUE type de document :
|
||
- Tous les statuts possibles avec leurs descriptions
|
||
- Les statuts requis pour transformation
|
||
- Les changements de statuts après transformation
|
||
- Les restrictions de changement de statut
|
||
|
||
Cette route analyse la base Sage pour découvrir les règles réelles
|
||
"""
|
||
try:
|
||
if not sage or not sage.cial:
|
||
raise HTTPException(503, "Service Sage indisponible")
|
||
|
||
with sage._com_context(), sage._lock_com:
|
||
factory = sage.cial.FactoryDocumentVente
|
||
|
||
# Définition des types de documents
|
||
types_documents = {
|
||
0: "Devis",
|
||
10: "Bon de commande",
|
||
20: "Préparation",
|
||
30: "Bon de livraison",
|
||
40: "Bon de retour",
|
||
50: "Bon d'avoir",
|
||
60: "Facture",
|
||
}
|
||
|
||
# Descriptions standard des statuts Sage
|
||
descriptions_statuts = {
|
||
0: "Brouillon",
|
||
1: "Soumis/En attente",
|
||
2: "Accepté/Validé",
|
||
3: "Réalisé partiellement",
|
||
4: "Réalisé totalement",
|
||
5: "Transformé",
|
||
6: "Annulé",
|
||
}
|
||
|
||
matrice_complete = {}
|
||
|
||
logger.info(
|
||
"[DIAG] 🔍 Analyse des statuts pour tous les types de documents..."
|
||
)
|
||
|
||
# Pour chaque type de document
|
||
for type_doc, libelle_type in types_documents.items():
|
||
logger.info(f"[DIAG] Analyse type {type_doc} ({libelle_type})...")
|
||
|
||
analyse_type = {
|
||
"type": type_doc,
|
||
"libelle": libelle_type,
|
||
"statuts_observes": {},
|
||
"exemples_par_statut": {},
|
||
"nb_documents_total": 0,
|
||
}
|
||
|
||
# Scanner tous les documents de ce type
|
||
index = 1
|
||
max_scan = 1000
|
||
|
||
while index < max_scan:
|
||
try:
|
||
persist = factory.List(index)
|
||
if persist is None:
|
||
break
|
||
|
||
doc = win32com.client.CastTo(persist, "IBODocumentVente3")
|
||
doc.Read()
|
||
|
||
doc_type = getattr(doc, "DO_Type", -1)
|
||
|
||
# Filtrer sur le type qu'on analyse
|
||
if doc_type != type_doc:
|
||
index += 1
|
||
continue
|
||
|
||
analyse_type["nb_documents_total"] += 1
|
||
|
||
# Récupérer le statut
|
||
statut = getattr(doc, "DO_Statut", -1)
|
||
|
||
# Compter les statuts observés
|
||
if statut not in analyse_type["statuts_observes"]:
|
||
analyse_type["statuts_observes"][statut] = {
|
||
"count": 0,
|
||
"description": descriptions_statuts.get(
|
||
statut, f"Statut {statut}"
|
||
),
|
||
"exemples": [],
|
||
}
|
||
|
||
analyse_type["statuts_observes"][statut]["count"] += 1
|
||
|
||
# Garder quelques exemples
|
||
if (
|
||
len(analyse_type["statuts_observes"][statut]["exemples"])
|
||
< 3
|
||
):
|
||
numero = getattr(doc, "DO_Piece", "")
|
||
date = str(getattr(doc, "DO_Date", ""))
|
||
|
||
analyse_type["statuts_observes"][statut]["exemples"].append(
|
||
{
|
||
"numero": numero,
|
||
"date": date,
|
||
"total_ttc": float(
|
||
getattr(doc, "DO_TotalTTC", 0.0)
|
||
),
|
||
}
|
||
)
|
||
|
||
index += 1
|
||
|
||
except Exception as e:
|
||
index += 1
|
||
continue
|
||
|
||
# Trier les statuts par nombre d'occurrences
|
||
analyse_type["statuts_par_frequence"] = sorted(
|
||
[
|
||
{
|
||
"statut": s,
|
||
"description": info["description"],
|
||
"count": info["count"],
|
||
"pourcentage": (
|
||
round(
|
||
info["count"]
|
||
/ analyse_type["nb_documents_total"]
|
||
* 100,
|
||
1,
|
||
)
|
||
if analyse_type["nb_documents_total"] > 0
|
||
else 0
|
||
),
|
||
}
|
||
for s, info in analyse_type["statuts_observes"].items()
|
||
],
|
||
key=lambda x: x["count"],
|
||
reverse=True,
|
||
)
|
||
|
||
matrice_complete[type_doc] = analyse_type
|
||
|
||
logger.info(
|
||
f"[DIAG] ✅ Type {type_doc}: {analyse_type['nb_documents_total']} docs, "
|
||
f"{len(analyse_type['statuts_observes'])} statuts différents"
|
||
)
|
||
|
||
# RÈGLES DE TRANSFORMATION
|
||
regles_transformation = {
|
||
"transformations_valides": [
|
||
{
|
||
"source_type": 0,
|
||
"source_libelle": "Devis",
|
||
"cible_type": 10,
|
||
"cible_libelle": "Bon de commande",
|
||
"statut_source_requis": [2],
|
||
"statut_source_requis_description": ["Accepté/Validé"],
|
||
"statut_source_apres": 5,
|
||
"statut_source_apres_description": "Transformé",
|
||
"statut_cible_initial": 2,
|
||
"statut_cible_initial_description": "Accepté/Validé",
|
||
},
|
||
{
|
||
"source_type": 10,
|
||
"source_libelle": "Bon de commande",
|
||
"cible_type": 30,
|
||
"cible_libelle": "Bon de livraison",
|
||
"statut_source_requis": [2],
|
||
"statut_source_requis_description": ["Accepté/Validé"],
|
||
"statut_source_apres": 5,
|
||
"statut_source_apres_description": "Transformé",
|
||
"statut_cible_initial": 2,
|
||
"statut_cible_initial_description": "Accepté/Validé",
|
||
},
|
||
{
|
||
"source_type": 10,
|
||
"source_libelle": "Bon de commande",
|
||
"cible_type": 60,
|
||
"cible_libelle": "Facture",
|
||
"statut_source_requis": [2],
|
||
"statut_source_requis_description": ["Accepté/Validé"],
|
||
"statut_source_apres": 5,
|
||
"statut_source_apres_description": "Transformé",
|
||
"statut_cible_initial": 2,
|
||
"statut_cible_initial_description": "Accepté/Validé",
|
||
},
|
||
{
|
||
"source_type": 30,
|
||
"source_libelle": "Bon de livraison",
|
||
"cible_type": 60,
|
||
"cible_libelle": "Facture",
|
||
"statut_source_requis": [2],
|
||
"statut_source_requis_description": ["Accepté/Validé"],
|
||
"statut_source_apres": 5,
|
||
"statut_source_apres_description": "Transformé",
|
||
"statut_cible_initial": 2,
|
||
"statut_cible_initial_description": "Accepté/Validé",
|
||
},
|
||
{
|
||
"source_type": 0,
|
||
"source_libelle": "Devis",
|
||
"cible_type": 60,
|
||
"cible_libelle": "Facture",
|
||
"statut_source_requis": [2],
|
||
"statut_source_requis_description": ["Accepté/Validé"],
|
||
"statut_source_apres": 5,
|
||
"statut_source_apres_description": "Transformé",
|
||
"statut_cible_initial": 2,
|
||
"statut_cible_initial_description": "Accepté/Validé",
|
||
},
|
||
],
|
||
"statuts_bloquants_pour_transformation": [
|
||
{
|
||
"statut": 5,
|
||
"description": "Transformé",
|
||
"raison": "Le document a déjà été transformé",
|
||
},
|
||
{
|
||
"statut": 6,
|
||
"description": "Annulé",
|
||
"raison": "Le document est annulé",
|
||
},
|
||
{
|
||
"statut": 3,
|
||
"description": "Réalisé partiellement",
|
||
"raison": "Un document cible existe probablement déjà (transformation partielle effectuée)",
|
||
},
|
||
{
|
||
"statut": 4,
|
||
"description": "Réalisé totalement",
|
||
"raison": "Le document a été entièrement réalisé (transformation déjà effectuée)",
|
||
},
|
||
],
|
||
"changements_statut_autorises": {
|
||
"0_Brouillon": {
|
||
"vers": [2, 6],
|
||
"descriptions": ["Accepté/Validé", "Annulé"],
|
||
"note": "Un brouillon peut être accepté ou annulé",
|
||
},
|
||
"2_Accepte": {
|
||
"vers": [5, 6],
|
||
"descriptions": ["Transformé", "Annulé"],
|
||
"note": "Un document accepté peut être transformé ou annulé",
|
||
},
|
||
"5_Transforme": {
|
||
"vers": [],
|
||
"descriptions": [],
|
||
"note": "Un document transformé ne peut plus changer de statut",
|
||
},
|
||
"6_Annule": {
|
||
"vers": [],
|
||
"descriptions": [],
|
||
"note": "Un document annulé ne peut plus changer de statut",
|
||
},
|
||
},
|
||
}
|
||
|
||
return {
|
||
"success": True,
|
||
"matrice_statuts_par_type": matrice_complete,
|
||
"regles_transformation": regles_transformation,
|
||
"legende_statuts": descriptions_statuts,
|
||
"types_documents": types_documents,
|
||
"date_analyse": datetime.now().isoformat(),
|
||
"note": "Cette matrice est construite à partir des documents réels dans votre base Sage",
|
||
}
|
||
|
||
except Exception as e:
|
||
logger.error(f"[DIAG] Erreur diagnostic global: {e}", exc_info=True)
|
||
raise HTTPException(500, str(e))
|
||
|
||
|
||
@app.get(
|
||
"/sage/diagnostic/statuts-permis/{numero}", dependencies=[Depends(verify_token)]
|
||
)
|
||
def diagnostiquer_statuts_permis(numero: str):
|
||
"""
|
||
🔍 DIAGNOSTIC CRITIQUE: Découvre TOUS les statuts possibles pour un document
|
||
|
||
Teste tous les statuts de 0 à 10 pour identifier lesquels sont valides
|
||
"""
|
||
try:
|
||
if not sage or not sage.cial:
|
||
raise HTTPException(503, "Service Sage indisponible")
|
||
|
||
with sage._com_context(), sage._lock_com:
|
||
factory = sage.cial.FactoryDocumentVente
|
||
|
||
# Chercher le document (tous types confondus)
|
||
persist = None
|
||
type_doc_trouve = None
|
||
|
||
# Essayer ReadPiece pour différents types
|
||
for type_test in range(7): # 0-6
|
||
try:
|
||
persist_test = factory.ReadPiece(type_test, numero)
|
||
if persist_test:
|
||
persist = persist_test
|
||
type_doc_trouve = type_test
|
||
logger.info(
|
||
f"[DIAG] Document {numero} trouvé avec ReadPiece(type={type_test})"
|
||
)
|
||
break
|
||
except:
|
||
continue
|
||
|
||
# Si pas trouvé, chercher dans List()
|
||
if not persist:
|
||
index = 1
|
||
while index < 10000:
|
||
try:
|
||
persist_test = factory.List(index)
|
||
if persist_test is None:
|
||
break
|
||
|
||
doc_test = win32com.client.CastTo(
|
||
persist_test, "IBODocumentVente3"
|
||
)
|
||
doc_test.Read()
|
||
|
||
if getattr(doc_test, "DO_Piece", "") == numero:
|
||
persist = persist_test
|
||
type_doc_trouve = getattr(doc_test, "DO_Type", -1)
|
||
logger.info(
|
||
f"[DIAG] Document {numero} trouvé dans List() à l'index {index}"
|
||
)
|
||
break
|
||
|
||
index += 1
|
||
except:
|
||
index += 1
|
||
|
||
if not persist:
|
||
raise HTTPException(404, f"Document {numero} introuvable")
|
||
|
||
doc = win32com.client.CastTo(persist, "IBODocumentVente3")
|
||
doc.Read()
|
||
|
||
# Infos du document
|
||
statut_actuel = getattr(doc, "DO_Statut", -1)
|
||
type_actuel = getattr(doc, "DO_Type", -1)
|
||
|
||
diagnostic = {
|
||
"numero": numero,
|
||
"type_document": type_actuel,
|
||
"type_libelle": {
|
||
0: "Devis",
|
||
10: "Bon de commande",
|
||
20: "Préparation",
|
||
30: "Bon de livraison",
|
||
40: "Bon de retour",
|
||
50: "Bon d'avoir",
|
||
60: "Facture",
|
||
}.get(type_actuel, f"Type {type_actuel}"),
|
||
"statut_actuel": statut_actuel,
|
||
"statut_actuel_libelle": {
|
||
0: "Brouillon",
|
||
1: "Soumis/En attente",
|
||
2: "Accepté/Validé",
|
||
3: "Réalisé partiellement",
|
||
4: "Réalisé totalement",
|
||
5: "Transformé",
|
||
6: "Annulé",
|
||
}.get(statut_actuel, f"Statut {statut_actuel}"),
|
||
"tests_statuts": [],
|
||
}
|
||
|
||
# Tester tous les statuts de 0 à 10
|
||
logger.info(f"[DIAG] Test des statuts pour {numero}...")
|
||
|
||
for statut_test in range(11):
|
||
resultat_test = {
|
||
"statut": statut_test,
|
||
"libelle": {
|
||
0: "Brouillon",
|
||
1: "Soumis/En attente",
|
||
2: "Accepté/Validé",
|
||
3: "Réalisé partiellement",
|
||
4: "Réalisé totalement",
|
||
5: "Transformé",
|
||
6: "Annulé",
|
||
7: "Statut 7",
|
||
8: "Statut 8",
|
||
9: "Statut 9",
|
||
10: "Statut 10",
|
||
}.get(statut_test, f"Statut {statut_test}"),
|
||
"autorise": False,
|
||
"erreur": None,
|
||
"est_statut_actuel": (statut_test == statut_actuel),
|
||
}
|
||
|
||
# Si c'est le statut actuel, on sait qu'il est valide
|
||
if statut_test == statut_actuel:
|
||
resultat_test["autorise"] = True
|
||
resultat_test["note"] = "Statut actuel du document"
|
||
else:
|
||
# Tester le changement de statut
|
||
try:
|
||
# Relire le document
|
||
doc.Read()
|
||
|
||
# Essayer de changer le statut
|
||
doc.DO_Statut = statut_test
|
||
|
||
# Essayer d'écrire
|
||
doc.Write()
|
||
|
||
# Si on arrive ici, le statut est valide !
|
||
resultat_test["autorise"] = True
|
||
resultat_test["note"] = "Changement de statut réussi"
|
||
|
||
logger.info(f"[DIAG] ✅ Statut {statut_test} AUTORISÉ")
|
||
|
||
# Restaurer le statut d'origine immédiatement
|
||
doc.Read()
|
||
doc.DO_Statut = statut_actuel
|
||
doc.Write()
|
||
|
||
except Exception as e:
|
||
erreur_str = str(e)
|
||
resultat_test["autorise"] = False
|
||
resultat_test["erreur"] = erreur_str
|
||
|
||
logger.debug(
|
||
f"[DIAG] ❌ Statut {statut_test} REFUSÉ: {erreur_str[:100]}"
|
||
)
|
||
|
||
# Restaurer en cas d'erreur
|
||
try:
|
||
doc.Read()
|
||
except:
|
||
pass
|
||
|
||
diagnostic["tests_statuts"].append(resultat_test)
|
||
|
||
# Résumé
|
||
statuts_autorises = [
|
||
t["statut"] for t in diagnostic["tests_statuts"] if t["autorise"]
|
||
]
|
||
statuts_refuses = [
|
||
t["statut"] for t in diagnostic["tests_statuts"] if not t["autorise"]
|
||
]
|
||
|
||
diagnostic["resume"] = {
|
||
"nb_statuts_autorises": len(statuts_autorises),
|
||
"statuts_autorises": statuts_autorises,
|
||
"statuts_autorises_libelles": [
|
||
t["libelle"] for t in diagnostic["tests_statuts"] if t["autorise"]
|
||
],
|
||
"nb_statuts_refuses": len(statuts_refuses),
|
||
"statuts_refuses": statuts_refuses,
|
||
}
|
||
|
||
# Recommandations
|
||
recommendations = []
|
||
|
||
if 2 in statuts_autorises and statut_actuel == 0:
|
||
recommendations.append(
|
||
"✅ Vous pouvez passer ce document de 'Brouillon' (0) à 'Accepté' (2)"
|
||
)
|
||
|
||
if 5 in statuts_autorises:
|
||
recommendations.append(
|
||
"✅ Le statut 'Transformé' (5) est disponible - utilisé après transformation"
|
||
)
|
||
|
||
if 6 in statuts_autorises:
|
||
recommendations.append("✅ Vous pouvez annuler ce document (statut 6)")
|
||
|
||
if not any(s in statuts_autorises for s in [2, 3, 4]):
|
||
recommendations.append(
|
||
"⚠️ Aucun statut de validation (2/3/4) n'est disponible - "
|
||
"le document a peut-être déjà été traité"
|
||
)
|
||
|
||
diagnostic["recommendations"] = recommendations
|
||
|
||
logger.info(
|
||
f"[DIAG] Statuts autorisés pour {numero}: "
|
||
f"{statuts_autorises} / Refusés: {statuts_refuses}"
|
||
)
|
||
|
||
return {"success": True, "diagnostic": diagnostic}
|
||
|
||
except HTTPException:
|
||
raise
|
||
except Exception as e:
|
||
logger.error(f"[DIAG] Erreur diagnostic statuts: {e}", exc_info=True)
|
||
raise HTTPException(500, str(e))
|
||
|
||
|
||
@app.get(
|
||
"/sage/diagnostic/erreur-transformation/{numero}",
|
||
dependencies=[Depends(verify_token)],
|
||
)
|
||
def diagnostiquer_erreur_transformation(
|
||
numero: str, type_source: int = Query(...), type_cible: int = Query(...)
|
||
):
|
||
"""
|
||
🔍 DIAGNOSTIC AVANCÉ: Analyse pourquoi une transformation échoue
|
||
|
||
Vérifie:
|
||
- Statut du document source
|
||
- Statuts autorisés
|
||
- Lignes du document
|
||
- Client associé
|
||
- Champs obligatoires manquants
|
||
"""
|
||
try:
|
||
if not sage or not sage.cial:
|
||
raise HTTPException(503, "Service Sage indisponible")
|
||
|
||
with sage._com_context(), sage._lock_com:
|
||
factory = sage.cial.FactoryDocumentVente
|
||
|
||
# Lire le document source
|
||
persist = factory.ReadPiece(type_source, numero)
|
||
|
||
if not persist:
|
||
persist = sage._find_document_in_list(numero, type_source)
|
||
|
||
if not persist:
|
||
raise HTTPException(
|
||
404, f"Document {numero} (type {type_source}) introuvable"
|
||
)
|
||
|
||
doc = win32com.client.CastTo(persist, "IBODocumentVente3")
|
||
doc.Read()
|
||
|
||
diagnostic = {
|
||
"numero": numero,
|
||
"type_source": type_source,
|
||
"type_cible": type_cible,
|
||
"problemes_detectes": [],
|
||
"avertissements": [],
|
||
"suggestions": [],
|
||
}
|
||
|
||
# 1. Vérifier le statut
|
||
statut_actuel = getattr(doc, "DO_Statut", -1)
|
||
diagnostic["statut_actuel"] = statut_actuel
|
||
|
||
if statut_actuel == 5:
|
||
diagnostic["problemes_detectes"].append(
|
||
{
|
||
"severite": "BLOQUANT",
|
||
"champ": "DO_Statut",
|
||
"valeur": 5,
|
||
"message": "Document déjà transformé (statut=5)",
|
||
}
|
||
)
|
||
|
||
elif statut_actuel == 6:
|
||
diagnostic["problemes_detectes"].append(
|
||
{
|
||
"severite": "BLOQUANT",
|
||
"champ": "DO_Statut",
|
||
"valeur": 6,
|
||
"message": "Document annulé (statut=6)",
|
||
}
|
||
)
|
||
|
||
elif statut_actuel in [3, 4]:
|
||
diagnostic["avertissements"].append(
|
||
{
|
||
"severite": "ATTENTION",
|
||
"champ": "DO_Statut",
|
||
"valeur": statut_actuel,
|
||
"message": f"Document déjà réalisé (statut={statut_actuel}). "
|
||
f"Un document cible existe peut-être déjà.",
|
||
}
|
||
)
|
||
|
||
elif statut_actuel == 0:
|
||
diagnostic["suggestions"].append(
|
||
"Le document est en 'Brouillon' (statut=0). "
|
||
"Le système le passera automatiquement à 'Accepté' (statut=2) avant transformation."
|
||
)
|
||
|
||
# 2. Vérifier le client
|
||
client_code = ""
|
||
try:
|
||
client_obj = getattr(doc, "Client", None)
|
||
if client_obj:
|
||
client_obj.Read()
|
||
client_code = getattr(client_obj, "CT_Num", "").strip()
|
||
except:
|
||
pass
|
||
|
||
if not client_code:
|
||
diagnostic["problemes_detectes"].append(
|
||
{
|
||
"severite": "BLOQUANT",
|
||
"champ": "CT_Num",
|
||
"valeur": None,
|
||
"message": "Aucun client associé au document",
|
||
}
|
||
)
|
||
else:
|
||
diagnostic["client_code"] = client_code
|
||
|
||
# 3. Vérifier les lignes
|
||
try:
|
||
factory_lignes = getattr(doc, "FactoryDocumentLigne", None) or getattr(
|
||
doc, "FactoryDocumentVenteLigne", None
|
||
)
|
||
|
||
nb_lignes = 0
|
||
lignes_problemes = []
|
||
|
||
if factory_lignes:
|
||
index = 1
|
||
while index <= 100:
|
||
try:
|
||
ligne_p = factory_lignes.List(index)
|
||
if ligne_p is None:
|
||
break
|
||
|
||
ligne = win32com.client.CastTo(ligne_p, "IBODocumentLigne3")
|
||
ligne.Read()
|
||
|
||
nb_lignes += 1
|
||
|
||
# Vérifier article
|
||
article_ref = ""
|
||
try:
|
||
article_ref = getattr(ligne, "AR_Ref", "").strip()
|
||
if not article_ref:
|
||
article_obj = getattr(ligne, "Article", None)
|
||
if article_obj:
|
||
article_obj.Read()
|
||
article_ref = getattr(
|
||
article_obj, "AR_Ref", ""
|
||
).strip()
|
||
except:
|
||
pass
|
||
|
||
if not article_ref:
|
||
lignes_problemes.append(
|
||
{
|
||
"ligne": index,
|
||
"probleme": "Aucune référence article",
|
||
}
|
||
)
|
||
|
||
# Vérifier prix
|
||
prix = float(getattr(ligne, "DL_PrixUnitaire", 0.0))
|
||
if prix == 0:
|
||
lignes_problemes.append(
|
||
{"ligne": index, "probleme": "Prix unitaire = 0"}
|
||
)
|
||
|
||
index += 1
|
||
except:
|
||
break
|
||
|
||
diagnostic["nb_lignes"] = nb_lignes
|
||
|
||
if nb_lignes == 0:
|
||
diagnostic["problemes_detectes"].append(
|
||
{
|
||
"severite": "BLOQUANT",
|
||
"champ": "Lignes",
|
||
"valeur": 0,
|
||
"message": "Document vide (aucune ligne)",
|
||
}
|
||
)
|
||
|
||
if lignes_problemes:
|
||
diagnostic["avertissements"].append(
|
||
{
|
||
"severite": "ATTENTION",
|
||
"champ": "Lignes",
|
||
"message": f"{len(lignes_problemes)} ligne(s) avec des problèmes",
|
||
"details": lignes_problemes,
|
||
}
|
||
)
|
||
|
||
except Exception as e:
|
||
diagnostic["avertissements"].append(
|
||
{
|
||
"severite": "ERREUR",
|
||
"champ": "Lignes",
|
||
"message": f"Impossible de lire les lignes: {e}",
|
||
}
|
||
)
|
||
|
||
# 4. Vérifier les totaux
|
||
total_ht = float(getattr(doc, "DO_TotalHT", 0.0))
|
||
total_ttc = float(getattr(doc, "DO_TotalTTC", 0.0))
|
||
|
||
diagnostic["totaux"] = {"total_ht": total_ht, "total_ttc": total_ttc}
|
||
|
||
if total_ht == 0 and total_ttc == 0:
|
||
diagnostic["avertissements"].append(
|
||
{
|
||
"severite": "ATTENTION",
|
||
"champ": "Totaux",
|
||
"message": "Tous les totaux sont à 0",
|
||
}
|
||
)
|
||
|
||
# 5. Vérifier si la transformation est autorisée
|
||
transformations_valides = {(0, 10), (10, 30), (10, 60), (30, 60), (0, 60)}
|
||
|
||
if (type_source, type_cible) not in transformations_valides:
|
||
diagnostic["problemes_detectes"].append(
|
||
{
|
||
"severite": "BLOQUANT",
|
||
"champ": "Transformation",
|
||
"message": f"Transformation {type_source} → {type_cible} non autorisée. "
|
||
f"Transformations valides: {transformations_valides}",
|
||
}
|
||
)
|
||
|
||
# Résumé
|
||
nb_bloquants = sum(
|
||
1
|
||
for p in diagnostic["problemes_detectes"]
|
||
if p.get("severite") == "BLOQUANT"
|
||
)
|
||
nb_avertissements = len(diagnostic["avertissements"])
|
||
|
||
diagnostic["resume"] = {
|
||
"peut_transformer": nb_bloquants == 0,
|
||
"nb_problemes_bloquants": nb_bloquants,
|
||
"nb_avertissements": nb_avertissements,
|
||
}
|
||
|
||
if nb_bloquants == 0:
|
||
diagnostic["suggestions"].append(
|
||
"✅ Aucun problème bloquant détecté. La transformation devrait fonctionner."
|
||
)
|
||
else:
|
||
diagnostic["suggestions"].append(
|
||
f"❌ {nb_bloquants} problème(s) bloquant(s) doivent être résolus avant la transformation."
|
||
)
|
||
|
||
return {"success": True, "diagnostic": diagnostic}
|
||
|
||
except HTTPException:
|
||
raise
|
||
except Exception as e:
|
||
logger.error(f"[DIAG] Erreur diagnostic transformation: {e}", exc_info=True)
|
||
raise HTTPException(500, str(e))
|
||
|
||
|
||
# =====================================================
|
||
# ENDPOINTS - PROSPECTS
|
||
# =====================================================
|
||
@app.post("/sage/prospects/list", dependencies=[Depends(verify_token)])
|
||
def prospects_list(req: FiltreRequest):
|
||
"""📋 Liste tous les prospects (CT_Type=0 AND CT_Prospect=1)"""
|
||
try:
|
||
prospects = sage.lister_tous_prospects(req.filtre)
|
||
return {"success": True, "data": prospects}
|
||
except Exception as e:
|
||
logger.error(f"Erreur liste prospects: {e}")
|
||
raise HTTPException(500, str(e))
|
||
|
||
|
||
@app.post("/sage/prospects/get", dependencies=[Depends(verify_token)])
|
||
def prospect_get(req: CodeRequest):
|
||
"""📄 Lecture d'un prospect par code"""
|
||
try:
|
||
prospect = sage.lire_prospect(req.code)
|
||
if not prospect:
|
||
raise HTTPException(404, f"Prospect {req.code} non trouvé")
|
||
return {"success": True, "data": prospect}
|
||
except HTTPException:
|
||
raise
|
||
except Exception as e:
|
||
logger.error(f"Erreur lecture prospect: {e}")
|
||
raise HTTPException(500, str(e))
|
||
|
||
|
||
# =====================================================
|
||
# ENDPOINTS - FOURNISSEURS
|
||
# =====================================================
|
||
@app.post("/sage/fournisseurs/list", dependencies=[Depends(verify_token)])
|
||
def fournisseurs_list(req: FiltreRequest):
|
||
"""
|
||
⚡ ENDPOINT DIRECT : Liste fournisseurs via FactoryFournisseur
|
||
|
||
✅ Utilise la méthode corrigée qui ne dépend pas du cache
|
||
"""
|
||
try:
|
||
# ✅ Appel direct à la méthode corrigée
|
||
fournisseurs = sage.lister_tous_fournisseurs(req.filtre)
|
||
|
||
logger.info(f"✅ {len(fournisseurs)} fournisseurs retournés via endpoint")
|
||
|
||
return {"success": True, "data": fournisseurs}
|
||
|
||
except Exception as e:
|
||
logger.error(f"❌ Erreur liste fournisseurs: {e}", exc_info=True)
|
||
raise HTTPException(500, str(e))
|
||
|
||
@app.post("/sage/fournisseurs/create", dependencies=[Depends(verify_token)])
|
||
def create_fournisseur_endpoint(req: FournisseurCreateRequest):
|
||
"""
|
||
➕ Création d'un fournisseur dans Sage
|
||
|
||
✅ Utilise FactoryFournisseur.Create() directement
|
||
"""
|
||
try:
|
||
# Appel au connecteur Sage
|
||
resultat = sage.creer_fournisseur(req.dict())
|
||
|
||
logger.info(f"✅ Fournisseur créé: {resultat.get('numero')}")
|
||
|
||
return {
|
||
"success": True,
|
||
"data": resultat
|
||
}
|
||
|
||
except ValueError as e:
|
||
# Erreur métier (ex: doublon)
|
||
logger.warning(f"⚠️ Erreur métier création fournisseur: {e}")
|
||
raise HTTPException(400, str(e))
|
||
|
||
except Exception as e:
|
||
# Erreur technique (ex: COM)
|
||
logger.error(f"❌ Erreur technique création fournisseur: {e}")
|
||
raise HTTPException(500, str(e))
|
||
|
||
@app.post("/sage/fournisseurs/update", dependencies=[Depends(verify_token)])
|
||
def modifier_fournisseur_endpoint(req: FournisseurUpdateGatewayRequest):
|
||
"""
|
||
✏️ Modification d'un fournisseur dans Sage
|
||
"""
|
||
try:
|
||
resultat = sage.modifier_fournisseur(req.code, req.fournisseur_data)
|
||
return {"success": True, "data": resultat}
|
||
|
||
except ValueError as e:
|
||
logger.warning(f"Erreur métier modification fournisseur: {e}")
|
||
raise HTTPException(404, str(e))
|
||
except Exception as e:
|
||
logger.error(f"Erreur technique modification fournisseur: {e}")
|
||
raise HTTPException(500, str(e))
|
||
|
||
@app.post("/sage/fournisseurs/get", dependencies=[Depends(verify_token)])
|
||
def fournisseur_get(req: CodeRequest):
|
||
"""
|
||
✅ NOUVEAU : Lecture d'un fournisseur par code
|
||
"""
|
||
try:
|
||
fournisseur = sage.lire_fournisseur(req.code)
|
||
if not fournisseur:
|
||
raise HTTPException(404, f"Fournisseur {req.code} non trouvé")
|
||
return {"success": True, "data": fournisseur}
|
||
except HTTPException:
|
||
raise
|
||
except Exception as e:
|
||
logger.error(f"Erreur lecture fournisseur: {e}")
|
||
raise HTTPException(500, str(e))
|
||
|
||
|
||
# =====================================================
|
||
# ENDPOINTS - AVOIRS
|
||
# =====================================================
|
||
@app.post("/sage/avoirs/list", dependencies=[Depends(verify_token)])
|
||
def avoirs_list(limit: int = 100, statut: Optional[int] = None):
|
||
"""📋 Liste tous les avoirs (DO_Domaine=0 AND DO_Type=5)"""
|
||
try:
|
||
avoirs = sage.lister_avoirs(limit=limit, statut=statut)
|
||
return {"success": True, "data": avoirs}
|
||
except Exception as e:
|
||
logger.error(f"Erreur liste avoirs: {e}")
|
||
raise HTTPException(500, str(e))
|
||
|
||
|
||
@app.post("/sage/avoirs/get", dependencies=[Depends(verify_token)])
|
||
def avoir_get(req: CodeRequest):
|
||
"""📄 Lecture d'un avoir avec ses lignes"""
|
||
try:
|
||
avoir = sage.lire_avoir(req.code)
|
||
if not avoir:
|
||
raise HTTPException(404, f"Avoir {req.code} non trouvé")
|
||
return {"success": True, "data": avoir}
|
||
except HTTPException:
|
||
raise
|
||
except Exception as e:
|
||
logger.error(f"Erreur lecture avoir: {e}")
|
||
raise HTTPException(500, str(e))
|
||
|
||
|
||
# =====================================================
|
||
# ENDPOINTS - LIVRAISONS
|
||
# =====================================================
|
||
@app.post("/sage/livraisons/list", dependencies=[Depends(verify_token)])
|
||
def livraisons_list(limit: int = 100, statut: Optional[int] = None):
|
||
"""📋 Liste tous les bons de livraison (DO_Domaine=0 AND DO_Type=30)"""
|
||
try:
|
||
livraisons = sage.lister_livraisons(limit=limit, statut=statut)
|
||
return {"success": True, "data": livraisons}
|
||
except Exception as e:
|
||
logger.error(f"Erreur liste livraisons: {e}")
|
||
raise HTTPException(500, str(e))
|
||
|
||
|
||
@app.post("/sage/livraisons/get", dependencies=[Depends(verify_token)])
|
||
def livraison_get(req: CodeRequest):
|
||
"""📄 Lecture d'une livraison avec ses lignes"""
|
||
try:
|
||
livraison = sage.lire_livraison(req.code)
|
||
if not livraison:
|
||
raise HTTPException(404, f"Livraison {req.code} non trouvée")
|
||
return {"success": True, "data": livraison}
|
||
except HTTPException:
|
||
raise
|
||
except Exception as e:
|
||
logger.error(f"Erreur lecture livraison: {e}")
|
||
raise HTTPException(500, str(e))
|
||
|
||
@app.post("/sage/devis/update", dependencies=[Depends(verify_token)])
|
||
def modifier_devis_endpoint(req: DevisUpdateGatewayRequest):
|
||
"""
|
||
✏️ Modification d'un devis dans Sage
|
||
|
||
Permet de modifier:
|
||
- La date du devis
|
||
- Les lignes (remplace toutes les lignes)
|
||
- Le statut
|
||
"""
|
||
try:
|
||
resultat = sage.modifier_devis(req.numero, req.devis_data)
|
||
return {"success": True, "data": resultat}
|
||
|
||
except ValueError as e:
|
||
logger.warning(f"Erreur métier modification devis: {e}")
|
||
raise HTTPException(404, str(e))
|
||
except Exception as e:
|
||
logger.error(f"Erreur technique modification devis: {e}")
|
||
raise HTTPException(500, str(e))
|
||
|
||
|
||
# =====================================================
|
||
# ENDPOINTS - CRÉATION ET MODIFICATION COMMANDES
|
||
# =====================================================
|
||
|
||
@app.post("/sage/commandes/create", dependencies=[Depends(verify_token)])
|
||
def creer_commande_endpoint(req: CommandeCreateRequest):
|
||
"""
|
||
➕ Création d'une commande (Bon de commande) dans Sage
|
||
"""
|
||
try:
|
||
# Transformer en format attendu par sage_connector
|
||
commande_data = {
|
||
"client": {"code": req.client_id, "intitule": ""},
|
||
"date_commande": req.date_commande or date.today(),
|
||
"reference": req.reference,
|
||
"lignes": req.lignes,
|
||
}
|
||
|
||
resultat = sage.creer_commande_enrichi(commande_data)
|
||
return {"success": True, "data": resultat}
|
||
|
||
except ValueError as e:
|
||
logger.warning(f"Erreur métier création commande: {e}")
|
||
raise HTTPException(400, str(e))
|
||
except Exception as e:
|
||
logger.error(f"Erreur technique création commande: {e}")
|
||
raise HTTPException(500, str(e))
|
||
|
||
|
||
@app.post("/sage/commandes/update", dependencies=[Depends(verify_token)])
|
||
def modifier_commande_endpoint(req: CommandeUpdateGatewayRequest):
|
||
"""
|
||
✏️ Modification d'une commande dans Sage
|
||
|
||
Permet de modifier:
|
||
- La date de la commande
|
||
- Les lignes (remplace toutes les lignes)
|
||
- Le statut
|
||
- La référence externe
|
||
"""
|
||
try:
|
||
resultat = sage.modifier_commande(req.numero, req.commande_data)
|
||
return {"success": True, "data": resultat}
|
||
|
||
except ValueError as e:
|
||
logger.warning(f"Erreur métier modification commande: {e}")
|
||
raise HTTPException(404, str(e))
|
||
except Exception as e:
|
||
logger.error(f"Erreur technique modification commande: {e}")
|
||
raise HTTPException(500, str(e))
|
||
|
||
|
||
# À ajouter dans main.py (Windows Gateway)
|
||
|
||
@app.get("/sage/devis/{numero}/diagnostic-brouillon", dependencies=[Depends(verify_token)])
|
||
def diagnostiquer_devis_brouillon(numero: str):
|
||
"""
|
||
🔍 DIAGNOSTIC: Cherche un devis brouillon partout dans Sage
|
||
|
||
Teste toutes les méthodes de lecture possibles
|
||
"""
|
||
try:
|
||
if not sage or not sage.cial:
|
||
raise HTTPException(503, "Service Sage indisponible")
|
||
|
||
with sage._com_context(), sage._lock_com:
|
||
factory = sage.cial.FactoryDocumentVente
|
||
|
||
diagnostic = {
|
||
"numero_recherche": numero,
|
||
"methodes_testees": [],
|
||
"document_trouve": False,
|
||
"details": None
|
||
}
|
||
|
||
# ===== TEST 1: ReadPiece(0, numero) =====
|
||
try:
|
||
persist_rp = factory.ReadPiece(0, numero)
|
||
if persist_rp:
|
||
doc_rp = win32com.client.CastTo(persist_rp, "IBODocumentVente3")
|
||
doc_rp.Read()
|
||
|
||
diagnostic["methodes_testees"].append({
|
||
"methode": "ReadPiece(0, numero)",
|
||
"succes": True,
|
||
"statut": getattr(doc_rp, "DO_Statut", -1),
|
||
"type": getattr(doc_rp, "DO_Type", -1)
|
||
})
|
||
diagnostic["document_trouve"] = True
|
||
diagnostic["details"] = {
|
||
"numero": getattr(doc_rp, "DO_Piece", ""),
|
||
"type": getattr(doc_rp, "DO_Type", -1),
|
||
"statut": getattr(doc_rp, "DO_Statut", -1),
|
||
"total_ht": float(getattr(doc_rp, "DO_TotalHT", 0.0)),
|
||
"total_ttc": float(getattr(doc_rp, "DO_TotalTTC", 0.0)),
|
||
"client_code": getattr(doc_rp, "CT_Num", "")
|
||
}
|
||
else:
|
||
diagnostic["methodes_testees"].append({
|
||
"methode": "ReadPiece(0, numero)",
|
||
"succes": False,
|
||
"erreur": "Retourne None"
|
||
})
|
||
except Exception as e:
|
||
diagnostic["methodes_testees"].append({
|
||
"methode": "ReadPiece(0, numero)",
|
||
"succes": False,
|
||
"erreur": str(e)
|
||
})
|
||
|
||
# ===== TEST 2: Recherche dans List() =====
|
||
if not diagnostic["document_trouve"]:
|
||
try:
|
||
logger.info(f"🔍 Scan List() pour {numero}...")
|
||
index = 1
|
||
trouve_index = None
|
||
|
||
while index < 1000:
|
||
try:
|
||
persist_list = factory.List(index)
|
||
if persist_list is None:
|
||
break
|
||
|
||
doc_list = win32com.client.CastTo(persist_list, "IBODocumentVente3")
|
||
doc_list.Read()
|
||
|
||
piece = getattr(doc_list, "DO_Piece", "")
|
||
type_doc = getattr(doc_list, "DO_Type", -1)
|
||
|
||
if type_doc == 0 and piece == numero:
|
||
trouve_index = index
|
||
diagnostic["document_trouve"] = True
|
||
diagnostic["details"] = {
|
||
"numero": piece,
|
||
"type": type_doc,
|
||
"statut": getattr(doc_list, "DO_Statut", -1),
|
||
"total_ht": float(getattr(doc_list, "DO_TotalHT", 0.0)),
|
||
"total_ttc": float(getattr(doc_list, "DO_TotalTTC", 0.0)),
|
||
"client_code": getattr(doc_list, "CT_Num", ""),
|
||
"trouve_a_index": index
|
||
}
|
||
break
|
||
|
||
index += 1
|
||
except:
|
||
index += 1
|
||
continue
|
||
|
||
diagnostic["methodes_testees"].append({
|
||
"methode": f"List() scan (0-{index})",
|
||
"succes": diagnostic["document_trouve"],
|
||
"trouve_a_index": trouve_index if diagnostic["document_trouve"] else None
|
||
})
|
||
|
||
except Exception as e:
|
||
diagnostic["methodes_testees"].append({
|
||
"methode": "List() scan",
|
||
"succes": False,
|
||
"erreur": str(e)
|
||
})
|
||
|
||
# ===== TEST 3: Compter tous les devis brouillons récents =====
|
||
try:
|
||
nb_brouillons_recents = 0
|
||
index = 1
|
||
|
||
while index < 100:
|
||
try:
|
||
persist = factory.List(index)
|
||
if persist is None:
|
||
break
|
||
|
||
doc = win32com.client.CastTo(persist, "IBODocumentVente3")
|
||
doc.Read()
|
||
|
||
if getattr(doc, "DO_Type", -1) == 0 and getattr(doc, "DO_Statut", -1) == 0:
|
||
nb_brouillons_recents += 1
|
||
|
||
index += 1
|
||
except:
|
||
index += 1
|
||
continue
|
||
|
||
diagnostic["statistiques"] = {
|
||
"nb_brouillons_dans_100_premiers": nb_brouillons_recents
|
||
}
|
||
|
||
except Exception as e:
|
||
diagnostic["statistiques"] = {
|
||
"erreur": str(e)
|
||
}
|
||
|
||
return {
|
||
"success": True,
|
||
"diagnostic": diagnostic
|
||
}
|
||
|
||
except HTTPException:
|
||
raise
|
||
except Exception as e:
|
||
logger.error(f"[DIAG] Erreur: {e}", exc_info=True)
|
||
raise HTTPException(500, str(e))
|
||
|
||
# À ajouter dans main.py (Windows Gateway)
|
||
|
||
@app.get("/sage/diagnostic/commande/{numero}", dependencies=[Depends(verify_token)])
|
||
def diagnostiquer_commande_complete(numero: str):
|
||
"""
|
||
🔍 DIAGNOSTIC ULTRA-COMPLET d'une commande
|
||
|
||
Analyse TOUS les aspects qui peuvent bloquer une modification:
|
||
- Statut et type réels
|
||
- Champs verrouillés
|
||
- Liens avec d'autres documents
|
||
- Permissions
|
||
- Propriétés COM accessibles
|
||
"""
|
||
try:
|
||
if not sage or not sage.cial:
|
||
raise HTTPException(503, "Service Sage indisponible")
|
||
|
||
with sage._com_context(), sage._lock_com:
|
||
factory = sage.cial.FactoryDocumentVente
|
||
|
||
diagnostic = {
|
||
"numero": numero,
|
||
"trouve": False,
|
||
"methode_lecture": None,
|
||
"proprietes_document": {},
|
||
"tests_modification": {},
|
||
"liens_documents": {},
|
||
"diagnostic_lignes": {},
|
||
"conclusions": []
|
||
}
|
||
|
||
# ===== ÉTAPE 1: TROUVER LA COMMANDE =====
|
||
persist = None
|
||
|
||
# Test 1: ReadPiece avec différents types
|
||
for type_test in [10, 3, settings.SAGE_TYPE_BON_COMMANDE]:
|
||
try:
|
||
persist_test = factory.ReadPiece(type_test, numero)
|
||
if persist_test:
|
||
persist = persist_test
|
||
diagnostic["methode_lecture"] = f"ReadPiece(type={type_test})"
|
||
diagnostic["trouve"] = True
|
||
break
|
||
except:
|
||
continue
|
||
|
||
# Test 2: Scan List()
|
||
if not persist:
|
||
logger.info(f"[DIAG] Scan List() pour {numero}...")
|
||
index = 1
|
||
while index < 10000:
|
||
try:
|
||
persist_test = factory.List(index)
|
||
if persist_test is None:
|
||
break
|
||
|
||
doc_test = win32com.client.CastTo(persist_test, "IBODocumentVente3")
|
||
doc_test.Read()
|
||
|
||
if getattr(doc_test, "DO_Piece", "") == numero:
|
||
persist = persist_test
|
||
diagnostic["methode_lecture"] = f"List() à index {index}"
|
||
diagnostic["trouve"] = True
|
||
break
|
||
|
||
index += 1
|
||
except:
|
||
index += 1
|
||
|
||
if not persist:
|
||
diagnostic["conclusions"].append("❌ DOCUMENT INTROUVABLE")
|
||
return {"success": False, "diagnostic": diagnostic}
|
||
|
||
# ===== ÉTAPE 2: CAST ET LECTURE =====
|
||
doc = win32com.client.CastTo(persist, "IBODocumentVente3")
|
||
doc.Read()
|
||
|
||
# ===== ÉTAPE 3: PROPRIÉTÉS CRITIQUES =====
|
||
proprietes_critiques = [
|
||
"DO_Piece", "DO_Type", "DO_Statut", "DO_Date",
|
||
"DO_TotalHT", "DO_TotalTTC", "DO_Ref",
|
||
"CT_Num", "DO_Domaine", "DO_Souche",
|
||
"DO_Transfere", "DO_Valide", "DO_Cloture"
|
||
]
|
||
|
||
for prop in proprietes_critiques:
|
||
try:
|
||
valeur = getattr(doc, prop, "N/A")
|
||
diagnostic["proprietes_document"][prop] = {
|
||
"valeur": str(valeur),
|
||
"type": type(valeur).__name__
|
||
}
|
||
except Exception as e:
|
||
diagnostic["proprietes_document"][prop] = {
|
||
"erreur": str(e)
|
||
}
|
||
|
||
# ===== ÉTAPE 4: VÉRIFICATION TRANSFORMATION =====
|
||
numero_doc = diagnostic["proprietes_document"].get("DO_Piece", {}).get("valeur", numero)
|
||
type_doc = diagnostic["proprietes_document"].get("DO_Type", {}).get("valeur", "10")
|
||
|
||
try:
|
||
type_doc_int = int(type_doc)
|
||
verification = sage.verifier_si_deja_transforme(numero_doc, type_doc_int)
|
||
|
||
diagnostic["liens_documents"] = {
|
||
"deja_transforme": verification.get("deja_transforme", False),
|
||
"nb_transformations": verification.get("nb_transformations", 0),
|
||
"documents_cibles": verification.get("documents_cibles", [])
|
||
}
|
||
|
||
if verification.get("deja_transforme"):
|
||
diagnostic["conclusions"].append(
|
||
f"⚠️ TRANSFORMÉE {verification['nb_transformations']} fois - "
|
||
f"Docs cibles: {[d['numero'] for d in verification['documents_cibles']]}"
|
||
)
|
||
except Exception as e:
|
||
diagnostic["liens_documents"]["erreur"] = str(e)
|
||
|
||
# ===== ÉTAPE 5: ANALYSE DES LIGNES =====
|
||
try:
|
||
factory_lignes = getattr(doc, "FactoryDocumentLigne", None)
|
||
if not factory_lignes:
|
||
factory_lignes = getattr(doc, "FactoryDocumentVenteLigne", None)
|
||
|
||
nb_lignes = 0
|
||
lignes_detail = []
|
||
|
||
if factory_lignes:
|
||
index = 1
|
||
while index <= 100:
|
||
try:
|
||
ligne_p = factory_lignes.List(index)
|
||
if ligne_p is None:
|
||
break
|
||
|
||
ligne = win32com.client.CastTo(ligne_p, "IBODocumentLigne3")
|
||
ligne.Read()
|
||
|
||
nb_lignes += 1
|
||
|
||
# Propriétés de la ligne
|
||
ligne_info = {
|
||
"index": index,
|
||
"AR_Ref": getattr(ligne, "AR_Ref", ""),
|
||
"DL_Design": getattr(ligne, "DL_Design", ""),
|
||
"DL_Qte": float(getattr(ligne, "DL_Qte", 0.0)),
|
||
"DL_PrixUnitaire": float(getattr(ligne, "DL_PrixUnitaire", 0.0)),
|
||
}
|
||
|
||
# ✅ TEST CRITIQUE: Peut-on ÉCRIRE sur cette ligne ?
|
||
try:
|
||
# Sauvegarder la valeur originale
|
||
qte_originale = ligne_info["DL_Qte"]
|
||
|
||
# Tenter de modifier
|
||
ligne.DL_Qte = qte_originale
|
||
ligne.Write()
|
||
|
||
ligne_info["peut_ecrire"] = True
|
||
|
||
# Restaurer
|
||
ligne.Read()
|
||
except Exception as e:
|
||
ligne_info["peut_ecrire"] = False
|
||
ligne_info["erreur_ecriture"] = str(e)[:100]
|
||
|
||
lignes_detail.append(ligne_info)
|
||
index += 1
|
||
|
||
except Exception as e:
|
||
logger.debug(f"Erreur ligne {index}: {e}")
|
||
break
|
||
|
||
diagnostic["diagnostic_lignes"] = {
|
||
"nb_lignes": nb_lignes,
|
||
"lignes": lignes_detail,
|
||
"nb_lignes_modifiables": sum(1 for l in lignes_detail if l.get("peut_ecrire"))
|
||
}
|
||
|
||
except Exception as e:
|
||
diagnostic["diagnostic_lignes"]["erreur"] = str(e)
|
||
|
||
# ===== ÉTAPE 6: TESTS DE MODIFICATION =====
|
||
|
||
# Test 1: Peut-on écrire le document ?
|
||
try:
|
||
doc.Write()
|
||
diagnostic["tests_modification"]["write_basique"] = {
|
||
"succes": True,
|
||
"note": "Write() sans modification fonctionne"
|
||
}
|
||
except Exception as e:
|
||
diagnostic["tests_modification"]["write_basique"] = {
|
||
"succes": False,
|
||
"erreur": str(e)
|
||
}
|
||
diagnostic["conclusions"].append(f"❌ Write() basique ÉCHOUE: {str(e)[:100]}")
|
||
|
||
# Test 2: Peut-on modifier DO_Ref ?
|
||
try:
|
||
ref_originale = getattr(doc, "DO_Ref", "")
|
||
doc.DO_Ref = ref_originale
|
||
doc.Write()
|
||
doc.Read()
|
||
|
||
diagnostic["tests_modification"]["modification_do_ref"] = {
|
||
"succes": True
|
||
}
|
||
except Exception as e:
|
||
diagnostic["tests_modification"]["modification_do_ref"] = {
|
||
"succes": False,
|
||
"erreur": str(e)
|
||
}
|
||
|
||
# Test 3: Peut-on modifier le statut ?
|
||
statut_actuel = int(diagnostic["proprietes_document"].get("DO_Statut", {}).get("valeur", "0"))
|
||
|
||
try:
|
||
doc.DO_Statut = statut_actuel
|
||
doc.Write()
|
||
doc.Read()
|
||
|
||
diagnostic["tests_modification"]["modification_statut"] = {
|
||
"succes": True
|
||
}
|
||
except Exception as e:
|
||
diagnostic["tests_modification"]["modification_statut"] = {
|
||
"succes": False,
|
||
"erreur": str(e)
|
||
}
|
||
diagnostic["conclusions"].append(f"❌ Modification statut BLOQUÉE: {str(e)[:100]}")
|
||
|
||
# ===== ÉTAPE 7: COMPARAISON AVEC BC00067 (qui fonctionne) =====
|
||
if numero != "BC00067":
|
||
try:
|
||
# Lire BC00067 pour comparaison
|
||
persist_ref = None
|
||
|
||
for type_test in [10, 3, settings.SAGE_TYPE_BON_COMMANDE]:
|
||
try:
|
||
persist_ref = factory.ReadPiece(type_test, "BC00067")
|
||
if persist_ref:
|
||
break
|
||
except:
|
||
continue
|
||
|
||
if persist_ref:
|
||
doc_ref = win32com.client.CastTo(persist_ref, "IBODocumentVente3")
|
||
doc_ref.Read()
|
||
|
||
comparaison = {}
|
||
|
||
for prop in proprietes_critiques:
|
||
try:
|
||
val_actuelle = getattr(doc, prop, None)
|
||
val_ref = getattr(doc_ref, prop, None)
|
||
|
||
if val_actuelle != val_ref:
|
||
comparaison[prop] = {
|
||
"actuelle": str(val_actuelle),
|
||
"bc00067": str(val_ref),
|
||
"different": True
|
||
}
|
||
except:
|
||
pass
|
||
|
||
diagnostic["comparaison_bc00067"] = comparaison
|
||
|
||
if comparaison:
|
||
diagnostic["conclusions"].append(
|
||
f"🔍 DIFFÉRENCES avec BC00067: {list(comparaison.keys())}"
|
||
)
|
||
|
||
except Exception as e:
|
||
diagnostic["comparaison_bc00067"] = {"erreur": str(e)}
|
||
|
||
# ===== ÉTAPE 8: CONCLUSIONS FINALES =====
|
||
|
||
# Statut
|
||
if statut_actuel == 5:
|
||
diagnostic["conclusions"].append("❌ STATUT = 5 (Transformé) - MODIFICATION IMPOSSIBLE")
|
||
elif statut_actuel == 6:
|
||
diagnostic["conclusions"].append("❌ STATUT = 6 (Annulé) - MODIFICATION IMPOSSIBLE")
|
||
|
||
# Transformation
|
||
if diagnostic["liens_documents"].get("deja_transforme"):
|
||
diagnostic["conclusions"].append("⚠️ Document déjà transformé - Risque de blocage")
|
||
|
||
# Write basique
|
||
if not diagnostic["tests_modification"].get("write_basique", {}).get("succes"):
|
||
diagnostic["conclusions"].append("❌ CRITIQUE: Write() basique échoue - Document verrouillé")
|
||
|
||
# Lignes
|
||
nb_lignes_modif = diagnostic["diagnostic_lignes"].get("nb_lignes_modifiables", 0)
|
||
nb_lignes_total = diagnostic["diagnostic_lignes"].get("nb_lignes", 0)
|
||
|
||
if nb_lignes_total > 0 and nb_lignes_modif == 0:
|
||
diagnostic["conclusions"].append("❌ AUCUNE ligne modifiable - Document figé")
|
||
elif nb_lignes_modif < nb_lignes_total:
|
||
diagnostic["conclusions"].append(f"⚠️ Seulement {nb_lignes_modif}/{nb_lignes_total} lignes modifiables")
|
||
|
||
# Si aucun problème détecté
|
||
if not diagnostic["conclusions"]:
|
||
diagnostic["conclusions"].append("✅ Aucun blocage évident détecté")
|
||
|
||
return {
|
||
"success": True,
|
||
"diagnostic": diagnostic
|
||
}
|
||
|
||
except HTTPException:
|
||
raise
|
||
except Exception as e:
|
||
logger.error(f"[DIAG] Erreur diagnostic complet: {e}", exc_info=True)
|
||
raise HTTPException(500, str(e))
|
||
|
||
|
||
@app.get("/sage/diagnostic/comparer-commandes", dependencies=[Depends(verify_token)])
|
||
def comparer_commandes_modifiables():
|
||
"""
|
||
🔍 COMPARAISON GLOBALE: BC00067 (fonctionne) vs autres (bloquées)
|
||
|
||
Scanne les 20 premières commandes et compare leurs propriétés
|
||
pour identifier LE facteur qui bloque les modifications
|
||
"""
|
||
try:
|
||
if not sage or not sage.cial:
|
||
raise HTTPException(503, "Service Sage indisponible")
|
||
|
||
with sage._com_context(), sage._lock_com:
|
||
factory = sage.cial.FactoryDocumentVente
|
||
|
||
commandes_analysees = []
|
||
bc00067_ref = None
|
||
|
||
index = 1
|
||
max_scan = 500 # Scanner plus large
|
||
|
||
logger.info("[DIAG] Scan de toutes les commandes...")
|
||
|
||
while index < max_scan and len(commandes_analysees) < 50:
|
||
try:
|
||
persist = factory.List(index)
|
||
if persist is None:
|
||
break
|
||
|
||
doc = win32com.client.CastTo(persist, "IBODocumentVente3")
|
||
doc.Read()
|
||
|
||
# Filtrer sur commandes (type 10 ou 3)
|
||
doc_type = getattr(doc, "DO_Type", -1)
|
||
if doc_type not in [3, 10, settings.SAGE_TYPE_BON_COMMANDE]:
|
||
index += 1
|
||
continue
|
||
|
||
numero = getattr(doc, "DO_Piece", "")
|
||
|
||
analyse = {
|
||
"numero": numero,
|
||
"type": doc_type,
|
||
"statut": getattr(doc, "DO_Statut", -1),
|
||
"date": str(getattr(doc, "DO_Date", "")),
|
||
"total_ttc": float(getattr(doc, "DO_TotalTTC", 0.0)),
|
||
"reference": getattr(doc, "DO_Ref", ""),
|
||
"client": getattr(doc, "CT_Num", ""),
|
||
}
|
||
|
||
# Propriétés supplémentaires
|
||
for prop in ["DO_Transfere", "DO_Valide", "DO_Cloture", "DO_Souche", "DO_Domaine"]:
|
||
try:
|
||
analyse[prop] = str(getattr(doc, prop, "N/A"))
|
||
except:
|
||
analyse[prop] = "N/A"
|
||
|
||
# ✅ TEST: Peut-on écrire ?
|
||
try:
|
||
doc.Write()
|
||
analyse["peut_ecrire"] = True
|
||
except Exception as e:
|
||
analyse["peut_ecrire"] = False
|
||
analyse["erreur_ecriture"] = str(e)[:100]
|
||
|
||
# Vérifier transformation
|
||
try:
|
||
verif = sage.verifier_si_deja_transforme(numero, doc_type)
|
||
analyse["deja_transforme"] = verif.get("deja_transforme", False)
|
||
analyse["nb_transformations"] = verif.get("nb_transformations", 0)
|
||
except:
|
||
analyse["deja_transforme"] = None
|
||
|
||
commandes_analysees.append(analyse)
|
||
|
||
# Sauvegarder BC00067 comme référence
|
||
if numero == "BC00067":
|
||
bc00067_ref = analyse
|
||
|
||
index += 1
|
||
|
||
except Exception as e:
|
||
logger.debug(f"Erreur index {index}: {e}")
|
||
index += 1
|
||
|
||
# ===== ANALYSE COMPARATIVE =====
|
||
|
||
if not bc00067_ref:
|
||
return {
|
||
"success": False,
|
||
"erreur": "BC00067 introuvable pour comparaison"
|
||
}
|
||
|
||
# Séparer modifiables vs bloquées
|
||
modifiables = [c for c in commandes_analysees if c.get("peut_ecrire")]
|
||
bloquees = [c for c in commandes_analysees if not c.get("peut_ecrire")]
|
||
|
||
# Identifier les propriétés COMMUNES aux modifiables
|
||
# mais DIFFÉRENTES pour les bloquées
|
||
|
||
proprietes_a_comparer = [
|
||
"type", "statut", "DO_Transfere", "DO_Valide",
|
||
"DO_Cloture", "DO_Souche", "DO_Domaine",
|
||
"deja_transforme"
|
||
]
|
||
|
||
facteurs_distinctifs = {}
|
||
|
||
for prop in proprietes_a_comparer:
|
||
# Valeur chez BC00067
|
||
valeur_ref = bc00067_ref.get(prop)
|
||
|
||
# Compter combien de modifiables ont la même valeur
|
||
modif_meme_valeur = sum(
|
||
1 for c in modifiables
|
||
if c.get(prop) == valeur_ref
|
||
)
|
||
|
||
# Compter combien de bloquées ont une valeur différente
|
||
bloq_valeur_diff = sum(
|
||
1 for c in bloquees
|
||
if c.get(prop) != valeur_ref
|
||
)
|
||
|
||
if bloq_valeur_diff > len(bloquees) * 0.5: # Plus de 50%
|
||
facteurs_distinctifs[prop] = {
|
||
"valeur_bc00067": str(valeur_ref),
|
||
"pct_modifiables_meme_valeur": round(modif_meme_valeur / len(modifiables) * 100, 1) if modifiables else 0,
|
||
"pct_bloquees_valeur_differente": round(bloq_valeur_diff / len(bloquees) * 100, 1) if bloquees else 0,
|
||
"correlation": "FORTE" if bloq_valeur_diff > len(bloquees) * 0.8 else "MOYENNE"
|
||
}
|
||
|
||
# Statistiques
|
||
statistiques = {
|
||
"total_commandes": len(commandes_analysees),
|
||
"nb_modifiables": len(modifiables),
|
||
"nb_bloquees": len(bloquees),
|
||
"taux_modification": round(len(modifiables) / len(commandes_analysees) * 100, 1) if commandes_analysees else 0
|
||
}
|
||
|
||
# Distribution des statuts
|
||
statuts_modif = {}
|
||
statuts_bloq = {}
|
||
|
||
for c in modifiables:
|
||
s = c.get("statut", -1)
|
||
statuts_modif[s] = statuts_modif.get(s, 0) + 1
|
||
|
||
for c in bloquees:
|
||
s = c.get("statut", -1)
|
||
statuts_bloq[s] = statuts_bloq.get(s, 0) + 1
|
||
|
||
return {
|
||
"success": True,
|
||
"bc00067_reference": bc00067_ref,
|
||
"statistiques": statistiques,
|
||
"facteurs_distinctifs": facteurs_distinctifs,
|
||
"distribution_statuts": {
|
||
"modifiables": statuts_modif,
|
||
"bloquees": statuts_bloq
|
||
},
|
||
"exemples_modifiables": modifiables[:5],
|
||
"exemples_bloquees": bloquees[:5],
|
||
"conclusion": (
|
||
"✅ Facteurs identifiés - Voir 'facteurs_distinctifs'"
|
||
if facteurs_distinctifs
|
||
else "⚠️ Aucun facteur distinctif évident - Nécessite analyse manuelle"
|
||
)
|
||
}
|
||
|
||
except Exception as e:
|
||
logger.error(f"[DIAG] Erreur comparaison: {e}", exc_info=True)
|
||
raise HTTPException(500, str(e))
|
||
|
||
|
||
@app.post("/sage/diagnostic/test-suppression-ligne/{numero}", dependencies=[Depends(verify_token)])
|
||
def tester_suppression_ligne(numero: str):
|
||
"""
|
||
🧪 TEST CRITIQUE: Peut-on supprimer les lignes de cette commande ?
|
||
|
||
Teste la méthode WriteDefault() + Delete() sur la première ligne
|
||
"""
|
||
try:
|
||
if not sage or not sage.cial:
|
||
raise HTTPException(503, "Service Sage indisponible")
|
||
|
||
with sage._com_context(), sage._lock_com:
|
||
factory = sage.cial.FactoryDocumentVente
|
||
|
||
# Trouver la commande
|
||
persist = None
|
||
for type_test in [10, 3, settings.SAGE_TYPE_BON_COMMANDE]:
|
||
try:
|
||
persist = factory.ReadPiece(type_test, numero)
|
||
if persist:
|
||
break
|
||
except:
|
||
continue
|
||
|
||
if not persist:
|
||
raise HTTPException(404, f"Commande {numero} introuvable")
|
||
|
||
doc = win32com.client.CastTo(persist, "IBODocumentVente3")
|
||
doc.Read()
|
||
|
||
# Obtenir factory lignes
|
||
try:
|
||
factory_lignes = doc.FactoryDocumentLigne
|
||
except:
|
||
factory_lignes = doc.FactoryDocumentVenteLigne
|
||
|
||
resultats = {
|
||
"numero": numero,
|
||
"tests": []
|
||
}
|
||
|
||
# Test 1: Lire la première ligne
|
||
try:
|
||
ligne_p = factory_lignes.List(1)
|
||
if ligne_p is None:
|
||
return {
|
||
"success": False,
|
||
"erreur": "Aucune ligne trouvée"
|
||
}
|
||
|
||
ligne = win32com.client.CastTo(ligne_p, "IBODocumentLigne3")
|
||
ligne.Read()
|
||
|
||
resultats["tests"].append({
|
||
"test": "Lecture ligne 1",
|
||
"succes": True,
|
||
"article": getattr(ligne, "AR_Ref", ""),
|
||
"quantite": float(getattr(ligne, "DL_Qte", 0.0))
|
||
})
|
||
|
||
except Exception as e:
|
||
resultats["tests"].append({
|
||
"test": "Lecture ligne 1",
|
||
"succes": False,
|
||
"erreur": str(e)
|
||
})
|
||
return {"success": False, "resultats": resultats}
|
||
|
||
# Test 2: WriteDefault()
|
||
try:
|
||
ligne.WriteDefault()
|
||
resultats["tests"].append({
|
||
"test": "WriteDefault()",
|
||
"succes": True
|
||
})
|
||
except Exception as e:
|
||
resultats["tests"].append({
|
||
"test": "WriteDefault()",
|
||
"succes": False,
|
||
"erreur": str(e)
|
||
})
|
||
return {"success": False, "resultats": resultats}
|
||
|
||
# Test 3: Delete()
|
||
try:
|
||
ligne.Delete()
|
||
resultats["tests"].append({
|
||
"test": "Delete()",
|
||
"succes": True
|
||
})
|
||
except Exception as e:
|
||
resultats["tests"].append({
|
||
"test": "Delete()",
|
||
"succes": False,
|
||
"erreur": str(e)
|
||
})
|
||
return {"success": False, "resultats": resultats}
|
||
|
||
# Test 4: Write() sur le document
|
||
try:
|
||
doc.Write()
|
||
resultats["tests"].append({
|
||
"test": "Write() document après suppression",
|
||
"succes": True
|
||
})
|
||
except Exception as e:
|
||
resultats["tests"].append({
|
||
"test": "Write() document après suppression",
|
||
"succes": False,
|
||
"erreur": str(e)
|
||
})
|
||
|
||
# Test 5: Vérifier que la ligne a bien été supprimée
|
||
try:
|
||
doc.Read()
|
||
|
||
ligne_test = factory_lignes.List(1)
|
||
if ligne_test:
|
||
ligne_test_obj = win32com.client.CastTo(ligne_test, "IBODocumentLigne3")
|
||
ligne_test_obj.Read()
|
||
|
||
article_apres = getattr(ligne_test_obj, "AR_Ref", "")
|
||
article_avant = resultats["tests"][0].get("article", "")
|
||
|
||
if article_apres != article_avant:
|
||
resultats["tests"].append({
|
||
"test": "Vérification suppression",
|
||
"succes": True,
|
||
"note": "La ligne a bien été supprimée (ligne suivante est devenue ligne 1)"
|
||
})
|
||
else:
|
||
resultats["tests"].append({
|
||
"test": "Vérification suppression",
|
||
"succes": False,
|
||
"note": "La même ligne est toujours en position 1 - Suppression échouée"
|
||
})
|
||
else:
|
||
resultats["tests"].append({
|
||
"test": "Vérification suppression",
|
||
"succes": True,
|
||
"note": "Aucune ligne trouvée - Document maintenant vide"
|
||
})
|
||
|
||
except Exception as e:
|
||
resultats["tests"].append({
|
||
"test": "Vérification suppression",
|
||
"succes": False,
|
||
"erreur": str(e)
|
||
})
|
||
|
||
# Conclusion
|
||
tous_succes = all(t.get("succes") for t in resultats["tests"])
|
||
|
||
resultats["conclusion"] = (
|
||
"✅ TOUTES les opérations de suppression fonctionnent"
|
||
if tous_succes
|
||
else "❌ Certaines opérations échouent - Voir détails"
|
||
)
|
||
|
||
return {
|
||
"success": True,
|
||
"resultats": resultats
|
||
}
|
||
|
||
except HTTPException:
|
||
raise
|
||
except Exception as e:
|
||
logger.error(f"[TEST] Erreur test suppression: {e}", exc_info=True)
|
||
raise HTTPException(500, str(e))
|
||
|
||
|
||
# 🔍 SCRIPT DE DIAGNOSTIC ULTRA-DÉTAILLÉ
|
||
# À ajouter dans main.py (Windows Gateway)
|
||
|
||
@app.post("/sage/diagnostic/modification-commande/{numero}", dependencies=[Depends(verify_token)])
|
||
def diagnostiquer_modification_commande(
|
||
numero: str,
|
||
test_date: bool = Query(False, description="Tester modification date"),
|
||
test_statut: bool = Query(False, description="Tester modification statut"),
|
||
test_lignes: bool = Query(False, description="Tester modification lignes")
|
||
):
|
||
"""
|
||
🔬 DIAGNOSTIC ULTRA-DÉTAILLÉ : Modification Commande
|
||
|
||
Ce script va :
|
||
1. Capturer TOUS les champs avant modification
|
||
2. Tenter chaque type de modification séparément
|
||
3. Identifier EXACTEMENT quel champ pose problème
|
||
4. Vérifier si le client reste attaché
|
||
"""
|
||
try:
|
||
if not sage or not sage.cial:
|
||
raise HTTPException(503, "Service Sage indisponible")
|
||
|
||
with sage._com_context(), sage._lock_com:
|
||
factory = sage.cial.FactoryDocumentVente
|
||
|
||
diagnostic = {
|
||
"numero": numero,
|
||
"etapes": [],
|
||
"champs_avant": {},
|
||
"champs_apres": {},
|
||
"tests_modifications": [],
|
||
"erreurs_detectees": [],
|
||
"recommandations": []
|
||
}
|
||
|
||
# ========================================
|
||
# ÉTAPE 1 : CHARGER LE DOCUMENT
|
||
# ========================================
|
||
diagnostic["etapes"].append("🔍 Chargement document...")
|
||
|
||
persist = None
|
||
for type_test in [10, 3, settings.SAGE_TYPE_BON_COMMANDE]:
|
||
try:
|
||
persist = factory.ReadPiece(type_test, numero)
|
||
if persist:
|
||
diagnostic["type_utilise"] = type_test
|
||
break
|
||
except:
|
||
continue
|
||
|
||
if not persist:
|
||
raise HTTPException(404, f"Commande {numero} introuvable")
|
||
|
||
doc = win32com.client.CastTo(persist, "IBODocumentVente3")
|
||
doc.Read()
|
||
|
||
diagnostic["etapes"].append("✅ Document chargé")
|
||
|
||
# ========================================
|
||
# ÉTAPE 2 : CAPTURER L'ÉTAT INITIAL COMPLET
|
||
# ========================================
|
||
diagnostic["etapes"].append("📸 Capture état initial...")
|
||
|
||
champs_critiques = [
|
||
# Identification
|
||
"DO_Piece", "DO_Type", "DO_Domaine", "DO_Souche",
|
||
|
||
# Client (CRITIQUE)
|
||
"CT_Num",
|
||
|
||
# Dates
|
||
"DO_Date", "DO_DateLivr",
|
||
|
||
# Statut
|
||
"DO_Statut",
|
||
|
||
# Montants
|
||
"DO_TotalHT", "DO_TotalTTC",
|
||
|
||
# Références
|
||
"DO_Ref",
|
||
|
||
# Champs métier
|
||
"DO_Expedit", "DO_NbFacture", "DO_BLFact",
|
||
"DO_TxEscompte", "DO_Reliquat", "DO_Imprim",
|
||
|
||
# Champs comptables
|
||
"DO_Condition", "DO_Tarif", "DO_Colisage",
|
||
"DO_TypeColis", "DO_Transaction", "DO_Langue",
|
||
"DO_Ecart", "DO_Regime",
|
||
|
||
# Flags
|
||
"DO_Valide", "DO_Transfere", "DO_Cloture",
|
||
"DO_NoWeb", "DO_Attente", "DO_Provenance"
|
||
]
|
||
|
||
for champ in champs_critiques:
|
||
try:
|
||
valeur = getattr(doc, champ, None)
|
||
|
||
# Conversion en string pour éviter les problèmes de sérialisation
|
||
if valeur is None:
|
||
valeur_str = "NULL"
|
||
elif isinstance(valeur, bool):
|
||
valeur_str = "True" if valeur else "False"
|
||
elif isinstance(valeur, (int, float)):
|
||
valeur_str = str(valeur)
|
||
else:
|
||
valeur_str = str(valeur)
|
||
|
||
diagnostic["champs_avant"][champ] = {
|
||
"valeur": valeur_str,
|
||
"type": type(valeur).__name__ if valeur is not None else "NoneType"
|
||
}
|
||
|
||
except Exception as e:
|
||
diagnostic["champs_avant"][champ] = {
|
||
"erreur": str(e)[:100]
|
||
}
|
||
|
||
# ========================================
|
||
# ÉTAPE 3 : VÉRIFIER LE CLIENT (ULTRA-CRITIQUE)
|
||
# ========================================
|
||
diagnostic["etapes"].append("👤 Vérification client...")
|
||
|
||
client_info = {
|
||
"avant_modification": {}
|
||
}
|
||
|
||
try:
|
||
# Méthode 1 : Via CT_Num
|
||
client_code_direct = getattr(doc, "CT_Num", "")
|
||
client_info["avant_modification"]["CT_Num_direct"] = client_code_direct
|
||
|
||
# Méthode 2 : Via objet Client
|
||
client_obj = getattr(doc, "Client", None)
|
||
if client_obj:
|
||
client_obj.Read()
|
||
client_info["avant_modification"]["Client_obj_exists"] = True
|
||
client_info["avant_modification"]["Client_CT_Num"] = getattr(client_obj, "CT_Num", "").strip()
|
||
client_info["avant_modification"]["Client_CT_Intitule"] = getattr(client_obj, "CT_Intitule", "").strip()
|
||
else:
|
||
client_info["avant_modification"]["Client_obj_exists"] = False
|
||
diagnostic["erreurs_detectees"].append({
|
||
"severite": "CRITIQUE",
|
||
"message": "Objet Client est NULL avant toute modification"
|
||
})
|
||
|
||
except Exception as e:
|
||
client_info["avant_modification"]["erreur"] = str(e)
|
||
diagnostic["erreurs_detectees"].append({
|
||
"severite": "CRITIQUE",
|
||
"message": f"Impossible de lire le client: {e}"
|
||
})
|
||
|
||
diagnostic["client"] = client_info
|
||
|
||
# ========================================
|
||
# ÉTAPE 4 : TEST WRITE() BASIQUE (SANS MODIFICATION)
|
||
# ========================================
|
||
diagnostic["etapes"].append("🧪 Test Write() sans modification...")
|
||
|
||
test_write_basique = {
|
||
"description": "Write() sans aucune modification",
|
||
"succes": False
|
||
}
|
||
|
||
try:
|
||
doc.Write()
|
||
test_write_basique["succes"] = True
|
||
test_write_basique["note"] = "✅ Write() basique fonctionne"
|
||
|
||
except Exception as e:
|
||
test_write_basique["succes"] = False
|
||
test_write_basique["erreur"] = str(e)
|
||
test_write_basique["note"] = "❌ CRITIQUE: Write() échoue même sans modification"
|
||
|
||
diagnostic["erreurs_detectees"].append({
|
||
"severite": "BLOQUANT",
|
||
"message": f"Write() basique échoue: {str(e)[:200]}"
|
||
})
|
||
|
||
diagnostic["tests_modifications"].append(test_write_basique)
|
||
|
||
# Si Write() basique échoue, inutile de continuer
|
||
if not test_write_basique["succes"]:
|
||
diagnostic["recommandations"].append(
|
||
"❌ Le document est VERROUILLÉ - Impossible de le modifier même sans changement"
|
||
)
|
||
return {"success": False, "diagnostic": diagnostic}
|
||
|
||
# ========================================
|
||
# ÉTAPE 5 : TEST MODIFICATION DATE
|
||
# ========================================
|
||
if test_date:
|
||
diagnostic["etapes"].append("📅 Test modification date...")
|
||
|
||
test_date_modif = {
|
||
"description": "Modification de DO_Date",
|
||
"succes": False
|
||
}
|
||
|
||
try:
|
||
# Sauvegarder la date originale
|
||
date_originale = getattr(doc, "DO_Date", None)
|
||
|
||
# Réaffecter la même date
|
||
doc.DO_Date = date_originale
|
||
|
||
# ✅ CRITIQUE : Vérifier si le client est toujours là
|
||
client_obj_test = getattr(doc, "Client", None)
|
||
if client_obj_test:
|
||
client_obj_test.Read()
|
||
test_date_modif["client_apres_date"] = getattr(client_obj_test, "CT_Num", "")
|
||
else:
|
||
test_date_modif["client_apres_date"] = "NULL"
|
||
diagnostic["erreurs_detectees"].append({
|
||
"severite": "CRITIQUE",
|
||
"etape": "Après modification date",
|
||
"message": "Le client a DISPARU après modification de DO_Date"
|
||
})
|
||
|
||
# Écrire
|
||
doc.Write()
|
||
|
||
test_date_modif["succes"] = True
|
||
test_date_modif["note"] = "✅ Modification date OK"
|
||
|
||
except Exception as e:
|
||
test_date_modif["succes"] = False
|
||
test_date_modif["erreur"] = str(e)
|
||
test_date_modif["note"] = f"❌ Échec: {str(e)[:100]}"
|
||
|
||
diagnostic["erreurs_detectees"].append({
|
||
"severite": "BLOQUANT",
|
||
"etape": "Modification date",
|
||
"message": str(e)
|
||
})
|
||
|
||
diagnostic["tests_modifications"].append(test_date_modif)
|
||
|
||
# Relire le document
|
||
doc.Read()
|
||
|
||
# ========================================
|
||
# ÉTAPE 6 : TEST MODIFICATION STATUT
|
||
# ========================================
|
||
if test_statut:
|
||
diagnostic["etapes"].append("📊 Test modification statut...")
|
||
|
||
test_statut_modif = {
|
||
"description": "Modification de DO_Statut",
|
||
"succes": False
|
||
}
|
||
|
||
try:
|
||
# Sauvegarder le statut original
|
||
statut_original = getattr(doc, "DO_Statut", 0)
|
||
|
||
# Réaffecter le même statut
|
||
doc.DO_Statut = statut_original
|
||
|
||
# Vérifier client
|
||
client_obj_test = getattr(doc, "Client", None)
|
||
if client_obj_test:
|
||
client_obj_test.Read()
|
||
test_statut_modif["client_apres_statut"] = getattr(client_obj_test, "CT_Num", "")
|
||
else:
|
||
test_statut_modif["client_apres_statut"] = "NULL"
|
||
diagnostic["erreurs_detectees"].append({
|
||
"severite": "CRITIQUE",
|
||
"etape": "Après modification statut",
|
||
"message": "Le client a DISPARU après modification de DO_Statut"
|
||
})
|
||
|
||
# Écrire
|
||
doc.Write()
|
||
|
||
test_statut_modif["succes"] = True
|
||
test_statut_modif["note"] = "✅ Modification statut OK"
|
||
|
||
except Exception as e:
|
||
test_statut_modif["succes"] = False
|
||
test_statut_modif["erreur"] = str(e)
|
||
test_statut_modif["note"] = f"❌ Échec: {str(e)[:100]}"
|
||
|
||
diagnostic["erreurs_detectees"].append({
|
||
"severite": "BLOQUANT",
|
||
"etape": "Modification statut",
|
||
"message": str(e)
|
||
})
|
||
|
||
diagnostic["tests_modifications"].append(test_statut_modif)
|
||
|
||
# Relire
|
||
doc.Read()
|
||
|
||
# ========================================
|
||
# ÉTAPE 7 : TEST MODIFICATION LIGNES
|
||
# ========================================
|
||
if test_lignes:
|
||
diagnostic["etapes"].append("📦 Test modification lignes...")
|
||
|
||
test_lignes_modif = {
|
||
"description": "Modification lignes",
|
||
"succes": False,
|
||
"details": []
|
||
}
|
||
|
||
try:
|
||
# Obtenir factory lignes
|
||
try:
|
||
factory_lignes = doc.FactoryDocumentLigne
|
||
except:
|
||
factory_lignes = doc.FactoryDocumentVenteLigne
|
||
|
||
# Lire la première ligne
|
||
ligne_p = factory_lignes.List(1)
|
||
if ligne_p is None:
|
||
test_lignes_modif["note"] = "⚠️ Aucune ligne trouvée"
|
||
else:
|
||
ligne = win32com.client.CastTo(ligne_p, "IBODocumentLigne3")
|
||
ligne.Read()
|
||
|
||
# Sauvegarder quantité originale
|
||
qte_originale = float(getattr(ligne, "DL_Qte", 0.0))
|
||
|
||
test_lignes_modif["details"].append({
|
||
"action": "Lecture ligne 1",
|
||
"quantite_originale": qte_originale
|
||
})
|
||
|
||
# Réaffecter la même quantité
|
||
ligne.DL_Qte = qte_originale
|
||
ligne.Write()
|
||
|
||
test_lignes_modif["details"].append({
|
||
"action": "Write() ligne",
|
||
"succes": True
|
||
})
|
||
|
||
# ✅ CRITIQUE : Vérifier si le client du document est toujours là
|
||
doc.Read()
|
||
client_obj_test = getattr(doc, "Client", None)
|
||
if client_obj_test:
|
||
client_obj_test.Read()
|
||
test_lignes_modif["client_apres_lignes"] = getattr(client_obj_test, "CT_Num", "")
|
||
else:
|
||
test_lignes_modif["client_apres_lignes"] = "NULL"
|
||
diagnostic["erreurs_detectees"].append({
|
||
"severite": "CRITIQUE",
|
||
"etape": "Après modification lignes",
|
||
"message": "Le client a DISPARU après modification des lignes"
|
||
})
|
||
|
||
# Écrire le document
|
||
doc.Write()
|
||
|
||
test_lignes_modif["succes"] = True
|
||
test_lignes_modif["note"] = "✅ Modification lignes OK"
|
||
|
||
except Exception as e:
|
||
test_lignes_modif["succes"] = False
|
||
test_lignes_modif["erreur"] = str(e)
|
||
test_lignes_modif["note"] = f"❌ Échec: {str(e)[:100]}"
|
||
|
||
diagnostic["erreurs_detectees"].append({
|
||
"severite": "BLOQUANT",
|
||
"etape": "Modification lignes",
|
||
"message": str(e)
|
||
})
|
||
|
||
diagnostic["tests_modifications"].append(test_lignes_modif)
|
||
|
||
# ========================================
|
||
# ÉTAPE 8 : CAPTURER L'ÉTAT FINAL
|
||
# ========================================
|
||
diagnostic["etapes"].append("📸 Capture état final...")
|
||
|
||
doc.Read()
|
||
|
||
for champ in champs_critiques:
|
||
try:
|
||
valeur = getattr(doc, champ, None)
|
||
|
||
if valeur is None:
|
||
valeur_str = "NULL"
|
||
elif isinstance(valeur, bool):
|
||
valeur_str = "True" if valeur else "False"
|
||
elif isinstance(valeur, (int, float)):
|
||
valeur_str = str(valeur)
|
||
else:
|
||
valeur_str = str(valeur)
|
||
|
||
diagnostic["champs_apres"][champ] = {
|
||
"valeur": valeur_str,
|
||
"type": type(valeur).__name__ if valeur is not None else "NoneType"
|
||
}
|
||
|
||
except Exception as e:
|
||
diagnostic["champs_apres"][champ] = {
|
||
"erreur": str(e)[:100]
|
||
}
|
||
|
||
# ========================================
|
||
# ÉTAPE 9 : COMPARAISON AVANT/APRÈS
|
||
# ========================================
|
||
diagnostic["etapes"].append("🔍 Comparaison avant/après...")
|
||
|
||
champs_modifies = []
|
||
champs_vides = []
|
||
|
||
for champ in champs_critiques:
|
||
avant = diagnostic["champs_avant"].get(champ, {}).get("valeur", "N/A")
|
||
apres = diagnostic["champs_apres"].get(champ, {}).get("valeur", "N/A")
|
||
|
||
if avant != apres:
|
||
champs_modifies.append({
|
||
"champ": champ,
|
||
"avant": avant,
|
||
"apres": apres
|
||
})
|
||
|
||
# Vérifier si un champ critique est devenu vide
|
||
if apres in ["NULL", "", "0"] and avant not in ["NULL", "", "0"]:
|
||
if champ in ["CT_Num", "DO_Date", "DO_Type", "DO_Souche"]:
|
||
champs_vides.append({
|
||
"champ": champ,
|
||
"avant": avant,
|
||
"apres": apres,
|
||
"severite": "CRITIQUE"
|
||
})
|
||
|
||
diagnostic["comparaison"] = {
|
||
"champs_modifies": champs_modifies,
|
||
"champs_vides": champs_vides
|
||
}
|
||
|
||
# ========================================
|
||
# ÉTAPE 10 : RECOMMANDATIONS
|
||
# ========================================
|
||
|
||
if champs_vides:
|
||
diagnostic["recommandations"].append(
|
||
f"❌ CRITIQUE: {len(champs_vides)} champ(s) critique(s) sont devenus vides: "
|
||
f"{[c['champ'] for c in champs_vides]}"
|
||
)
|
||
|
||
if any(e["severite"] == "CRITIQUE" for e in diagnostic["erreurs_detectees"] if "client" in e.get("message", "").lower()):
|
||
diagnostic["recommandations"].append(
|
||
"❌ PROBLÈME CLIENT DÉTECTÉ: Le client se perd pendant les modifications. "
|
||
"Vous devez réassocier le client APRÈS chaque modification."
|
||
)
|
||
|
||
if not diagnostic["erreurs_detectees"]:
|
||
diagnostic["recommandations"].append(
|
||
"✅ Aucun problème détecté dans les tests. Le document semble modifiable."
|
||
)
|
||
|
||
return {
|
||
"success": True,
|
||
"diagnostic": diagnostic
|
||
}
|
||
|
||
except HTTPException:
|
||
raise
|
||
except Exception as e:
|
||
logger.error(f"[DIAG] Erreur diagnostic modification: {e}", exc_info=True)
|
||
raise HTTPException(500, str(e))
|
||
|
||
|
||
# À ajouter dans main.py (Windows Gateway)
|
||
|
||
@app.get("/sage/diagnostic/comparer-bc00067-bc00068")
|
||
def comparer_bc00067_bc00068():
|
||
"""
|
||
🔬 DIAGNOSTIC ULTRA-DÉTAILLÉ : BC00067 (échoue) vs BC00068 (marche)
|
||
|
||
Compare TOUS les champs pour identifier LA différence qui fait que BC00067 ne peut pas être modifié
|
||
"""
|
||
try:
|
||
if not sage or not sage.cial:
|
||
raise HTTPException(503, "Service Sage indisponible")
|
||
|
||
with sage._com_context(), sage._lock_com:
|
||
factory = sage.cial.FactoryDocumentVente
|
||
|
||
comparaison = {
|
||
"bc00067": {},
|
||
"bc00068": {},
|
||
"differences": [],
|
||
"tests": []
|
||
}
|
||
|
||
# ========================================
|
||
# CHARGER LES DEUX DOCUMENTS
|
||
# ========================================
|
||
docs = {}
|
||
|
||
for numero in ["BC00067", "BC00068"]:
|
||
persist = None
|
||
|
||
for type_test in [10, 3, settings.SAGE_TYPE_BON_COMMANDE]:
|
||
try:
|
||
persist = factory.ReadPiece(type_test, numero)
|
||
if persist:
|
||
break
|
||
except:
|
||
continue
|
||
|
||
if not persist:
|
||
return {
|
||
"success": False,
|
||
"error": f"{numero} introuvable"
|
||
}
|
||
|
||
doc = win32com.client.CastTo(persist, "IBODocumentVente3")
|
||
doc.Read()
|
||
|
||
docs[numero] = doc
|
||
|
||
# ========================================
|
||
# COMPARER TOUS LES CHAMPS CRITIQUES
|
||
# ========================================
|
||
champs_a_comparer = [
|
||
# Identification
|
||
"DO_Piece", "DO_Type", "DO_Domaine", "DO_Souche",
|
||
|
||
# Client
|
||
"CT_Num",
|
||
|
||
# Dates
|
||
"DO_Date", "DO_DateLivr",
|
||
|
||
# Statut et état
|
||
"DO_Statut", "DO_Valide", "DO_Transfere", "DO_Cloture",
|
||
|
||
# Montants
|
||
"DO_TotalHT", "DO_TotalTTC",
|
||
|
||
# Références
|
||
"DO_Ref",
|
||
|
||
# Champs métier
|
||
"DO_Expedit", "DO_NbFacture", "DO_BLFact",
|
||
"DO_TxEscompte", "DO_Reliquat", "DO_Imprim",
|
||
|
||
# Champs comptables
|
||
"DO_Condition", "DO_Tarif", "DO_Colisage",
|
||
"DO_TypeColis", "DO_Transaction", "DO_Langue",
|
||
"DO_Ecart", "DO_Regime",
|
||
|
||
# Flags
|
||
"DO_NoWeb", "DO_Attente", "DO_Provenance"
|
||
]
|
||
|
||
for champ in champs_a_comparer:
|
||
try:
|
||
val_67 = getattr(docs["BC00067"], champ, None)
|
||
val_68 = getattr(docs["BC00068"], champ, None)
|
||
|
||
# Convertir en string pour comparaison
|
||
str_67 = str(val_67) if val_67 is not None else "NULL"
|
||
str_68 = str(val_68) if val_68 is not None else "NULL"
|
||
|
||
comparaison["bc00067"][champ] = str_67
|
||
comparaison["bc00068"][champ] = str_68
|
||
|
||
if str_67 != str_68:
|
||
comparaison["differences"].append({
|
||
"champ": champ,
|
||
"bc00067": str_67,
|
||
"bc00068": str_68,
|
||
"critique": champ in [
|
||
"DO_Type", "DO_Domaine", "DO_Souche",
|
||
"DO_Statut", "DO_Transfere", "DO_Cloture",
|
||
"CT_Num"
|
||
]
|
||
})
|
||
|
||
except Exception as e:
|
||
comparaison["differences"].append({
|
||
"champ": champ,
|
||
"erreur": str(e)
|
||
})
|
||
|
||
# ========================================
|
||
# TEST WRITE() SUR CHAQUE DOCUMENT
|
||
# ========================================
|
||
for numero in ["BC00067", "BC00068"]:
|
||
test_result = {
|
||
"numero": numero,
|
||
"write_basique": False,
|
||
"client_avant": "",
|
||
"client_apres": "",
|
||
"erreur": None
|
||
}
|
||
|
||
doc = docs[numero]
|
||
|
||
try:
|
||
# Client avant
|
||
client_obj = getattr(doc, "Client", None)
|
||
if client_obj:
|
||
client_obj.Read()
|
||
test_result["client_avant"] = getattr(client_obj, "CT_Num", "")
|
||
|
||
# Test Write()
|
||
doc.Write()
|
||
test_result["write_basique"] = True
|
||
|
||
# Client après
|
||
doc.Read()
|
||
client_obj = getattr(doc, "Client", None)
|
||
if client_obj:
|
||
client_obj.Read()
|
||
test_result["client_apres"] = getattr(client_obj, "CT_Num", "")
|
||
|
||
except Exception as e:
|
||
test_result["write_basique"] = False
|
||
test_result["erreur"] = str(e)
|
||
|
||
comparaison["tests"].append(test_result)
|
||
|
||
# ========================================
|
||
# RÉSUMÉ
|
||
# ========================================
|
||
nb_diff = len(comparaison["differences"])
|
||
nb_diff_critiques = sum(1 for d in comparaison["differences"] if d.get("critique", False))
|
||
|
||
comparaison["resume"] = {
|
||
"nb_differences": nb_diff,
|
||
"nb_differences_critiques": nb_diff_critiques,
|
||
"bc00067_write_ok": any(t["numero"] == "BC00067" and t["write_basique"] for t in comparaison["tests"]),
|
||
"bc00068_write_ok": any(t["numero"] == "BC00068" and t["write_basique"] for t in comparaison["tests"]),
|
||
}
|
||
|
||
return {
|
||
"success": True,
|
||
"comparaison": comparaison
|
||
}
|
||
|
||
except Exception as e:
|
||
logger.error(f"❌ Erreur comparaison: {e}", exc_info=True)
|
||
raise HTTPException(500, str(e))
|
||
|
||
|
||
# =====================================================
|
||
# LANCEMENT
|
||
# =====================================================
|
||
if __name__ == "__main__":
|
||
uvicorn.run(
|
||
"main:app",
|
||
host=settings.api_host,
|
||
port=settings.api_port,
|
||
reload=False, # Pas de reload en production
|
||
log_level="info",
|
||
)
|