PRIP.py

from flask import Flask, request, render_template, jsonify, redirect, url_for
import json
import os
from datetime import datetime
from Extractor import process_request

app = Flask(__name__)

# Configuration
LOG_FILE = 'prip_test_logs.json'

def log_test_result(test_data):
    """Log test results to JSON file"""
    try:
        if os.path.exists(LOG_FILE):
            with open(LOG_FILE, 'r') as f:
                logs = json.load(f)
        else:
            logs = []
        
        logs.append(test_data)
        
        with open(LOG_FILE, 'w') as f:
            json.dump(logs, f, indent=2)
    except Exception as e:
        print(f"Error logging test result: {e}")

@app.route('/')
def index():
    """Main test page with HTML template"""
    return render_template('template.html')

@app.route('/test', methods=['POST'])
def test_extractor():
    """Test the extractor functionality"""
    try:
        # Process the request using the extractor
        extracted_data = process_request(request)
        print(f"Extracted Data: {extracted_data}")
        
        # Create test log entry
        test_log = {
            "timestamp": datetime.now().isoformat(),
            "test_type": "extractor_test",
            "request_info": {
                "method": request.method,
                "user_agent": request.headers.get('User-Agent', ''),
                "remote_addr": request.remote_addr,
                "cookies_count": len(request.cookies)
            },
            "extracted_data": extracted_data,
            "status": "success"
        }
        
        log_test_result(test_log)
        
        return jsonify({
            "status": "success",
            "message": "Data extracted successfully",
            "data": extracted_data
        })
        
    except Exception as e:
        error_log = {
            "timestamp": datetime.now().isoformat(),
            "test_type": "extractor_test",
            "error": str(e),
            "status": "error"
        }
        
        log_test_result(error_log)
        
        return jsonify({
            "status": "error",
            "message": str(e)
        }), 400

@app.route('/reconnect_user', methods=['GET', 'POST'])
def reconnect_user():
    """Handle reconnect user requests from the JS library"""
    try:
        # Log the reconnect attempt
        reconnect_log = {
            "timestamp": datetime.now().isoformat(),
            "test_type": "reconnect_user",
            "request_info": {
                "method": request.method,
                "user_agent": request.headers.get('User-Agent', ''),
                "remote_addr": request.remote_addr,
                "headers": dict(request.headers),
                "cookies": dict(request.cookies)
            },
            "status": "success"
        }
        
        log_test_result(reconnect_log)
        
        # Return response for the JS library
        response_data = {
            "status": "connected",
            "timestamp": datetime.now().isoformat(),
            "session_id": f"session_{datetime.now().strftime('%Y%m%d_%H%M%S')}",
            "user_id": request.cookies.get('PRIP_USERID', 'unknown'),
            "device_id": request.cookies.get('PRIP_USERDEVICE', 'unknown')
        }
        
        return jsonify(response_data)
        
    except Exception as e:
        error_log = {
            "timestamp": datetime.now().isoformat(),
            "test_type": "reconnect_user",
            "error": str(e),
            "status": "error"
        }
        
        log_test_result(error_log)
        
        return jsonify({
            "status": "error",
            "message": str(e)
        }), 500

@app.route('/logs')
def view_logs():
    """View test logs"""
    try:
        if os.path.exists(LOG_FILE):
            with open(LOG_FILE, 'r') as f:
                logs = json.load(f)
        else:
            logs = []
        
        return jsonify({
            "status": "success",
            "logs": logs,
            "count": len(logs)
        })
    except Exception as e:
        return jsonify({
            "status": "error",
            "message": str(e)
        }), 500

@app.route('/clear-logs', methods=['POST'])
def clear_logs():
    """Clear test logs"""
    try:
        if os.path.exists(LOG_FILE):
            os.remove(LOG_FILE)
        
        return jsonify({
            "status": "success",
            "message": "Logs cleared successfully"
        })
    except Exception as e:
        return jsonify({
            "status": "error",
            "message": str(e)
        }), 500

@app.route('/status')
def status():
    """Server status endpoint"""
    return jsonify({
        "status": "running",
        "timestamp": datetime.now().isoformat(),
        "version": "1.0.0",
        "endpoints": {
            "/": "Main test interface",
            "/test": "POST - Test extractor",
            "/reconnect_user": "GET/POST - User reconnection",
            "/logs": "GET - View logs",
            "/clear-logs": "POST - Clear logs",
            "/status": "GET - Server status"
        }
    })

if __name__ == '__main__':
    # Create templates directory if it doesn't exist
    if not os.path.exists('templates'):
        os.makedirs('templates')
    
    print("🚀 PRIP Flask Test Server Starting...")
    print("📋 Available endpoints:")
    print("   • http://localhost:5000/ - Main test interface")
    print("   • http://localhost:5000/test - Test extractor (POST)")
    print("   • http://localhost:5000/reconnect_user - User reconnection")
    print("   • http://localhost:5000/logs - View test logs")
    print("   • http://localhost:5000/status - Server status")
    
    app.run(debug=True, host='0.0.0.0', port=5000)