Brancheneinstufung2/gtm_db_manager.py

import sqlite3
import json
import os
import uuid
from datetime import datetime

# Database path for GTM projects
DB_PATH = os.environ.get("GTM_DB_PATH", "/app/gtm_projects.db")

def get_db_connection():
    """Establishes a connection to the SQLite database."""
    conn = sqlite3.connect(DB_PATH)
    conn.row_factory = sqlite3.Row
    return conn

def init_gtm_db():
    """Initializes the database and creates the gtm_projects table if it doesn't exist."""
    try:
        conn = get_db_connection()
        # A flexible schema to store project-related data in a single JSON column
        conn.execute('''
            CREATE TABLE IF NOT EXISTS gtm_projects (
                id TEXT PRIMARY KEY,
                name TEXT NOT NULL,
                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                data JSON NOT NULL
            )
        ''')
        conn.commit()
    finally:
        if conn:
            conn.close()

def create_project(name):
    """Creates a new project with a given name and returns the new project's ID."""
    conn = get_db_connection()
    try:
        project_id = str(uuid.uuid4())
        initial_data = {"id": project_id, "name": name, "phases": {}}
        conn.execute(
            'INSERT INTO gtm_projects (id, name, data) VALUES (?, ?, ?)',
            (project_id, name, json.dumps(initial_data))
        )
        conn.commit()
        return {"id": project_id, "name": name}
    finally:
        if conn:
            conn.close()

def save_gtm_result(project_id, phase, result):
    """Saves or updates the result of a specific phase for a given project."""
    conn = get_db_connection()
    try:
        # First, load the existing data
        cursor = conn.cursor()
        cursor.execute('SELECT data FROM gtm_projects WHERE id = ?', (project_id,))
        row = cursor.fetchone()
        
        if not row:
            return {"error": "Project not found"}

        project_data = json.loads(row['data'])
        
        # Update the specific phase result
        if 'phases' not in project_data:
            project_data['phases'] = {}
        project_data['phases'][phase] = result
        
        # Save the updated data back to the DB
        cursor.execute(
            '''UPDATE gtm_projects
               SET data = ?, updated_at = CURRENT_TIMESTAMP
               WHERE id = ?''',
            (json.dumps(project_data), project_id)
        )
        conn.commit()
        return {"id": project_id, "status": f"Phase '{phase}' saved successfully."}
    finally:
        if conn:
            conn.close()

def get_project_data(project_id):
    """Retrieves all data for a specific project."""
    conn = get_db_connection()
    try:
        cursor = conn.cursor()
        cursor.execute('SELECT data FROM gtm_projects WHERE id = ?', (project_id,))
        row = cursor.fetchone()
        return json.loads(row['data']) if row else None
    finally:
        if conn:
            conn.close()

def get_all_projects():
    """Lists all projects."""
    conn = get_db_connection()
    try:
        projects = conn.execute('SELECT id, name, created_at, updated_at FROM gtm_projects ORDER BY updated_at DESC').fetchall()
        return [dict(ix) for ix in projects]
    finally:
        if conn:
            conn.close()

def delete_project(project_id):
    """Deletes a project by its ID."""
    conn = get_db_connection()
    try:
        conn.execute('DELETE FROM gtm_projects WHERE id = ?', (project_id,))
        conn.commit()
        return {"status": "deleted", "id": project_id}
    finally:
        if conn:
            conn.close()
            
if __name__ == "__main__":
    # Simple CLI for testing and potential Node.js bridge
    # Usage: python gtm_db_manager.py [init|create|save|load|list|delete] [args...]
    import sys
    
    if len(sys.argv) < 2:
        print(json.dumps({"error": "Mode is required."}))
        sys.exit(1)

    mode = sys.argv[1]
    
    if mode == "init":
        init_gtm_db()
        print(json.dumps({"status": "GTM database initialized"}))
        
    elif mode == "create":
        project_name = sys.argv[2] if len(sys.argv) > 2 else "Untitled GTM Project"
        print(json.dumps(create_project(project_name)))

    elif mode == "save":
        project_id = sys.argv[2]
        phase = sys.argv[3]
        result_json = sys.argv[4]
        print(json.dumps(save_gtm_result(project_id, phase, json.loads(result_json))))

    elif mode == "load":
        project_id = sys.argv[2]
        project = get_project_data(project_id)
        print(json.dumps(project if project else {"error": "Project not found"}))
        
    elif mode == "list":
        print(json.dumps(get_all_projects()))
        
    elif mode == "delete":
        project_id = sys.argv[2]
        print(json.dumps(delete_project(project_id)))
        
    else:
        print(json.dumps({"error": f"Unknown mode: {mode}"}))