325 lines
9.9 KiB
Python
325 lines
9.9 KiB
Python
import asyncio
|
|
import os
|
|
import sys
|
|
from pathlib import Path
|
|
from typing import Any, Dict, Literal
|
|
|
|
import httpx
|
|
|
|
|
|
PROJECT_ROOT = Path(__file__).resolve().parents[1]
|
|
sys.path.insert(0, str(PROJECT_ROOT))
|
|
os.chdir(PROJECT_ROOT)
|
|
|
|
from app.config import settings
|
|
from app.db import init_db
|
|
from app.integration_outbox_service import (
|
|
claim_pending_outbox,
|
|
recover_stale_processing_outbox,
|
|
mark_outbox_blocked,
|
|
mark_outbox_dry_run,
|
|
mark_outbox_failed,
|
|
mark_outbox_sent,
|
|
)
|
|
|
|
|
|
Outcome = Literal["processed", "skipped"]
|
|
|
|
|
|
def env_bool(name: str, default: bool = False) -> bool:
|
|
fallback = "true" if default else "false"
|
|
value = os.getenv(name, fallback).strip().lower()
|
|
return value in {"true", "1", "yes", "on"}
|
|
|
|
|
|
def is_dry_run() -> bool:
|
|
return env_bool("OUTBOX_DRY_RUN", True)
|
|
|
|
|
|
def integration_enabled(target_system: str) -> bool:
|
|
key = f"{str(target_system or '').upper()}_OUTBOX_ENABLED"
|
|
return env_bool(key, False)
|
|
|
|
|
|
def build_chatwoot_note(payload: Dict[str, Any]) -> str:
|
|
event_type = payload.get("event_type", "")
|
|
action = payload.get("action", "")
|
|
note = payload.get("note", "")
|
|
conversation_id = payload.get("conversation_id", "")
|
|
|
|
return f"""🤖 ClientFlow
|
|
|
|
Evento:
|
|
{event_type}
|
|
|
|
Ação:
|
|
{action}
|
|
|
|
Nota:
|
|
{note}
|
|
|
|
Conversa:
|
|
{conversation_id}
|
|
"""
|
|
|
|
|
|
async def process_chatwoot_add_private_note(item: Dict[str, Any]) -> Outcome:
|
|
payload = item.get("payload") or {}
|
|
conversation_id = payload.get("conversation_id")
|
|
|
|
if not conversation_id:
|
|
raise RuntimeError("conversation_id em falta no payload")
|
|
|
|
if is_dry_run():
|
|
message = f"DRY-RUN chatwoot.add_private_note conversation_id={conversation_id}"
|
|
print(message)
|
|
mark_outbox_dry_run(item["id"], message)
|
|
return "processed"
|
|
|
|
if not settings.chatwoot_write_enabled:
|
|
raise RuntimeError("CHATWOOT_WRITE_ENABLED=false")
|
|
|
|
if not settings.chatwoot_base_url or not settings.chatwoot_account_id or not settings.chatwoot_api_token:
|
|
raise RuntimeError("Configuração Chatwoot incompleta")
|
|
|
|
url = (
|
|
settings.chatwoot_base_url.rstrip("/")
|
|
+ f"/api/v1/accounts/{settings.chatwoot_account_id}"
|
|
+ f"/conversations/{conversation_id}/messages"
|
|
)
|
|
|
|
body = {
|
|
"content": build_chatwoot_note(payload),
|
|
"message_type": "outgoing",
|
|
"private": True,
|
|
"content_type": "text",
|
|
"content_attributes": {},
|
|
}
|
|
|
|
headers = {
|
|
"Content-Type": "application/json",
|
|
"api_access_token": settings.chatwoot_api_token,
|
|
}
|
|
|
|
async with httpx.AsyncClient(timeout=30) as client:
|
|
response = await client.post(url, headers=headers, json=body)
|
|
|
|
if response.status_code >= 400:
|
|
raise RuntimeError(f"Chatwoot error {response.status_code}: {response.text}")
|
|
|
|
mark_outbox_sent(item["id"])
|
|
return "processed"
|
|
|
|
|
|
async def process_mautic_add_tag(item: Dict[str, Any]) -> Outcome:
|
|
payload = item.get("payload") or {}
|
|
|
|
if is_dry_run():
|
|
message = (
|
|
"DRY-RUN mautic.add_tag "
|
|
f"conversation_id={payload.get('conversation_id')} "
|
|
f"tag={payload.get('tag')}"
|
|
)
|
|
print(message)
|
|
mark_outbox_dry_run(item["id"], message)
|
|
return "processed"
|
|
|
|
from app.mautic_client import add_tag_from_outbox_payload
|
|
|
|
add_tag_from_outbox_payload(payload)
|
|
mark_outbox_sent(item["id"])
|
|
return "processed"
|
|
|
|
|
|
async def process_mautic_remove_tag(item: Dict[str, Any]) -> Outcome:
|
|
payload = item.get("payload") or {}
|
|
|
|
if is_dry_run():
|
|
message = (
|
|
"DRY-RUN mautic.remove_tag "
|
|
f"conversation_id={payload.get('conversation_id')} "
|
|
f"tag={payload.get('tag')}"
|
|
)
|
|
print(message)
|
|
mark_outbox_dry_run(item["id"], message)
|
|
return "processed"
|
|
|
|
from app.mautic_client import remove_tag_from_outbox_payload
|
|
|
|
remove_tag_from_outbox_payload(payload)
|
|
mark_outbox_sent(item["id"])
|
|
return "processed"
|
|
|
|
|
|
async def process_packlink_create_shipment(item: Dict[str, Any]) -> Outcome:
|
|
payload = item.get("payload") or {}
|
|
opportunity_id = payload.get("opportunity_id")
|
|
|
|
if is_dry_run():
|
|
message = f"DRY-RUN packlink.create_shipment opportunity_id={opportunity_id}"
|
|
print(message)
|
|
mark_outbox_dry_run(item["id"], message)
|
|
return "processed"
|
|
|
|
if not settings.packlink_enabled:
|
|
raise RuntimeError("PACKLINK_ENABLED=false")
|
|
|
|
from app.packlink_service import create_shipment_from_outbox_payload
|
|
|
|
result = await create_shipment_from_outbox_payload(payload)
|
|
print(f"Packlink shipment created reference={result.get('reference')}")
|
|
mark_outbox_sent(item["id"])
|
|
return "processed"
|
|
|
|
|
|
|
|
|
|
async def process_jasmin_create_quotation(item: Dict[str, Any]) -> Outcome:
|
|
payload = item.get("payload") or {}
|
|
opportunity_id = payload.get("opportunity_id")
|
|
|
|
if is_dry_run():
|
|
message = f"DRY-RUN jasmin.create_quotation opportunity_id={opportunity_id}"
|
|
print(message)
|
|
mark_outbox_dry_run(item["id"], message)
|
|
return "processed"
|
|
|
|
if not settings.jasmin_enabled:
|
|
raise RuntimeError("JASMIN_ENABLED=false")
|
|
|
|
from app.jasmin_service import process_create_quotation_outbox
|
|
|
|
result = await process_create_quotation_outbox(payload)
|
|
print(f"Jasmin quotation created id={result.get('quotation_id')}")
|
|
mark_outbox_sent(item["id"])
|
|
return "processed"
|
|
|
|
|
|
async def process_jasmin_convert_invoice(item: Dict[str, Any]) -> Outcome:
|
|
payload = item.get("payload") or {}
|
|
opportunity_id = payload.get("opportunity_id")
|
|
|
|
if is_dry_run():
|
|
message = f"DRY-RUN jasmin.convert_quotation_to_invoice opportunity_id={opportunity_id}"
|
|
print(message)
|
|
mark_outbox_dry_run(item["id"], message)
|
|
return "processed"
|
|
|
|
if not settings.jasmin_enabled:
|
|
raise RuntimeError("JASMIN_ENABLED=false")
|
|
|
|
from app.jasmin_service import process_convert_invoice_outbox
|
|
|
|
result = await process_convert_invoice_outbox(payload)
|
|
print(f"Jasmin invoice created id={result.get('invoice_id')}")
|
|
mark_outbox_sent(item["id"])
|
|
return "processed"
|
|
|
|
async def process_item(item: Dict[str, Any]) -> Outcome:
|
|
target_system = item.get("target_system")
|
|
action_type = item.get("action_type")
|
|
|
|
print(f"Processing {item['id']} {target_system}.{action_type}")
|
|
|
|
if not integration_enabled(target_system):
|
|
message = f"Integração desativada: {target_system}.{action_type}. Ative {str(target_system or '').upper()}_OUTBOX_ENABLED=true para processar."
|
|
print(f"BLOCKED {message}")
|
|
mark_outbox_blocked(item["id"], message)
|
|
return "skipped"
|
|
|
|
if target_system == "chatwoot" and action_type == "add_private_note":
|
|
return await process_chatwoot_add_private_note(item)
|
|
|
|
if target_system == ("t" + "wenty"):
|
|
print(f"SKIP legacy external CRM outbox item {item.get('id')}: integração removida")
|
|
return "skipped"
|
|
|
|
if target_system == "mautic" and action_type == "add_tag":
|
|
return await process_mautic_add_tag(item)
|
|
|
|
if target_system == "mautic" and action_type == "remove_tag":
|
|
return await process_mautic_remove_tag(item)
|
|
|
|
if target_system == "packlink" and action_type == "create_shipment":
|
|
return await process_packlink_create_shipment(item)
|
|
|
|
if target_system == "jasmin" and action_type == "create_quotation":
|
|
return await process_jasmin_create_quotation(item)
|
|
|
|
if target_system == "jasmin" and action_type == "convert_quotation_to_invoice":
|
|
return await process_jasmin_convert_invoice(item)
|
|
|
|
if is_dry_run():
|
|
message = f"DRY-RUN unsupported-now {target_system}.{action_type}"
|
|
print(message)
|
|
mark_outbox_dry_run(item["id"], message)
|
|
return "processed"
|
|
|
|
raise RuntimeError(f"Handler não implementado: {target_system}.{action_type}")
|
|
|
|
|
|
async def main() -> int:
|
|
|
|
# Ensure outbox schema compatibility before claiming rows. This makes the
|
|
# systemd worker safe on upgraded installs where the API has not yet run
|
|
# schema self-healing for newly selected columns such as sent_at.
|
|
init_db()
|
|
|
|
# Nota: as notas privadas do Chatwoot podem estar desligadas sem bloquear
|
|
# outras integrações como Packlink, Mautic ou Jasmin. A decisão de processar
|
|
# cada target_system fica em integration_enabled() e no handler específico.
|
|
if os.getenv("CLIENTFLOW_DISABLE_CHATWOOT_PRIVATE_NOTES", "true").lower() in {"1", "true", "yes", "sim"}:
|
|
print("ClientFlow Chatwoot private notes disabled by env; non-Chatwoot outbox will still run.")
|
|
|
|
limit = int(os.getenv("OUTBOX_LIMIT", "50"))
|
|
target_system = os.getenv("OUTBOX_TARGET_SYSTEM", "").strip() or None
|
|
|
|
worker_id = os.getenv("OUTBOX_WORKER_ID", f"process_outbox:{os.getpid()}")
|
|
|
|
if env_bool("OUTBOX_RECOVER_STALE_BEFORE_PROCESS", True):
|
|
recovered = recover_stale_processing_outbox(
|
|
mode=os.getenv("OUTBOX_STALE_RECOVERY_MODE", "manual_only"),
|
|
actor=worker_id,
|
|
)
|
|
if recovered:
|
|
print(f"Recovered stale processing outbox items: {len(recovered)}")
|
|
|
|
items = claim_pending_outbox(
|
|
limit=limit,
|
|
target_system=target_system,
|
|
lock_owner=worker_id,
|
|
)
|
|
|
|
print(f"Claimed outbox items: {len(items)}")
|
|
print(f"OUTBOX_WORKER_ID={worker_id}")
|
|
print(f"OUTBOX_DRY_RUN={is_dry_run()}")
|
|
print(f"OUTBOX_TARGET_SYSTEM={target_system or 'all'}")
|
|
|
|
processed = 0
|
|
skipped = 0
|
|
failed = 0
|
|
|
|
for item in items:
|
|
try:
|
|
outcome = await process_item(item)
|
|
|
|
if outcome == "processed":
|
|
processed += 1
|
|
else:
|
|
skipped += 1
|
|
|
|
except Exception as exc:
|
|
failed += 1
|
|
print(f"FAILED {item.get('id')}: {exc}")
|
|
mark_outbox_failed(item["id"], str(exc))
|
|
|
|
print(f"Processed: {processed}")
|
|
print(f"Skipped: {skipped}")
|
|
print(f"Failed: {failed}")
|
|
|
|
return 0 if failed == 0 else 1
|
|
|
|
|
|
if __name__ == "__main__":
|
|
raise SystemExit(asyncio.run(main()))
|