InvisaGig Telemetry System – Complete Installation Guide

				
					cd /opt/invisagig-telemetry

cat > collector/collector.py << 'EOF'
#!/usr/bin/env python3
"""
InvisaGig Telemetry Collector
Created by: didneyworl with Claude Opus 4.1
Email: didney@netsolution.shop
"""
import requests, json, logging, time, sys, os, re
from datetime import datetime
try:
    import psycopg as psycopg2
except ImportError:
    import psycopg2

DB_CONFIG = {
    'host': os.getenv('DB_HOST', 'postgres'),
    'port': 5432,
    'dbname': os.getenv('DB_NAME'),
    'user': os.getenv('DB_USER'),
    'password': os.getenv('DB_PASSWORD'),
}

INVISAGIG_URL = os.getenv('INVISAGIG_URL')
COLLECTION_INTERVAL = int(os.getenv('COLLECTION_INTERVAL', '60'))

logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler('/app/logs/collector.log'),
        logging.StreamHandler()
    ]
)
logger = logging.getLogger(__name__)

def safe_get(data, *keys, default=None):
    try:
        result = data
        for key in keys:
            if result is None: return default
            result = result.get(key) if isinstance(result, dict) else default
        return None if result in ["null", "", " "] else result
    except: return default

def parse_temperature(temp_str):
    if not temp_str or temp_str == "null": return None
    try: return int(float(str(temp_str).lower().replace('c', '').replace('°', '').strip()))
    except: return None

def fix_json(raw_text):
    raw_text = re.sub(r':\s*,', ': null,', raw_text)
    raw_text = re.sub(r':\s*\n\s*}', ': null\n}', raw_text)
    raw_text = re.sub(r':\s*}', ': null}', raw_text)
    raw_text = re.sub(r':\s*]', ': null]', raw_text)
    return raw_text

def wait_for_database():
    for i in range(30):
        try:
            conn = psycopg2.connect(**DB_CONFIG)
            conn.close()
            logger.info("Database connected")
            return True
        except Exception as e:
            logger.info(f"Waiting for database... ({i+1}/30)")
            time.sleep(2)
    return False

def create_tables():
    try:
        conn = psycopg2.connect(**DB_CONFIG)
        cur = conn.cursor()
        cur.execute("""
            CREATE TABLE IF NOT EXISTS telemetry_data (
                id SERIAL PRIMARY KEY,
                timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                company VARCHAR(255), model VARCHAR(50), modem VARCHAR(50),
                ig_version VARCHAR(50), fw_version VARCHAR(255),
                temp_c INTEGER, carrier VARCHAR(100), network_mode VARCHAR(50),
                lte_str INTEGER, nsa_str INTEGER, sa_str INTEGER,
                lte_snr INTEGER, nsa_snr INTEGER, sa_snr INTEGER,
                lte_band INTEGER, nsa_band INTEGER, sa_band INTEGER,
                sim1_total_mbytes DECIMAL(10,2), sim2_total_mbytes DECIMAL(10,2),
                sim1_tx_mbytes DECIMAL(10,2), sim1_rx_mbytes DECIMAL(10,2),
                sim2_tx_mbytes DECIMAL(10,2), sim2_rx_mbytes DECIMAL(10,2),
                up_time BIGINT,
                car_agg_lte JSONB, car_agg_nr5g JSONB,
                raw_json JSONB
            )
        """)
        cur.execute("CREATE INDEX IF NOT EXISTS idx_timestamp ON telemetry_data(timestamp DESC)")
        conn.commit()
        cur.close()
        conn.close()
        logger.info("Database tables ready")
        return True
    except Exception as e:
        logger.error(f"Table creation error: {e}")
        return False

def collect_data():
    try:
        response = requests.get(INVISAGIG_URL, timeout=30)
        response.raise_for_status()
        
        raw_text = response.text
        fixed_text = fix_json(raw_text)
        data = json.loads(fixed_text)
        
        conn = psycopg2.connect(**DB_CONFIG)
        cur = conn.cursor()
        
        values = [
            safe_get(data, 'device', 'company'),
            safe_get(data, 'device', 'model'),
            safe_get(data, 'device', 'modem'),
            safe_get(data, 'device', 'igVersion'),
            safe_get(data, 'device', 'fwVersion'),
            parse_temperature(safe_get(data, 'timeTemp', 'temp')),
            safe_get(data, 'activeSim', 'carrier'),
            safe_get(data, 'activeSim', 'networkMode'),
            safe_get(data, 'lteCell', 'lteStr'),
            safe_get(data, 'nsaCell', 'nsaStr'),
            safe_get(data, 'saCell', 'saStr'),
            safe_get(data, 'lteCell', 'lteSnr'),
            safe_get(data, 'nsaCell', 'nsaSnr'),
            safe_get(data, 'saCell', 'saSnr'),
            safe_get(data, 'lteCell', 'lteBand'),
            safe_get(data, 'nsaCell', 'nsaBand'),
            safe_get(data, 'saCell', 'saBand'),
            safe_get(data, 'dataUsed', 'SIM1', 'totalMBytes'),
            safe_get(data, 'dataUsed', 'SIM2', 'totalMBytes'),
            safe_get(data, 'dataUsed', 'SIM1', 'txMBytes'),
            safe_get(data, 'dataUsed', 'SIM1', 'rxMBytes'),
            safe_get(data, 'dataUsed', 'SIM2', 'txMBytes'),
            safe_get(data, 'dataUsed', 'SIM2', 'rxMBytes'),
            safe_get(data, 'timeTemp', 'upTime'),
            json.dumps(safe_get(data, 'carAgg', 'lte', default=[])),
            json.dumps(safe_get(data, 'carAgg', 'nr5g', default=[])),
            json.dumps(data)
        ]
        
        cur.execute("""
            INSERT INTO telemetry_data 
            (company, model, modem, ig_version, fw_version, temp_c, carrier, network_mode,
             lte_str, nsa_str, sa_str, lte_snr, nsa_snr, sa_snr,
             lte_band, nsa_band, sa_band, sim1_total_mbytes, sim2_total_mbytes,
             sim1_tx_mbytes, sim1_rx_mbytes, sim2_tx_mbytes, sim2_rx_mbytes,
             up_time, car_agg_lte, car_agg_nr5g, raw_json)
            VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s)
        """, values)
        
        conn.commit()
        cur.close()
        conn.close()
        
        logger.info(f"Data collected - Carrier: {values[6]}, Temp: {values[5]}°C")
        return True
        
    except Exception as e:
        logger.error(f"Collection error: {e}")
        return False

def main():
    logger.info("InvisaGig Collector Started")
    if not wait_for_database() or not create_tables():
        sys.exit(1)
    
    while True:
        try:
            collect_data()
            time.sleep(COLLECTION_INTERVAL)
        except KeyboardInterrupt:
            break
        except Exception as e:
            logger.error(f"Error: {e}")
            time.sleep(60)

if __name__ == "__main__":
    main()
EOF

echo "Collector script created"