Update app.py

app.py

@@ -1,35 +1,654 @@
-import requests
+import os
+import json
+import time
+import threading
+from flask import Flask, render_template, request, redirect, url_for, jsonify, session
+from flask_socketio import SocketIO, emit
+from functools import wraps
+from database.db import fetch_json_from_github as fetch_user_json
+from database.db import update_user_json_file as update_user_json
+from database.db import fetch_authenticity_token_and_commit_oid as fetch_user_tokens
+from database.msg import fetch_json_from_github as fetch_messages_json
+from database.msg import update_user_json_file as update_messages_json
+from database.msg import fetch_authenticity_token_and_commit_oid as fetch_messages_tokens
 
-# Replace 'YOUR_BOT_TOKEN' with your actual bot token
-bot_token = '6990801595:AAE79xNVO1D_0SeWZlzYLE57Suwfp9GyKT8'
+app = Flask(__name__)
+app.secret_key = os.urandom(24)
+socketio = SocketIO(app, cors_allowed_origins="*")
 
-def send_message(chat_id, text):
-    url = f'https://api.telegram.org/bot{bot_token}/sendMessage'
-    params = {'chat_id': chat_id, 'text': text}
-    response = requests.get(url, params=params)
-    return response.json()
+# Cache for user data and messages
+user_data_cache = {}
+messages_cache = {}
+last_fetch_time = 0
+CACHE_TIMEOUT = 60  # seconds
 
-def handle_message(message):
-    chat_id = message['chat']['id']
-    text = message['text']
+# Background thread for checking updates
+thread = None
+thread_lock = threading.Lock()
+
+def login_required(f):
+    @wraps(f)
+    def decorated_function(*args, **kwargs):
+        if 'logged_in' not in session or not session['logged_in']:
+            return redirect(url_for('login'))
+        return f(*args, **kwargs)
+    return decorated_function
+
+def background_thread():
+    """Background thread for checking updates in messages"""
+    while True:
+        with thread_lock:
+            # Check for new messages every 10 seconds
+            fetch_and_update_messages()
+        socketio.sleep(10)
+
+def fetch_and_update_messages():
+    """Fetch messages and notify clients if there are changes"""
+    global messages_cache
     
-    if text == '/start':
-        send_message(chat_id, 'Hi')
+    # Only fetch if we have active users
+    if not user_data_cache:
+        return
     
-def main():
-    offset = None
+    for page_id in user_data_cache.get('page_ids', []):
+        result = fetch_messages_json()
+        if result['success']:
+            new_messages = result['data'].get(page_id, [])
+            old_messages = messages_cache.get(page_id, [])
+            
+            # Check if there are new messages
+            if len(new_messages) > len(old_messages):
+                messages_cache[page_id] = new_messages
+                # Notify clients about new messages
+                socketio.emit('new_messages', {
+                    'page_id': page_id,
+                    'count': len(new_messages) - len(old_messages)
+                })
+
+def get_user_data(force_refresh=False):
+    """Get user data from GitHub or cache"""
+    global user_data_cache, last_fetch_time
     
-    while True:
-        url = f'https://api.telegram.org/bot{bot_token}/getUpdates'
-        params = {'offset': offset}
-        response = requests.get(url, params=params)
-        data = response.json()
+    current_time = time.time()
+    if force_refresh or not user_data_cache or (current_time - last_fetch_time) > CACHE_TIMEOUT:
+        result = fetch_user_json()
+        if result['success']:
+            # Process the data to make it easier to work with
+            pages = result['data'].get('pages', [])
+            page_ids = [page.get('page_id') for page in pages]
+            
+            user_data_cache = {
+                'pages': pages,
+                'page_ids': page_ids,
+                'raw_data': result['data']
+            }
+            last_fetch_time = current_time
+            return user_data_cache
+    
+    return user_data_cache
+
+def get_messages(page_id, force_refresh=False):
+    """Get messages for a specific page from GitHub or cache"""
+    global messages_cache
+    
+    if force_refresh or page_id not in messages_cache:
+        result = fetch_messages_json()
+        if result['success']:
+            messages = result['data'].get(page_id, [])
+            messages_cache[page_id] = messages
+            return messages
+    
+    return messages_cache.get(page_id, [])
+
+@app.route('/')
+def index():
+    if 'logged_in' in session and session['logged_in']:
+        return redirect(url_for('dashboard'))
+    return redirect(url_for('login'))
+
+@app.route('/login', methods=['GET', 'POST'])
+def login():
+    error = None
+    if request.method == 'POST':
+        username = request.form['username']
+        password = request.form['password']
+        
+        # Get user data
+        user_data = get_user_data(force_refresh=True)
+        
+        # Check credentials
+        authenticated = False
+        for page in user_data.get('pages', []):
+            if page.get('username') == username and page.get('password') == password:
+                authenticated = True
+                session['logged_in'] = True
+                session['page_id'] = page.get('page_id')
+                session['username'] = username
+                
+                # Start background thread if not already running
+                global thread
+                with thread_lock:
+                    if thread is None:
+                        thread = socketio.start_background_task(background_thread)
+                
+                return redirect(url_for('dashboard'))
         
-        if data['ok']:
-            for update in data['result']:
-                offset = update['update_id'] + 1
-                if 'message' in update:
-                    handle_message(update['message'])
+        if not authenticated:
+            error = 'اسم المستخدم أو كلمة المرور غير صحيح. الرجاء المحاولة مرة أخرى'
+    
+    return render_template('login.html', error=error)
+
+@app.route('/logout')
+def logout():
+    session.clear()
+    return redirect(url_for('login'))
+
+@app.route('/dashboard')
+@login_required
+def dashboard():
+    page_id = session.get('page_id')
+    user_data = get_user_data()
+
+    # Find the current page data
+    current_page = None
+    for page in user_data.get('pages', []):
+        if page.get('page_id') == page_id:
+            current_page = page
+            break
+
+    if not current_page:
+        return redirect(url_for('logout'))
+
+    # Extract system prompt, style, and products
+    system_prompt = current_page.get('system', '')
+
+    # Extract style if it exists
+    style = ""
+    style_start = system_prompt.find('<style>')
+    style_end = system_prompt.find('</style>')
+    if style_start != -1 and style_end != -1:
+        style = system_prompt[style_start + 7:style_end]
+
+    # Extract products if they exist and pre-parse them
+    products = []
+    product_start = system_prompt.find('<product>')
+    while product_start != -1:
+        product_end = system_prompt.find('</product>', product_start)
+        if product_end != -1:
+            product_text = system_prompt[product_start + 9:product_end]
+
+            # Parse the product text into a dictionary
+            product_data = {
+                'name': '',
+                'price': '',
+                'description': '',
+                'info': '',
+                'raw_text': product_text  # Keep the raw text for editing/deleting
+            }
+
+            lines = product_text.split('\n')
+            for line in lines:
+                if 'NAME:' in line:
+                    product_data['name'] = line.replace('NAME:', '').strip()
+                elif 'PRICE (LIBYAN DINNER):' in line:
+                    product_data['price'] = line.replace('PRICE (LIBYAN DINNER):', '').strip()
+                elif 'DESCRIPTION:' in line:
+                    product_data['description'] = line.replace('DESCRIPTION:', '').strip()
+                elif 'ANOTHER INFO:' in line:
+                    product_data['info'] = line.replace('ANOTHER INFO:', '').strip()
+
+            products.append(product_data)
+            product_start = system_prompt.find('<product>', product_end)
+        else:
+            break
+
+    # Get bot status
+    bot_status = current_page.get('status', 'OFF')
+
+    # Get subscription info from the actual JSON structure and translate to Arabic
+    subscription_type = current_page.get('subscription', None)
+    subscription_message = None
+
+    if subscription_type == 'Basic':
+        subscription_status = 'اشتراك عادي'
+    elif subscription_type == 'Plus':
+        subscription_status = 'اشتراك +'
+    elif subscription_type == 'Premium':
+        subscription_status = 'اشتراك مميز'
+    elif subscription_type == 'Free':
+        subscription_status = 'اشتراك مجاني'
+    else:
+        subscription_status = 'لا يوجد اشتراك'
+        subscription_message = 'يرجى الاشتراك للاستفادة من جميع المميزات'
+
+    expiration_date = current_page.get('expiration', '2023-12-31')
+
+    # Calculate days until expiration
+    import datetime
+    is_expired = False
+    expiration_message = None
+    try:
+        exp_date = datetime.datetime.strptime(expiration_date, '%Y-%m-%d')
+        today = datetime.datetime.now()
+        days_left = (exp_date - today).days
+
+        if days_left <= 0:
+            is_expired = True
+            expiration_message = 'انتهت صلاحية اشتراكك! يرجى التجديد للاستمرار في استخدام الخدمة'
+        elif days_left <= 3:
+            expiration_message = f'سينتهي اشتراكك خلال {days_left} أيام!'
+    except:
+        days_left = 0
+        is_expired = True
+        expiration_message = 'تاريخ انتهاء غير صالح! يرجى التواصل مع الدعم الفني'
+
+    # Get unread messages count
+    messages = get_messages(page_id, force_refresh=True)
+    unread_count = sum(1 for msg in messages if not msg.get('seen', False))
+
+    return render_template(
+        'dashboard.html',
+        page=current_page,
+        style=style,
+        products=products,
+        system_prompt=system_prompt,
+        bot_status=bot_status,
+        subscription_status=subscription_status,
+        subscription_message=subscription_message,
+        expiration_date=expiration_date,
+        days_left=days_left,
+        is_expired=is_expired,
+        expiration_message=expiration_message,
+        unread_count=unread_count
+    )
+
+@app.route('/messages')
+@login_required
+def messages_page():
+    page_id = session.get('page_id')
+    messages = get_messages(page_id, force_refresh=True)
+
+    # Sort messages by timestamp (newest first)
+    messages = sorted(messages, key=lambda x: x.get('timestamp', ''), reverse=True)
+
+    user_data = get_user_data()
+    current_page = None
+    for page in user_data.get('pages', []):
+        if page.get('page_id') == page_id:
+            current_page = page
+            break
+
+    if not current_page:
+        return redirect(url_for('logout'))
+
+    return render_template(
+        'messages.html',
+        page=current_page,
+        messages=messages
+    )
+
+@app.route('/api/update_status', methods=['POST'])
+@login_required
+def update_status():
+    page_id = session.get('page_id')
+    status = request.json.get('status')
+    
+    if status not in ['ON', 'OFF']:
+        return jsonify({'success': False, 'message': 'Invalid status value'})
+    
+    # Get current data
+    user_data = get_user_data(force_refresh=True)
+    raw_data = user_data.get('raw_data', {})
+    
+    # Update the status for the current page
+    for page in raw_data.get('pages', []):
+        if page.get('page_id') == page_id:
+            page['status'] = status
+            break
+    
+    # Get tokens for updating
+    auth_token, commit_oid = fetch_user_tokens()
+    if not auth_token or not commit_oid:
+        return jsonify({'success': False, 'message': 'Failed to get authentication tokens'})
+    
+    # Update the file
+    result = update_user_json(auth_token, commit_oid, json.dumps(raw_data))
+    
+    if result['success']:
+        # Update cache
+        get_user_data(force_refresh=True)
+        # Notify all clients about the status change
+        socketio.emit('status_updated', {'page_id': page_id, 'status': status})
+        return jsonify({'success': True, 'message': 'Status updated successfully'})
+    else:
+        return jsonify({'success': False, 'message': 'Failed to update status'})
+
+@app.route('/api/update_system', methods=['POST'])
+@login_required
+def update_system():
+    page_id = session.get('page_id')
+    style = request.json.get('style', '')
+    
+    # Get current data
+    user_data = get_user_data(force_refresh=True)
+    raw_data = user_data.get('raw_data', {})
+    
+    # Find the current page
+    current_page = None
+    for page in raw_data.get('pages', []):
+        if page.get('page_id') == page_id:
+            current_page = page
+            break
+    
+    if not current_page:
+        return jsonify({'success': False, 'message': 'Page not found'})
+    
+    # Get the current system prompt
+    system_prompt = current_page.get('system', '')
+    
+    # Check if style tag already exists
+    style_start = system_prompt.find('<style>')
+    style_end = system_prompt.find('</style>')
+    
+    if style_start != -1 and style_end != -1:
+        # Replace existing style
+        new_system = system_prompt[:style_start] + f'<style>{style}</style>' + system_prompt[style_end + 8:]
+    else:
+        # Add style at the end of the system prompt
+        base_prompt_end = system_prompt.find('here how to talk style and products if there : ')
+        if base_prompt_end != -1:
+            new_system = system_prompt[:base_prompt_end + 46] + f'<style>{style}</style>'
+        else:
+            new_system = system_prompt + f' <style>{style}</style>'
+    
+    # Update the system prompt
+    current_page['system'] = new_system
+    
+    # Get tokens for updating
+    auth_token, commit_oid = fetch_user_tokens()
+    if not auth_token or not commit_oid:
+        return jsonify({'success': False, 'message': 'Failed to get authentication tokens'})
+    
+    # Update the file
+    result = update_user_json(auth_token, commit_oid, json.dumps(raw_data))
+    
+    if result['success']:
+        # Update cache
+        get_user_data(force_refresh=True)
+        return jsonify({'success': True, 'message': 'System prompt updated successfully'})
+    else:
+        return jsonify({'success': False, 'message': 'Failed to update system prompt'})
+
+@app.route('/api/add_product', methods=['POST'])
+@login_required
+def add_product():
+    page_id = session.get('page_id')
+    product_data = request.json.get('product', {})
+    
+    # Format product data
+    product_text = f"NAME: {product_data.get('name', '')}\n"
+    product_text += f"DESCRIPTION: {product_data.get('description', '')}\n"
+    product_text += f"PRICE (LIBYAN DINNER): {product_data.get('price', '')}\n"
+    product_text += f"ANOTHER INFO: {product_data.get('info', '')}"
+    
+    # Get current data
+    user_data = get_user_data(force_refresh=True)
+    raw_data = user_data.get('raw_data', {})
+    
+    # Find the current page
+    current_page = None
+    for page in raw_data.get('pages', []):
+        if page.get('page_id') == page_id:
+            current_page = page
+            break
+    
+    if not current_page:
+        return jsonify({'success': False, 'message': 'Page not found'})
+    
+    # Get the current system prompt
+    system_prompt = current_page.get('system', '')
+    
+    # Add product tag at the end
+    new_system = system_prompt + f' <product>{product_text}</product>'
+    
+    # Update the system prompt
+    current_page['system'] = new_system
+    
+    # Get tokens for updating
+    auth_token, commit_oid = fetch_user_tokens()
+    if not auth_token or not commit_oid:
+        return jsonify({'success': False, 'message': 'Failed to get authentication tokens'})
+    
+    # Update the file
+    result = update_user_json(auth_token, commit_oid, json.dumps(raw_data))
+    
+    if result['success']:
+        # Update cache
+        get_user_data(force_refresh=True)
+        return jsonify({'success': True, 'message': 'Product added successfully'})
+    else:
+        return jsonify({'success': False, 'message': 'Failed to add product'})
+
+@app.route('/api/delete_product', methods=['POST'])
+@login_required
+def delete_product():
+    page_id = session.get('page_id')
+    product_index = request.json.get('index')
+    
+    # Get current data
+    user_data = get_user_data(force_refresh=True)
+    raw_data = user_data.get('raw_data', {})
+    
+    # Find the current page
+    current_page = None
+    for page in raw_data.get('pages', []):
+        if page.get('page_id') == page_id:
+            current_page = page
+            break
+    
+    if not current_page:
+        return jsonify({'success': False, 'message': 'Page not found'})
+    
+    # Get the current system prompt
+    system_prompt = current_page.get('system', '')
+    
+    # Find all products
+    products = []
+    product_start = system_prompt.find('<product>')
+    while product_start != -1:
+        product_end = system_prompt.find('</product>', product_start)
+        if product_end != -1:
+            products.append({
+                'start': product_start,
+                'end': product_end + 10,  # Include the closing tag
+                'text': system_prompt[product_start:product_end + 10]
+            })
+            product_start = system_prompt.find('<product>', product_end)
+        else:
+            break
+    
+    # Check if the index is valid
+    if product_index < 0 or product_index >= len(products):
+        return jsonify({'success': False, 'message': 'Invalid product index'})
+    
+    # Remove the product
+    product_to_remove = products[product_index]
+    new_system = system_prompt[:product_to_remove['start']] + system_prompt[product_to_remove['end']:]
+    
+    # Update the system prompt
+    current_page['system'] = new_system
+    
+    # Get tokens for updating
+    auth_token, commit_oid = fetch_user_tokens()
+    if not auth_token or not commit_oid:
+        return jsonify({'success': False, 'message': 'Failed to get authentication tokens'})
+    
+    # Update the file
+    result = update_user_json(auth_token, commit_oid, json.dumps(raw_data))
+    
+    if result['success']:
+        # Update cache
+        get_user_data(force_refresh=True)
+        return jsonify({'success': True, 'message': 'Product deleted successfully'})
+    else:
+        return jsonify({'success': False, 'message': 'Failed to delete product'})
+
+
+@app.route('/api/refresh_data', methods=['POST'])
+@login_required
+def refresh_data():
+    data_type = request.json.get('type', 'all')
+
+    if data_type == 'messages' or data_type == 'all':
+        # Force refresh messages
+        page_id = session.get('page_id')
+        messages = get_messages(page_id, force_refresh=True)
+
+        # Notify clients about the refresh
+        socketio.emit('data_refreshed', {'type': data_type})
+
+        return jsonify({'success': True, 'message': 'تم تحديث البيانات بنجاح'})
+
+    return jsonify({'success': False, 'message': 'نوع البيانات غير صالح'})
+
+
+@app.route('/api/mark_message_seen', methods=['POST'])
+@login_required
+def mark_message_seen():
+    page_id = session.get('page_id')
+    message_index = request.json.get('index')
+
+    # Ensure message_index is an integer
+    try:
+        message_index = int(message_index)
+    except (ValueError, TypeError):
+        return jsonify({'success': False, 'message': 'مؤشر الرسالة غير صالح'})
+
+    # Get current messages
+    result = fetch_messages_json()
+    if not result['success']:
+        return jsonify({'success': False, 'message': 'فشل في جلب الرسائل'})
+
+    messages_data = result['data']
+    page_messages = messages_data.get(page_id, [])
+
+    # Sort messages by timestamp (newest first) to match the display order
+    page_messages = sorted(page_messages, key=lambda x: x.get('timestamp', ''), reverse=True)
+
+    # Check if the index is valid
+    if message_index < 0 or message_index >= len(page_messages):
+        return jsonify({'success': False, 'message': 'مؤشر الرسالة غير صالح'})
+
+    # Mark the message as seen
+    page_messages[message_index]['seen'] = True
+
+    # Re-sort messages back to their original order before saving
+    # This is needed because we're working with the sorted list but need to update the original data
+    original_messages = messages_data.get(page_id, [])
+
+    # Find the corresponding message in the original list by matching properties
+    message_to_mark = page_messages[message_index]
+    for orig_msg in original_messages:
+        if (orig_msg.get('message') == message_to_mark.get('message') and
+            orig_msg.get('sender_id') == message_to_mark.get('sender_id') and
+            orig_msg.get('timestamp') == message_to_mark.get('timestamp')):
+            orig_msg['seen'] = True
+            break
+
+    # Update messages data
+    messages_data[page_id] = original_messages
+
+    # Get tokens for updating
+    auth_token, commit_oid = fetch_messages_tokens()
+    if not auth_token or not commit_oid:
+        return jsonify({'success': False, 'message': 'فشل في الحصول على رموز المصادقة'})
+
+    # Update the file
+    result = update_messages_json(auth_token, commit_oid, json.dumps(messages_data))
+
+    if result['success']:
+        # Update cache
+        messages_cache[page_id] = original_messages
+        # Notify clients about the message being seen
+        socketio.emit('message_seen', {'page_id': page_id, 'index': message_index})
+        return jsonify({'success': True, 'message': 'تم تعليم الرسالة كمقروءة'})
+    else:
+        return jsonify({'success': False, 'message': 'فشل في تحديث حالة الرسالة'})
+@app.route('/api/delete_message', methods=['POST'])
+@login_required
+def delete_message():
+    page_id = session.get('page_id')
+    message_index = request.json.get('index')
+
+    # Ensure message_index is an integer
+    try:
+        message_index = int(message_index)
+    except (ValueError, TypeError):
+        return jsonify({'success': False, 'message': 'مؤشر الرسالة غير صالح'})
+
+    # Get current messages
+    result = fetch_messages_json()
+    if not result['success']:
+        return jsonify({'success': False, 'message': 'فشل في جلب الرسائل'})
+
+    messages_data = result['data']
+    page_messages = messages_data.get(page_id, [])
+
+    # Sort messages by timestamp (newest first) to match the display order
+    sorted_messages = sorted(page_messages, key=lambda x: x.get('timestamp', ''), reverse=True)
+
+    # Check if the index is valid
+    if message_index < 0 or message_index >= len(sorted_messages):
+        return jsonify({'success': False, 'message': 'مؤشر الرسالة غير صالح'})
+
+    # Get the message to delete
+    message_to_delete = sorted_messages[message_index]
+
+    # Find and remove the message from the original list
+    original_messages = messages_data.get(page_id, [])
+    for i, msg in enumerate(original_messages):
+        if (msg.get('message') == message_to_delete.get('message') and
+            msg.get('sender_id') == message_to_delete.get('sender_id') and
+            msg.get('timestamp') == message_to_delete.get('timestamp')):
+            original_messages.pop(i)
+            break
+
+    # Update messages data
+    messages_data[page_id] = original_messages
+
+    # Get tokens for updating
+    auth_token, commit_oid = fetch_messages_tokens()
+    if not auth_token or not commit_oid:
+        return jsonify({'success': False, 'message': 'فشل في الحصول على رموز المصادقة'})
+
+    # Update the file
+    result = update_messages_json(auth_token, commit_oid, json.dumps(messages_data))
+
+    if result['success']:
+        # Update cache
+        messages_cache[page_id] = original_messages
+        # Notify all clients about the message deletion
+        socketio.emit('message_deleted', {'page_id': page_id, 'index': message_index})
+        return jsonify({'success': True, 'message': 'تم حذف الرسالة بنجاح'})
+    else:
+        return jsonify({'success': False, 'message': 'فشل في حذف الرسالة'})    
+
+# WebSocket events
+@socketio.on('connect')
+def handle_connect():
+    # Start background thread if not already running
+    global thread
+    with thread_lock:
+        if thread is None:
+            thread = socketio.start_background_task(background_thread)
+    emit('connected', {'data': 'Connected'})
+
+@socketio.on('request_messages_update')
+def handle_messages_update(data):
+    page_id = data.get('page_id')
+    if page_id:
+        messages = get_messages(page_id, force_refresh=True)
+        emit('messages_updated', {'page_id': page_id, 'messages': messages})
 
 if __name__ == '__main__':
-    main()
+    socketio.run(host="0.0.0.0", port=7860, debug=True ,app)