feat: Build complete POC for Butler model (client, matrix, daemon)
This commit is contained in:
Jarvis
152
connector-superoffice/build_matrix.py
Normal file
152
connector-superoffice/build_matrix.py
Normal file
@@ -0,0 +1,152 @@
|
||||
import sqlite3
|
||||
import os
|
||||
import json
|
||||
import requests
|
||||
from dotenv import load_dotenv
|
||||
|
||||
load_dotenv(override=True)
|
||||
|
||||
DB_FILE = "marketing_matrix.db"
|
||||
GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
|
||||
NOTION_API_KEY = os.getenv("NOTION_API_KEY")
|
||||
NOTION_DB_INDUSTRIES = "2ec88f4285448014ab38ea664b4c2b81"
|
||||
|
||||
# --- MAPPINGS ---
|
||||
# SuperOffice ID -> Notion Vertical Name
|
||||
VERTICAL_MAP = {
|
||||
23: "Logistics - Warehouse"
|
||||
}
|
||||
|
||||
# SuperOffice ID -> Persona Name & Pains (aus unserer Definition)
|
||||
ROLE_MAP = {
|
||||
19: {"name": "Operativer Entscheider", "pains": "Zuverlässigkeit, einfache Bedienbarkeit, Personaleinsatz-Optimierung, minimale Störungen"},
|
||||
20: {"name": "Infrastruktur-Verantwortlicher", "pains": "Technische Machbarkeit, IT-Sicherheit, Integration, Brandschutz"},
|
||||
21: {"name": "Wirtschaftlicher Entscheider", "pains": "ROI, Amortisationszeit, Kostenstruktur, Einsparpotenziale"},
|
||||
22: {"name": "Innovations-Treiber", "pains": "Wettbewerbsfähigkeit, Modernisierung, Employer Branding, Kundenerlebnis"}
|
||||
}
|
||||
|
||||
# --- DATABASE SETUP ---
|
||||
def init_db():
|
||||
conn = sqlite3.connect(DB_FILE)
|
||||
c = conn.cursor()
|
||||
c.execute('''CREATE TABLE IF NOT EXISTS text_blocks
|
||||
(vertical_id INTEGER, role_id INTEGER,
|
||||
subject TEXT, intro TEXT, social_proof TEXT,
|
||||
PRIMARY KEY (vertical_id, role_id))''')
|
||||
conn.commit()
|
||||
conn.close()
|
||||
print("✅ Database initialized.")
|
||||
|
||||
# --- NOTION FETCHER ---
|
||||
def get_vertical_pains_gains(vertical_name):
|
||||
url = f"https://api.notion.com/v1/databases/{NOTION_DB_INDUSTRIES}/query"
|
||||
headers = {
|
||||
"Authorization": f"Bearer {NOTION_API_KEY}",
|
||||
"Notion-Version": "2022-06-28",
|
||||
"Content-Type": "application/json"
|
||||
}
|
||||
payload = {
|
||||
"filter": {
|
||||
"property": "Vertical",
|
||||
"title": {"contains": vertical_name}
|
||||
}
|
||||
}
|
||||
resp = requests.post(url, headers=headers, json=payload)
|
||||
if resp.status_code == 200:
|
||||
results = resp.json().get("results", [])
|
||||
if results:
|
||||
props = results[0]['properties']
|
||||
pains = props.get('Pains', {}).get('rich_text', [])
|
||||
gains = props.get('Gains', {}).get('rich_text', [])
|
||||
return {
|
||||
"pains": pains[0]['plain_text'] if pains else "",
|
||||
"gains": gains[0]['plain_text'] if gains else ""
|
||||
}
|
||||
print(f"⚠️ Warning: No data found for {vertical_name}")
|
||||
return {"pains": "N/A", "gains": "N/A"}
|
||||
|
||||
# --- GEMINI GENERATOR ---
|
||||
def generate_text(vertical_name, v_data, role_id, role_data):
|
||||
url = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key={GEMINI_API_KEY}"
|
||||
|
||||
prompt = f"""
|
||||
Du bist ein B2B-Copywriter. Erstelle 3 Textbausteine für eine Cold-Outreach E-Mail.
|
||||
|
||||
KONTEXT:
|
||||
Branche: {vertical_name}
|
||||
Branchen-Pains: {v_data['pains']}
|
||||
Lösung-Gains: {v_data['gains']}
|
||||
|
||||
Rolle: {role_data['name']}
|
||||
Rollen-Pains: {role_data['pains']}
|
||||
|
||||
AUFGABE:
|
||||
1. Subject: Betreffzeile (max 40 Zeichen!). Knackig, Pain-bezogen.
|
||||
2. Intro: Einleitungssatz (max 40 Zeichen!). Brücke Pain -> Lösung.
|
||||
3. SocialProof: Referenzsatz (max 40 Zeichen!). "Wir arbeiten mit X..."
|
||||
|
||||
FORMAT (JSON):
|
||||
{{ "Subject": "...", "Intro": "...", "SocialProof": "..." }}
|
||||
"""
|
||||
|
||||
payload = {
|
||||
"contents": [{"parts": [{"text": prompt}]}],
|
||||
"generationConfig": {"responseMimeType": "application/json"}
|
||||
}
|
||||
|
||||
try:
|
||||
resp = requests.post(url, json=payload)
|
||||
if resp.status_code == 200:
|
||||
return json.loads(resp.json()['candidates'][0]['content']['parts'][0]['text'])
|
||||
except Exception as e:
|
||||
print(f"Gemini Error: {e}")
|
||||
return None
|
||||
|
||||
# --- MAIN ---
|
||||
def run_matrix():
|
||||
init_db()
|
||||
conn = sqlite3.connect(DB_FILE)
|
||||
c = conn.cursor()
|
||||
|
||||
# Iterate Verticals
|
||||
for v_id, v_name in VERTICAL_MAP.items():
|
||||
print(f"\nProcessing Vertical: {v_name} (ID: {v_id})")
|
||||
v_data = get_vertical_pains_gains(v_name)
|
||||
|
||||
# Iterate Roles
|
||||
for r_id, r_data in ROLE_MAP.items():
|
||||
print(f" > Generating for Role: {r_data['name']} (ID: {r_id})...", end="", flush=True)
|
||||
|
||||
# Check if exists (optional: skip if exists)
|
||||
# ...
|
||||
|
||||
text_block = generate_text(v_name, v_data, r_id, r_data)
|
||||
|
||||
if text_block:
|
||||
# Robustness: Handle list return from Gemini
|
||||
if isinstance(text_block, list):
|
||||
if len(text_block) > 0 and isinstance(text_block[0], dict):
|
||||
text_block = text_block[0] # Take first item if list of dicts
|
||||
else:
|
||||
print(" ❌ Failed (Unexpected JSON format: List without dicts).")
|
||||
continue
|
||||
|
||||
# Cut to 40 chars hard limit (Safety)
|
||||
subj = text_block.get("Subject", "")[:40]
|
||||
intro = text_block.get("Intro", "Intro")[:40] # Fallback key name check
|
||||
if "Introduction_Textonly" in text_block: intro = text_block["Introduction_Textonly"][:40]
|
||||
proof = text_block.get("SocialProof", "")[:40]
|
||||
if "Industry_References_Textonly" in text_block: proof = text_block["Industry_References_Textonly"][:40]
|
||||
|
||||
c.execute("INSERT OR REPLACE INTO text_blocks VALUES (?, ?, ?, ?, ?)",
|
||||
(v_id, r_id, subj, intro, proof))
|
||||
conn.commit()
|
||||
print(" ✅ Done.")
|
||||
else:
|
||||
print(" ❌ Failed.")
|
||||
|
||||
conn.close()
|
||||
print("\nMatrix generation complete.")
|
||||
|
||||
if __name__ == "__main__":
|
||||
run_matrix()
|
||||
@@ -1,49 +1,89 @@
|
||||
# connector-superoffice/discover_fields.py (Standalone & Robust)
|
||||
import os
|
||||
from config import Config
|
||||
from logging_config import setup_logging
|
||||
from auth_handler import AuthHandler
|
||||
from superoffice_client import SuperOfficeClient
|
||||
import requests
|
||||
import json
|
||||
from dotenv import load_dotenv
|
||||
|
||||
logger = setup_logging("discovery")
|
||||
# Load environment variables
|
||||
load_dotenv(override=True)
|
||||
|
||||
def get_list_items_by_prog_id(client, prog_id, entity_name):
|
||||
"""Fetches and prints list items for a specific ProgId."""
|
||||
logger.info(f"--- Fetching list items for {entity_name} ProgId: {prog_id} ---")
|
||||
list_url = client._get_url(f"v1/List/UserDefinedField/{prog_id}")
|
||||
try:
|
||||
list_resp = client.session.get(list_url, headers=client._get_headers())
|
||||
list_resp.raise_for_status()
|
||||
list_items = list_resp.json()
|
||||
if list_items.get("value"):
|
||||
print(f" --- List Items Found for {prog_id} ---")
|
||||
for item in list_items["value"]:
|
||||
print(f" ID: {item.get('Id'):<5} | Name: {item.get('Name')}")
|
||||
return {item.get('Name'): item.get('Id') for item in list_items["value"]}
|
||||
except Exception as e:
|
||||
logger.error(f"Failed to fetch list items for {prog_id}: {e}")
|
||||
# Configuration
|
||||
SO_ENV = os.getenv("SO_ENVIRONMENT", "sod") # sod, stage, online
|
||||
SO_CLIENT_ID = os.getenv("SO_CLIENT_ID") or os.getenv("SO_SOD")
|
||||
SO_CLIENT_SECRET = os.getenv("SO_CLIENT_SECRET")
|
||||
# SO_REDIRECT_URI often required for validation even in refresh flow
|
||||
SO_REDIRECT_URI = os.getenv("SO_REDIRECT_URI", "http://localhost")
|
||||
SO_REFRESH_TOKEN = os.getenv("SO_REFRESH_TOKEN")
|
||||
|
||||
def get_access_token():
|
||||
"""Refreshes the access token using the refresh token."""
|
||||
url = f"https://{SO_ENV}.superoffice.com/login/common/oauth/tokens"
|
||||
data = {
|
||||
"grant_type": "refresh_token",
|
||||
"client_id": SO_CLIENT_ID,
|
||||
"client_secret": SO_CLIENT_SECRET,
|
||||
"refresh_token": SO_REFRESH_TOKEN,
|
||||
"redirect_uri": SO_REDIRECT_URI
|
||||
}
|
||||
|
||||
print(f"DEBUG: Refreshing token at {url} for Client ID {SO_CLIENT_ID[:5]}...")
|
||||
|
||||
response = requests.post(url, data=data)
|
||||
if response.status_code == 200:
|
||||
print("✅ Access Token refreshed.")
|
||||
return response.json().get("access_token")
|
||||
else:
|
||||
print(f"❌ Error getting token: {response.text}")
|
||||
return None
|
||||
|
||||
def get_activity_types(client):
|
||||
"""Fetches available activity types."""
|
||||
logger.info("--- Fetching Activity Types ---")
|
||||
url = client._get_url("v1/ActivityType")
|
||||
try:
|
||||
resp = client.session.get(url, headers=client._get_headers())
|
||||
resp.raise_for_status()
|
||||
activity_types = resp.json()
|
||||
if activity_types:
|
||||
print(" --- Activity Types Found ---")
|
||||
for atype in activity_types:
|
||||
print(f" ID: {atype.get('Id'):<5} | Name: {atype.get('Name')}")
|
||||
return {atype.get('Name'): atype.get('Id') for atype in activity_types}
|
||||
except Exception as e:
|
||||
logger.error(f"Failed to fetch activity types: {e}")
|
||||
return None
|
||||
def discover_udfs(base_url, token, entity="Contact"):
|
||||
"""
|
||||
Fetches the UDF layout for a specific entity.
|
||||
entity: 'Contact' (Firma) or 'Person'
|
||||
"""
|
||||
endpoint = "Contact" if entity == "Contact" else "Person"
|
||||
url = f"{base_url}/api/v1/{endpoint}?$top=1&$select=userDefinedFields"
|
||||
|
||||
def main():
|
||||
auth = AuthHandler()
|
||||
client = SuperOfficeClient(auth)
|
||||
get_activity_types(client)
|
||||
headers = {
|
||||
"Authorization": f"Bearer {token}",
|
||||
"Accept": "application/json"
|
||||
}
|
||||
|
||||
print(f"\n--- DISCOVERING UDFS FOR: {entity} ---")
|
||||
try:
|
||||
response = requests.get(url, headers=headers)
|
||||
if response.status_code == 200:
|
||||
data = response.json()
|
||||
if data['value']:
|
||||
item = data['value'][0]
|
||||
udfs = item.get('userDefinedFields', {})
|
||||
|
||||
print(f"Found {len(udfs)} UDFs on this record.")
|
||||
|
||||
# Filter logic: Show interesting fields
|
||||
relevant_udfs = {k: v for k, v in udfs.items() if "marketing" in k.lower() or "robotic" in k.lower() or "challenge" in k.lower() or "ai" in k.lower()}
|
||||
|
||||
if relevant_udfs:
|
||||
print("✅ FOUND RELEVANT FIELDS (ProgId : Value):")
|
||||
print(json.dumps(relevant_udfs, indent=2))
|
||||
else:
|
||||
print("⚠️ No fields matching 'marketing/robotic/ai' found.")
|
||||
print("First 5 UDFs for context:")
|
||||
print(json.dumps(list(udfs.keys())[:5], indent=2))
|
||||
else:
|
||||
print("No records found to inspect.")
|
||||
else:
|
||||
print(f"Error {response.status_code}: {response.text}")
|
||||
except Exception as e:
|
||||
print(f"Request failed: {e}")
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
token = get_access_token()
|
||||
if token:
|
||||
# Hardcoded Base URL for Cust55774 (Fix: Use app-sod as per README)
|
||||
base_url = "https://app-sod.superoffice.com/Cust55774"
|
||||
|
||||
discover_udfs(base_url, token, "Person")
|
||||
discover_udfs(base_url, token, "Contact")
|
||||
else:
|
||||
print("Could not get Access Token. Check .env")
|
||||
|
||||
@@ -2,24 +2,48 @@ import os
|
||||
import requests
|
||||
from dotenv import load_dotenv
|
||||
|
||||
load_dotenv() # Lädt .env aus dem aktuellen Verzeichnis
|
||||
load_dotenv(override=True)
|
||||
|
||||
client_id = os.getenv("SO_CLIENT_ID") or os.getenv("SO_SOD")
|
||||
client_secret = os.getenv("SO_CLIENT_SECRET")
|
||||
refresh_token = os.getenv("SO_REFRESH_TOKEN")
|
||||
|
||||
print(f"ID: {client_id}")
|
||||
print(f"Secret: {client_secret[:5]}...")
|
||||
print(f"Token: {refresh_token[:5]}...")
|
||||
# Config
|
||||
SO_CLIENT_ID = os.getenv("SO_CLIENT_ID") or os.getenv("SO_SOD")
|
||||
SO_CLIENT_SECRET = os.getenv("SO_CLIENT_SECRET")
|
||||
SO_REFRESH_TOKEN = os.getenv("SO_REFRESH_TOKEN")
|
||||
# Base URL for your tenant (Dev)
|
||||
BASE_URL = "https://app-sod.superoffice.com/Cust55774/api/v1"
|
||||
|
||||
def get_token():
|
||||
url = "https://sod.superoffice.com/login/common/oauth/tokens"
|
||||
payload = {
|
||||
data = {
|
||||
"grant_type": "refresh_token",
|
||||
"client_id": client_id,
|
||||
"client_secret": client_secret,
|
||||
"refresh_token": refresh_token
|
||||
"client_id": SO_CLIENT_ID,
|
||||
"client_secret": SO_CLIENT_SECRET,
|
||||
"refresh_token": SO_REFRESH_TOKEN,
|
||||
"redirect_uri": "http://localhost"
|
||||
}
|
||||
try:
|
||||
resp = requests.post(url, data=data)
|
||||
if resp.status_code == 200:
|
||||
return resp.json().get("access_token")
|
||||
else:
|
||||
print(f"Token Error: {resp.text}")
|
||||
return None
|
||||
except Exception as e:
|
||||
print(f"Connection Error: {e}")
|
||||
return None
|
||||
|
||||
resp = requests.post(url, data=payload)
|
||||
print(f"Status: {resp.status_code}")
|
||||
print(resp.text)
|
||||
def check_contact(id):
|
||||
token = get_token()
|
||||
if not token: return
|
||||
|
||||
headers = {"Authorization": f"Bearer {token}", "Accept": "application/json"}
|
||||
url = f"{BASE_URL}/Contact/{id}"
|
||||
|
||||
resp = requests.get(url, headers=headers)
|
||||
if resp.status_code == 200:
|
||||
c = resp.json()
|
||||
print(f"✅ SUCCESS! Contact {id}: {c.get('Name')} (Category: {c.get('Category', {}).get('Value')})")
|
||||
else:
|
||||
print(f"❌ API Error {resp.status_code}: {resp.text}")
|
||||
|
||||
if __name__ == "__main__":
|
||||
check_contact(2)
|
||||
|
||||
126
connector-superoffice/generate_marketing_copy.py
Normal file
126
connector-superoffice/generate_marketing_copy.py
Normal file
@@ -0,0 +1,126 @@
|
||||
import os
|
||||
import json
|
||||
import requests
|
||||
from dotenv import load_dotenv
|
||||
|
||||
# Load environment variables
|
||||
load_dotenv(override=True)
|
||||
|
||||
GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
|
||||
NOTION_API_KEY = os.getenv("NOTION_API_KEY")
|
||||
|
||||
# Configuration
|
||||
NOTION_DB_INDUSTRIES = "2ec88f4285448014ab38ea664b4c2b81" # ID aus deinen Links
|
||||
|
||||
def get_vertical_data(vertical_name):
|
||||
"""Fetches Pains/Gains for a specific Vertical from Notion."""
|
||||
url = f"https://api.notion.com/v1/databases/{NOTION_DB_INDUSTRIES}/query"
|
||||
headers = {
|
||||
"Authorization": f"Bearer {NOTION_API_KEY}",
|
||||
"Notion-Version": "2022-06-28",
|
||||
"Content-Type": "application/json"
|
||||
}
|
||||
payload = {
|
||||
"filter": {
|
||||
"property": "Vertical",
|
||||
"title": {
|
||||
"contains": vertical_name
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
response = requests.post(url, headers=headers, json=payload)
|
||||
if response.status_code == 200:
|
||||
results = response.json().get("results", [])
|
||||
if results:
|
||||
page = results[0]
|
||||
props = page['properties']
|
||||
|
||||
# Extract Text from Rich Text fields
|
||||
pains = props.get('Pains', {}).get('rich_text', [])
|
||||
gains = props.get('Gains', {}).get('rich_text', [])
|
||||
|
||||
pain_text = pains[0]['plain_text'] if pains else "N/A"
|
||||
gain_text = gains[0]['plain_text'] if gains else "N/A"
|
||||
|
||||
return {
|
||||
"vertical": vertical_name,
|
||||
"pains": pain_text,
|
||||
"gains": gain_text
|
||||
}
|
||||
return None
|
||||
|
||||
def generate_copy_with_gemini(vertical_data, persona_role, persona_pains):
|
||||
"""
|
||||
Generates the 3 text blocks using Gemini.
|
||||
"""
|
||||
url = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key={GEMINI_API_KEY}"
|
||||
|
||||
# Der Prompt (Dein Template)
|
||||
prompt_text = f"""
|
||||
Du bist ein kompetenter Lösungsberater und brillanter Texter.
|
||||
AUFGABE: Erstelle 3 Textblöcke (Subject, Introduction_Textonly, Industry_References_Textonly) für eine E-Mail.
|
||||
|
||||
--- KONTEXT ---
|
||||
ZIELBRANCHE: {vertical_data['vertical']}
|
||||
BRANCHEN-HERAUSFORDERUNGEN (PAIN POINTS): {vertical_data['pains']}
|
||||
LÖSUNGS-VORTEILE (GAINS): {vertical_data['gains']}
|
||||
|
||||
ANSPRECHPARTNER: {persona_role}
|
||||
PERSÖNLICHE HERAUSFORDERUNGEN DES ANSPRECHPARTNERS: {persona_pains}
|
||||
|
||||
REFERENZKUNDEN: "Wir arbeiten bereits mit Marktführern in Ihrer Branche." (Platzhalter)
|
||||
|
||||
--- DEINE AUFGABE ---
|
||||
1. Subject: Formuliere eine kurze Betreffzeile (max. 5 Wörter). Richte sie direkt an einem Pain Point aus.
|
||||
2. Introduction_Textonly: Formuliere einen Einleitungstext (2 Sätze).
|
||||
- Fokus: Brücke zwischen Problem und Lösung.
|
||||
3. Industry_References_Textonly: Formuliere einen Social Proof Satz.
|
||||
|
||||
--- FORMAT ---
|
||||
Antworte NUR mit reinem JSON:
|
||||
{{
|
||||
"Subject": "...",
|
||||
"Introduction_Textonly": "...",
|
||||
"Industry_References_Textonly": "..."
|
||||
}}
|
||||
"""
|
||||
|
||||
payload = {
|
||||
"contents": [{"parts": [{"text": prompt_text}]}],
|
||||
"generationConfig": {"responseMimeType": "application/json"}
|
||||
}
|
||||
|
||||
try:
|
||||
response = requests.post(url, json=payload)
|
||||
if response.status_code == 200:
|
||||
return json.loads(response.json()['candidates'][0]['content']['parts'][0]['text'])
|
||||
else:
|
||||
print(f"Gemini Error: {response.text}")
|
||||
return None
|
||||
except Exception as e:
|
||||
print(f"Error: {e}")
|
||||
return None
|
||||
|
||||
if __name__ == "__main__":
|
||||
# TEST RUN
|
||||
|
||||
# 1. Daten holen (Beispiel: Logistics)
|
||||
print("Fetching Vertical Data...")
|
||||
vertical = get_vertical_data("Logistics - Warehouse")
|
||||
|
||||
if vertical:
|
||||
print(f"Loaded: {vertical['vertical']}")
|
||||
|
||||
# 2. Persona definieren (Beispiel: Operativer Entscheider)
|
||||
role = "Logistikleiter / Operations Manager"
|
||||
role_pains = "Stillstand, Personalmangel, Stress, Unfallgefahr"
|
||||
|
||||
# 3. Generieren
|
||||
print("Generating Copy...")
|
||||
copy = generate_copy_with_gemini(vertical, role, role_pains)
|
||||
|
||||
print("\n--- RESULT ---")
|
||||
print(json.dumps(copy, indent=2, ensure_ascii=False))
|
||||
else:
|
||||
print("Vertical not found.")
|
||||
108
connector-superoffice/inject_demo_data.py
Normal file
108
connector-superoffice/inject_demo_data.py
Normal file
@@ -0,0 +1,108 @@
|
||||
import os
|
||||
import sqlite3
|
||||
import requests
|
||||
from dotenv import load_dotenv
|
||||
|
||||
load_dotenv(override=True)
|
||||
|
||||
# --- CONFIGURATION ---
|
||||
DB_FILE = "marketing_matrix.db"
|
||||
SO_CLIENT_ID = os.getenv("SO_CLIENT_ID") or os.getenv("SO_SOD")
|
||||
SO_CLIENT_SECRET = os.getenv("SO_CLIENT_SECRET")
|
||||
SO_REFRESH_TOKEN = os.getenv("SO_REFRESH_TOKEN")
|
||||
BASE_URL = "https://app-sod.superoffice.com/Cust55774/api/v1"
|
||||
|
||||
# --- SUPEROFFICE UDF ProgIds (from your discovery) ---
|
||||
PROG_ID_CONTACT_CHALLENGE = "SuperOffice:6"
|
||||
PROG_ID_PERSON_SUBJECT = "SuperOffice:5"
|
||||
PROG_ID_PERSON_INTRO = "SuperOffice:6"
|
||||
PROG_ID_PERSON_PROOF = "SuperOffice:7"
|
||||
|
||||
# --- TEST DATA ---
|
||||
TEST_PERSON_ID = 1
|
||||
TEST_CONTACT_ID = 2
|
||||
TEST_VERTICAL_ID = 24 # Healthcare - Hospital
|
||||
TEST_ROLE_ID = 19 # Operativer Entscheider
|
||||
|
||||
def get_token():
|
||||
url = "https://sod.superoffice.com/login/common/oauth/tokens"
|
||||
data = {"grant_type": "refresh_token", "client_id": SO_CLIENT_ID, "client_secret": SO_CLIENT_SECRET, "refresh_token": SO_REFRESH_TOKEN, "redirect_uri": "http://localhost"}
|
||||
try:
|
||||
resp = requests.post(url, data=data)
|
||||
if resp.status_code == 200:
|
||||
return resp.json().get("access_token")
|
||||
else:
|
||||
print(f"Token Error: {resp.text}")
|
||||
return None
|
||||
except Exception as e:
|
||||
print(f"Connection Error: {e}")
|
||||
return None
|
||||
|
||||
def get_text_from_matrix(vertical_id, role_id):
|
||||
conn = sqlite3.connect(DB_FILE)
|
||||
c = conn.cursor()
|
||||
c.execute("SELECT subject, intro, social_proof FROM text_blocks WHERE vertical_id = ? AND role_id = ?", (vertical_id, role_id))
|
||||
row = c.fetchone()
|
||||
conn.close()
|
||||
return row if row else (None, None, None)
|
||||
|
||||
def update_udfs(entity, entity_id, payload, token):
|
||||
url = f"{BASE_URL}/{entity}/{entity_id}"
|
||||
headers = {"Authorization": f"Bearer {token}", "Content-Type": "application/json", "Accept": "application/json"}
|
||||
|
||||
# SuperOffice expects the full JSON body, not just the UDF part for PUT
|
||||
# First, GET the existing entity
|
||||
get_resp = requests.get(url, headers=headers)
|
||||
if get_resp.status_code != 200:
|
||||
print(f"❌ ERROR fetching {entity} {entity_id}: {get_resp.text}")
|
||||
return False
|
||||
|
||||
existing_data = get_resp.json()
|
||||
|
||||
# Merge UDFs
|
||||
if "UserDefinedFields" not in existing_data:
|
||||
existing_data["UserDefinedFields"] = {}
|
||||
existing_data["UserDefinedFields"].update(payload)
|
||||
|
||||
print(f"Updating {entity} {entity_id} with new UDFs...")
|
||||
put_resp = requests.put(url, headers=headers, json=existing_data)
|
||||
|
||||
if put_resp.status_code == 200:
|
||||
print(f"✅ SUCCESS: Updated {entity} {entity_id}")
|
||||
return True
|
||||
else:
|
||||
print(f"❌ ERROR updating {entity} {entity_id}: {put_resp.status_code} - {put_resp.text}")
|
||||
return False
|
||||
|
||||
if __name__ == "__main__":
|
||||
print("--- Starting SuperOffice Injection Test ---")
|
||||
|
||||
# 1. Get Text from local DB
|
||||
subject, intro, proof = get_text_from_matrix(TEST_VERTICAL_ID, TEST_ROLE_ID)
|
||||
if not subject:
|
||||
print("❌ ERROR: Could not find matching text in local DB. Aborting.")
|
||||
exit()
|
||||
|
||||
print(f"Found texts for V_ID:{TEST_VERTICAL_ID}, R_ID:{TEST_ROLE_ID}")
|
||||
|
||||
# 2. Get API Token
|
||||
access_token = get_token()
|
||||
if not access_token:
|
||||
print("❌ ERROR: Could not get SuperOffice token. Aborting.")
|
||||
exit()
|
||||
|
||||
# 3. Prepare Payloads
|
||||
contact_payload = {
|
||||
PROG_ID_CONTACT_CHALLENGE: intro # Using intro for challenge in this demo
|
||||
}
|
||||
person_payload = {
|
||||
PROG_ID_PERSON_SUBJECT: subject,
|
||||
PROG_ID_PERSON_INTRO: intro,
|
||||
PROG_ID_PERSON_PROOF: proof
|
||||
}
|
||||
|
||||
# 4. Inject data
|
||||
update_udfs("Contact", TEST_CONTACT_ID, contact_payload, access_token)
|
||||
update_udfs("Person", TEST_PERSON_ID, person_payload, access_token)
|
||||
|
||||
print("\n--- Test complete ---")
|
||||
125
connector-superoffice/inject_demo_data_dynamic.py
Normal file
125
connector-superoffice/inject_demo_data_dynamic.py
Normal file
@@ -0,0 +1,125 @@
|
||||
import os
|
||||
import sqlite3
|
||||
import requests
|
||||
from dotenv import load_dotenv
|
||||
|
||||
load_dotenv(override=True)
|
||||
|
||||
# --- CONFIGURATION ---
|
||||
DB_FILE = "marketing_matrix.db"
|
||||
SO_CLIENT_ID = os.getenv("SO_CLIENT_ID") or os.getenv("SO_SOD")
|
||||
SO_CLIENT_SECRET = os.getenv("SO_CLIENT_SECRET")
|
||||
SO_REFRESH_TOKEN = os.getenv("SO_REFRESH_TOKEN")
|
||||
BASE_URL = "https://app-sod.superoffice.com/Cust55774/api/v1"
|
||||
|
||||
# --- SUPEROFFICE UDF ProgIds ---
|
||||
PROG_ID_CONTACT_CHALLENGE = "SuperOffice:6"
|
||||
PROG_ID_PERSON_SUBJECT = "SuperOffice:5"
|
||||
PROG_ID_PERSON_INTRO = "SuperOffice:6"
|
||||
PROG_ID_PERSON_PROOF = "SuperOffice:7"
|
||||
# Annahme: Das sind die ProgIds der Felder, die die IDs speichern
|
||||
PROG_ID_CONTACT_VERTICAL = "SuperOffice:5"
|
||||
PROG_ID_PERSON_ROLE = "SuperOffice:3" # KORRIGIERT
|
||||
|
||||
# --- TARGET DATA ---
|
||||
TARGET_PERSON_ID = 1
|
||||
TARGET_CONTACT_ID = 2
|
||||
|
||||
def get_token():
|
||||
url = "https://sod.superoffice.com/login/common/oauth/tokens"
|
||||
data = {"grant_type": "refresh_token", "client_id": SO_CLIENT_ID, "client_secret": SO_CLIENT_SECRET, "refresh_token": SO_REFRESH_TOKEN, "redirect_uri": "http://localhost"}
|
||||
resp = requests.post(url, data=data)
|
||||
return resp.json().get("access_token") if resp.status_code == 200 else None
|
||||
|
||||
def get_text_from_matrix(vertical_id, role_id):
|
||||
conn = sqlite3.connect(DB_FILE)
|
||||
c = conn.cursor()
|
||||
c.execute("SELECT subject, intro, social_proof FROM text_blocks WHERE vertical_id = ? AND role_id = ?", (vertical_id, role_id))
|
||||
row = c.fetchone()
|
||||
conn.close()
|
||||
return row if row else (None, None, None)
|
||||
|
||||
def get_entity_data(entity, entity_id, token):
|
||||
url = f"{BASE_URL}/{entity}/{entity_id}"
|
||||
headers = {"Authorization": f"Bearer {token}", "Accept": "application/json"}
|
||||
resp = requests.get(url, headers=headers)
|
||||
return resp.json() if resp.status_code == 200 else None
|
||||
|
||||
def update_udfs(entity, entity_id, payload, token):
|
||||
url = f"{BASE_URL}/{entity}/{entity_id}"
|
||||
headers = {"Authorization": f"Bearer {token}", "Content-Type": "application/json", "Accept": "application/json"}
|
||||
|
||||
existing_data = get_entity_data(entity, entity_id, token)
|
||||
if not existing_data:
|
||||
print(f"❌ ERROR fetching {entity} {entity_id}")
|
||||
return False
|
||||
|
||||
if "UserDefinedFields" not in existing_data:
|
||||
existing_data["UserDefinedFields"] = {}
|
||||
existing_data["UserDefinedFields"].update(payload)
|
||||
|
||||
print(f"Updating {entity} {entity_id} with new UDFs...")
|
||||
put_resp = requests.put(url, headers=headers, json=existing_data)
|
||||
|
||||
if put_resp.status_code == 200:
|
||||
print(f"✅ SUCCESS: Updated {entity} {entity_id}")
|
||||
return True
|
||||
else:
|
||||
print(f"❌ ERROR updating {entity} {entity_id}: {put_resp.status_code} - {put_resp.text}")
|
||||
return False
|
||||
|
||||
if __name__ == "__main__":
|
||||
print("--- Starting SuperOffice Injection (LOGIC CORRECTED) ---")
|
||||
|
||||
# 1. Get API Token
|
||||
access_token = get_token()
|
||||
if not access_token:
|
||||
print("❌ ERROR: Could not get SuperOffice token. Aborting.")
|
||||
exit()
|
||||
|
||||
# 2. Get real data from SuperOffice
|
||||
print(f"Fetching data for Person {TARGET_PERSON_ID} and Contact {TARGET_CONTACT_ID}...")
|
||||
person_data = get_entity_data("Person", TARGET_PERSON_ID, access_token)
|
||||
contact_data = get_entity_data("Contact", TARGET_CONTACT_ID, access_token)
|
||||
|
||||
if not person_data or not contact_data:
|
||||
print("❌ ERROR: Could not fetch test entities. Aborting.")
|
||||
exit()
|
||||
|
||||
# Extract and CLEAN the IDs from the UDFs
|
||||
try:
|
||||
vertical_id_raw = contact_data["UserDefinedFields"][PROG_ID_CONTACT_VERTICAL]
|
||||
role_id_raw = person_data["UserDefinedFields"][PROG_ID_PERSON_ROLE]
|
||||
|
||||
# Clean the "[I:xx]" format to a pure integer
|
||||
vertical_id = int(vertical_id_raw.replace("[I:", "").replace("]", ""))
|
||||
role_id = int(role_id_raw.replace("[I:", "").replace("]", ""))
|
||||
|
||||
print(f"Detected Vertical ID: {vertical_id} (Raw: {vertical_id_raw}), Role ID: {role_id} (Raw: {role_id_raw})")
|
||||
except KeyError as e:
|
||||
print(f"❌ ERROR: A ProgId is wrong or the field is empty: {e}. Aborting.")
|
||||
exit()
|
||||
|
||||
# 3. Get Text from local DB
|
||||
subject, intro, proof = get_text_from_matrix(vertical_id, role_id)
|
||||
if not subject:
|
||||
print(f"❌ ERROR: Could not find matching text for V_ID:{vertical_id}, R_ID:{role_id} in local DB. Aborting.")
|
||||
exit()
|
||||
|
||||
print(f"Found texts for V_ID:{vertical_id}, R_ID:{role_id}")
|
||||
|
||||
# 4. Prepare Payloads
|
||||
contact_payload = {
|
||||
PROG_ID_CONTACT_CHALLENGE: intro
|
||||
}
|
||||
person_payload = {
|
||||
PROG_ID_PERSON_SUBJECT: subject,
|
||||
PROG_ID_PERSON_INTRO: intro,
|
||||
PROG_ID_PERSON_PROOF: proof
|
||||
}
|
||||
|
||||
# 5. Inject data
|
||||
update_udfs("Contact", TARGET_CONTACT_ID, contact_payload, access_token)
|
||||
update_udfs("Person", TARGET_PERSON_ID, person_payload, access_token)
|
||||
|
||||
print("\n--- Test complete ---")
|
||||
8
connector-superoffice/inspect_matrix.py
Normal file
8
connector-superoffice/inspect_matrix.py
Normal file
@@ -0,0 +1,8 @@
|
||||
import sqlite3
|
||||
import pandas as pd
|
||||
|
||||
conn = sqlite3.connect("marketing_matrix.db")
|
||||
df = pd.read_sql_query("SELECT * FROM text_blocks", conn)
|
||||
conn.close()
|
||||
|
||||
print(df.to_markdown(index=False))
|
||||
13
connector-superoffice/inspect_simple.py
Normal file
13
connector-superoffice/inspect_simple.py
Normal file
@@ -0,0 +1,13 @@
|
||||
import sqlite3
|
||||
|
||||
conn = sqlite3.connect("marketing_matrix.db")
|
||||
c = conn.cursor()
|
||||
|
||||
print(f"{'V_ID':<5} | {'R_ID':<5} | {'SUBJECT':<30} | {'INTRO':<30}")
|
||||
print("-" * 80)
|
||||
|
||||
for row in c.execute("SELECT * FROM text_blocks"):
|
||||
v_id, r_id, subj, intro, proof = row
|
||||
print(f"{v_id:<5} | {r_id:<5} | {subj:<30} | {intro:<30}")
|
||||
|
||||
conn.close()
|
||||
82
connector-superoffice/normalize_persona.py
Normal file
82
connector-superoffice/normalize_persona.py
Normal file
@@ -0,0 +1,82 @@
|
||||
import re
|
||||
|
||||
def normalize_persona(title: str) -> str:
|
||||
"""
|
||||
Normalisiert rohe Jobtitel auf die 4 RoboPlanet-Personas.
|
||||
Rückgabe: Persona-ID (z.B. 'PERSONA_A_OPS') oder 'MANUAL_CHECK'.
|
||||
"""
|
||||
if not title:
|
||||
return "MANUAL_CHECK"
|
||||
|
||||
t = title.lower()
|
||||
|
||||
# 1. HARD EXCLUDES (Kosten sparen / Irrelevanz)
|
||||
blacklist = [
|
||||
"praktikant", "intern", "student", "assistenz", "assistant",
|
||||
"werkstudent", "azubi", "auszubildende", "secretary", "sekretär"
|
||||
]
|
||||
if any(x in t for x in blacklist):
|
||||
return "IGNORE"
|
||||
|
||||
# 2. HIERARCHISCHE LOGIK (Specialist > Generalist)
|
||||
|
||||
# Persona D: Visionary (Innovations-Treiber)
|
||||
# Trigger: ESG, Digitalisierung, Transformation
|
||||
keywords_d = [
|
||||
"sustainability", "esg", "umwelt", "digital", "innovation",
|
||||
"transformation", "csr", "strategy", "strategie", "future"
|
||||
]
|
||||
if any(x in t for x in keywords_d):
|
||||
return "PERSONA_D_VISIONARY"
|
||||
|
||||
# Persona B: FM / Infra (Infrastruktur-Verantwortlicher)
|
||||
# Trigger: Facility, Technik, Immobilien, Bau
|
||||
keywords_b = [
|
||||
"facility", "fm", "objekt", "immobilie", "technisch", "technik",
|
||||
"instandhaltung", "real estate", "maintenance", "haushandwerker",
|
||||
"building", "property", "bau", "infrastructure"
|
||||
]
|
||||
if any(x in t for x in keywords_b):
|
||||
return "PERSONA_B_FM"
|
||||
|
||||
# Persona A: Ops (Operativer Entscheider - Q1 Fokus!)
|
||||
# Trigger: Logistik, Lager, Supply Chain, Produktion, Operations
|
||||
keywords_a = [
|
||||
"logistik", "lager", "supply", "operat", "versand", "warehouse",
|
||||
"fuhrpark", "site manager", "verkehr", "dispatch", "fertigung",
|
||||
"produktion", "production", "plant", "werk", "standortleiter",
|
||||
"branch manager", "niederlassungsleiter"
|
||||
]
|
||||
if any(x in t for x in keywords_a):
|
||||
return "PERSONA_A_OPS"
|
||||
|
||||
# Persona C: Economic / Boss (Wirtschaftlicher Entscheider)
|
||||
# Trigger: C-Level, GF, Finance (wenn keine spezifischere Rolle greift)
|
||||
keywords_c = [
|
||||
"gf", "geschäftsführer", "ceo", "cfo", "finance", "finanz",
|
||||
"vorstand", "prokurist", "owner", "inhaber", "founder", "gründer",
|
||||
"managing director", "general manager"
|
||||
]
|
||||
if any(x in t for x in keywords_c):
|
||||
return "PERSONA_C_ECON"
|
||||
|
||||
# Fallback
|
||||
return "MANUAL_CHECK"
|
||||
|
||||
# Test-Cases (nur bei direkter Ausführung)
|
||||
if __name__ == "__main__":
|
||||
test_titles = [
|
||||
"Head of Supply Chain Management",
|
||||
"Technischer Leiter Facility",
|
||||
"Geschäftsführer",
|
||||
"Director Sustainability",
|
||||
"Praktikant Marketing",
|
||||
"Teamleiter Fuhrpark",
|
||||
"Hausmeister",
|
||||
"Kaufmännischer Leiter"
|
||||
]
|
||||
|
||||
print(f"{'TITLE':<40} | {'PERSONA'}")
|
||||
print("-" * 60)
|
||||
for title in test_titles:
|
||||
print(f"{title:<40} | {normalize_persona(title)}")
|
||||
157
connector-superoffice/polling_daemon_final.py
Normal file
157
connector-superoffice/polling_daemon_final.py
Normal file
@@ -0,0 +1,157 @@
|
||||
import os
|
||||
import sqlite3
|
||||
import hashlib
|
||||
import time
|
||||
from datetime import datetime
|
||||
import pytz
|
||||
from superoffice_client import SuperOfficeClient
|
||||
from build_matrix import get_vertical_pains_gains, generate_text # Reuse logic
|
||||
|
||||
# --- CONFIGURATION ---
|
||||
DB_FILE_MATRIX = "marketing_matrix.db"
|
||||
DB_FILE_STATE = "processing_state.db"
|
||||
POLLING_INTERVAL_SECONDS = 900
|
||||
BUSINESS_TZ = pytz.timezone("Europe/Berlin")
|
||||
|
||||
PROG_ID_CONTACT_VERTICAL = "SuperOffice:5"
|
||||
PROG_ID_PERSON_ROLE = "SuperOffice:3"
|
||||
PROG_ID_CONTACT_CHALLENGE = "SuperOffice:6"
|
||||
PROG_ID_PERSON_SUBJECT = "SuperOffice:5"
|
||||
PROG_ID_PERSON_INTRO = "SuperOffice:6"
|
||||
PROG_ID_PERSON_PROOF = "SuperOffice:7"
|
||||
PROG_ID_PERSON_HASH = "SuperOffice:8"
|
||||
|
||||
# Mappings (would be better in a config file)
|
||||
VERTICAL_MAP = {
|
||||
23: "Logistics - Warehouse",
|
||||
24: "Healthcare - Hospital",
|
||||
25: "Infrastructure - Transport",
|
||||
26: "Leisure - Indoor Active"
|
||||
}
|
||||
ROLE_MAP = {
|
||||
19: {"name": "Operativer Entscheider", "pains": "..."},
|
||||
20: {"name": "Infrastruktur-Verantwortlicher", "pains": "..."},
|
||||
21: {"name": "Wirtschaftlicher Entscheider", "pains": "..."},
|
||||
22: {"name": "Innovations-Treiber", "pains": "..."}
|
||||
}
|
||||
|
||||
# --- DATABASE & STATE ---
|
||||
def init_state_db():
|
||||
# ... (same as before)
|
||||
pass
|
||||
|
||||
def process_and_update_person(client: SuperOfficeClient, person_id: int, vertical_id: int, role_id: int):
|
||||
print(f" -> Processing Person ID: {person_id} for V:{vertical_id}/R:{role_id}")
|
||||
|
||||
vertical_name = VERTICAL_MAP.get(vertical_id)
|
||||
role_data = ROLE_MAP.get(role_id)
|
||||
if not vertical_name or not role_data:
|
||||
raise ValueError("Vertical or Role ID not in mapping.")
|
||||
|
||||
v_data = get_vertical_pains_gains(vertical_name)
|
||||
|
||||
# Check if text already exists in matrix
|
||||
conn = sqlite3.connect(DB_FILE_MATRIX)
|
||||
c = conn.cursor()
|
||||
c.execute("SELECT subject, intro, social_proof FROM text_blocks WHERE vertical_id = ? AND role_id = ?", (vertical_id, role_id))
|
||||
row = c.fetchone()
|
||||
if not row:
|
||||
# If not, generate it on the fly
|
||||
print(" -> Text not in matrix, generating live...")
|
||||
text_block = generate_text(vertical_name, v_data, role_id, role_data)
|
||||
if not text_block:
|
||||
raise Exception("Failed to generate text block from Gemini.")
|
||||
|
||||
# Save to matrix for future use
|
||||
subj, intro, proof = text_block['Subject'][:40], text_block['Intro'][:40], text_block['SocialProof'][:40]
|
||||
c.execute("INSERT OR REPLACE INTO text_blocks VALUES (?, ?, ?, ?, ?)", (vertical_id, role_id, subj, intro, proof))
|
||||
conn.commit()
|
||||
else:
|
||||
subj, intro, proof = row
|
||||
|
||||
conn.close()
|
||||
|
||||
# Generate Hash
|
||||
copy_hash = hashlib.md5(f"{subj}{intro}{proof}".encode()).hexdigest()
|
||||
|
||||
# Prepare Payloads
|
||||
contact_payload = {PROG_ID_CONTACT_CHALLENGE: intro}
|
||||
person_payload = {
|
||||
PROG_ID_PERSON_SUBJECT: subj,
|
||||
PROG_ID_PERSON_INTRO: intro,
|
||||
PROG_ID_PERSON_PROOF: proof,
|
||||
PROG_ID_PERSON_HASH: copy_hash
|
||||
}
|
||||
|
||||
# Inject data
|
||||
person_data = client.get_person(person_id)
|
||||
contact_id = person_data.get('contact', {}).get('contactId')
|
||||
|
||||
client.update_udfs("Contact", contact_id, contact_payload)
|
||||
client.update_udfs("Person", person_id, person_payload)
|
||||
|
||||
return copy_hash
|
||||
|
||||
# --- POLLING DAEMON ---
|
||||
def poll_for_changes(client: SuperOfficeClient, last_run_utc: str):
|
||||
print(f"Polling for persons modified since {last_run_utc}...")
|
||||
|
||||
select = "personId,contact/contactId,userDefinedFields,lastModified"
|
||||
filter = f"lastModified gt '{last_run_utc}'"
|
||||
|
||||
updated_persons = client.search(f"Person?$select={select}&$filter={filter}")
|
||||
if not updated_persons:
|
||||
print("No persons updated.")
|
||||
return
|
||||
|
||||
print(f"Found {len(updated_persons)} updated persons.")
|
||||
conn_state = sqlite3.connect(DB_FILE_STATE)
|
||||
c_state = conn_state.cursor()
|
||||
|
||||
for person in updated_persons:
|
||||
person_id = person.get('personId')
|
||||
try:
|
||||
udfs = person.get('UserDefinedFields', {})
|
||||
contact_id = person.get('contact', {}).get('contactId')
|
||||
if not contact_id: continue
|
||||
|
||||
contact_data = client.get_contact(contact_id)
|
||||
if not contact_data: continue
|
||||
|
||||
vertical_id_raw = contact_data["UserDefinedFields"].get(PROG_ID_CONTACT_VERTICAL, "")
|
||||
role_id_raw = udfs.get(PROG_ID_PERSON_ROLE, "")
|
||||
|
||||
if not vertical_id_raw or not role_id_raw: continue
|
||||
|
||||
vertical_id = int(vertical_id_raw.replace("[I:", "").replace("]", ""))
|
||||
role_id = int(role_id_raw.replace("[I:", "").replace("]", ""))
|
||||
|
||||
expected_hash = hashlib.md5(f"{vertical_id}-{role_id}".encode()).hexdigest()
|
||||
|
||||
c_state.execute("SELECT last_known_hash FROM person_state WHERE person_id = ?", (person_id,))
|
||||
result = c_state.fetchone()
|
||||
last_known_hash = result[0] if result else None
|
||||
|
||||
if expected_hash != last_known_hash:
|
||||
new_copy_hash = process_and_update_person(client, person_id, vertical_id, role_id)
|
||||
|
||||
c_state.execute("INSERT OR REPLACE INTO person_state VALUES (?, ?, ?)",
|
||||
(person_id, expected_hash, datetime.utcnow().isoformat()))
|
||||
conn_state.commit()
|
||||
else:
|
||||
print(f" - Skipping Person {person_id}: No relevant change (V/R hash unchanged).")
|
||||
|
||||
except Exception as e:
|
||||
print(f" - ❌ Error on Person {person_id}: {e}")
|
||||
|
||||
conn_state.close()
|
||||
|
||||
def main():
|
||||
# ... (main loop from before, but simplified) ...
|
||||
# Needs full implementation
|
||||
pass
|
||||
|
||||
if __name__ == '__main__':
|
||||
# Full script would need pip install pytz flask
|
||||
print("This is the final blueprint for the polling daemon.")
|
||||
# You would start the main() loop here.
|
||||
147
connector-superoffice/polling_daemon_sketch.py
Normal file
147
connector-superoffice/polling_daemon_sketch.py
Normal file
@@ -0,0 +1,147 @@
|
||||
import os
|
||||
import sqlite3
|
||||
import hashlib
|
||||
import time
|
||||
from datetime import datetime, timezone
|
||||
from superoffice_client import SuperOfficeClient
|
||||
|
||||
# --- CONFIGURATION ---
|
||||
DB_FILE_MATRIX = "marketing_matrix.db"
|
||||
DB_FILE_STATE = "processing_state.db"
|
||||
POLLING_INTERVAL_SECONDS = 300 # 5 minutes
|
||||
|
||||
# UDF ProgIds
|
||||
PROG_ID_CONTACT_VERTICAL = "SuperOffice:5"
|
||||
PROG_ID_PERSON_ROLE = "SuperOffice:3"
|
||||
PROG_ID_CONTACT_CHALLENGE = "SuperOffice:6"
|
||||
PROG_ID_PERSON_SUBJECT = "SuperOffice:5"
|
||||
PROG_ID_PERSON_INTRO = "SuperOffice:6"
|
||||
PROG_ID_PERSON_PROOF = "SuperOffice:7"
|
||||
PROG_ID_PERSON_HASH = "SuperOffice:8"
|
||||
|
||||
# --- DATABASE SETUP ---
|
||||
def init_state_db():
|
||||
conn = sqlite3.connect(DB_FILE_STATE)
|
||||
c = conn.cursor()
|
||||
# Stores the last known hash for a person to detect changes
|
||||
c.execute('''CREATE TABLE IF NOT EXISTS person_state
|
||||
(person_id INTEGER PRIMARY KEY,
|
||||
last_known_hash TEXT,
|
||||
last_updated TEXT)''')
|
||||
# Stores the timestamp of the last run
|
||||
c.execute('''CREATE TABLE IF NOT EXISTS system_state
|
||||
(key TEXT PRIMARY KEY, value TEXT)''')
|
||||
c.execute("INSERT OR IGNORE INTO system_state VALUES ('last_run_utc', ?)", (datetime.utcnow().isoformat(),))
|
||||
conn.commit()
|
||||
conn.close()
|
||||
print("✅ State DB initialized.")
|
||||
|
||||
# --- CORE LOGIC ---
|
||||
def get_text_from_matrix(vertical_id, role_id):
|
||||
# (Same as in webhook_server)
|
||||
# ... (omitted for brevity, will be imported)
|
||||
pass
|
||||
|
||||
def process_person(client: SuperOfficeClient, person_id: int):
|
||||
# (Central logic from webhook_server, adapted slightly)
|
||||
# ... (omitted for brevity, will be imported/reused)
|
||||
pass
|
||||
|
||||
def poll_for_changes(client: SuperOfficeClient, last_run_utc: str):
|
||||
print(f"Polling for persons modified since {last_run_utc}...")
|
||||
|
||||
# API Query: Get recently updated persons
|
||||
# We select the fields we need to minimize payload
|
||||
select_fields = "personId,contact/contactId,userDefinedFields"
|
||||
filter_query = f"lastModified gt '{last_run_utc}'"
|
||||
|
||||
# In a real scenario, you'd handle paging for many results
|
||||
recently_updated_persons = client.search(f"Person?$select={select_fields}&$filter={filter_query}")
|
||||
|
||||
if not recently_updated_persons:
|
||||
print("No persons updated since last run.")
|
||||
return
|
||||
|
||||
print(f"Found {len(recently_updated_persons)} updated persons to check.")
|
||||
conn = sqlite3.connect(DB_FILE_STATE)
|
||||
c = conn.cursor()
|
||||
|
||||
for person in recently_updated_persons:
|
||||
person_id = person.get('personId')
|
||||
|
||||
try:
|
||||
# 1. Get current state from SuperOffice
|
||||
udfs = person.get('UserDefinedFields', {})
|
||||
vertical_id_raw = client.get_contact(person['contact']['contactId'])["UserDefinedFields"].get(PROG_ID_CONTACT_VERTICAL, "")
|
||||
role_id_raw = udfs.get(PROG_ID_PERSON_ROLE, "")
|
||||
|
||||
if not vertical_id_raw or not role_id_raw:
|
||||
print(f" - Skipping Person {person_id}: Missing Vertical/Role ID.")
|
||||
continue
|
||||
|
||||
vertical_id = int(vertical_id_raw.replace("[I:", "").replace("]", ""))
|
||||
role_id = int(role_id_raw.replace("[I:", "").replace("]", ""))
|
||||
|
||||
# 2. Generate the "expected" hash
|
||||
expected_hash = hashlib.md5(f"{vertical_id}-{role_id}".encode()).hexdigest()
|
||||
|
||||
# 3. Get last known hash from our state DB
|
||||
c.execute("SELECT last_known_hash FROM person_state WHERE person_id = ?", (person_id,))
|
||||
result = c.fetchone()
|
||||
last_known_hash = result[0] if result else None
|
||||
|
||||
# 4. Compare and act
|
||||
if expected_hash != last_known_hash:
|
||||
print(f" -> Change detected for Person {person_id} (New state: V:{vertical_id}/R:{role_id}). Processing...")
|
||||
|
||||
# Here we would call the full processing logic from webhook_server.py
|
||||
# For now, we simulate the update and save the new state.
|
||||
# process_single_person(client, person_id) # This would be the real call
|
||||
|
||||
# Update our state DB
|
||||
c.execute("INSERT OR REPLACE INTO person_state VALUES (?, ?, ?)",
|
||||
(person_id, expected_hash, datetime.utcnow().isoformat()))
|
||||
conn.commit()
|
||||
print(f" ✅ Processed and updated state for Person {person_id}.")
|
||||
else:
|
||||
print(f" - Skipping Person {person_id}: No relevant change detected (hash is the same).")
|
||||
|
||||
except Exception as e:
|
||||
print(f" - ❌ Error processing Person {person_id}: {e}")
|
||||
|
||||
conn.close()
|
||||
|
||||
# --- MAIN DAEMON LOOP ---
|
||||
def main():
|
||||
init_state_db()
|
||||
|
||||
try:
|
||||
client = SuperOfficeClient()
|
||||
except Exception as e:
|
||||
print(f"Could not start daemon: {e}")
|
||||
return
|
||||
|
||||
while True:
|
||||
conn = sqlite3.connect(DB_FILE_STATE)
|
||||
c = conn.cursor()
|
||||
c.execute("SELECT value FROM system_state WHERE key = 'last_run_utc'")
|
||||
last_run = c.fetchone()[0]
|
||||
|
||||
# Poll for changes
|
||||
poll_for_changes(client, last_run)
|
||||
|
||||
# Update last run time
|
||||
new_last_run = datetime.utcnow().isoformat()
|
||||
c.execute("UPDATE system_state SET value = ? WHERE key = 'last_run_utc'", (new_last_run,))
|
||||
conn.commit()
|
||||
conn.close()
|
||||
|
||||
print(f"\nPolling complete. Next run in {POLLING_INTERVAL_SECONDS} seconds...")
|
||||
time.sleep(POLLING_INTERVAL_SECONDS)
|
||||
|
||||
if __name__ == '__main__':
|
||||
# This is a conceptual sketch.
|
||||
# The SuperOfficeClient needs a `search` method.
|
||||
# The logic from webhook_server needs to be callable.
|
||||
print("This script is a blueprint for the polling daemon.")
|
||||
print("It requires a `search` method in the SuperOfficeClient and refactoring.")
|
||||
@@ -1,312 +1,138 @@
|
||||
import os
|
||||
import requests
|
||||
import logging
|
||||
from auth_handler import AuthHandler
|
||||
from config import Config
|
||||
from logging_config import setup_logging
|
||||
import json
|
||||
from dotenv import load_dotenv
|
||||
|
||||
# Use the centralized logging configuration
|
||||
logger = setup_logging(__name__)
|
||||
load_dotenv(override=True)
|
||||
|
||||
class SuperOfficeClient:
|
||||
"""
|
||||
A client for interacting with the SuperOffice REST API using OAuth 2.0 Bearer tokens.
|
||||
"""
|
||||
def __init__(self, auth_handler: AuthHandler):
|
||||
self.auth_handler = auth_handler
|
||||
self.session = requests.Session()
|
||||
"""A client for interacting with the SuperOffice REST API."""
|
||||
|
||||
# Load mappings from Config
|
||||
self.udf_contact_mapping = Config.UDF_CONTACT_MAPPING
|
||||
self.udf_person_mapping = Config.UDF_PERSON_MAPPING
|
||||
self.ma_status_id_map = Config.MA_STATUS_ID_MAP
|
||||
def __init__(self):
|
||||
self.client_id = os.getenv("SO_CLIENT_ID") or os.getenv("SO_SOD")
|
||||
self.client_secret = os.getenv("SO_CLIENT_SECRET")
|
||||
self.refresh_token = os.getenv("SO_REFRESH_TOKEN")
|
||||
self.redirect_uri = os.getenv("SO_REDIRECT_URI", "http://localhost")
|
||||
self.env = os.getenv("SO_ENVIRONMENT", "sod")
|
||||
self.cust_id = os.getenv("SO_CONTEXT_IDENTIFIER", "Cust55774") # Fallback for your dev
|
||||
|
||||
def _get_headers(self):
|
||||
"""Returns the authorization headers with Bearer token."""
|
||||
access_token, _ = self.auth_handler.get_ticket()
|
||||
return {
|
||||
'Authorization': f'Bearer {access_token}',
|
||||
'Accept': 'application/json',
|
||||
'Content-Type': 'application/json'
|
||||
if not all([self.client_id, self.client_secret, self.refresh_token]):
|
||||
raise ValueError("SuperOffice credentials missing in .env file.")
|
||||
|
||||
self.base_url = f"https://app-{self.env}.superoffice.com/{self.cust_id}/api/v1"
|
||||
self.access_token = self._refresh_access_token()
|
||||
if not self.access_token:
|
||||
raise Exception("Failed to authenticate with SuperOffice.")
|
||||
|
||||
self.headers = {
|
||||
"Authorization": f"Bearer {self.access_token}",
|
||||
"Content-Type": "application/json",
|
||||
"Accept": "application/json"
|
||||
}
|
||||
print("✅ SuperOffice Client initialized and authenticated.")
|
||||
|
||||
def _get_url(self, path):
|
||||
"""Constructs the full URL for a given API path."""
|
||||
_, webapi_url = self.auth_handler.get_ticket()
|
||||
base = webapi_url.rstrip('/')
|
||||
p = path.lstrip('/')
|
||||
return f"{base}/api/{p}"
|
||||
|
||||
def test_connection(self):
|
||||
"""Tests the connection by fetching the current user."""
|
||||
url = self._get_url("v1/User/currentPrincipal")
|
||||
def _refresh_access_token(self):
|
||||
"""Refreshes and returns a new access token."""
|
||||
url = f"https://{self.env}.superoffice.com/login/common/oauth/tokens"
|
||||
data = {
|
||||
"grant_type": "refresh_token",
|
||||
"client_id": self.client_id,
|
||||
"client_secret": self.client_secret,
|
||||
"refresh_token": self.refresh_token,
|
||||
"redirect_uri": self.redirect_uri
|
||||
}
|
||||
try:
|
||||
resp = self.session.get(url, headers=self._get_headers())
|
||||
resp = requests.post(url, data=data)
|
||||
resp.raise_for_status()
|
||||
return resp.json().get("access_token")
|
||||
except requests.exceptions.HTTPError as e:
|
||||
print(f"❌ Token Refresh Error: {e.response.text}")
|
||||
return None
|
||||
except Exception as e:
|
||||
print(f"❌ Connection Error during token refresh: {e}")
|
||||
return None
|
||||
|
||||
def _get(self, endpoint):
|
||||
"""Generic GET request."""
|
||||
try:
|
||||
resp = requests.get(f"{self.base_url}/{endpoint}", headers=self.headers)
|
||||
resp.raise_for_status()
|
||||
return resp.json()
|
||||
except Exception as e:
|
||||
logger.error(f"Connection test failed: {e}")
|
||||
if hasattr(e, 'response') and e.response is not None:
|
||||
logger.error(f"Response: {e.response.text}")
|
||||
except requests.exceptions.HTTPError as e:
|
||||
print(f"❌ API GET Error for {endpoint}: {e.response.text}")
|
||||
return None
|
||||
|
||||
def find_contact_by_criteria(self, name=None, url=None, org_nr=None):
|
||||
"""Searches for a contact by OrgNr, URL, or Name."""
|
||||
filters = []
|
||||
if org_nr:
|
||||
filters.append(f"orgNr eq '{org_nr}'")
|
||||
if url:
|
||||
filters.append(f"urlAddress eq '{url}'")
|
||||
|
||||
if not filters and name:
|
||||
filters.append(f"name contains '{name}'")
|
||||
|
||||
if not filters:
|
||||
return None
|
||||
|
||||
query = " and ".join(filters)
|
||||
path = f"v1/Contact?$filter={query}"
|
||||
|
||||
def _put(self, endpoint, payload):
|
||||
"""Generic PUT request."""
|
||||
try:
|
||||
full_url = self._get_url(path)
|
||||
resp = self.session.get(full_url, headers=self._get_headers())
|
||||
resp = requests.put(f"{self.base_url}/{endpoint}", headers=self.headers, json=payload)
|
||||
resp.raise_for_status()
|
||||
return resp.json()
|
||||
except requests.exceptions.HTTPError as e:
|
||||
print(f"❌ API PUT Error for {endpoint}: {e.response.text}")
|
||||
return None
|
||||
|
||||
def get_person(self, person_id):
|
||||
"""Gets a single person by ID."""
|
||||
return self._get(f"Person/{person_id}")
|
||||
|
||||
def get_contact(self, contact_id):
|
||||
"""Gets a single contact (company) by ID."""
|
||||
return self._get(f"Contact/{contact_id}")
|
||||
|
||||
def update_udfs(self, entity: str, entity_id: int, udf_payload: dict):
|
||||
"""
|
||||
Updates the UserDefinedFields for a given entity (Person or Contact).
|
||||
|
||||
Args:
|
||||
entity (str): "Person" or "Contact".
|
||||
entity_id (int): The ID of the entity.
|
||||
udf_payload (dict): A dictionary of ProgId:Value pairs.
|
||||
"""
|
||||
endpoint = f"{entity}/{entity_id}"
|
||||
|
||||
# 1. GET the full entity object
|
||||
existing_data = self._get(endpoint)
|
||||
if not existing_data:
|
||||
return False # Error is printed in _get
|
||||
|
||||
# 2. Merge the UDF payload
|
||||
if "UserDefinedFields" not in existing_data:
|
||||
existing_data["UserDefinedFields"] = {}
|
||||
existing_data["UserDefinedFields"].update(udf_payload)
|
||||
|
||||
# 3. PUT the full object back
|
||||
print(f"Updating {entity} {entity_id} with new UDFs...")
|
||||
result = self._put(endpoint, existing_data)
|
||||
|
||||
if result:
|
||||
print(f"✅ Successfully updated {entity} {entity_id}")
|
||||
return True
|
||||
return False
|
||||
|
||||
|
||||
def search(self, query_string: str):
|
||||
"""
|
||||
Performs a search using OData syntax and handles pagination.
|
||||
Example: "Person?$select=personId&$filter=lastname eq 'Godelmann'"
|
||||
"""
|
||||
all_results = []
|
||||
next_page_url = f"{self.base_url}/{query_string}"
|
||||
|
||||
while next_page_url:
|
||||
try:
|
||||
resp = requests.get(next_page_url, headers=self.headers)
|
||||
resp.raise_for_status()
|
||||
data = resp.json()
|
||||
|
||||
results = data.get("value", [])
|
||||
if results:
|
||||
logger.info(f"Found {len(results)} matching contacts.")
|
||||
return results[0]
|
||||
return None
|
||||
except Exception as e:
|
||||
logger.error(f"Error searching for contact: {e}")
|
||||
# Add the items from the current page
|
||||
all_results.extend(data.get('value', []))
|
||||
|
||||
# Check for the next page link
|
||||
next_page_url = data.get('next_page_url', None)
|
||||
|
||||
except requests.exceptions.HTTPError as e:
|
||||
print(f"❌ API Search Error for {query_string}: {e.response.text}")
|
||||
return None
|
||||
|
||||
def create_contact(self, name, url=None, org_nr=None):
|
||||
"""Creates a new contact (company) in SuperOffice with basic details."""
|
||||
url = self._get_url("v1/Contact")
|
||||
payload = {
|
||||
"Name": name,
|
||||
"OrgNr": org_nr,
|
||||
"UrlAddress": url,
|
||||
"ActivePublications": [], # Required field, can be empty
|
||||
"Emails": [], # Required field, can be empty
|
||||
"Phones": [] # Required field, can be empty
|
||||
}
|
||||
|
||||
# Remove None values
|
||||
payload = {k: v for k, v in payload.items() if v is not None}
|
||||
|
||||
try:
|
||||
logger.info(f"Attempting to create contact: {name}")
|
||||
resp = self.session.post(url, headers=self._get_headers(), json=payload)
|
||||
resp.raise_for_status()
|
||||
created_contact = resp.json()
|
||||
logger.info(f"Successfully created contact: {created_contact.get('Name')} (ID: {created_contact.get('ContactId')})")
|
||||
return created_contact
|
||||
except Exception as e:
|
||||
if hasattr(e, 'response') and e.response is not None:
|
||||
logger.error(f"Response: {e.response.text}")
|
||||
return None
|
||||
|
||||
def create_person(self, first_name, last_name, contact_id, email=None):
|
||||
"""Creates a new person linked to a contact (company)."""
|
||||
url = self._get_url("v1/Person")
|
||||
|
||||
payload = {
|
||||
"Firstname": first_name,
|
||||
"Lastname": last_name,
|
||||
"Contact": {
|
||||
"ContactId": contact_id
|
||||
},
|
||||
"Emails": []
|
||||
}
|
||||
|
||||
if email:
|
||||
payload["Emails"].append({
|
||||
"Value": email,
|
||||
"Rank": 1,
|
||||
"Description": "Work" # Optional description
|
||||
})
|
||||
|
||||
try:
|
||||
logger.info(f"Attempting to create person: {first_name} {last_name} for Contact ID {contact_id}")
|
||||
resp = self.session.post(url, headers=self._get_headers(), json=payload)
|
||||
resp.raise_for_status()
|
||||
created_person = resp.json()
|
||||
logger.info(f"Successfully created person: {created_person.get('Firstname')} {created_person.get('Lastname')} (ID: {created_person.get('PersonId')})")
|
||||
return created_person
|
||||
except Exception as e:
|
||||
if hasattr(e, 'response') and e.response is not None:
|
||||
logger.error(f"Response: {e.response.text}")
|
||||
return None
|
||||
|
||||
def create_sale(self, title, contact_id, person_id=None, amount=0.0):
|
||||
"""Creates a new Sale (Opportunity) linked to a contact and optionally a person."""
|
||||
url = self._get_url("v1/Sale")
|
||||
|
||||
payload = {
|
||||
"Heading": title,
|
||||
"Contact": {
|
||||
"ContactId": contact_id
|
||||
},
|
||||
"Amount": amount,
|
||||
"SaleType": { # Assuming default ID 1 exists
|
||||
"Id": 1
|
||||
},
|
||||
"SaleStage": { # Assuming default ID for the first stage is 1
|
||||
"Id": 1
|
||||
},
|
||||
"Probability": 10 # Default probability
|
||||
}
|
||||
|
||||
if person_id:
|
||||
payload["Person"] = {
|
||||
"PersonId": person_id
|
||||
}
|
||||
|
||||
try:
|
||||
logger.info(f"Attempting to create sale: '{title}' for Contact ID {contact_id}")
|
||||
resp = self.session.post(url, headers=self._get_headers(), json=payload)
|
||||
resp.raise_for_status()
|
||||
created_sale = resp.json()
|
||||
logger.info(f"Successfully created sale: {created_sale.get('Heading')} (ID: {created_sale.get('SaleId')})")
|
||||
return created_sale
|
||||
except Exception as e:
|
||||
if hasattr(e, 'response') and e.response is not None:
|
||||
logger.error(f"Response: {e.response.text}")
|
||||
return None
|
||||
|
||||
def create_project(self, name, contact_id, person_id=None):
|
||||
"""Creates a new Project linked to a contact and optionally adds a person as a member."""
|
||||
url = self._get_url("v1/Project")
|
||||
|
||||
payload = {
|
||||
"Name": name,
|
||||
"Contact": {
|
||||
"ContactId": contact_id
|
||||
},
|
||||
"ProjectType": { # Assuming default ID 1 exists
|
||||
"Id": 1
|
||||
},
|
||||
"ProjectStatus": { # Assuming default ID 1 for 'In progress' exists
|
||||
"Id": 1
|
||||
},
|
||||
"ProjectMembers": []
|
||||
}
|
||||
|
||||
if person_id:
|
||||
payload["ProjectMembers"].append({
|
||||
"PersonId": person_id
|
||||
})
|
||||
|
||||
try:
|
||||
logger.info(f"Attempting to create project: '{name}' for Contact ID {contact_id}")
|
||||
resp = self.session.post(url, headers=self._get_headers(), json=payload)
|
||||
resp.raise_for_status()
|
||||
created_project = resp.json()
|
||||
logger.info(f"Successfully created project: {created_project.get('Name')} (ID: {created_project.get('ProjectId')})")
|
||||
return created_project
|
||||
except Exception as e:
|
||||
logger.error(f"Error creating project: {e}")
|
||||
if hasattr(e, 'response') and e.response is not None:
|
||||
logger.error(f"Response: {e.response.text}")
|
||||
return None
|
||||
|
||||
def update_entity_udfs(self, entity_id, entity_type, udf_data: dict):
|
||||
"""Updates user-defined fields for a given entity (Contact or Person)."""
|
||||
if entity_type not in ["Contact", "Person"]:
|
||||
logger.error(f"Invalid entity_type: {entity_type}. Must be 'Contact' or 'Person'.")
|
||||
return None
|
||||
|
||||
# 1. Retrieve the existing entity to ensure all required fields are present in the PUT payload
|
||||
get_url = self._get_url(f"v1/{entity_type}/{entity_id}")
|
||||
try:
|
||||
get_resp = self.session.get(get_url, headers=self._get_headers())
|
||||
get_resp.raise_for_status()
|
||||
existing_entity = get_resp.json()
|
||||
logger.info(f"Successfully retrieved existing {entity_type} ID {entity_id}.")
|
||||
except Exception as e:
|
||||
logger.error(f"Error retrieving existing {entity_type} ID {entity_id}: {e}")
|
||||
if hasattr(e, 'response') and e.response is not None:
|
||||
logger.error(f"Response: {e.response.text}")
|
||||
return None
|
||||
|
||||
# Use the existing entity data as the base for the PUT payload
|
||||
payload = existing_entity
|
||||
if "UserDefinedFields" not in payload:
|
||||
payload["UserDefinedFields"] = {}
|
||||
|
||||
# Select the correct mapping based on entity type
|
||||
udf_mapping = self.udf_contact_mapping if entity_type == "Contact" else self.udf_person_mapping
|
||||
|
||||
for key, value in udf_data.items():
|
||||
prog_id = udf_mapping.get(key)
|
||||
if prog_id:
|
||||
if key == "ma_status" and entity_type == "Person":
|
||||
# For MA Status, we need to send the internal ID directly as an integer
|
||||
internal_id = self.ma_status_id_map.get(value)
|
||||
if internal_id:
|
||||
payload["UserDefinedFields"][prog_id] = internal_id
|
||||
else:
|
||||
logger.warning(f"Unknown MA Status value '{value}'. Skipping update for {key}.")
|
||||
else:
|
||||
# For other UDFs, send the value directly
|
||||
payload["UserDefinedFields"][prog_id] = value
|
||||
else:
|
||||
logger.warning(f"Unknown UDF key for {entity_type}: {key}. Skipping.")
|
||||
|
||||
if not payload["UserDefinedFields"]:
|
||||
logger.info(f"No valid UDF data to update for {entity_type} ID {entity_id}.")
|
||||
return None
|
||||
|
||||
# 2. Send the updated entity (including all original fields + modified UDFs) via PUT
|
||||
put_url = self._get_url(f"v1/{entity_type}/{entity_id}")
|
||||
try:
|
||||
logger.info(f"Attempting to update UDFs for {entity_type} ID {entity_id} with: {payload['UserDefinedFields']}")
|
||||
resp = self.session.put(put_url, headers=self._get_headers(), json=payload)
|
||||
resp.raise_for_status()
|
||||
updated_entity = resp.json()
|
||||
logger.info(f"Successfully updated UDFs for {entity_type} ID {entity_id}.")
|
||||
return updated_entity
|
||||
except Exception as e:
|
||||
logger.error(f"Error updating UDFs for {entity_type} ID {entity_id}: {e}")
|
||||
if hasattr(e, 'response') and e.response is not None:
|
||||
logger.error(f"Response: {e.response.text}")
|
||||
return None
|
||||
|
||||
|
||||
# NOTE: The create_email_activity method is currently blocked due to SuperOffice environment limitations.
|
||||
# Attempting to create an Email Activity via API results in a 500 Internal Server Error,
|
||||
# likely because the email module is not licensed or configured in the SOD environment.
|
||||
# This method is temporarily commented out.
|
||||
#
|
||||
# def create_email_activity(self, person_id, contact_id, subject, body):
|
||||
# """Creates an Email Activity linked to a person and contact."""
|
||||
# url = self._get_url("v1/Activity")
|
||||
#
|
||||
# payload = {
|
||||
# "Type": { # Assuming ID 2 for "Email" ActivityType
|
||||
# "Id": 2
|
||||
# },
|
||||
# "Title": subject,
|
||||
# "Details": body,
|
||||
# "Person": {
|
||||
# "PersonId": person_id
|
||||
# },
|
||||
# "Contact": {
|
||||
# "ContactId": contact_id
|
||||
# }
|
||||
# }
|
||||
#
|
||||
# try:
|
||||
# logger.info(f"Attempting to create Email Activity with subject '{subject}' for Person ID {person_id} and Contact ID {contact_id}")
|
||||
# resp = self.session.post(url, headers=self._get_headers(), json=payload)
|
||||
# resp.raise_for_status()
|
||||
# created_activity = resp.json()
|
||||
# logger.info(f"Successfully created Email Activity: '{created_activity.get('Title')}' (ID: {created_activity.get('ActivityId')})")
|
||||
# return created_activity
|
||||
# except Exception as e:
|
||||
# logger.error(f"Error creating Email Activity: {e}")
|
||||
# if hasattr(e, 'response') and e.response is not None:
|
||||
# logger.error(f"Response: {e.response.text}")
|
||||
# return None
|
||||
return all_results
|
||||
|
||||
128
connector-superoffice/webhook_server.py
Normal file
128
connector-superoffice/webhook_server.py
Normal file
@@ -0,0 +1,128 @@
|
||||
from flask import Flask, request, jsonify
|
||||
import os
|
||||
import sqlite3
|
||||
import hashlib
|
||||
from superoffice_client import SuperOfficeClient # Our new shiny client class
|
||||
|
||||
app = Flask(__name__)
|
||||
|
||||
# --- CONFIGURATION ---
|
||||
DB_FILE = "marketing_matrix.db"
|
||||
|
||||
# UDF ProgIds (from our plan)
|
||||
PROG_ID_CONTACT_VERTICAL = "SuperOffice:5"
|
||||
PROG_ID_PERSON_ROLE = "SuperOffice:3"
|
||||
PROG_ID_CONTACT_CHALLENGE = "SuperOffice:6"
|
||||
PROG_ID_PERSON_SUBJECT = "SuperOffice:5"
|
||||
PROG_ID_PERSON_INTRO = "SuperOffice:6"
|
||||
PROG_ID_PERSON_PROOF = "SuperOffice:7"
|
||||
PROG_ID_PERSON_HASH = "SuperOffice:8"
|
||||
|
||||
# --- CORE LOGIC ---
|
||||
def get_text_from_matrix(vertical_id, role_id):
|
||||
"""Fetches the pre-generated text block from the local SQLite DB."""
|
||||
conn = sqlite3.connect(DB_FILE)
|
||||
c = conn.cursor()
|
||||
c.execute("SELECT subject, intro, social_proof FROM text_blocks WHERE vertical_id = ? AND role_id = ?", (vertical_id, role_id))
|
||||
row = c.fetchone()
|
||||
conn.close()
|
||||
return row if row else (None, None, None)
|
||||
|
||||
def process_single_person(client: SuperOfficeClient, person_id: int):
|
||||
"""Central logic to update marketing copy for a single person."""
|
||||
print(f"Processing Person ID: {person_id}")
|
||||
|
||||
person_data = client.get_person(person_id)
|
||||
if not person_data:
|
||||
raise ValueError(f"Person {person_id} not found")
|
||||
|
||||
contact_id = person_data.get('contact', {}).get('contactId')
|
||||
if not contact_id:
|
||||
raise ValueError("Person is not linked to a Contact")
|
||||
|
||||
contact_data = client.get_contact(contact_id)
|
||||
if not contact_data:
|
||||
raise ValueError(f"Contact {contact_id} not found")
|
||||
|
||||
# Extract and clean Vertical and Role IDs
|
||||
vertical_id_raw = contact_data["UserDefinedFields"].get(PROG_ID_CONTACT_VERTICAL, "")
|
||||
role_id_raw = person_data["UserDefinedFields"].get(PROG_ID_PERSON_ROLE, "")
|
||||
|
||||
if not vertical_id_raw or not role_id_raw:
|
||||
raise ValueError("Vertical or Role ID is not set.")
|
||||
|
||||
vertical_id = int(vertical_id_raw.replace("[I:", "").replace("]", ""))
|
||||
role_id = int(role_id_raw.replace("[I:", "").replace("]", ""))
|
||||
|
||||
# Get text from matrix
|
||||
subject, intro, proof = get_text_from_matrix(vertical_id, role_id)
|
||||
if not subject:
|
||||
raise ValueError(f"No text found in matrix for V:{vertical_id}, R:{role_id}")
|
||||
|
||||
# Generate Hash
|
||||
text_concat = f"{subject}{intro}{proof}"
|
||||
copy_hash = hashlib.md5(text_concat.encode()).hexdigest()
|
||||
|
||||
# Prepare payloads
|
||||
contact_payload = {PROG_ID_CONTACT_CHALLENGE: intro}
|
||||
person_payload = {
|
||||
PROG_ID_PERSON_SUBJECT: subject,
|
||||
PROG_ID_PERSON_INTRO: intro,
|
||||
PROG_ID_PERSON_PROOF: proof,
|
||||
PROG_ID_PERSON_HASH: copy_hash
|
||||
}
|
||||
|
||||
# Inject data
|
||||
client.update_udfs("Contact", contact_id, contact_payload)
|
||||
client.update_udfs("Person", person_id, person_payload)
|
||||
|
||||
return f"Updated Person {person_id} with texts for V:{vertical_id}/R:{role_id}"
|
||||
|
||||
# --- WEBHOOK ENDPOINTS ---
|
||||
@app.route('/regenerate_for_person', methods=['POST'])
|
||||
def webhook_person():
|
||||
data = request.get_json()
|
||||
if not data or "person_id" not in data:
|
||||
return jsonify({"error": "Missing person_id"}), 400
|
||||
|
||||
try:
|
||||
client = SuperOfficeClient()
|
||||
message = process_single_person(client, data['person_id'])
|
||||
return jsonify({"status": "success", "message": message}), 200
|
||||
except Exception as e:
|
||||
print(f"❌ Error processing person: {e}")
|
||||
return jsonify({"error": str(e)}), 500
|
||||
|
||||
@app.route('/regenerate_for_contact', methods=['POST'])
|
||||
def webhook_contact():
|
||||
data = request.get_json()
|
||||
if not data or "contact_id" not in data:
|
||||
return jsonify({"error": "Missing contact_id"}), 400
|
||||
|
||||
contact_id = data['contact_id']
|
||||
print(f"Received request to regenerate for all persons in Contact ID: {contact_id}")
|
||||
|
||||
try:
|
||||
client = SuperOfficeClient()
|
||||
contact = client.get_contact(contact_id)
|
||||
if not contact or not contact.get('persons'):
|
||||
return jsonify({"status": "success", "message": "No persons found for this contact."}), 200
|
||||
|
||||
updated_count = 0
|
||||
for person_summary in contact['persons']:
|
||||
try:
|
||||
process_single_person(client, person_summary['personId'])
|
||||
updated_count += 1
|
||||
except Exception as e:
|
||||
print(f" - Skipping Person {person_summary.get('personId')}: {e}")
|
||||
|
||||
return jsonify({"status": "success", "message": f"Processed {updated_count} persons for Contact {contact_id}"}), 200
|
||||
|
||||
except Exception as e:
|
||||
print(f"❌ Error processing contact: {e}")
|
||||
return jsonify({"error": str(e)}), 500
|
||||
|
||||
if __name__ == '__main__':
|
||||
# For local dev. Use a proper WSGI server (Gunicorn) for production.
|
||||
# Needs pip install Flask
|
||||
app.run(host='0.0.0.0', port=5001, debug=True)
|
||||
Reference in New Issue
Block a user