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: RelanceFacture, + 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=StatutEmailDB.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 == StatutEmailDB[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 == StatutEmailDB[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 TemplatePreview(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: TemplatePreview): + 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("/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: FournisseurCreate, + 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: FournisseurUpdate, + 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: AvoirCreate, 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": _preparer_lignes_document(avoir.lignes), + } + + resultat = sage_client.creer_avoir(avoir_data) + + logger.info( + f"Avoir créé: {resultat.get('numero_avoir')} " + f"({resultat.get('total_ttc')}€ TTC)" + ) + + 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": resultat.get("reference"), + "date_livraison": resultat.get("date_livraison"), + }, + } + + 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: AvoirUpdate, + 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: LivraisonCreate, session: AsyncSession = Depends(get_session) +): + """ + Crée un bon de livraison dans Sage 100 + + - Le prix_unitaire_ht est optionnel (utilise le prix Sage si non fourni) + - La remise_pourcentage est appliquée après le prix + """ + 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": _preparer_lignes_document(livraison.lignes), + } + + resultat = sage_client.creer_livraison(livraison_data) + + logger.info( + f"Livraison créée: {resultat.get('numero_livraison')} " + f"({resultat.get('total_ttc')}€ TTC)" + ) + + 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"], + "date_livraison_prevue": resultat.get("date_livraison_prevue"), + "total_ht": resultat["total_ht"], + "total_ttc": resultat["total_ttc"], + "nb_lignes": resultat["nb_lignes"], + "reference": resultat.get("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: LivraisonUpdate, + 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[Familles], + 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 [Familles(**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=Familles, + 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 Familles(**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=Familles, + status_code=status.HTTP_201_CREATED, + tags=["Familles"], + summary="Création d'une famille d'articles", +) +async def creer_famille(famille: FamilleCreate): + 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 Familles(**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=MouvementStock, + 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: EntreeStock): + 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 MouvementStock(**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=MouvementStock, + status_code=status.HTTP_201_CREATED, + tags=["Stock"], + summary="SORTIE DE STOCK : Retire des articles du stock", +) +async def creer_sortie_stock(sortie: SortieStock): + 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 MouvementStock(**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=MouvementStock, + 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 MouvementStock(**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[Users], 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( + Users( + 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.post("/tiers/{numero}/contacts", response_model=Contact, tags=["Contacts"]) +async def creer_contact(numero: str, contact: ContactCreate): + try: + try: + sage_client.lire_tiers(numero) + except HTTPException: + raise + except Exception: + raise HTTPException(404, f"Tiers {numero} non trouvé") + + if contact.numero != numero: + contact.numero = numero + + resultat = sage_client.creer_contact(contact.dict()) + + if isinstance(resultat, dict) and "data" in resultat: + contact_data = resultat["data"] + else: + contact_data = resultat + + return Contact(**contact_data) + + except HTTPException: + raise + except Exception as e: + logger.error(f"Erreur création contact: {e}", exc_info=True) + raise HTTPException(500, str(e)) + + +@app.get("/tiers/{numero}/contacts", response_model=List[Contact], tags=["Contacts"]) +async def lister_contacts(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( + "/tiers/{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( + "/tiers/{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) + if isinstance(resultat, dict) and "data" in resultat: + contact_data = resultat["data"] + else: + contact_data = resultat + + return Contact(**contact_data) + + except HTTPException: + raise + except Exception as e: + logger.error(f"Erreur modification contact: {e}") + raise HTTPException(500, str(e)) + + +@app.delete("/tiers/{numero}/contacts/{contact_numero}", tags=["Contacts"]) +async def supprimer_contact(numero: str, contact_numero: int): + try: + 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("/tiers/{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[str] = Query( + None, + description="Filtre par type: 0/client, 1/fournisseur, 2/prospect, 3/all ou strings", + ), + query: Optional[str] = Query(None, description="Recherche sur code ou intitulé"), +): + try: + type_normalise = normaliser_type_tiers(type_tiers) + tiers = sage_client.lister_tiers(type_tiers=type_normalise, 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)) + + +@app.get("/sage/current-config", tags=["System"]) +async def get_current_sage_config( + ctx: GatewayContext = Depends(get_gateway_context_for_user), +): + return { + "source": "user_gateway" if not ctx.is_fallback else "fallback_env", + "gateway_id": ctx.gateway_id, + "gateway_name": ctx.gateway_name, + "gateway_url": ctx.url, + "user_id": ctx.user_id, + } + + +# Routes Collaborateurs +@app.get( + "/collaborateurs", + response_model=List[CollaborateurDetails], + tags=["Collaborateurs"], +) +async def lister_collaborateurs( + filtre: Optional[str] = Query(None, description="Filtre sur nom/prénom"), + actifs_seulement: bool = Query( + True, description="Exclure les collaborateurs en sommeil" + ), +): + """Liste tous les collaborateurs""" + try: + collaborateurs = sage_client.lister_collaborateurs(filtre, actifs_seulement) + return [CollaborateurDetails(**c) for c in collaborateurs] + except Exception as e: + logger.error(f"Erreur liste collaborateurs: {e}") + raise HTTPException(500, str(e)) + + +@app.get( + "/collaborateurs/{numero}", + response_model=CollaborateurDetails, + tags=["Collaborateurs"], +) +async def lire_collaborateur_detail(numero: int): + """Lit un collaborateur par son numéro""" + try: + collaborateur = sage_client.lire_collaborateur(numero) + + if not collaborateur: + raise HTTPException(404, f"Collaborateur {numero} introuvable") + + return CollaborateurDetails(**collaborateur) + + except HTTPException: + raise + except Exception as e: + logger.error(f"Erreur lecture collaborateur {numero}: {e}") + raise HTTPException(500, str(e)) + + +@app.post( + "/collaborateurs", + response_model=CollaborateurDetails, + tags=["Collaborateurs"], + status_code=201, +) +async def creer_collaborateur(collaborateur: CollaborateurCreate): + """Crée un nouveau collaborateur""" + try: + nouveau = sage_client.creer_collaborateur(collaborateur.model_dump()) + + if not nouveau: + raise HTTPException(500, "Échec création collaborateur") + + return CollaborateurDetails(**nouveau) + + except HTTPException: + raise + except Exception as e: + logger.error(f"Erreur création collaborateur: {e}") + raise HTTPException(500, str(e)) + + +@app.put( + "/collaborateurs/{numero}", + response_model=CollaborateurDetails, + tags=["Collaborateurs"], +) +async def modifier_collaborateur(numero: int, collaborateur: CollaborateurUpdate): + """Modifie un collaborateur existant""" + try: + modifie = sage_client.modifier_collaborateur( + numero, collaborateur.model_dump(exclude_unset=True) + ) + + if not modifie: + raise HTTPException(404, f"Collaborateur {numero} introuvable") + + return CollaborateurDetails(**modifie) + + except HTTPException: + raise + except Exception as e: + logger.error(f"Erreur modification collaborateur {numero}: {e}") + raise HTTPException(500, str(e)) + + @app.get("/health", tags=["System"]) -async def health_check(): - """🏥 Health check""" - gateway_health = sage_client.health() - +async def health_check( + sage: SageGatewayClient = Depends(get_sage_client_for_user), +): + gateway_health = sage.health() + return { "status": "healthy", "sage_gateway": gateway_health, + "using_gateway_id": sage.gateway_id, "email_queue": { "running": email_queue.running, "workers": len(email_queue.workers), - "queue_size": email_queue.queue.qsize() + "queue_size": email_queue.queue.qsize(), }, - "timestamp": datetime.now().isoformat() + "timestamp": datetime.now().isoformat(), } + @app.get("/", tags=["System"]) async def root(): - """🏠 Page d'accueil""" return { "api": "Sage 100c Dataven - VPS Linux", "version": "2.0.0", "documentation": "/docs", - "health": "/health" + "health": "/health", } -# ===================================================== -# LANCEMENT -# ===================================================== + +@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, + } + + if __name__ == "__main__": uvicorn.run( "api:app", host=settings.api_host, port=settings.api_port, - reload=settings.api_reload - ) \ No newline at end of file + reload=settings.api_reload, + ) diff --git a/config.py b/config/config.py similarity index 52% rename from config.py rename to config/config.py index 2ed4336..63bf99b 100644 --- a/config.py +++ b/config/config.py @@ -1,20 +1,33 @@ from pydantic_settings import BaseSettings, SettingsConfigDict from typing import List + class Settings(BaseSettings): model_config = SettingsConfigDict( - env_file=".env", - env_file_encoding="utf-8", - case_sensitive=False, - extra="ignore" + env_file=".env", env_file_encoding="utf-8", case_sensitive=False, extra="ignore" ) + # === JWT & Auth === + jwt_secret: str + jwt_algorithm: str + access_token_expire_minutes: int + refresh_token_expire_days: int + + SAGE_TYPE_DEVIS: int = 0 + SAGE_TYPE_BON_COMMANDE: int = 10 + SAGE_TYPE_PREPARATION: int = 20 + SAGE_TYPE_BON_LIVRAISON: int = 30 + SAGE_TYPE_BON_RETOUR: int = 40 + SAGE_TYPE_BON_AVOIR: int = 50 + SAGE_TYPE_FACTURE: int = 60 + # === Sage Gateway (Windows) === sage_gateway_url: str sage_gateway_token: str + frontend_url: str # === Base de données === - database_url: str = "sqlite+aiosqlite:///./sage_dataven.db" + database_url: str = "sqlite+aiosqlite:///./data/sage_dataven.db" # === SMTP === smtp_host: str @@ -22,6 +35,7 @@ class Settings(BaseSettings): smtp_user: str smtp_password: str smtp_from: str + smtp_use_tls: bool = True # === Universign === universign_api_key: str @@ -31,13 +45,14 @@ class Settings(BaseSettings): api_host: str api_port: int api_reload: bool = False - + # === Email Queue === max_email_workers: int = 3 max_retry_attempts: int = 3 - retry_delay_seconds: int = 60 - + retry_delay_seconds: int = 3 + # === CORS === cors_origins: List[str] = ["*"] -settings = Settings() \ No newline at end of file + +settings = Settings() diff --git a/core/dependencies.py b/core/dependencies.py new file mode 100644 index 0000000..039081c --- /dev/null +++ b/core/dependencies.py @@ -0,0 +1,94 @@ +from fastapi import Depends, HTTPException, status +from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials +from sqlalchemy.ext.asyncio import AsyncSession +from sqlalchemy import select +from database import get_session, User +from security.auth import decode_token +from typing import Optional +from datetime import datetime + +security = HTTPBearer() + + +async def get_current_user( + credentials: HTTPAuthorizationCredentials = Depends(security), + session: AsyncSession = Depends(get_session), +) -> User: + token = credentials.credentials + + payload = decode_token(token) + if not payload: + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail="Token invalide ou expiré", + headers={"WWW-Authenticate": "Bearer"}, + ) + + if payload.get("type") != "access": + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail="Type de token incorrect", + headers={"WWW-Authenticate": "Bearer"}, + ) + + user_id: str = payload.get("sub") + if not user_id: + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail="Token malformé", + headers={"WWW-Authenticate": "Bearer"}, + ) + + result = await session.execute(select(User).where(User.id == user_id)) + user = result.scalar_one_or_none() + + if not user: + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail="Utilisateur introuvable", + headers={"WWW-Authenticate": "Bearer"}, + ) + + if not user.is_active: + raise HTTPException( + status_code=status.HTTP_403_FORBIDDEN, detail="Compte désactivé" + ) + + if not user.is_verified: + raise HTTPException( + status_code=status.HTTP_403_FORBIDDEN, + detail="Email non vérifié. Consultez votre boîte de réception.", + ) + + if user.locked_until and user.locked_until > datetime.now(): + raise HTTPException( + status_code=status.HTTP_403_FORBIDDEN, + detail="Compte temporairement verrouillé suite à trop de tentatives échouées", + ) + + return user + + +async def get_current_user_optional( + credentials: Optional[HTTPAuthorizationCredentials] = Depends(security), + session: AsyncSession = Depends(get_session), +) -> Optional[User]: + if not credentials: + return None + + try: + return await get_current_user(credentials, session) + except HTTPException: + return None + + +def require_role(*allowed_roles: str): + async def role_checker(user: User = Depends(get_current_user)) -> User: + if user.role not in allowed_roles: + raise HTTPException( + status_code=status.HTTP_403_FORBIDDEN, + detail=f"Accès refusé. Rôles requis: {', '.join(allowed_roles)}", + ) + return user + + return role_checker diff --git a/core/sage_context.py b/core/sage_context.py new file mode 100644 index 0000000..cd092a4 --- /dev/null +++ b/core/sage_context.py @@ -0,0 +1,77 @@ +from dataclasses import dataclass +from typing import Optional +from fastapi import Depends +from sqlalchemy.ext.asyncio import AsyncSession + +from database import get_session, User +from core.dependencies import get_current_user +from sage_client import SageGatewayClient +from config.config import settings +import logging + +logger = logging.getLogger(__name__) + + +@dataclass +class GatewayContext: + + url: str + token: str + gateway_id: Optional[str] = None + gateway_name: Optional[str] = None + user_id: Optional[str] = None + is_fallback: bool = False + + +async def get_sage_client_for_user( + session: AsyncSession = Depends(get_session), + user: User = Depends(get_current_user), +) -> SageGatewayClient: + from services.sage_gateway import SageGatewayService + + service = SageGatewayService(session) + active_gateway = await service.get_active_gateway(user.id) + + if active_gateway: + logger.debug(f"Gateway active: {active_gateway.name} pour {user.email}") + return SageGatewayClient( + gateway_url=active_gateway.gateway_url, + gateway_token=active_gateway.gateway_token, + gateway_id=active_gateway.id, + ) + + logger.debug(f"Fallback .env pour {user.email}") + return SageGatewayClient() + + +async def get_gateway_context_for_user( + session: AsyncSession = Depends(get_session), + user: User = Depends(get_current_user), +) -> GatewayContext: + from services.sage_gateway import SageGatewayService + + service = SageGatewayService(session) + active_gateway = await service.get_active_gateway(user.id) + + if active_gateway: + return GatewayContext( + url=active_gateway.gateway_url, + token=active_gateway.gateway_token, + gateway_id=active_gateway.id, + gateway_name=active_gateway.name, + user_id=user.id, + is_fallback=False, + ) + + return GatewayContext( + url=settings.sage_gateway_url, + token=settings.sage_gateway_token, + gateway_id=None, + gateway_name="Fallback (.env)", + user_id=user.id, + is_fallback=True, + ) + + +async def get_sage_client_public() -> SageGatewayClient: + return SageGatewayClient() diff --git a/create_admin.py b/create_admin.py new file mode 100644 index 0000000..d3cb786 --- /dev/null +++ b/create_admin.py @@ -0,0 +1,97 @@ +import asyncio +import sys +from pathlib import Path +import uuid +from datetime import datetime + +sys.path.insert(0, str(Path(__file__).parent)) + +from database import async_session_factory, User +from security.auth import hash_password, validate_password_strength +import logging + +logging.basicConfig(level=logging.INFO) +logger = logging.getLogger(__name__) + + +async def create_admin(): + print("\n" + "=" * 60) + print(" Création d'un compte administrateur") + print("=" * 60 + "\n") + + # Saisie des informations + email = input("Email de l'admin: ").strip().lower() + if not email or "@" not in email: + print(" Email invalide") + return False + + prenom = input("Prénom: ").strip() + nom = input("Nom: ").strip() + + if not prenom or not nom: + print(" Prénom et nom requis") + return False + + # Mot de passe avec validation + while True: + password = input( + "Mot de passe (min 8 car., 1 maj, 1 min, 1 chiffre, 1 spécial): " + ) + is_valid, error_msg = validate_password_strength(password) + + if is_valid: + confirm = input("Confirmez le mot de passe: ") + if password == confirm: + break + else: + print(" Les mots de passe ne correspondent pas\n") + else: + print(f" {error_msg}\n") + + async with async_session_factory() as session: + from sqlalchemy import select + + result = await session.execute(select(User).where(User.email == email)) + existing = result.scalar_one_or_none() + + if existing: + print(f"\n Un utilisateur avec l'email {email} existe déjà") + return False + + # Créer l'admin + admin = User( + id=str(uuid.uuid4()), + email=email, + hashed_password=hash_password(password), + nom=nom, + prenom=prenom, + role="admin", + is_verified=True, + is_active=True, + created_at=datetime.now(), + ) + + session.add(admin) + await session.commit() + + print("\n Administrateur créé avec succès!") + print(f" Email: {email}") + print(f" Nom: {prenom} {nom}") + print(" Rôle: admin") + print(f" ID: {admin.id}") + print("\n Vous pouvez maintenant vous connecter à l'API\n") + + return True + + +if __name__ == "__main__": + try: + result = asyncio.run(create_admin()) + sys.exit(0 if result else 1) + except KeyboardInterrupt: + print("\n\n Création annulée") + sys.exit(1) + except Exception as e: + print(f"\n Erreur: {e}") + logger.exception("Détails:") + sys.exit(1) diff --git a/data/data.py b/data/data.py new file mode 100644 index 0000000..c49c5d5 --- /dev/null +++ b/data/data.py @@ -0,0 +1,405 @@ +TAGS_METADATA = [ + {"name": "System", "description": "Health checks et informations système"}, + {"name": "Admin", "description": "Administration système (cache, queue)"}, + {"name": "Debug", "description": "Routes de debug et diagnostics"}, + { + "name": "Authentication", + "description": "Authentification, gestion des sessions et contrôle d'accès", + }, + { + "name": "Sage Gateways", + "description": "Passerelles de communication avec Sage (API, synchronisation, échanges)", + }, + { + "name": "Tiers", + "description": "Gestion des tiers (clients, fournisseurs et prospects)", + }, + { + "name": "Clients", + "description": "Gestion des clients (recherche, création, modification)", + }, + {"name": "Fournisseurs", "description": "Gestion des fournisseurs"}, + {"name": "Prospects", "description": "Gestion des prospects"}, + { + "name": "Contacts", + "description": "Gestion des contacts rattachés aux tiers", + }, + { + "name": "Familles", + "description": "Gestion des familles et catégories d'articles", + }, + {"name": "Articles", "description": "Gestion des articles et produits"}, + { + "name": "Stock", + "description": "Consultation et gestion des stocks d'articles", + }, + {"name": "Devis", "description": "Création, consultation et gestion des devis"}, + { + "name": "Commandes", + "description": "Création, consultation et gestion des commandes", + }, + { + "name": "Livraisons", + "description": "Création, consultation et gestion des bons de livraison", + }, + { + "name": "Factures", + "description": "Création, consultation et gestion des factures", + }, + {"name": "Avoirs", "description": "Création, consultation et gestion des avoirs"}, + { + "name": "Documents", + "description": "Gestion des documents liés aux tiers (devis, commandes, factures, avoirs)", + }, + { + "name": "Workflows", + "description": "Transformations de documents (devis→commande, commande→facture, etc.)", + }, + {"name": "Signatures", "description": "Signature électronique via Universign"}, + {"name": "Emails", "description": "Envoi d'emails, templates et logs d'envoi"}, + {"name": "Validation", "description": "Validation de données (remises, etc.)"}, +] + +templates_signature_email = { + "demande_signature": { + "id": "demande_signature", + "nom": "Demande de Signature Électronique", + "sujet": "Signature requise - {{TYPE_DOC}} {{NUMERO}}", + "corps_html": """ + + + + + + + +
+
|
+
+
|
+
+
|
+
Merci de vous être inscrit ! Pour activer votre compte, veuillez cliquer sur le bouton ci-dessous :
+ + + +Ou copiez ce lien dans votre navigateur :
++ {verification_link} +
+ ++ Ce lien expire dans 24 heures +
+ ++ Si vous n'avez pas créé de compte, ignorez cet email. +
+Vous avez demandé à réinitialiser votre mot de passe. Cliquez sur le bouton ci-dessous pour créer un nouveau mot de passe :
+ + + +Ou copiez ce lien dans votre navigateur :
++ {reset_link} +
+ ++ Ce lien expire dans 1 heure +
+ ++ Si vous n'avez pas demandé cette réinitialisation, ignorez cet email. Votre mot de passe actuel reste inchangé. +
+Ce message confirme que le mot de passe de votre compte Sage Dataven a été modifié.
+ ++ Si vous n'êtes pas à l'origine de ce changement, contactez immédiatement notre support. +
+