304 lines
10 KiB
Python
304 lines
10 KiB
Python
# app.py | v1.3 | 2026-05-29
|
|
# FastAPI server pro příjem .msg a .db souborů, upload do Dropboxu a import do Graph API.
|
|
# Endpointy: /upload (.msg → /msgs + Graph import), /upload-db (.db → /msgs/db),
|
|
# /upload-dropbox (→ Dropbox /!!!Days/Downloads Z230).
|
|
|
|
from fastapi import FastAPI, UploadFile, File, Form, Header, HTTPException
|
|
import shutil
|
|
import base64
|
|
import logging
|
|
from pathlib import Path
|
|
from typing import Optional
|
|
import os
|
|
import dropbox
|
|
import msal
|
|
import requests as http_requests
|
|
import extract_msg
|
|
from dateutil import parser as dtparser
|
|
from datetime import timezone
|
|
from dotenv import load_dotenv
|
|
|
|
load_dotenv(Path(__file__).parent / ".env")
|
|
|
|
app = FastAPI()
|
|
log = logging.getLogger("msgreceiver")
|
|
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
|
|
|
|
TOKEN = "13e1bb01-9fd5-44a8-8ce9-4ee27133d340"
|
|
SAVE_DIR = Path("/msgs")
|
|
DB_DIR = Path("/msgs/db")
|
|
|
|
SAVE_DIR.mkdir(parents=True, exist_ok=True)
|
|
DB_DIR.mkdir(parents=True, exist_ok=True)
|
|
|
|
DROPBOX_APP_KEY = os.getenv("DROPBOX_APP_KEY", "")
|
|
DROPBOX_APP_SECRET = os.getenv("DROPBOX_APP_SECRET", "")
|
|
DROPBOX_REFRESH_TOKEN = os.getenv("DROPBOX_APP_REFRESH_TOKEN", "")
|
|
|
|
# --- Graph API config ---
|
|
GRAPH_TENANT_ID = "7d269944-37a4-43a1-8140-c7517dc426e9"
|
|
GRAPH_CLIENT_ID = "4b222bfd-78c9-4239-a53f-43006b3ed07f"
|
|
GRAPH_CLIENT_SECRET = "Txg8Q~MjhocuopxsJyJBhPmDfMxZ2r5WpTFj1dfk"
|
|
GRAPH_MAILBOX = "vladimir.buzalka@buzalka.cz"
|
|
GRAPH_ROOT_FOLDER = "JNJ" # subfolder under Inbox — root for imported emails
|
|
GRAPH_URL = "https://graph.microsoft.com/v1.0"
|
|
|
|
# Cache: folder path → Graph folder ID
|
|
_folder_id_cache: dict[str, str] = {}
|
|
_graph_token: Optional[str] = None
|
|
|
|
|
|
def _get_graph_token() -> str:
|
|
global _graph_token
|
|
msalapp = msal.ConfidentialClientApplication(
|
|
GRAPH_CLIENT_ID,
|
|
authority=f"https://login.microsoftonline.com/{GRAPH_TENANT_ID}",
|
|
client_credential=GRAPH_CLIENT_SECRET,
|
|
)
|
|
result = msalapp.acquire_token_for_client(scopes=["https://graph.microsoft.com/.default"])
|
|
if "access_token" not in result:
|
|
raise RuntimeError(f"Graph auth failed: {result}")
|
|
_graph_token = result["access_token"]
|
|
return _graph_token
|
|
|
|
|
|
def _graph_headers() -> dict:
|
|
token = _graph_token or _get_graph_token()
|
|
return {"Authorization": f"Bearer {token}", "Content-Type": "application/json"}
|
|
|
|
|
|
def _ensure_folder(path_parts: list[str]) -> str:
|
|
"""Ensure folder hierarchy exists under Inbox, return leaf folder ID."""
|
|
cache_key = "/".join(path_parts)
|
|
if cache_key in _folder_id_cache:
|
|
return _folder_id_cache[cache_key]
|
|
|
|
headers = _graph_headers()
|
|
parent_id = "Inbox"
|
|
|
|
for i, part in enumerate(path_parts):
|
|
partial_key = "/".join(path_parts[: i + 1])
|
|
if partial_key in _folder_id_cache:
|
|
parent_id = _folder_id_cache[partial_key]
|
|
continue
|
|
|
|
# List children of parent
|
|
if parent_id == "Inbox":
|
|
url = f"{GRAPH_URL}/users/{GRAPH_MAILBOX}/mailFolders/Inbox/childFolders"
|
|
else:
|
|
url = f"{GRAPH_URL}/users/{GRAPH_MAILBOX}/mailFolders/{parent_id}/childFolders"
|
|
|
|
r = http_requests.get(url, headers=headers, timeout=15)
|
|
if r.status_code == 401:
|
|
_get_graph_token()
|
|
headers = _graph_headers()
|
|
r = http_requests.get(url, headers=headers, timeout=15)
|
|
|
|
found = None
|
|
for f in r.json().get("value", []):
|
|
if f["displayName"].lower() == part.lower():
|
|
found = f["id"]
|
|
break
|
|
|
|
if not found:
|
|
# Create folder
|
|
cr = http_requests.post(url, headers=headers, json={"displayName": part}, timeout=15)
|
|
if cr.status_code in (200, 201):
|
|
found = cr.json()["id"]
|
|
elif cr.status_code == 409:
|
|
# Already exists (race condition) — re-fetch
|
|
r2 = http_requests.get(url, headers=headers, timeout=15)
|
|
for f in r2.json().get("value", []):
|
|
if f["displayName"].lower() == part.lower():
|
|
found = f["id"]
|
|
break
|
|
if not found:
|
|
raise RuntimeError(f"Cannot create folder '{part}': {cr.text}")
|
|
|
|
_folder_id_cache[partial_key] = found
|
|
parent_id = found
|
|
|
|
return parent_id
|
|
|
|
|
|
def _map_jnj_folder(folder: str) -> list[str]:
|
|
"""Map JNJ folder path to Graph folder parts under JNJ root.
|
|
|
|
'/vbuzalka@its.jnj.com/Inbox/TMP' → ['JNJ', 'Inbox', 'TMP']
|
|
'/Online Archive - vbuzalka@its.jnj.com/Inbox' → ['JNJ', 'Online Archive', 'Inbox']
|
|
"""
|
|
parts = [p for p in folder.split("/") if p]
|
|
if not parts:
|
|
return [GRAPH_ROOT_FOLDER]
|
|
|
|
# First part is mailbox name — strip it but detect Online Archive
|
|
mailbox = parts[0]
|
|
rest = parts[1:]
|
|
|
|
prefix = [GRAPH_ROOT_FOLDER]
|
|
if "online archive" in mailbox.lower():
|
|
prefix.append("Online Archive")
|
|
|
|
return prefix + rest if rest else prefix
|
|
|
|
|
|
def _make_recipient(addr: str) -> dict:
|
|
if "<" in addr and ">" in addr:
|
|
name = addr[: addr.index("<")].strip().strip('"')
|
|
email = addr[addr.index("<") + 1 : addr.index(">")].strip()
|
|
else:
|
|
name = addr
|
|
email = addr
|
|
return {"emailAddress": {"name": name, "address": email}}
|
|
|
|
|
|
def _import_msg_to_graph(msg_path: Path, folder: str) -> Optional[str]:
|
|
"""Parse .msg and import into Graph API mailbox. Returns message ID or None."""
|
|
try:
|
|
msg = extract_msg.Message(str(msg_path))
|
|
|
|
subject = msg.subject or "(no subject)"
|
|
body_html = msg.htmlBody
|
|
if isinstance(body_html, bytes):
|
|
body_html = body_html.decode("utf-8", errors="replace")
|
|
body_text = msg.body or ""
|
|
|
|
sender_email = msg.sender or ""
|
|
sender_name = getattr(msg, "senderName", None) or sender_email
|
|
to_raw = msg.to or ""
|
|
cc_raw = msg.cc or ""
|
|
date_raw = msg.date
|
|
|
|
att_list = []
|
|
for att in msg.attachments:
|
|
if att.data and att.longFilename:
|
|
att_list.append({
|
|
"@odata.type": "#microsoft.graph.fileAttachment",
|
|
"name": att.longFilename,
|
|
"contentType": getattr(att, "mimetype", None) or "application/octet-stream",
|
|
"contentBytes": base64.b64encode(att.data).decode(),
|
|
})
|
|
|
|
msg.close()
|
|
|
|
to_list = [a.strip() for a in to_raw.split(";") if a.strip()]
|
|
cc_list = [a.strip() for a in cc_raw.split(";") if a.strip()]
|
|
|
|
# Map folder and ensure it exists
|
|
folder_parts = _map_jnj_folder(folder)
|
|
folder_id = _ensure_folder(folder_parts)
|
|
|
|
payload = {
|
|
"subject": subject,
|
|
"body": {
|
|
"contentType": "HTML" if body_html else "Text",
|
|
"content": body_html or body_text,
|
|
},
|
|
"from": _make_recipient(f"{sender_name} <{sender_email}>"),
|
|
"toRecipients": [_make_recipient(a) for a in to_list],
|
|
"ccRecipients": [_make_recipient(a) for a in cc_list],
|
|
"isRead": True,
|
|
"singleValueExtendedProperties": [
|
|
{"id": "Integer 0x0E07", "value": "1"}
|
|
],
|
|
}
|
|
|
|
if date_raw:
|
|
try:
|
|
dt = dtparser.parse(str(date_raw))
|
|
payload["receivedDateTime"] = dt.astimezone(timezone.utc).strftime(
|
|
"%Y-%m-%dT%H:%M:%SZ"
|
|
)
|
|
except Exception:
|
|
pass
|
|
|
|
if att_list:
|
|
payload["attachments"] = att_list
|
|
|
|
headers = _graph_headers()
|
|
url = f"{GRAPH_URL}/users/{GRAPH_MAILBOX}/mailFolders/{folder_id}/messages"
|
|
r = http_requests.post(url, headers=headers, json=payload, timeout=30)
|
|
|
|
if r.status_code == 401:
|
|
_get_graph_token()
|
|
headers = _graph_headers()
|
|
r = http_requests.post(url, headers=headers, json=payload, timeout=30)
|
|
|
|
if r.status_code in (200, 201):
|
|
msg_id = r.json().get("id", "")
|
|
log.info("Graph OK: %s → %s", subject[:60], "/".join(folder_parts))
|
|
return msg_id
|
|
else:
|
|
log.error("Graph FAIL [%d]: %s | %s", r.status_code, subject[:60], r.text[:200])
|
|
return None
|
|
|
|
except Exception as e:
|
|
log.error("Graph import error for %s: %s", msg_path.name, e)
|
|
return None
|
|
|
|
|
|
@app.post("/upload")
|
|
async def upload_msg(
|
|
file: UploadFile = File(...),
|
|
authorization: str = Header(None),
|
|
folder: str = Form(""),
|
|
):
|
|
if authorization != f"Bearer {TOKEN}":
|
|
raise HTTPException(status_code=401, detail="Unauthorized")
|
|
if not file.filename.endswith(".msg"):
|
|
raise HTTPException(status_code=400, detail="Only .msg files accepted")
|
|
dest = SAVE_DIR / file.filename
|
|
if dest.exists():
|
|
return {"status": "exists", "file": file.filename}
|
|
with dest.open("wb") as f:
|
|
shutil.copyfileobj(file.file, f)
|
|
|
|
# Import to Graph API if folder was provided by client
|
|
graph_id = None
|
|
if folder:
|
|
graph_id = _import_msg_to_graph(dest, folder)
|
|
|
|
return {
|
|
"status": "saved",
|
|
"file": file.filename,
|
|
"graph_imported": graph_id is not None,
|
|
}
|
|
|
|
|
|
@app.post("/upload-db")
|
|
async def upload_db(
|
|
file: UploadFile = File(...),
|
|
authorization: str = Header(None)
|
|
):
|
|
if authorization != f"Bearer {TOKEN}":
|
|
raise HTTPException(status_code=401, detail="Unauthorized")
|
|
if not file.filename.endswith(".db"):
|
|
raise HTTPException(status_code=400, detail="Only .db files accepted")
|
|
for old in DB_DIR.glob("*.db"):
|
|
old.unlink()
|
|
dest = DB_DIR / file.filename
|
|
with dest.open("wb") as f:
|
|
shutil.copyfileobj(file.file, f)
|
|
return {"status": "saved", "file": file.filename}
|
|
|
|
|
|
@app.post("/upload-dropbox")
|
|
async def upload_dropbox(
|
|
file: UploadFile = File(...),
|
|
authorization: str = Header(None),
|
|
):
|
|
if authorization != f"Bearer {TOKEN}":
|
|
raise HTTPException(status_code=401, detail="Unauthorized")
|
|
if not DROPBOX_REFRESH_TOKEN:
|
|
raise HTTPException(status_code=500, detail="Dropbox not configured")
|
|
|
|
content = await file.read()
|
|
dbx = dropbox.Dropbox(
|
|
app_key=DROPBOX_APP_KEY,
|
|
app_secret=DROPBOX_APP_SECRET,
|
|
oauth2_refresh_token=DROPBOX_REFRESH_TOKEN,
|
|
)
|
|
dropbox_path = f"/!!!Days/Downloads Z230/{file.filename}"
|
|
dbx.files_upload(content, dropbox_path, mode=dropbox.files.WriteMode.overwrite)
|
|
return {"status": "uploaded", "file": file.filename, "dropbox_path": dropbox_path}
|