piko.py

import requests
import json

import os

# Central Configuration
# Local: http://localhost:9002/api/piko/v1
# Production: http://www.postpipe.in/api/piko/v1
BASE_URL = os.getenv("PIKO_BASE_URL", "https://www.postpipe.in/api/piko/v1")

# --- Authentication & Verification ---

def verify_login(api_key: str, **kwargs):
    """
    Verifies the Piko API key and returns associated user profile.
    """
    url = f"{BASE_URL}/loginVerify"
    headers = {"x-piko-api-key": api_key}
    
    try:
        response = requests.get(url, headers=headers)
        if response.status_code == 200:
            return response.json()
        error_msg = f"Auth Failed: {response.status_code} - {response.text[:200]}"
        print(error_msg)
        return {"error": error_msg}
    except Exception as e:
        print(f"Error verifying login: {e}")
        return None

# --- Resource Discovery ---

def get_connectors(api_key: str, **kwargs):
    """
    Retrieves all active connectors.
    Returns: Dict mapping connector names to their IDs.
    """
    url = f"{BASE_URL}/connectorsAndSecrets"
    headers = {"x-piko-api-key": api_key}
    
    try:
        response = requests.get(url, headers=headers)
        if response.status_code == 200:
            connectors = response.json().get('connectors', [])
            # Filters for active connectors (ignores PENDING ones)
            return {c['name']: c['id'] for c in connectors if c.get('url') != 'PENDING'}
        return {}
    except Exception as e:
        print(f"Error fetching connectors: {e}")
        return {}

def get_databases(api_key: str, connector_id: str = None, **kwargs):
    """
    Fetches target databases available for storage.
    :param connector_id: (Optional) Filter databases by a specific connector.
    """
    url = f"{BASE_URL}/databases"
    headers = {"x-piko-api-key": api_key}
    params = {"connectorId": connector_id} if connector_id else {}
    
    try:
        response = requests.get(url, headers=headers, params=params)
        if response.status_code == 200:
            return response.json()
        return {"error": f"Failed to fetch databases: {response.status_code} - {response.text[:200]}"}
    except Exception as e:
        print(f"Error fetching databases: {e}")
        return None

# --- Form Management ---

def create_form(api_key: str, name: str = None, connector_id: str = None, target_database: str = None, fields: list = None, routing: dict = None, **kwargs):
    """Creates a new form in Piko."""
    # Resilience: Extract missing params from kwargs if needed
    name = name or kwargs.get("name")
    connector_id = connector_id or kwargs.get("connector_id")
    target_database = target_database or kwargs.get("target_database") or kwargs.get("database")
    fields = fields or kwargs.get("fields") or []
    
    if not name or not connector_id or not target_database:
        return {"error": f"Missing required parameters for create_form: name={name}, connector_id={connector_id}, target_database={target_database}"}

    # Normalize field types
    type_map = {
        "string": "text",
        "uuid": "text",
        "timestamp": "datetime",
        "boolean": "checkbox",
        "integer": "number",
        "float": "decimal"
    }
    
    normalized_fields = []
    for field in fields:
        f = field.copy()
        if f.get("type") in type_map:
            f["type"] = type_map[f["type"]]
        normalized_fields.append(f)

    url = f"{BASE_URL}/forms"
    headers = {"x-piko-api-key": api_key}
    body = {
        "name": name,
        "connectorId": connector_id,
        "targetDatabase": target_database,
        "fields": normalized_fields,
        **({"routing": routing} if routing else {})
    }
    
    try:
        response = requests.post(url, headers=headers, json=body)
        if response.status_code == 200:
            print(f"Success: Form '{name}' created successfully.")
            return response.json()
        return {"error": f"Failed to create form: {response.status_code} - {response.text[:200]}"}
    except Exception as e:
        print(f"Error creating form: {e}")
        return None

def update_form(api_key: str, form_id: str, updates: dict, **kwargs):
    """
    Updates an existing form configuration.
    :param updates: Dict of fields to update, e.g. {"name": "New Name", "fields": [...]}
    """
    url = f"{BASE_URL}/forms"
    headers = {"x-piko-api-key": api_key}
    
    body = {
        "id": form_id,
        **updates
    }
    
    try:
        response = requests.patch(url, headers=headers, json=body)
        if response.status_code == 200:
            print(f"Success: Form '{form_id}' updated.")
            return response.json()
        return {"error": f"Failed to update form: {response.status_code} - {response.text[:200]}"}
    except Exception as e:
        print(f"Error updating form: {e}")
        return None

def list_forms(api_key: str, **kwargs):
    """Returns a list of all forms registered under the Piko API."""
    url = f"{BASE_URL}/forms"
    headers = {"x-piko-api-key": api_key}
    
    try:
        response = requests.get(url, headers=headers)
        if response.status_code == 200:
            return response.json().get("forms", [])
        return []
    except Exception as e:
        print(f"Error listing forms: {e}")
        return []

def get_form_snippets(api_key: str, form_id: str = None, **kwargs):
    """Fetches HTML and React embedding code for a form."""
    fid = form_id or kwargs.get("form_id") or kwargs.get("form_name")
    
    # Handle LLM hallucination: array of form_ids
    form_ids = kwargs.get("form_ids")
    if not fid and form_ids and isinstance(form_ids, list) and len(form_ids) > 0:
        fid = form_ids[0]
        
    if not fid:
        return {"error": "Missing form_id or form_name"}
        
    # Attempt to use fid directly
    url = f"{BASE_URL}/snippets"
    headers = {"x-piko-api-key": api_key}
    params = {"formId": fid}
    
    try:
        response = requests.get(url, headers=headers, params=params)
        if response.status_code == 200:
            return response.json()
            
        # Fallback: if fid looks like a name (no dashes or not found), try to find by name
        all_forms = list_forms(api_key)
        for f in all_forms:
            if f.get("name") == fid or f.get("id") == fid:
                params["formId"] = f.get("id")
                response = requests.get(url, headers=headers, params=params)
                if response.status_code == 200:
                    return response.json()
                    
        return {"error": f"Form not found: {fid}"}
    except Exception as e:
        print(f"Error fetching snippets: {e}")
        return None

def get_auth_snippets(api_key: str, preset_id: str = None, **kwargs):
    """Fetches HTML and React embedding code for an Auth Preset."""
    pid = preset_id or kwargs.get("preset_id") or kwargs.get("preset_name") or kwargs.get("name")
    if not pid:
        return {"error": "Missing preset_id or preset_name"}
        
    # Attempt to use pid directly
    url = f"{BASE_URL}/snippets"
    headers = {"x-piko-api-key": api_key}
    params = {"type": "auth-preset", "presetId": pid}
    
    try:
        response = requests.get(url, headers=headers, params=params)
        if response.status_code == 200:
            return response.json()
            
        # Fallback: find by name
        all_presets = list_auth_presets(api_key)
        for p in all_presets:
            if p.get("name") == pid or p.get("id") == pid:
                params["presetId"] = p.get("id")
                response = requests.get(url, headers=headers, params=params)
                if response.status_code == 200:
                    return response.json()
                    
        return {"error": f"Auth Preset not found: {pid}"}
    except Exception as e:
        print(f"Error fetching auth snippets: {e}")
        return None

# --- Auth Preset Management ---

def create_auth_preset(api_key: str, name: str, providers: dict = None, redirect_url: str = None, connector_id: str = None, **kwargs):
    """
    Creates a new Auth Preset for handling user authentication.
    :param providers: Dict, e.g. {"email": True, "google": True, "github": False}
    """
    url = f"{BASE_URL}/auth-presets"
    headers = {"x-piko-api-key": api_key}
    
    # Default providers if missing
    if providers is None:
        providers = {"email": True}
    
    # Handle providers if passed as a list (common LLM hallucination)
    if isinstance(providers, list):
        providers = {p: True for p in providers}
        
    body = {
        "name": name,
        "providers": providers
    }
    if redirect_url: body["redirectUrl"] = redirect_url
    if connector_id: body["connectorId"] = connector_id
    
    try:
        response = requests.post(url, headers=headers, json=body)
        if response.status_code == 200:
            print(f"Success: Auth Preset '{name}' created.")
            return response.json().get("preset")
        return {"error": f"Failed to create Auth Preset: {response.status_code} - {response.text[:200]}"}
    except Exception as e:
        print(f"Error creating auth preset: {e}")
        return None

def list_auth_presets(api_key: str, **kwargs):
    """Lists all authentication configurations."""
    url = f"{BASE_URL}/auth-presets"
    headers = {"x-piko-api-key": api_key}
    
    try:
        response = requests.get(url, headers=headers)
        if response.status_code == 200:
            return response.json().get("presets", [])
        return []
    except Exception as e:
        print(f"Error listing auth presets: {e}")
        return []

def get_auth_preset(api_key: str, preset_id: str, **kwargs):
    """Fetches a specific Auth Preset by its ID."""
    url = f"{BASE_URL}/auth-presets/{preset_id}"
    headers = {"x-piko-api-key": api_key}
    
    try:
        response = requests.get(url, headers=headers)
        if response.status_code == 200:
            return response.json().get("preset")
        return {"error": f"Failed to fetch auth preset: {response.status_code} - {response.text[:200]}"}
    except Exception as e:
        print(f"Error fetching auth preset: {e}")
        return None

# --- System Management ---

def create_system(api_key: str, name: str, type: str, template_id: str = None, **kwargs):
    """
    Registers a new high-level system (e.g. E-commerce, CRM).
    """
    url = f"{BASE_URL}/systems"
    headers = {"x-piko-api-key": api_key}
    body = {"name": name, "type": type}
    if template_id: body["templateId"] = template_id
    
    try:
        response = requests.post(url, headers=headers, json=body)
        if response.status_code == 200:
            print(f"Success: System '{name}' registered.")
            return response.json()
        return {"error": f"Failed to create system: {response.status_code} - {response.text[:200]}"}
    except Exception as e:
        print(f"Error creating system: {e}")
        return None

def list_systems(api_key: str, **kwargs):
    """Lists all systems registered for this user."""
    url = f"{BASE_URL}/systems"
    headers = {"x-piko-api-key": api_key}
    
    try:
        response = requests.get(url, headers=headers)
        if response.status_code == 200:
            return response.json().get("systems", [])
        return []
    except Exception as e:
        print(f"Error listing systems: {e}")
        return []

# --- Visualization Helpers ---

def display_databases(data):
    """Pretty-prints database records in a table format."""
    if not data or not data.get("success"):
        print("No database data to display.")
        return
    
    databases = data.get("databases", {})
    print(f"\n{'Key':<20} {'URI':<30} {'Type':<10}")
    print("-" * 65)
    for k, v in databases.items():
        print(f"{k:<20} {v.get('uri', 'N/A'):<30} {v.get('type', 'N/A'):<10}")

def display_forms(forms):
    """Pretty-prints form records."""
    if not forms:
        print("\nNo forms found.")
        return
    print(f"\n{'Form ID':<25} {'Name':<35}")
    print("-" * 60)
    for f in forms:
        print(f"{f['id']:<25} {f['name']:<35}")

def display_snippets(data):
    """Pretty-prints embedding snippets."""
    if not data or not data.get("success"):
        return
    
    is_auth = data.get("type") == 'auth-preset'
    name = data.get('presetName') if is_auth else data.get('formName')
    id_val = data.get('presetId') if is_auth else data.get('formId')
    type_label = "AUTH PRESET" if is_auth else "FORM"

    print("\n" + "="*80)
    print(f"SNIPPETS FOR {type_label}: {name} ({id_val})")
    print("="*80)
    
    snippets = data.get("snippets", {})
    print("\n[ HTML SNIPPET ]")
    print(snippets.get("html", "Not found"))
    
    print("\n[ REACT SNIPPET ]")
    print(snippets.get("react", "Not found"))
    print("="*80)