From 3952101712fed86358205428bf9f135e7cb45eb2 Mon Sep 17 00:00:00 2001
From: PeninsulaInd <bryan@peninsulaindustries.com>
Date: Sat, 14 Jun 2025 13:52:44 -0500
Subject: [PATCH] now synce to central server

---
 link_tracker.db  | Bin 36864 -> 69632 bytes
 main.py          | 213 ++++++++++++++++++++++++++++++++++++++++++++++-
 sync_config.json |   6 ++
 3 files changed, 217 insertions(+), 2 deletions(-)
 create mode 100644 sync_config.json

diff --git a/link_tracker.db b/link_tracker.db
index 135c265a97bc46de1bda0881b97a970e464caa75..fc13c1cd24a911d767e789e0d842ef7aaa7a7685 100644
GIT binary patch
literal 69632
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
LFYIZ@+R^_H@kH?=

delta 420
zcmZozz|ydQX@ayMF9QPuClJE``$QdMSzZRcE&*QNsSF(Kdl=aF@So*%=8oYO<~qm~
z$;GnSP{DzntHqU(U0ht8u_JTyeBPUklgoMJCoko6-OS82g_()TV)IPi`!GS%$!GXY
zfW|FkU}52AVBzLY<(SQuy|M8(^X4qEcFxHQX7LHfGB7a3Gc>w4ayG}>Hn}r$aBys1
zFxQt!fD7m_7Ct=&K0W?<{PKJ=Hwzlb@om=A+aqYk!pX!e&X|*#mtD*QRK>+vkeHrY
z4Dt{UyDS5LC|^GBFWx|&Ebgb=hFp=Hr5tD2zp=}1Z2Zf%S$6wl4qQgZU1OBt;mc&;
zkK@ba`^SHX|0Vxwes{ik{FC|h`JVBe1G>PIZ*p9|$>zCv=|H9YE)4v8`4{ld=C9-T
z<aYsUSjykbpT_S8RI0+y#lp<M$O9s{Cl}_5Pfo3$57e}Wf&UNxcm7ZOZ}^|_Kj6Q`
We}(@X{|TVxJwQ!!_$Tk_cL4x=jcy|V

diff --git a/main.py b/main.py
index 53d88d1..956de7a 100644
--- a/main.py
+++ b/main.py
@@ -7,9 +7,28 @@ from datetime import datetime
 import sqlite3
 import json
 from pathlib import Path
+import requests
+import os
 
 app = FastAPI(title="Link Tracker API", version="1.0.0")
+CONFIG_PATH = "sync_config.json"
+DEFAULT_CONFIG = {
+    "central_server_url": "",
+    "username": "",
+    "password": "",
+    "enabled": False
+}
+def load_sync_config():
+    """Load sync configuration from file"""
+    if os.path.exists(CONFIG_PATH):
+        with open(CONFIG_PATH, 'r') as f:
+            return json.load(f)
+    return DEFAULT_CONFIG.copy()
 
+def save_sync_config(config):
+    """Save sync configuration to file"""
+    with open(CONFIG_PATH, 'w') as f:
+        json.dump(config, f, indent=2)
 # Enable CORS for your Chrome extension
 app.add_middleware(
     CORSMiddleware,
@@ -41,10 +60,17 @@ def init_db():
             colinkiri BOOLEAN DEFAULT FALSE,
             indexer BOOLEAN DEFAULT FALSE,
             t2 BOOLEAN DEFAULT FALSE,
+            synced_at DATETIME NULL,  -- NEW: when this was last synced
             created_at DATETIME DEFAULT CURRENT_TIMESTAMP
         )
     """)
     
+    # Add sync column to existing databases
+    try:
+        cursor.execute("ALTER TABLE pages ADD COLUMN synced_at DATETIME NULL")
+    except sqlite3.OperationalError:
+        pass  # Column already exists
+    
     # For existing databases, add the new columns if they don't exist
     try:
         cursor.execute("ALTER TABLE pages ADD COLUMN colinkiri BOOLEAN DEFAULT FALSE")
@@ -85,6 +111,7 @@ def init_db():
     
     # Create indexes for better query performance
     cursor.execute("CREATE INDEX IF NOT EXISTS idx_pages_url ON pages (url)")
+    cursor.execute("CREATE INDEX IF NOT EXISTS idx_pages_synced ON pages (synced_at)")
     cursor.execute("CREATE INDEX IF NOT EXISTS idx_links_domain ON links (domain)")
     cursor.execute("CREATE INDEX IF NOT EXISTS idx_links_client_domain ON links (client_domain)")
     cursor.execute("CREATE INDEX IF NOT EXISTS idx_links_page_id ON links (page_id)")
@@ -92,6 +119,7 @@ def init_db():
     conn.commit()
     conn.close()
 
+
 # Pydantic models for API requests
 class LinkData(BaseModel):
     href: str
@@ -128,6 +156,12 @@ class LinkSummary(BaseModel):
     is_client_link: bool
     client_name: Optional[str] = None
 
+class SyncConfig(BaseModel):
+    central_server_url: str
+    username: str
+    password: str
+    enabled: bool
+    
 @app.on_event("startup")
 async def startup_event():
     """Initialize database on startup"""
@@ -158,12 +192,12 @@ async def capture_page(data: PageCaptureRequest):
         client_urls = []
         
         if existing_page:
-            # Update existing page
+            # Update existing page (reset synced_at since data changed)
             page_id = existing_page[0]
             cursor.execute("""
                 UPDATE pages 
                 SET title = ?, keywords = ?, timestamp = ?, 
-                    detected_clients = ?, total_links = ?, linked_to = ?
+                    detected_clients = ?, total_links = ?, linked_to = ?, synced_at = NULL
                 WHERE id = ?
             """, (
                 data.title,
@@ -474,6 +508,10 @@ async def get_stats():
         cursor.execute("SELECT COUNT(*) FROM links WHERE is_client_link = 1")
         client_links = cursor.fetchone()[0]
         
+        # Sync stats
+        cursor.execute("SELECT COUNT(*) FROM pages WHERE synced_at IS NOT NULL")
+        synced_pages = cursor.fetchone()[0]
+        
         # Links by client
         cursor.execute("""
             SELECT client_name, COUNT(*) as link_count
@@ -491,11 +529,182 @@ async def get_stats():
             "total_links": total_links,
             "client_links": client_links,
             "other_links": total_links - client_links,
+            "synced_pages": synced_pages,
+            "unsynced_pages": total_pages - synced_pages,
             "client_breakdown": client_stats
         }
         
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Error fetching stats: {str(e)}")
+    
+@app.get("/sync/config")
+async def get_sync_config():
+    """Get current sync configuration (without password)"""
+    config = load_sync_config()
+    # Don't return password in response
+    config_safe = config.copy()
+    config_safe["password"] = "***" if config["password"] else ""
+    return config_safe
+
+@app.post("/sync/config")
+async def update_sync_config(config: SyncConfig):
+    """Update sync configuration"""
+    try:
+        config_dict = config.dict()
+        save_sync_config(config_dict)
+        return {"success": True, "message": "Sync configuration updated"}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error updating config: {str(e)}")
+
+@app.post("/sync/to-central")
+async def sync_to_central():
+    """Sync unsynced data to central server"""
+    try:
+        config = load_sync_config()
+        print(f"Config loaded: {config['central_server_url']}")
+        if not config["enabled"] or not config["central_server_url"]:
+            raise HTTPException(status_code=400, detail="Sync not configured or disabled")
+        
+        conn = sqlite3.connect(DB_PATH)
+        cursor = conn.cursor()
+        
+        # Get unsynced pages
+        cursor.execute("""
+            SELECT id, url, title, keywords, timestamp, detected_clients, total_links
+            FROM pages 
+            WHERE synced_at IS NULL
+            ORDER BY created_at ASC
+        """)
+        
+        unsynced_pages = cursor.fetchall()
+        
+        if not unsynced_pages:
+            return {"success": True, "message": "No pages to sync", "synced_count": 0}
+        
+        # Prepare sync data
+        pages_data = []
+        
+        for page_row in unsynced_pages:
+            page_id, url, title, keywords, timestamp, detected_clients, total_links = page_row
+            
+            # Get links for this page
+            cursor.execute("""
+                SELECT href, anchor_text, title_attr
+                FROM links
+                WHERE page_id = ?
+            """, (page_id,))
+            
+            links_data = []
+            for link_row in cursor.fetchall():
+                links_data.append({
+                    "href": link_row[0],
+                    "text": link_row[1] or "",
+                    "title": link_row[2] or ""
+                })
+            
+            # Parse JSON fields
+            keywords_list = json.loads(keywords) if keywords else []
+            clients_list = json.loads(detected_clients) if detected_clients else []
+            
+            clients = [{"domain": c["domain"], "name": c["name"]} for c in clients_list]
+            
+            pages_data.append({
+                "url": url,
+                "title": title,
+                "timestamp": timestamp,
+                "keywords": keywords_list,
+                "detectedClients": clients,
+                "totalLinks": total_links,
+                "links": links_data
+            })
+        
+        # Send to central server
+        sync_data = {"pages": pages_data}
+        print(f"Sending {len(pages_data)} pages to central server")
+        response = requests.post(
+            f"{config['central_server_url'].rstrip('/')}/sync",
+            json=sync_data,
+            auth=(config["username"], config["password"]),
+            timeout=30
+        )
+        print(f"Response status: {response.status_code}")
+        print(f"Response text: {response.text}")
+        
+        if response.status_code == 200:
+            result = response.json()
+            
+            # Mark pages as synced
+            page_ids = [row[0] for row in unsynced_pages]
+            placeholders = ','.join(['?'] * len(page_ids))
+            cursor.execute(f"""
+                UPDATE pages 
+                SET synced_at = CURRENT_TIMESTAMP 
+                WHERE id IN ({placeholders})
+            """, page_ids)
+            
+            conn.commit()
+            conn.close()
+            
+            return {
+                "success": True,
+                "message": f"Successfully synced {len(pages_data)} pages",
+                "synced_count": result.get("synced_pages", len(pages_data)),
+                "skipped_count": result.get("skipped_pages", 0),
+                "server_response": result.get("message", "")
+            }
+        else:
+            conn.close()
+            raise HTTPException(
+                status_code=response.status_code, 
+                detail=f"Central server error: {response.text}"
+            )
+            
+    except requests.exceptions.RequestException as e:
+        print(f"Network error details: {e}")
+        return {"success": False, "message": f"Network error: {str(e)}"}
+    except Exception as e:
+        print(f"Full error: {e}")
+        import traceback
+        traceback.print_exc()
+        raise HTTPException(status_code=500, detail=f"Sync error: {str(e)}")
+
+@app.get("/sync/status")
+async def get_sync_status():
+    """Get sync status information"""
+    try:
+        conn = sqlite3.connect(DB_PATH)
+        cursor = conn.cursor()
+        
+        # Count synced vs unsynced pages
+        cursor.execute("SELECT COUNT(*) FROM pages WHERE synced_at IS NOT NULL")
+        synced_count = cursor.fetchone()[0]
+        
+        cursor.execute("SELECT COUNT(*) FROM pages WHERE synced_at IS NULL")
+        unsynced_count = cursor.fetchone()[0]
+        
+        # Get last sync time
+        cursor.execute("SELECT MAX(synced_at) FROM pages WHERE synced_at IS NOT NULL")
+        last_sync = cursor.fetchone()[0]
+        
+        # Get oldest unsynced page
+        cursor.execute("SELECT MIN(created_at) FROM pages WHERE synced_at IS NULL")
+        oldest_unsynced = cursor.fetchone()[0]
+        
+        conn.close()
+        
+        config = load_sync_config()
+        
+        return {
+            "sync_enabled": config["enabled"],
+            "server_configured": bool(config["central_server_url"]),
+            "synced_pages": synced_count,
+            "unsynced_pages": unsynced_count,
+            "last_sync": last_sync,
+            "oldest_unsynced": oldest_unsynced
+        }
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error getting sync status: {str(e)}")
 
 if __name__ == "__main__":
     import uvicorn
diff --git a/sync_config.json b/sync_config.json
new file mode 100644
index 0000000..11d0ec7
--- /dev/null
+++ b/sync_config.json
@@ -0,0 +1,6 @@
+{
+    "central_server_url": "http://192.168.174.35:8001",
+    "username": "bryan",
+    "password": "admin123", 
+    "enabled": true
+  }
\ No newline at end of file