|
|
|
Bonjour {{CT_Intitule}},
La facture {{DO_Piece}} du {{DO_Date}} d'un montant de {{DO_TotalTTC}}€ TTC reste impayée.
Merci de régulariser dans les meilleurs délais.
Cordialement,
""", "variables_disponibles": [ "DO_Piece", "DO_Date", "CT_Intitule", "DO_TotalHT", "DO_TotalTTC", ], } } @app.post("/factures/{id}/relancer", tags=["Factures"]) async def relancer_facture( id: str, relance: RelanceFactureRequest, session: AsyncSession = Depends(get_session), ): try: facture = sage_client.lire_document(id, TypeDocumentSQL.FACTURE) if not facture: raise HTTPException(404, f"Facture {id} introuvable") contact = sage_client.lire_contact_client(facture["client_code"]) if not contact or not contact.get("email"): raise HTTPException(400, "Aucun email trouvé pour ce client") template = templates_email_db["relance_facture"] variables = { "DO_Piece": facture.get("numero", id), "DO_Date": str(facture.get("date", "")), "CT_Intitule": facture.get("client_intitule", ""), "DO_TotalHT": f"{facture.get('total_ht', 0):.2f}", "DO_TotalTTC": f"{facture.get('total_ttc', 0):.2f}", } sujet = template["sujet"] corps = relance.message_personnalise or template["corps_html"] for var, valeur in variables.items(): sujet = sujet.replace(f"{{{{{var}}}}}", valeur) corps = corps.replace(f"{{{{{var}}}}}", valeur) email_log = EmailLog( id=str(uuid.uuid4()), destinataire=contact["email"], sujet=sujet, corps_html=corps, document_ids=id, type_document=TypeDocument.FACTURE, statut=StatutEmailEnum.EN_ATTENTE, date_creation=datetime.now(), nb_tentatives=0, ) session.add(email_log) await session.flush() email_queue.enqueue(email_log.id) sage_client.mettre_a_jour_derniere_relance(id, TypeDocument.FACTURE) await session.commit() logger.info(f"Relance facture: {id} → {contact['email']}") return { "success": True, "facture_id": id, "email_log_id": email_log.id, "destinataire": contact["email"], } except HTTPException: raise except Exception as e: logger.error(f"Erreur relance facture: {e}") raise HTTPException(500, str(e)) @app.get("/emails/logs", tags=["Emails"]) async def journal_emails( statut: Optional[StatutEmail] = Query(None), destinataire: Optional[str] = Query(None), limit: int = Query(100, le=1000), session: AsyncSession = Depends(get_session), ): query = select(EmailLog) if statut: query = query.where(EmailLog.statut == StatutEmailEnum[statut.value]) if destinataire: query = query.where(EmailLog.destinataire.contains(destinataire)) query = query.order_by(EmailLog.date_creation.desc()).limit(limit) result = await session.execute(query) logs = result.scalars().all() return [ { "id": log.id, "destinataire": log.destinataire, "sujet": log.sujet, "statut": log.statut.value, "date_creation": log.date_creation.isoformat(), "date_envoi": log.date_envoi.isoformat() if log.date_envoi else None, "nb_tentatives": log.nb_tentatives, "derniere_erreur": log.derniere_erreur, "document_ids": log.document_ids, } for log in logs ] @app.get("/emails/logs/export", tags=["Emails"]) async def exporter_logs_csv( statut: Optional[StatutEmail] = Query(None), session: AsyncSession = Depends(get_session), ): query = select(EmailLog) if statut: query = query.where(EmailLog.statut == StatutEmailEnum[statut.value]) query = query.order_by(EmailLog.date_creation.desc()) result = await session.execute(query) logs = result.scalars().all() output = io.StringIO() writer = csv.writer(output) writer.writerow( [ "ID", "Destinataire", "Sujet", "Statut", "Date Création", "Date Envoi", "Nb Tentatives", "Erreur", "Documents", ] ) for log in logs: writer.writerow( [ log.id, log.destinataire, log.sujet, log.statut.value, log.date_creation.isoformat(), log.date_envoi.isoformat() if log.date_envoi else "", log.nb_tentatives, log.derniere_erreur or "", log.document_ids or "", ] ) output.seek(0) return StreamingResponse( iter([output.getvalue()]), media_type="text/csv", headers={ "Content-Disposition": f"attachment; filename=emails_logs_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv" }, ) class TemplateEmail(BaseModel): id: Optional[str] = None nom: str sujet: str corps_html: str variables_disponibles: List[str] = [] class TemplatePreviewRequest(BaseModel): template_id: str document_id: str type_document: TypeDocument @app.get("/templates/emails", response_model=List[TemplateEmail], tags=["Emails"]) async def lister_templates(): return [TemplateEmail(**template) for template in templates_email_db.values()] @app.get( "/templates/emails/{template_id}", response_model=TemplateEmail, tags=["Emails"] ) async def lire_template(template_id: str): if template_id not in templates_email_db: raise HTTPException(404, f"Template {template_id} introuvable") return TemplateEmail(**templates_email_db[template_id]) @app.post("/templates/emails", response_model=TemplateEmail, tags=["Emails"]) async def creer_template(template: TemplateEmail): template_id = str(uuid.uuid4()) templates_email_db[template_id] = { "id": template_id, "nom": template.nom, "sujet": template.sujet, "corps_html": template.corps_html, "variables_disponibles": template.variables_disponibles, } logger.info(f"Template créé: {template_id}") return TemplateEmail(id=template_id, **template.dict()) @app.put( "/templates/emails/{template_id}", response_model=TemplateEmail, tags=["Emails"] ) async def modifier_template(template_id: str, template: TemplateEmail): if template_id not in templates_email_db: raise HTTPException(404, f"Template {template_id} introuvable") if template_id in ["relance_devis", "relance_facture"]: raise HTTPException(400, "Les templates système ne peuvent pas être modifiés") templates_email_db[template_id] = { "id": template_id, "nom": template.nom, "sujet": template.sujet, "corps_html": template.corps_html, "variables_disponibles": template.variables_disponibles, } logger.info(f"Template modifié: {template_id}") return TemplateEmail(id=template_id, **template.dict()) @app.delete("/templates/emails/{template_id}", tags=["Emails"]) async def supprimer_template(template_id: str): if template_id not in templates_email_db: raise HTTPException(404, f"Template {template_id} introuvable") if template_id in ["relance_devis", "relance_facture"]: raise HTTPException(400, "Les templates système ne peuvent pas être supprimés") del templates_email_db[template_id] logger.info(f"Template supprimé: {template_id}") return {"success": True, "message": f"Template {template_id} supprimé"} @app.post("/templates/emails/preview", tags=["Emails"]) async def previsualiser_email(preview: TemplatePreviewRequest): if preview.template_id not in templates_email_db: raise HTTPException(404, f"Template {preview.template_id} introuvable") template = templates_email_db[preview.template_id] doc = sage_client.lire_document(preview.document_id, preview.type_document) if not doc: raise HTTPException(404, f"Document {preview.document_id} introuvable") variables = { "DO_Piece": doc.get("numero", preview.document_id), "DO_Date": str(doc.get("date", "")), "CT_Intitule": doc.get("client_intitule", ""), "DO_TotalHT": f"{doc.get('total_ht', 0):.2f}", "DO_TotalTTC": f"{doc.get('total_ttc', 0):.2f}", } sujet_preview = template["sujet"] corps_preview = template["corps_html"] for var, valeur in variables.items(): sujet_preview = sujet_preview.replace(f"{{{{{var}}}}}", valeur) corps_preview = corps_preview.replace(f"{{{{{var}}}}}", valeur) return { "template_id": preview.template_id, "document_id": preview.document_id, "sujet": sujet_preview, "corps_html": corps_preview, "variables_utilisees": variables, } @app.get("/health", tags=["System"]) async def health_check(): gateway_health = sage_client.health() return { "status": "healthy", "sage_gateway": gateway_health, "email_queue": { "running": email_queue.running, "workers": len(email_queue.workers), "queue_size": email_queue.queue.qsize(), }, "timestamp": datetime.now().isoformat(), } @app.get("/", tags=["System"]) async def root(): return { "api": "Sage 100c Dataven - VPS Linux", "version": "2.0.0", "documentation": "/docs", "health": "/health", } @app.get("/admin/cache/info", tags=["Admin"]) async def info_cache(): try: cache_info = sage_client.get_cache_info() return cache_info except Exception as e: logger.error(f"Erreur info cache: {e}") raise HTTPException(500, str(e)) @app.get("/admin/queue/status", tags=["Admin"]) async def statut_queue(): return { "queue_size": email_queue.queue.qsize(), "workers": len(email_queue.workers), "running": email_queue.running, } @app.get("/prospects", tags=["Prospects"]) async def rechercher_prospects(query: Optional[str] = Query(None)): try: prospects = sage_client.lister_prospects(filtre=query or "") return prospects except Exception as e: logger.error(f"Erreur recherche prospects: {e}") raise HTTPException(500, str(e)) @app.get("/prospects/{code}", tags=["Prospects"]) async def lire_prospect(code: str): try: prospect = sage_client.lire_prospect(code) if not prospect: raise HTTPException(404, f"Prospect {code} introuvable") return prospect except HTTPException: raise except Exception as e: logger.error(f"Erreur lecture prospect: {e}") raise HTTPException(500, str(e)) @app.get("/fournisseurs", response_model=List[FournisseurDetails], tags=["Fournisseurs"]) async def rechercher_fournisseurs(query: Optional[str] = Query(None)): try: fournisseurs = sage_client.lister_fournisseurs(filtre=query or "") logger.info(f"{len(fournisseurs)} fournisseurs") if len(fournisseurs) == 0: logger.warning("Aucun fournisseur retourné - vérifier la gateway Windows") return [FournisseurDetails(**f) for f in fournisseurs] except Exception as e: logger.error(f"Erreur recherche fournisseurs: {e}") raise HTTPException(500, str(e)) @app.post("/fournisseurs", status_code=201, tags=["Fournisseurs"]) async def ajouter_fournisseur( fournisseur: FournisseurCreateAPIRequest, session: AsyncSession = Depends(get_session), ): try: nouveau_fournisseur = sage_client.creer_fournisseur(fournisseur.dict()) logger.info(f"Fournisseur créé via API: {nouveau_fournisseur.get('numero')}") return { "success": True, "message": "Fournisseur créé avec succès", "data": nouveau_fournisseur, } except ValueError as e: logger.warning(f"Erreur métier création fournisseur: {e}") raise HTTPException(400, str(e)) except Exception as e: logger.error(f"Erreur technique création fournisseur: {e}") raise HTTPException(500, str(e)) @app.put("/fournisseurs/{code}", response_model=FournisseurDetails, tags=["Fournisseurs"]) async def modifier_fournisseur( code: str, fournisseur_update: FournisseurUpdateRequest, session: AsyncSession = Depends(get_session), ): try: resultat = sage_client.modifier_fournisseur( code, fournisseur_update.dict(exclude_none=True) ) logger.info(f"Fournisseur {code} modifié avec succès") return FournisseurDetails(**resultat) except ValueError as e: logger.warning(f"Erreur métier modification fournisseur {code}: {e}") raise HTTPException(404, str(e)) except Exception as e: logger.error(f"Erreur technique modification fournisseur {code}: {e}") raise HTTPException(500, str(e)) @app.get("/fournisseurs/{code}", tags=["Fournisseurs"]) async def lire_fournisseur(code: str): try: fournisseur = sage_client.lire_fournisseur(code) if not fournisseur: raise HTTPException(404, f"Fournisseur {code} introuvable") return fournisseur except HTTPException: raise except Exception as e: logger.error(f"Erreur lecture fournisseur: {e}") raise HTTPException(500, str(e)) @app.get("/avoirs", tags=["Avoirs"]) async def lister_avoirs( limit: int = Query(100, le=1000), statut: Optional[int] = Query(None) ): try: avoirs = sage_client.lister_avoirs(limit=limit, statut=statut) return avoirs except Exception as e: logger.error(f"Erreur liste avoirs: {e}") raise HTTPException(500, str(e)) @app.get("/avoirs/{numero}", tags=["Avoirs"]) async def lire_avoir(numero: str): try: avoir = sage_client.lire_document(numero, TypeDocumentSQL.BON_AVOIR) if not avoir: raise HTTPException(404, f"Avoir {numero} introuvable") return avoir except HTTPException: raise except Exception as e: logger.error(f"Erreur lecture avoir: {e}") raise HTTPException(500, str(e)) @app.post("/avoirs", status_code=201, tags=["Avoirs"]) async def creer_avoir( avoir: AvoirCreateRequest, session: AsyncSession = Depends(get_session) ): try: avoir_data = { "client_id": avoir.client_id, "date_avoir": (avoir.date_avoir.isoformat() if avoir.date_avoir else None), "date_livraison": ( avoir.date_livraison.isoformat() if avoir.date_livraison else None ), "reference": avoir.reference, "lignes": [ { "article_code": ligne.article_code, "quantite": ligne.quantite, "remise_pourcentage": ligne.remise_pourcentage, } for ligne in avoir.lignes ], } resultat = sage_client.creer_avoir(avoir_data) logger.info(f"Avoir créé: {resultat.get('numero_avoir')}") return { "success": True, "message": "Avoir créé avec succès", "data": { "numero_avoir": resultat["numero_avoir"], "client_id": avoir.client_id, "date_avoir": resultat["date_avoir"], "total_ht": resultat["total_ht"], "total_ttc": resultat["total_ttc"], "nb_lignes": resultat["nb_lignes"], "reference": avoir.reference, }, } except HTTPException: raise except Exception as e: logger.error(f"Erreur création avoir: {e}") raise HTTPException(500, str(e)) @app.put("/avoirs/{id}", tags=["Avoirs"]) async def modifier_avoir( id: str, avoir_update: AvoirUpdateRequest, session: AsyncSession = Depends(get_session), ): try: update_data = {} if avoir_update.date_avoir: update_data["date_avoir"] = avoir_update.date_avoir.isoformat() if avoir_update.lignes is not None: update_data["lignes"] = [ { "article_code": ligne.article_code, "quantite": ligne.quantite, "remise_pourcentage": ligne.remise_pourcentage, } for ligne in avoir_update.lignes ] if avoir_update.statut is not None: update_data["statut"] = avoir_update.statut if avoir_update.reference is not None: update_data["reference"] = avoir_update.reference resultat = sage_client.modifier_avoir(id, update_data) logger.info(f"Avoir {id} modifié avec succès") return { "success": True, "message": f"Avoir {id} modifié avec succès", "avoir": resultat, } except HTTPException: raise except Exception as e: logger.error(f"Erreur modification avoir {id}: {e}") raise HTTPException(500, str(e)) @app.get("/livraisons", tags=["Livraisons"]) async def lister_livraisons( limit: int = Query(100, le=1000), statut: Optional[int] = Query(None) ): try: livraisons = sage_client.lister_livraisons(limit=limit, statut=statut) return livraisons except Exception as e: logger.error(f"Erreur liste livraisons: {e}") raise HTTPException(500, str(e)) @app.get("/livraisons/{numero}", tags=["Livraisons"]) async def lire_livraison(numero: str): try: livraison = sage_client.lire_document(numero, TypeDocumentSQL.BON_LIVRAISON) if not livraison: raise HTTPException(404, f"Livraison {numero} introuvable") return livraison except HTTPException: raise except Exception as e: logger.error(f"Erreur lecture livraison: {e}") raise HTTPException(500, str(e)) @app.post("/livraisons", status_code=201, tags=["Livraisons"]) async def creer_livraison( livraison: LivraisonCreateRequest, session: AsyncSession = Depends(get_session) ): try: livraison_data = { "client_id": livraison.client_id, "date_livraison": ( livraison.date_livraison.isoformat() if livraison.date_livraison else None ), "date_livraison_prevue": ( livraison.date_livraison_prevue.isoformat() if livraison.date_livraison_prevue else None ), "reference": livraison.reference, "lignes": [ { "article_code": ligne.article_code, "quantite": ligne.quantite, "remise_pourcentage": ligne.remise_pourcentage, } for ligne in livraison.lignes ], } resultat = sage_client.creer_livraison(livraison_data) logger.info(f"Livraison créée: {resultat.get('numero_livraison')}") return { "success": True, "message": "Livraison créée avec succès", "data": { "numero_livraison": resultat["numero_livraison"], "client_id": livraison.client_id, "date_livraison": resultat["date_livraison"], "total_ht": resultat["total_ht"], "total_ttc": resultat["total_ttc"], "nb_lignes": resultat["nb_lignes"], "reference": livraison.reference, }, } except HTTPException: raise except Exception as e: logger.error(f"Erreur création livraison: {e}") raise HTTPException(500, str(e)) @app.put("/livraisons/{id}", tags=["Livraisons"]) async def modifier_livraison( id: str, livraison_update: LivraisonUpdateRequest, session: AsyncSession = Depends(get_session), ): try: update_data = {} if livraison_update.date_livraison: update_data["date_livraison"] = livraison_update.date_livraison.isoformat() if livraison_update.lignes is not None: update_data["lignes"] = [ { "article_code": ligne.article_code, "quantite": ligne.quantite, "remise_pourcentage": ligne.remise_pourcentage, } for ligne in livraison_update.lignes ] if livraison_update.statut is not None: update_data["statut"] = livraison_update.statut if livraison_update.reference is not None: update_data["reference"] = livraison_update.reference resultat = sage_client.modifier_livraison(id, update_data) logger.info(f"Livraison {id} modifiée avec succès") return { "success": True, "message": f"Livraison {id} modifiée avec succès", "livraison": resultat, } except HTTPException: raise except Exception as e: logger.error(f"Erreur modification livraison {id}: {e}") raise HTTPException(500, str(e)) @app.post("/workflow/livraison/{id}/to-facture", tags=["Workflows"]) async def livraison_vers_facture(id: str, session: AsyncSession = Depends(get_session)): try: resultat = sage_client.transformer_document( numero_source=id, type_source=settings.SAGE_TYPE_BON_LIVRAISON, # = 30 type_cible=settings.SAGE_TYPE_FACTURE, # = 60 ) workflow_log = WorkflowLog( id=str(uuid.uuid4()), document_source=id, type_source=TypeDocument.BON_LIVRAISON, document_cible=resultat.get("document_cible", ""), type_cible=TypeDocument.FACTURE, nb_lignes=resultat.get("nb_lignes", 0), date_transformation=datetime.now(), succes=True, ) session.add(workflow_log) await session.commit() logger.info( f"Transformation: Livraison {id} → Facture {resultat['document_cible']}" ) return { "success": True, "document_source": id, "document_cible": resultat["document_cible"], "nb_lignes": resultat["nb_lignes"], } except Exception as e: logger.error(f"Erreur transformation: {e}") raise HTTPException(500, str(e)) @app.post("/workflow/devis/{id}/to-facture", tags=["Workflows"]) async def devis_vers_facture_direct( id: str, session: AsyncSession = Depends(get_session) ): try: devis_existant = sage_client.lire_devis(id) if not devis_existant: raise HTTPException(404, f"Devis {id} introuvable") statut_devis = devis_existant.get("statut", 0) if statut_devis == 5: raise HTTPException( 400, f"Le devis {id} a déjà été transformé (statut=5). " f"Vérifiez les documents déjà créés depuis ce devis.", ) resultat = sage_client.transformer_document( numero_source=id, type_source=settings.SAGE_TYPE_DEVIS, # = 0 type_cible=settings.SAGE_TYPE_FACTURE, # = 60 ) workflow_log = WorkflowLog( id=str(uuid.uuid4()), document_source=id, type_source=TypeDocument.DEVIS, document_cible=resultat.get("document_cible", ""), type_cible=TypeDocument.FACTURE, nb_lignes=resultat.get("nb_lignes", 0), date_transformation=datetime.now(), succes=True, ) session.add(workflow_log) await session.commit() logger.info( f"Transformation DIRECTE: Devis {id} → Facture {resultat['document_cible']}" ) return { "success": True, "workflow": "devis_to_facture_direct", "document_source": id, "document_cible": resultat["document_cible"], "nb_lignes": resultat["nb_lignes"], "statut_devis_mis_a_jour": True, "message": f"Facture {resultat['document_cible']} créée directement depuis le devis {id}", } except HTTPException: raise except Exception as e: logger.error(f"Erreur transformation devis→facture: {e}", exc_info=True) raise HTTPException(500, str(e)) @app.post("/workflow/commande/{id}/to-livraison", tags=["Workflows"]) async def commande_vers_livraison( id: str, session: AsyncSession = Depends(get_session) ): try: commande_existante = sage_client.lire_document(id, TypeDocumentSQL.BON_COMMANDE) if not commande_existante: raise HTTPException(404, f"Commande {id} introuvable") statut_commande = commande_existante.get("statut", 0) if statut_commande == 5: raise HTTPException( 400, f"La commande {id} a déjà été transformée (statut=5). " f"Un bon de livraison existe probablement déjà.", ) if statut_commande == 6: raise HTTPException( 400, f"La commande {id} est annulée (statut=6) et ne peut pas être transformée.", ) resultat = sage_client.transformer_document( numero_source=id, type_source=settings.SAGE_TYPE_BON_COMMANDE, # = 10 type_cible=settings.SAGE_TYPE_BON_LIVRAISON, # = 30 ) workflow_log = WorkflowLog( id=str(uuid.uuid4()), document_source=id, type_source=TypeDocument.BON_COMMANDE, document_cible=resultat.get("document_cible", ""), type_cible=TypeDocument.BON_LIVRAISON, nb_lignes=resultat.get("nb_lignes", 0), date_transformation=datetime.now(), succes=True, ) session.add(workflow_log) await session.commit() logger.info( f"Transformation: Commande {id} → Livraison {resultat['document_cible']}" ) return { "success": True, "workflow": "commande_to_livraison", "document_source": id, "document_cible": resultat["document_cible"], "nb_lignes": resultat["nb_lignes"], "message": f"Bon de livraison {resultat['document_cible']} créé depuis la commande {id}", "next_step": f"Utilisez /workflow/livraison/{resultat['document_cible']}/to-facture pour créer la facture", } except HTTPException: raise except Exception as e: logger.error(f"Erreur transformation commande→livraison: {e}", exc_info=True) raise HTTPException(500, str(e)) @app.get( "/familles", response_model=List[FamilleResponse], tags=["Familles"], summary="Liste toutes les familles d'articles", ) async def lister_familles( filtre: Optional[str] = Query(None, description="Filtre sur code ou intitulé") ): try: familles = sage_client.lister_familles(filtre or "") logger.info(f"{len(familles)} famille(s) retournée(s)") return [FamilleResponse(**f) for f in familles] except Exception as e: logger.error(f"Erreur liste familles: {e}", exc_info=True) raise HTTPException( status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=f"Erreur lors de la récupération des familles: {str(e)}", ) @app.get( "/familles/{code}", response_model=FamilleResponse, tags=["Familles"], summary="Lecture d'une famille par son code", ) async def lire_famille( code: str = Path(..., description="Code de la famille (ex: ZDIVERS)") ): try: famille = sage_client.lire_famille(code) if not famille: logger.warning(f"Famille {code} introuvable") raise HTTPException( status_code=status.HTTP_404_NOT_FOUND, detail=f"Famille {code} introuvable", ) logger.info(f"Famille {code} lue: {famille.get('intitule', '')}") return FamilleResponse(**famille) except HTTPException: raise except Exception as e: logger.error(f"Erreur lecture famille {code}: {e}", exc_info=True) raise HTTPException( status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=f"Erreur lors de la lecture de la famille: {str(e)}", ) @app.post( "/familles", response_model=FamilleResponse, status_code=status.HTTP_201_CREATED, tags=["Familles"], summary="Création d'une famille d'articles", ) async def creer_famille(famille: FamilleCreateRequest): try: if not famille.code or not famille.intitule: raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail="Les champs 'code' et 'intitule' sont obligatoires", ) famille_data = famille.dict() logger.info(f"Création famille: {famille.code} - {famille.intitule}") resultat = sage_client.creer_famille(famille_data) logger.info(f"Famille créée: {resultat.get('code')}") return FamilleResponse(**resultat) except ValueError as e: logger.warning(f"Erreur métier création famille: {e}") raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e)) except HTTPException: raise except Exception as e: logger.error(f"Erreur technique création famille: {e}", exc_info=True) raise HTTPException( status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=f"Erreur lors de la création de la famille: {str(e)}", ) @app.post( "/stock/entree", response_model=MouvementStockResponse, status_code=status.HTTP_201_CREATED, tags=["Stock"], summary="ENTRÉE EN STOCK : Ajoute des articles dans le stock", ) async def creer_entree_stock(entree: EntreeStockRequest): try: entree_data = entree.dict() if entree_data.get("date_entree"): entree_data["date_entree"] = entree_data["date_entree"].isoformat() logger.info(f"Création entrée stock: {len(entree.lignes)} ligne(s)") resultat = sage_client.creer_entree_stock(entree_data) logger.info(f"Entrée stock créée: {resultat.get('numero')}") return MouvementStockResponse(**resultat) except ValueError as e: logger.warning(f"Erreur métier entrée stock: {e}") raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e)) except Exception as e: logger.error(f"Erreur technique entrée stock: {e}", exc_info=True) raise HTTPException( status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=f"Erreur lors de la création de l'entrée: {str(e)}", ) @app.post( "/stock/sortie", response_model=MouvementStockResponse, status_code=status.HTTP_201_CREATED, tags=["Stock"], summary="SORTIE DE STOCK : Retire des articles du stock", ) async def creer_sortie_stock(sortie: SortieStockRequest): try: sortie_data = sortie.dict() if sortie_data.get("date_sortie"): sortie_data["date_sortie"] = sortie_data["date_sortie"].isoformat() logger.info(f"📤 Création sortie stock: {len(sortie.lignes)} ligne(s)") resultat = sage_client.creer_sortie_stock(sortie_data) logger.info(f"Sortie stock créée: {resultat.get('numero')}") return MouvementStockResponse(**resultat) except ValueError as e: logger.warning(f"Erreur métier sortie stock: {e}") raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e)) except Exception as e: logger.error(f"Erreur technique sortie stock: {e}", exc_info=True) raise HTTPException( status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=f"Erreur lors de la création de la sortie: {str(e)}", ) @app.get( "/stock/mouvement/{numero}", response_model=MouvementStockResponse, tags=["Stock"], summary="Lecture d'un mouvement de stock", ) async def lire_mouvement_stock( numero: str = Path(..., description="Numéro du mouvement (ex: ME00123 ou MS00124)") ): try: mouvement = sage_client.lire_mouvement_stock(numero) if not mouvement: logger.warning(f"Mouvement {numero} introuvable") raise HTTPException( status_code=status.HTTP_404_NOT_FOUND, detail=f"Mouvement de stock {numero} introuvable", ) logger.info(f"Mouvement {numero} lu") return MouvementStockResponse(**mouvement) except HTTPException: raise except Exception as e: logger.error(f"Erreur lecture mouvement {numero}: {e}", exc_info=True) raise HTTPException( status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=f"Erreur lors de la lecture du mouvement: {str(e)}", ) @app.get( "/familles/stats/global", tags=["Familles"], summary="Statistiques sur les familles", ) async def statistiques_familles(): try: stats = sage_client.get_stats_familles() return {"success": True, "data": stats} except Exception as e: logger.error(f"Erreur stats familles: {e}", exc_info=True) raise HTTPException( status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=f"Erreur lors de la récupération des statistiques: {str(e)}", ) @app.get("/debug/users", response_model=List[UserResponse], tags=["Debug"]) async def lister_utilisateurs_debug( session: AsyncSession = Depends(get_session), limit: int = Query(100, le=1000), role: Optional[str] = Query(None), verified_only: bool = Query(False), ): from database import User from sqlalchemy import select try: query = select(User) if role: query = query.where(User.role == role) if verified_only: query = query.where(User.is_verified) query = query.order_by(User.created_at.desc()).limit(limit) result = await session.execute(query) users = result.scalars().all() users_response = [] for user in users: users_response.append( UserResponse( id=user.id, email=user.email, nom=user.nom, prenom=user.prenom, role=user.role, is_verified=user.is_verified, is_active=user.is_active, created_at=user.created_at.isoformat() if user.created_at else "", last_login=user.last_login.isoformat() if user.last_login else None, failed_login_attempts=user.failed_login_attempts or 0, ) ) logger.info( f"📋 Liste utilisateurs retournée: {len(users_response)} résultat(s)" ) return users_response except Exception as e: logger.error(f"Erreur liste utilisateurs: {e}") raise HTTPException(500, str(e)) @app.get("/debug/users/stats", tags=["Debug"]) async def statistiques_utilisateurs(session: AsyncSession = Depends(get_session)): from database import User from sqlalchemy import select, func try: total_query = select(func.count(User.id)) total_result = await session.execute(total_query) total = total_result.scalar() verified_query = select(func.count(User.id)).where(User.is_verified) verified_result = await session.execute(verified_query) verified = verified_result.scalar() active_query = select(func.count(User.id)).where(User.is_active) active_result = await session.execute(active_query) active = active_result.scalar() roles_query = select(User.role, func.count(User.id)).group_by(User.role) roles_result = await session.execute(roles_query) roles_stats = {role: count for role, count in roles_result.all()} return { "total_utilisateurs": total, "utilisateurs_verifies": verified, "utilisateurs_actifs": active, "utilisateurs_non_verifies": total - verified, "repartition_roles": roles_stats, "taux_verification": f"{(verified/total*100):.1f}%" if total > 0 else "0%", } except Exception as e: logger.error(f"Erreur stats utilisateurs: {e}") raise HTTPException(500, str(e)) @app.get("/modeles", tags=["PDF Sage-Like"]) async def get_modeles_disponibles(): """Liste tous les modèles PDF disponibles""" try: modeles = sage_client.lister_modeles_disponibles() return modeles except Exception as e: logger.error(f"Erreur listage modèles: {e}") raise HTTPException(500, str(e)) @app.get("/documents/{numero}/pdf", tags=["PDF Sage-Like"]) async def get_document_pdf( numero: str, type_doc: int = Query(..., description="0=devis, 60=facture, etc."), modele: str = Query( None, description="Nom du modèle (ex: 'Facture client logo.bgc')" ), download: bool = Query(False, description="Télécharger au lieu d'afficher"), ): try: pdf_bytes = sage_client.generer_pdf_document( numero=numero, type_doc=type_doc, modele=modele, base64_encode=False, # On veut les bytes bruts ) from fastapi.responses import Response disposition = "attachment" if download else "inline" filename = f"{numero}.pdf" return Response( content=pdf_bytes, media_type="application/pdf", headers={"Content-Disposition": f'{disposition}; filename="{filename}"'}, ) except Exception as e: logger.error(f"Erreur génération PDF: {e}") raise HTTPException(500, str(e)) @app.post("/clients/{numero}/contacts", response_model=Contact, tags=["Contacts"]) async def creer_contact(numero: str, contact: ContactCreate): try: try: sage_client.lire_client(numero) except: raise HTTPException(404, f"Client {numero} non trouvé") if contact.numero != numero: contact.numero = numero resultat = sage_client.creer_contact(contact.dict()) return Contact(**resultat) except HTTPException: raise except Exception as e: logger.error(f"Erreur création contact: {e}") raise HTTPException(500, str(e)) @app.get("/clients/{numero}/contacts", response_model=List[Contact], tags=["Contacts"]) async def lister_contacts_client(numero: str): try: contacts = sage_client.lister_contacts(numero) return [Contact(**c) for c in contacts] except Exception as e: logger.error(f"Erreur liste contacts: {e}") raise HTTPException(500, str(e)) @app.get("/clients/{numero}/contacts/{contact_numero}", response_model=Contact, tags=["Contacts"]) async def obtenir_contact(numero: str, contact_numero: int): try: contact = sage_client.obtenir_contact(numero, contact_numero) if not contact: raise HTTPException(404, f"Contact {contact_numero} non trouvé pour client {numero}") return Contact(**contact) except HTTPException: raise except Exception as e: logger.error(f"Erreur récupération contact: {e}") raise HTTPException(500, str(e)) @app.put("/clients/{numero}/contacts/{contact_numero}", response_model=Contact, tags=["Contacts"]) async def modifier_contact(numero: str, contact_numero: int, contact: ContactUpdate): try: contact_existant = sage_client.obtenir_contact(numero, contact_numero) if not contact_existant: raise HTTPException(404, f"Contact {contact_numero} non trouvé") updates = {k: v for k, v in contact.dict().items() if v is not None} if not updates: raise HTTPException(400, "Aucune modification fournie") resultat = sage_client.modifier_contact(numero, contact_numero, updates) return Contact(**resultat) except HTTPException: raise except Exception as e: logger.error(f"Erreur modification contact: {e}") raise HTTPException(500, str(e)) @app.delete("/clients/{numero}/contacts/{contact_numero}", tags=["Contacts"]) async def supprimer_contact(numero: str, contact_numero: int): try: resultat = sage_client.supprimer_contact(numero, contact_numero) return {"success": True, "message": f"Contact {contact_numero} supprimé"} except Exception as e: logger.error(f"Erreur suppression contact: {e}") raise HTTPException(500, str(e)) @app.post("/clients/{numero}/contacts/{contact_numero}/definir-defaut", tags=["Contacts"]) async def definir_contact_defaut(numero: str, contact_numero: int): try: resultat = sage_client.definir_contact_defaut(numero, contact_numero) return { "success": True, "message": f"Contact {contact_numero} défini comme contact par défaut", "data": resultat } except Exception as e: logger.error(f"Erreur définition contact par défaut: {e}") raise HTTPException(500, str(e)) @app.get("/tiers", response_model=List[TiersDetails], tags=["Tiers"]) async def obtenir_tiers( type_tiers: Optional[TypeTiers] = Query( None, description="Filtre par type: client, fournisseur, prospect, ou all" ), query: Optional[str] = Query( None, description="Recherche sur code ou intitulé" ) ): try: tiers = sage_client.lister_tiers( type_tiers=type_tiers.value if type_tiers else None, filtre=query or "" ) return [TiersDetails(**t) for t in tiers] except Exception as e: logger.error(f" Erreur recherche tiers: {e}") raise HTTPException(500, str(e)) @app.get("/tiers/{code}", response_model=TiersDetails, tags=["Tiers"]) async def lire_tiers_detail(code: str): try: tiers = sage_client.lire_tiers(code) if not tiers: raise HTTPException(404, f"Tiers {code} introuvable") return TiersDetails(**tiers) except HTTPException: raise except Exception as e: logger.error(f" Erreur lecture tiers {code}: {e}") raise HTTPException(500, str(e)) if __name__ == "__main__": uvicorn.run( "api:app", host=settings.api_host, port=settings.api_port, reload=settings.api_reload, )