Update app.py

app.py

@@ -1,416 +1,247 @@
-import time
+from flask import Flask, render_template, request, redirect, url_for, jsonify, flash
+from db import signals as signals_module
+from db import deeper as deeper_module
+from db import paires as paires_module
 import json
-import requests
-import re
-import logging
-from flask import Flask, jsonify
-from apscheduler.schedulers.background import BackgroundScheduler
-from datetime import datetime, timedelta
-from db import deeper, signals
-from ai import analyze_forex_pairs
-
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(levelname)s - %(message)s'
-)
-logger = logging.getLogger(__name__)
-
-# Initialize Flask app
-app = Flask(__name__)
 
-# Message API configuration
-MESSAGE_API_URL = "https://aoamrnuwara.pythonanywhere.com/api/send-message"
-MESSAGE_API_KEY = "Seakp0683asppoit"
+app = Flask(__name__)
+app.secret_key = 'trading_signals_secret_key'
 
-def send_message_to_api(message):
-    """Send a message via the message forwarding API."""
-    headers = {
-        "Content-Type": "application/json",
-        "X-API-Key": MESSAGE_API_KEY
+@app.route('/')
+def index():
+    # Fetch signals from GitHub
+    signals_response = signals_module.fetch_json_from_github()
+    deeper_response = deeper_module.fetch_json_from_github()
+    paires_response = paires_module.fetch_json_from_github()
+
+    signals_data = []
+    system_status = {
+        'deeper': False,
+        'paires': False
     }
 
-    payload = {
-        "message": message
-    }
+    if signals_response['success']:
+        signals_data = signals_response['data']
 
-    try:
-        logger.info("Sending message via API")
-        response = requests.post(MESSAGE_API_URL, headers=headers, data=json.dumps(payload))
-        response.raise_for_status()
-        response_json = response.json()
-        logger.info(f"Message sent to API successfully. Status Code: {response.status_code}")
-        return {"success": True, "response": response_json}
-    except requests.exceptions.RequestException as e:
-        logger.error(f"API request error: {e}", exc_info=True)
-        return {"success": False, "error": str(e)}
-    except Exception as e:
-        logger.error(f"Unexpected error sending message to API: {e}", exc_info=True)
-        return {"success": False, "error": str(e)}
-
-def get_active_signals():
-    """Get all active signals from the signals database"""
-    signals_response = signals.fetch_json_from_github()
-
-    if not signals_response["success"]:
-        logger.error(f"Error fetching signals data: {signals_response['message']}")
-        return "لا توجد صفقات نشطة حالياً."
-
-    signals_data = signals_response["data"]
-
-    # Defensive check - ensure signals_data is a list
-    if not isinstance(signals_data, list) or len(signals_data) == 0:
-        logger.warning("No active signals found in database")
-        return "لا توجد صفقات نشطة حالياً."
-
-    deals_string = []
-    for signal in signals_data:
-        deal = f"الزوج: {signal.get('pair', '')}, "
-        deal += f"النوع: {signal.get('type', '')}, "
-        deal += f"سعر الدخول: {signal.get('entry', '')}, "
-        deal += f"وقف الخسارة: {signal.get('stop_loss', '')}, "
-        deal += f"الهدف: {signal.get('take_profit', '')}"
-        deals_string.append(deal)
-
-    if not deals_string:
-        return "لا توجد صفقات نشطة حالياً."
-
-    return "\n".join(deals_string)
-
-def extract_signal_from_ai_response(response):
-    """Extract signal data from AI response if present"""
-    signal_pattern = r'<signal>(.*?)</signal>'
-    match = re.search(signal_pattern, response, re.DOTALL)
-
-    if not match:
-        return None
-
-    signal_text = match.group(1)
-
-    # Extract individual fields from signal - full format
-    pair_match = re.search(r'<pair>(.*?)</pair>', signal_text, re.DOTALL)
-    type_match = re.search(r'<type>(.*?)</type>', signal_text, re.DOTALL)
-    entry_match = re.search(r'<entry>(.*?)</entry>', signal_text, re.DOTALL)
-    stop_loss_match = re.search(r'<stop_loss>(.*?)</stop_loss>', signal_text, re.DOTALL)
-    take_profit_match = re.search(r'<take_profit>(.*?)</take_profit>', signal_text, re.DOTALL)
-    duration_match = re.search(r'<duration>(.*?)</duration>', signal_text, re.DOTALL)
-    reason_match = re.search(r'<reason>(.*?)</reason>', signal_text, re.DOTALL)
-
-    # Create signal dictionary
-    signal_data = {
-        "pair": pair_match.group(1).strip() if pair_match else "",
-        "timeframe": "15min",  # Default timeframe
-        "type": type_match.group(1).strip() if type_match else "",
-        "entry": entry_match.group(1).strip() if entry_match else "",
-        "stop_loss": stop_loss_match.group(1).strip() if stop_loss_match else "",
-        "take_profit": take_profit_match.group(1).strip() if take_profit_match else "",
-        "duration": duration_match.group(1).strip() if duration_match else "1-3 ساعات",
-        "reason": reason_match.group(1).strip() if reason_match else "تم التحليل بواسطة النظام الآلي",
-        "status": "starting"
-    }
+    if deeper_response['success']:
+        system_status['deeper'] = deeper_response['data'].get('status', False)
 
-    return signal_data
+    if paires_response['success']:
+        system_status['paires'] = paires_response['data'].get('status', False)
 
-def check_if_pairs_exist_in_signals(pairs_list):
-    """Check if a list of pairs already exists in the signals database"""
-    signals_response = signals.fetch_json_from_github()
+    return render_template('index.html',
+                          signals=signals_data,
+                          system_status=system_status)
 
-    if not signals_response["success"]:
-        logger.error(f"Error fetching signals data: {signals_response['message']}")
-        return False
+@app.route('/signals', methods=['GET'])
+def get_signals():
+    # Fetch signals from GitHub
+    response = signals_module.fetch_json_from_github()
+    if response['success']:
+        return jsonify(response['data'])
+    else:
+        return jsonify({"error": response['message']}), 500
 
-    signals_data = signals_response["data"]
+@app.route('/signals/delete/<int:signal_id>', methods=['POST'])
+def delete_signal(signal_id):
+    # Get current signals
+    response = signals_module.fetch_json_from_github()
+    if not response['success']:
+        flash('Failed to fetch signals data', 'error')
+        return redirect(url_for('index'))
 
-    # Defensive check - ensure signals_data is a list
-    if not isinstance(signals_data, list):
-        logger.warning(f"signals_data is not a list (type: {type(signals_data)}), converting to empty list")
-        signals_data = []
+    signals_data = response['data']
 
-    # Convert pairs_list to a sorted JSON string for consistent comparison
-    pairs_json = json.dumps(sorted(pairs_list), ensure_ascii=False)
+    # Check if signal_id is valid
+    if signal_id < 0 or signal_id >= len(signals_data):
+        flash('Invalid signal ID', 'error')
+        return redirect(url_for('index'))
 
-    # Check if pairs list exists
-    for signal in signals_data:
-        if "pairs" in signal and json.dumps(sorted(signal.get("pairs", [])), ensure_ascii=False) == pairs_json:
-            return True
+    # Remove the signal
+    signals_data.pop(signal_id)
 
-    return False
+    # Update the signals.json file
+    auth_token, commit_oid = signals_module.fetch_authenticity_token_and_commit_oid()
+    if not auth_token or not commit_oid:
+        flash('Failed to get authentication tokens', 'error')
+        return redirect(url_for('index'))
 
-def update_signals_file(signal_data, pairs_list):
-    """Update signals JSON file with new signal data including pairs list"""
-    # Fetch current signals data
-    signals_response = signals.fetch_json_from_github()
+    # Convert the updated signals data to JSON string
+    new_content = json.dumps(signals_data, ensure_ascii=False)
 
-    if not signals_response["success"]:
-        logger.error(f"Error fetching signals data: {signals_response['message']}")
-        return False
+    # Update the signals.json file
+    update_response = signals_module.update_user_json_file(auth_token, commit_oid, new_content)
 
-    signals_data = signals_response["data"]
+    if update_response['success']:
+        flash('Signal deleted successfully', 'success')
+    else:
+        flash(f'Failed to delete signal: {update_response["message"]}', 'error')
 
-    # Defensive check - ensure signals_data is a list
-    if not isinstance(signals_data, list):
-        logger.warning(f"signals_data is not a list (type: {type(signals_data)}), converting to empty list")
-        signals_data = []
+    return redirect(url_for('index'))
 
-    # Add pairs list to the signal data
-    signal_data["pairs"] = pairs_list
+@app.route('/signals/delete_all', methods=['POST'])
+def delete_all_signals():
+    # Get authentication tokens
+    auth_token, commit_oid = signals_module.fetch_authenticity_token_and_commit_oid()
+    if not auth_token or not commit_oid:
+        flash('Failed to get authentication tokens', 'error')
+        return redirect(url_for('index'))
 
-    # Add new signal
-    signals_data.append(signal_data)
+    # Create an empty array for signals
+    empty_signals = []
+    new_content = json.dumps(empty_signals, ensure_ascii=False)
 
-    # Get authenticity token and commit OID for signals file
-    auth_token, commit_oid = signals.fetch_authenticity_token_and_commit_oid()
-    if not auth_token or not commit_oid:
-        logger.error("Failed to get authenticity token or commit OID for signals file")
-        return False
+    # Update the signals.json file
+    update_response = signals_module.update_user_json_file(auth_token, commit_oid, new_content)
+
+    if update_response['success']:
+        flash('All signals deleted successfully', 'success')
+    else:
+        flash(f'Failed to delete all signals: {update_response["message"]}', 'error')
+
+    return redirect(url_for('index'))
+
+@app.route('/signals/edit/<int:signal_id>', methods=['GET', 'POST'])
+def edit_signal(signal_id):
+    # Get current signals
+    response = signals_module.fetch_json_from_github()
+    if not response['success']:
+        flash('Failed to fetch signals data', 'error')
+        return redirect(url_for('index'))
+
+    signals_data = response['data']
+
+    # Check if signal_id is valid
+    if signal_id < 0 or signal_id >= len(signals_data):
+        flash('Invalid signal ID', 'error')
+        return redirect(url_for('index'))
+
+    if request.method == 'POST':
+        # Update signal with form data
+        signals_data[signal_id]['pair'] = request.form['pair']
+        signals_data[signal_id]['timeframe'] = request.form['timeframe']
+        signals_data[signal_id]['type'] = request.form['type']
+        signals_data[signal_id]['entry'] = request.form['entry']
+        signals_data[signal_id]['stop_loss'] = request.form['stop_loss']
+        signals_data[signal_id]['take_profit'] = request.form['take_profit']
+        signals_data[signal_id]['duration'] = request.form['duration']
+        signals_data[signal_id]['reason'] = request.form['reason']
+        signals_data[signal_id]['status'] = request.form['status']
+
+        # Get authentication tokens
+        auth_token, commit_oid = signals_module.fetch_authenticity_token_and_commit_oid()
+        if not auth_token or not commit_oid:
+            flash('Failed to get authentication tokens', 'error')
+            return redirect(url_for('index'))
+
+        # Convert the updated signals data to JSON string
+        new_content = json.dumps(signals_data, ensure_ascii=False)
+
+        # Update the signals.json file
+        update_response = signals_module.update_user_json_file(auth_token, commit_oid, new_content)
+
+        if update_response['success']:
+            flash('Signal updated successfully', 'success')
+            return redirect(url_for('index'))
+        else:
+            flash(f'Failed to update signal: {update_response["message"]}', 'error')
+            return redirect(url_for('index'))
+
+    # GET request - display edit form with current signal data
+    return render_template('edit_signal.html', signal=signals_data[signal_id], signal_id=signal_id)
+
+@app.route('/signals/add', methods=['GET', 'POST'])
+def add_signal():
+    if request.method == 'POST':
+        # Get current signals
+        response = signals_module.fetch_json_from_github()
+        if not response['success']:
+            flash('Failed to fetch signals data', 'error')
+            return redirect(url_for('index'))
+
+        signals_data = response['data']
+
+        # Create new signal from form data
+        new_signal = {
+            'pair': request.form['pair'],
+            'timeframe': request.form['timeframe'],
+            'type': request.form['type'],
+            'entry': request.form['entry'],
+            'stop_loss': request.form['stop_loss'],
+            'take_profit': request.form['take_profit'],
+            'duration': request.form['duration'],
+            'reason': request.form['reason'],
+            'status': request.form['status']
+        }
+
+        # Add new signal to the beginning of the list
+        signals_data.insert(0, new_signal)
+
+        # Get authentication tokens
+        auth_token, commit_oid = signals_module.fetch_authenticity_token_and_commit_oid()
+        if not auth_token or not commit_oid:
+            flash('Failed to get authentication tokens', 'error')
+            return redirect(url_for('index'))
+
+        # Convert the updated signals data to JSON string
+        new_content = json.dumps(signals_data, ensure_ascii=False)
+
+        # Update the signals.json file
+        update_response = signals_module.update_user_json_file(auth_token, commit_oid, new_content)
+
+        if update_response['success']:
+            flash('Signal added successfully', 'success')
+            return redirect(url_for('index'))
+        else:
+            flash(f'Failed to add signal: {update_response["message"]}', 'error')
+            return redirect(url_for('index'))
 
-    # Update the signals file - using json.dumps with separators to ensure a single line
-    update_response = signals.update_user_json_file(
-        auth_token,
-        commit_oid,
-        json.dumps(signals_data, ensure_ascii=False, separators=(',', ':'))
-    )
+    # GET request - display add form
+    return render_template('add_signal.html')
 
-    return update_response["success"]
+@app.route('/system/toggle', methods=['POST'])
+def toggle_system():
+    system_type = request.form.get('system_type')
+    new_status = request.form.get('status') == 'true'
 
-def remove_group_from_deeper(group_key):
-    """Remove analyzed group from deeper.json file"""
-    # Fetch current deeper data
-    deeper_response = deeper.fetch_json_from_github()
+    if system_type == 'deeper':
+        # Update deeper.json
+        response = deeper_module.fetch_json_from_github()
+        if not response['success']:
+            return jsonify({"success": False, "message": "Failed to fetch deeper.json data"}), 500
 
-    if not deeper_response["success"]:
-        logger.error(f"Error fetching deeper data: {deeper_response['message']}")
-        return False
+        deeper_data = response['data']
+        deeper_data['status'] = new_status
 
-    deeper_data = deeper_response["data"]
+        auth_token, commit_oid = deeper_module.fetch_authenticity_token_and_commit_oid()
+        if not auth_token or not commit_oid:
+            return jsonify({"success": False, "message": "Failed to get authentication tokens"}), 500
 
-    # Remove the group from forwards if it exists
-    if group_key in deeper_data.get("forwards", {}):
-        del deeper_data["forwards"][group_key]
+        new_content = json.dumps(deeper_data, ensure_ascii=False)
+        update_response = deeper_module.update_user_json_file(auth_token, commit_oid, new_content)
 
-    # Get authenticity token and commit OID for deeper file
-    auth_token, commit_oid = deeper.fetch_authenticity_token_and_commit_oid()
-    if not auth_token or not commit_oid:
-        logger.error("Failed to get authenticity token or commit OID for deeper file")
-        return False
-
-    # Update the deeper file - using json.dumps with separators to ensure a single line
-    update_response = deeper.update_user_json_file(
-        auth_token,
-        commit_oid,
-        json.dumps(deeper_data, ensure_ascii=False, separators=(',', ':'))
-    )
-
-    return update_response["success"]
-
-def format_telegram_message(signal_data):
-    """تنسيق إشارة الفوركس للإرسال عبر تيليجرام - بصيغة احترافية"""
-    message = "🔔 <b>إشارة فوركس جديدة</b> 🔔\n\n"
-    message += f"<b>🔹 الزوج:</b> {signal_data['pair']}\n"
-    message += f"<b>📊 النوع:</b> {signal_data['type']}\n"
-    message += f"<b>🎯 الد��ول:</b> {signal_data['entry']}\n"
-    message += f"<b>🛡️ وقف الخسارة:</b> {signal_data['stop_loss']}\n"
-    message += f"<b>💰 الهدف:</b> {signal_data['take_profit']}\n"
-
-    return message
-
-def analyze_forex_groups():
-    """Function to analyze forex groups from the deeper.json file"""
-    logger.info("Starting forex group analysis cycle")
-
-    try:
-        # Fetch data from deeper.json
-        deeper_response = deeper.fetch_json_from_github()
-
-        if not deeper_response["success"]:
-            logger.error(f"Error fetching deeper data: {deeper_response['message']}")
-            return
-
-        deeper_data = deeper_response["data"]
-
-        # Check if system is enabled
-        if not deeper_data.get("status", False):
-            logger.info("System is currently turned OFF. Please turn it ON to continue.")
-            return
-
-        # Get active signals to pass to AI
-        active_deals = get_active_signals()
-        logger.info(f"Active deals: {active_deals}")
-
-        # Process each forex group in the forwards section
-        for group_key, group_data in deeper_data.get("forwards", {}).items():
-            pairs = group_data.get("pairs", [])
-            message = group_data.get("message", "")
-
-            if not pairs:
-                logger.warning(f"Group {group_key} has no pairs. Skipping.")
-                continue
-
-            logger.info(f"Analyzing group {group_key} with pairs: {', '.join(pairs)}")
-
-            # Check if this group already exists in signals database
-            if check_if_pairs_exist_in_signals(pairs):
-                logger.info(f"Signal for group {group_key} already exists in database. Skipping analysis.")
-
-                # Remove the group from deeper.json since we're not processing it
-                if remove_group_from_deeper(group_key):
-                    logger.info(f"Group {group_key} removed from deeper.json successfully")
-                else:
-                    logger.error(f"Failed to remove group {group_key} from deeper.json")
-
-                continue
-
-            # Call AI to analyze the forex pairs with active deals
-            ai_response = analyze_forex_pairs(pairs, message, active_deals)
-
-            # Check if the AI response contains a signal
-            signal_data = extract_signal_from_ai_response(ai_response)
-
-            if signal_data:
-                logger.info(f"Signal detected for group {group_key}")
-
-                # Update signals file with the new signal, including pairs list
-                if update_signals_file(signal_data, pairs):
-                    logger.info(f"Signal for group {group_key} saved successfully")
-
-                    # Format message and send via API instead of directly to Telegram
-                    formatted_message = format_telegram_message(signal_data)
-                    logger.info("Attempting to send message via API...")
-                    api_response = send_message_to_api(formatted_message)
-
-                    if api_response["success"]:
-                        logger.info(f"Message for group {group_key} sent successfully via API")
-                    else:
-                        logger.error(f"Failed to send message for group {group_key} via API. Error: {api_response.get('error')}")
-
-                    # Remove the group from deeper.json
-                    if remove_group_from_deeper(group_key):
-                        logger.info(f"Group {group_key} removed from deeper.json successfully")
-                    else:
-                        logger.error(f"Failed to remove group {group_key} from deeper.json")
-                else:
-                    logger.error(f"Failed to save signal for group {group_key}")
-            else:
-                logger.info(f"No signal detected in AI response for group {group_key}")
+        return jsonify(update_response)
 
-        logger.info("Analysis cycle completed successfully")
-
-    except Exception as e:
-        logger.error(f"Error in analyze_forex_groups: {e}", exc_info=True)
+    elif system_type == 'paires':
+        # Update paires.json
+        response = paires_module.fetch_json_from_github()
+        if not response['success']:
+            return jsonify({"success": False, "message": "Failed to fetch paires.json data"}), 500
 
-# Flask routes
-@app.route('/')
-def health_check():
-    """Health check endpoint to verify the service is running"""
-    return jsonify({
-        "status": "running",
-        "message": "Forex Analysis System is active"
-    })
-
-@app.route('/analyze/now')
-def trigger_analysis():
-    """Endpoint to manually trigger analysis"""
-    try:
-        analyze_forex_groups()
-        return jsonify({
-            "status": "success",
-            "message": "Analysis triggered successfully"
-        })
-    except Exception as e:
-        logger.error(f"Error triggering analysis: {e}", exc_info=True)
-        return jsonify({
-            "status": "error",
-            "message": f"Error triggering analysis: {str(e)}"
-        }), 500
-
-@app.route('/status')
-def get_status():
-    """Endpoint to get system status"""
-    try:
-        deeper_response = deeper.fetch_json_from_github()
-        if deeper_response["success"]:
-            system_status = deeper_response["data"].get("status", False)
-            return jsonify({
-                "system_enabled": system_status,
-                "service_status": "running"
-            })
-        else:
-            return jsonify({
-                "service_status": "running",
-                "error": deeper_response["message"]
-            })
-    except Exception as e:
-        logger.error(f"Error getting status: {e}", exc_info=True)
-        return jsonify({
-            "service_status": "running",
-            "error": str(e)
-        })
-
-def schedule_candle_analysis():
-    """Schedule analysis at candle close times (00, 15, 30, 45)"""
-    now = datetime.now()
-    current_minute = now.minute
-
-    # Calculate the next 15-minute mark
-    if current_minute < 17:
-        next_minute = 17
-    elif current_minute < 32:
-        next_minute = 32
-    elif current_minute < 47:
-        next_minute = 47
-    else:
-        next_minute = 0  # Next hour
+        paires_data = response['data']
+        paires_data['status'] = new_status
+
+        auth_token, commit_oid = paires_module.fetch_authenticity_token_and_commit_oid()
+        if not auth_token or not commit_oid:
+            return jsonify({"success": False, "message": "Failed to get authentication tokens"}), 500
+
+        new_content = json.dumps(paires_data, ensure_ascii=False)
+        update_response = paires_module.update_user_json_file(auth_token, commit_oid, new_content)
+
+        return jsonify(update_response)
 
-    # Calculate the target time
-    if next_minute == 0:
-        target_time = datetime(now.year, now.month, now.day, now.hour, 0, 0) + timedelta(hours=1)
     else:
-        target_time = datetime(now.year, now.month, now.day, now.hour, next_minute, 0)
-
-    # Calculate seconds until next run
-    time_diff = (target_time - now).total_seconds()
-
-    logger.info(f"Scheduling analysis to run at {target_time.strftime('%H:%M:%S')} (in {time_diff:.1f} seconds)")
-
-    # Schedule the job
-    scheduler.add_job(
-        run_analysis_and_reschedule,
-        'date',
-        run_date=target_time,
-        id='candle_analysis'
-    )
-
-def run_analysis_and_reschedule():
-    """Run the analysis and schedule the next run"""
-    logger.info("Running scheduled analysis at candle close")
-    try:
-        analyze_forex_groups()
-    except Exception as e:
-        logger.error(f"Error in scheduled analysis: {e}", exc_info=True)
-    finally:
-        # Always reschedule the next run
-        schedule_candle_analysis()
-
-# Initialize scheduler
-scheduler = BackgroundScheduler()
-
-def start_scheduler():
-    """Start the scheduler with the analysis job at candle close times"""
-    logger.info("Starting scheduler for forex analysis at candle close times (00, 15, 30, 45)")
-
-    # Schedule the first analysis
-    schedule_candle_analysis()
-
-    # Start the scheduler if it's not already running
-    if not scheduler.running:
-        scheduler.start()
-        logger.info("Scheduler started successfully")
-
-if __name__ == "__main__":
-    logger.info("Starting Forex Analysis System...")
-
-    # Start the scheduler
-    start_scheduler()
-
-    # Start the Flask application
+        return jsonify({"success": False, "message": "Invalid system type"}), 400
+
+if __name__ == '__main__':
     app.run(host='0.0.0.0', port=7860, debug=False)