Update app.py

app.py

@@ -1,76 +1,251 @@
-from flask import Flask, request, render_template_string, send_from_directory, jsonify
-from flask import render_template
+from flask import Flask, request, render_template_string, render_template, jsonify
 import sqlite3
 import os
-import uuid
-
+import random
+import requests
+import time
+import re
 import json
 import base64
-import unittest
-import requests 
 
-own_url = os.getenv('own_url')  
-key_d = os.getenv('gc_api')  
+from unidecode import unidecode
+
+api_key_sys = os.getenv('api_key_sys')  
+
 gc_url = os.getenv('gc_url')   
+gc_api = os.getenv('gc_api')  
+
+wa_url = os.getenv('wa_url') 
+wa_api_key = os.getenv('wa_api_key') 
 
 
 
 
 
-import json
-from datetime import datetime
 
-import whatsapp_api_webhook_server_python.webhooksHandler as handler
 
 app = Flask(__name__, template_folder="./")
+app.config['DEBUG'] = True
+UPLOAD_FOLDER = 'static'
 
+if not os.path.exists(UPLOAD_FOLDER):
+    os.makedirs(UPLOAD_FOLDER)
 
+DATABASES = ['data_gc.db', 'data1.db', 'data2.db', 'data3.db', 'data4.db', 'data5.db']
 
+def init_db(db_name):
+    conn = sqlite3.connect(db_name)
+    cursor = conn.cursor()
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS contacts (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            name TEXT NOT NULL,
+            phone TEXT NOT NULL,
+            email TEXT NOT NULL
+        )
+    ''')
+    conn.commit()
+    conn.close()
 
-app.config['DEBUG'] = True
+for db in DATABASES:
+    init_db(db)
 
-UPLOAD_FOLDER = 'static'
+def randomize_message(template):
+    def replace_placeholder(match):
+        options = match.group(1).split('|')
+        return random.choice(options)
+
+    return re.sub(r'\{([^}]+)\}', replace_placeholder, template)
+
+def clean_phone_number(phone):
+    if phone.startswith('+'):
+        return phone[1:]
+    return phone
+
+def send_message(chat_id, message):
+    #base_url = os.getenv('wa_url')
+    #api_key = os.getenv('wa_api_key')
+    full_url = f"{wa_url}{wa_api_key}"
+    payload = {
+        "chatId": chat_id,
+        "message": message
+    }
+    headers = {
+        'Content-Type': 'application/json'
+    }
+    response = requests.request("POST", full_url, headers=headers, json=payload)
+    try:
+        response_json = response.json()
+    except ValueError:
+        response_json = {"error": "Invalid JSON response"}
+    return response_json
 
+def check_and_send_mailings(mesage_db1, clean_db):
+    try:
+        results = []
+        for database in DATABASES:
+            conn = sqlite3.connect(database)
+            cursor = conn.cursor()
+            cursor.execute('SELECT name, phone FROM contacts')
+            contacts = cursor.fetchall()
+            conn.close()
+
+            for contact in contacts:
+                name = contact[0]
+                chat_id = f"{clean_phone_number(contact[1])}@c.us"
+                message = randomize_message(mesage_db1)
+                message = message.replace('[[nemes]]', name)  # Подстановка имени
+                send_result = send_message(chat_id, message)
+                results.append({
+                    "chat_id": chat_id,
+                    "message": message,
+                    "result": send_result
+                })
+
+            if clean_db == '1':
+                conn = sqlite3.connect(database)
+                cursor = conn.cursor()
+                cursor.execute('DELETE FROM contacts')
+                conn.commit()
+                conn.close()
+
+        return jsonify({"status": "success", "results": results}), 200
+    except Exception as e:
+        print(f"Error sending mailings: {e}")
+        return jsonify({"status": "error", "message": str(e)}), 500
+
+#С проверкой sys
+@app.route('/start_db', methods=['GET'])
+def start_mailings():
+    mesage_db1 = request.args.get('mesage')
+    clean_db = request.args.get('clean_db')
+    api_sys_control = request.args.get('api_sys')
+    
 
-# Создание директории, если она не существует
-if not os.path.exists(UPLOAD_FOLDER):
-    os.makedirs(UPLOAD_FOLDER)
+    if not mesage_db1:
+        return "Parameter 'mesage' is required.", 400
 
+    if api_sys_control != api_key_sys:
+        return "EUR 22", 200
 
+    return check_and_send_mailings(mesage_db1, clean_db)
 
-# Создание базы данных и таблицы
-DATABASES = ['data1.db', 'data2.db', 'data3.db', 'data4.db', 'data5.db']
 
-def init_db(db_name):
+
+
+        
+
+@app.route('/add_data_gc', methods=['GET'])
+def add_data_gc():
+    try:
+        name = request.args.get('name')
+        phone = request.args.get('phone')
+        email = request.args.get('email')
+        api_sys_control = request.args.get('api_sys')
+
+        if not name or not phone or not email:
+            return "Parameters 'name', 'phone', and 'email' are required.", 400
+
+        if api_sys_control != api_key_sys:
+            return "EUR 22", 200
+
+        # Проверка и удаление плюса в начале номера телефона, если он ��сть
+        if phone.startswith('+'):
+            phone = phone[1:]
+
+        conn = sqlite3.connect('data_gc.db')
+        cursor = conn.cursor()
+        cursor.execute('SELECT * FROM contacts WHERE phone = ? OR email = ?', (phone, email))
+        existing_contact = cursor.fetchone()
+
+        if existing_contact:
+            return f"Contact with phone {phone} or email {email} already exists."
+
+        cursor.execute('INSERT INTO contacts (name, phone, email) VALUES (?, ?, ?)', (name, phone, email))
+        conn.commit()
+        conn.close()
+
+        return f"Contact added: {name} - {phone} - {email}", 200
+    except Exception as e:
+        print(f"Error adding contact: {e}")
+        return "Internal Server Error", 500
+
+
+@app.route('/add_data_ras', methods=['GET'])
+def add_contact():
     try:
-        conn = sqlite3.connect(db_name)
+        name = request.args.get('name')
+        phone = request.args.get('phone')
+        email = request.args.get('email')
+        api_sys_control = request.args.get('api_sys')
+
+        if not name or not phone or not email:
+            return "Parameters 'name', 'phone', and 'email' are required.", 400
+
+        if api_sys_control != api_key_sys:
+            return "EUR 22", 200
+
+        # Проверка и удаление плюса в начале номера телефона, если он есть
+        if phone.startswith('+'):
+            phone = phone[1:]
+
+        conn = sqlite3.connect('data1.db')
         cursor = conn.cursor()
-        cursor.execute('''
-            CREATE TABLE IF NOT EXISTS contacts (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                name TEXT NOT NULL,
-                phone TEXT NOT NULL,
-                email TEXT NOT NULL
-            )
-        ''')
+        cursor.execute('INSERT INTO contacts (name, phone, email) VALUES (?, ?, ?)', (name, phone, email))
         conn.commit()
         conn.close()
+
+        return f"Contact added: {name} - {phone} - {email}", 200
     except Exception as e:
-        print(f"Error initializing database {db_name}: {e}")
+        print(f"Error adding contact: {e}")
+        return "Internal Server Error", 500
 
-for db in DATABASES:
-    init_db(db)
+@app.route('/data_gc')
+def show_data_gc():
+    try:
+        api_sys_control = request.args.get('api_sys')
 
+        if api_sys_control != api_key_sys:
+            return "EUR 22", 200
+
+        conn = sqlite3.connect('data_gc.db')
+        cursor = conn.cursor()
+        cursor.execute('SELECT name, phone, email FROM contacts')
+        contacts = cursor.fetchall()
+        cursor.execute('SELECT COUNT(*) FROM contacts')
+        total_users = cursor.fetchone()[0]
+        conn.close()
+
+        return render_template('data_gc.html', contacts=contacts, total_users=total_users)
+    except Exception as e:
+        print(f"Error showing contacts: {e}")
+        return "Internal Server Error", 500
+
+
+@app.route('/data_ras')
+def show_data_ras():
+    try:
+        api_sys_control = request.args.get('api_sys')
+
+        if api_sys_control != api_key_sys:
+            return "EUR 22", 200
+
+        conn = sqlite3.connect('data1.db')
+        cursor = conn.cursor()
+        cursor.execute('SELECT name, phone, email FROM contacts')
+        contacts = cursor.fetchall()
+        cursor.execute('SELECT COUNT(*) FROM contacts')
+        total_users = cursor.fetchone()[0]
+        conn.close()
+
+        return render_template('data_ras.html', contacts=contacts, total_users=total_users)
+    except Exception as e:
+        print(f"Error showing contacts: {e}")
+        return "Internal Server Error", 500
 
 
-@app.route('/settings', methods=['GET'])
-def settings():
-    return render_template('settings.html')
 
 
-@app.route('/online', methods=['GET'])
-def onli():
-    return render_template('online.html')
 
 
 
@@ -80,95 +255,104 @@ def onli():
 
 @app.route('/ver', methods=['GET'])
 def veref():
+    api_sys_control = request.args.get('api_sys')
+    if api_sys_control != api_key_sys:
+        return "EUR 22", 200
     return render_template('ver.html')
 
 @app.route('/se_mes', methods=['GET'])
 def se_mes():
+    api_sys_control = request.args.get('api_sys')
+    if api_sys_control != api_key_sys:
+        return "EUR 22", 200
     return render_template('se_mes.html')
 
 @app.route('/se_mes_im', methods=['GET'])
 def se_mes_im():
+    api_sys_control = request.args.get('api_sys')
+    if api_sys_control != api_key_sys:
+        return "EUR 22", 200
     return render_template('se_mes_im.html')
 
-
-
 @app.route('/se_mes_ran', methods=['GET'])
 def se_mes_ran():
+    api_sys_control = request.args.get('api_sys')
+    if api_sys_control != api_key_sys:
+        return "EUR 22", 200
     return render_template('se_mes_ran.html')
 
-    
-
 @app.route('/se_mes_im_ran', methods=['GET'])
 def se_mes_im_ran():
+    api_sys_control = request.args.get('api_sys')
+    if api_sys_control != api_key_sys:
+        return "EUR 22", 200
     return render_template('se_mes_im_ran.html')
 
-
-
-
-    
-
 @app.route('/se_mes_im2', methods=['GET'])
 def se_mes_im2():
+    api_sys_control = request.args.get('api_sys')
+    if api_sys_control != api_key_sys:
+        return "EUR 22", 200
     return render_template('se_mes_im2.html')
 
 @app.route('/se_mes_f', methods=['GET'])
 def se_mes_f():
+    api_sys_control = request.args.get('api_sys')
+    if api_sys_control != api_key_sys:
+        return "EUR 22", 200
     return render_template('se_mes_f.html')
 
 @app.route('/up_gr', methods=['GET'])
 def up_gr():
+    api_sys_control = request.args.get('api_sys')
+    if api_sys_control != api_key_sys:
+        return "EUR 22", 200
     return render_template('up_gr.html')
 
 @app.route('/up_user_gp', methods=['GET'])
 def up_user_gp():
+    api_sys_control = request.args.get('api_sys')
+    if api_sys_control != api_key_sys:
+        return "EUR 22", 200
     return render_template('up_user_gp.html')
 
 @app.route('/del_user_gp', methods=['GET'])
 def del_user_gp():
+    api_sys_control = request.args.get('api_sys')
+    if api_sys_control != api_key_sys:
+        return "EUR 22", 200
     return render_template('del_user_gp.html')
 
 @app.route('/up_ad', methods=['GET'])
 def up_ad():
+    api_sys_control = request.args.get('api_sys')
+    if api_sys_control != api_key_sys:
+        return "EUR 22", 200
     return render_template('up_ad.html')
 
 @app.route('/del_ad', methods=['GET'])
 def del_ad():
+    api_sys_control = request.args.get('api_sys')
+    if api_sys_control != api_key_sys:
+        return "EUR 22", 200
     return render_template('del_ad.html')
-    
+
 @app.route('/se_opr', methods=['GET'])
 def se_opr():
-    return render_template('se_opr.html')   
-
-
+    api_sys_control = request.args.get('api_sys')
+    if api_sys_control != api_key_sys:
+        return "EUR 22", 200
+    return render_template('se_opr.html')
 
 @app.route('/online', methods=['GET'])
 def online():
+    api_sys_control = request.args.get('api_sys')
+    if api_sys_control != api_key_sys:
+        return "EUR 22", 200
     return render_template('online.html')
 
-@app.route('/upload', methods=['POST'])
-def upload_file():
-    if 'file' not in request.files:
-        return "No file part", 400
-    file = request.files['file']
-    if file.filename == '':
-        return "No selected file", 400
-    
-    # Генерация уникального имени файла
-    unique_filename = str(uuid.uuid4()) + os.path.splitext(file.filename)[1]
-    save_path = os.path.join(UPLOAD_FOLDER, unique_filename)
-    file.save(save_path)
-    
-    # Возвращаем полный URL загруженного файла с протоколом https
-    full_url = request.url_root.replace('http://', 'https://') + 'uploads/' + unique_filename
-    return f"File uploaded successfully and saved to {full_url}", 200
 
-@app.route('/uploads/<filename>', methods=['GET'])
-def uploaded_file(filename):
-    return send_from_directory(UPLOAD_FOLDER, filename)
 
-@app.route('/up_fa', methods=['GET'])
-def up_fa():
-    return render_template('up_fa.html')
 
 
 
@@ -176,163 +360,238 @@ def up_fa():
 
 
 
-# Маршрут для обработки GET-запроса из gc
-@app.route('/add_contact', methods=['GET'])
-def add_contact():
+
+
+
+
+
+
+
+@app.route('/total_users', methods=['GET'])
+def total_users():
     try:
-        name = request.args.get('name')
-        phone = request.args.get('phone')
-        email = request.args.get('email')
+        api_sys_control = request.args.get('api_sys')
+
+        if api_sys_control != api_key_sys:
+            return "EUR 22", 200
+
+        total_users_gc = 0
+        total_users_ras = 0
+
+        conn_gc = sqlite3.connect('data_gc.db')
+        cursor_gc = conn_gc.cursor()
+        cursor_gc.execute('SELECT COUNT(*) FROM contacts')
+        total_users_gc = cursor_gc.fetchone()[0]
+        conn_gc.close()
+
+        conn_ras = sqlite3.connect('data1.db')
+        cursor_ras = conn_ras.cursor()
+        cursor_ras.execute('SELECT COUNT(*) FROM contacts')
+        total_users_ras = cursor_ras.fetchone()[0]
+        conn_ras.close()
+
+        return jsonify({
+            "total_users_gc": total_users_gc,
+            "total_users_ras": total_users_ras
+        }), 200
+    except Exception as e:
+        print(f"Error getting total users: {e}")
+        return "Internal Server Error", 500
 
-        if not name or not phone or not email:
-            return "Parameters 'name', 'phone', and 'email' are required.", 400
 
-        conn = sqlite3.connect('data1.db')
+
+
+
+
+
+
+@app.route('/all_users_gc', methods=['GET'])
+def all_users_gc():
+    try:
+        api_sys_control = request.args.get('api_sys')
+
+        if api_sys_control != api_key_sys:
+            return "EUR 22", 200
+
+        conn = sqlite3.connect('data_gc.db')
         cursor = conn.cursor()
-        cursor.execute('INSERT INTO contacts (name, phone, email) VALUES (?, ?, ?)', (name, phone, email))
-        conn.commit()
+        cursor.execute('SELECT name, phone, email FROM contacts')
+        contacts = cursor.fetchall()
         conn.close()
 
-        return f"Contact added: {name} - {phone} - {email}", 200
+        return jsonify(contacts), 200
     except Exception as e:
-        print(f"Error adding contact: {e}")
+        print(f"Error getting all users from data_gc: {e}")
         return "Internal Server Error", 500
 
-@app.route('/contacts')
-def show_contacts():
+
+
+@app.route('/all_users_ras', methods=['GET'])
+def all_users_ras():
     try:
+        api_sys_control = request.args.get('api_sys')
+
+        if api_sys_control != api_key_sys:
+            return "EUR 22", 200
+
         conn = sqlite3.connect('data1.db')
         cursor = conn.cursor()
         cursor.execute('SELECT name, phone, email FROM contacts')
         contacts = cursor.fetchall()
         conn.close()
 
-        html = '''
-        <!doctype html>
-        <html lang="en">
-          <head>
-            <meta charset="utf-8">
-            <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
-            <title>Contacts</title>
-            <style>
-              table {
-                width: 70%;
-                border-collapse: collapse;
-              }
-              th, td {
-                border: 1px solid black;
-                padding: 8px;
-                text-align: left;
-              }
-              th {
-                background-color: #f2f2f2;
-              }
-            </style>
-          </head>
-          <body>
-            <h1>Contacts</h1>
-            <table>
-              <tr>
-                <th>Name</th>
-                <th>Phone</th>
-                <th>Email</th>
-              </tr>
-              {% for contact in contacts %}
-              <tr>
-                <td>{{ contact[0] }}</td>
-                <td>{{ contact[1] }}</td>
-                <td>{{ contact[2] }}</td>
-              </tr>
-              {% endfor %}
-            </table>
-          </body>
-        </html>
-        '''
-
-        return render_template_string(html, contacts=contacts)
+        return jsonify(contacts), 200
     except Exception as e:
-        print(f"Error showing contacts: {e}")
+        print(f"Error getting all users from data_ras: {e}")
         return "Internal Server Error", 500
 
 
 
 
+        
 
+@app.route('/gc_db_no_email', methods=['GET'])
+def gc_db_no_email():
+    try:
+        api_sys_control = request.args.get('api_sys')
 
+        if api_sys_control != api_key_sys:
+            return "EUR 22", 200
 
+        # Чтение параметров из GET-запроса
+        name_d = request.args.get('name', '')
+        phone_d = request.args.get('phone', '')
+        pr1_d = request.args.get('pr1', '')
+        pr2_d = request.args.get('pr2', '')
+        pr3_d = request.args.get('pr3', '')
 
+        # Проверка базы данных на наличие email по номеру телефона
+        conn = sqlite3.connect('data_gc.db')
+        cursor = conn.cursor()
+        cursor.execute('SELECT email FROM contacts WHERE phone = ?', (phone_d,))
+        result = cursor.fetchone()
+        email_d = result[0] if result else ''
+        conn.close()
 
+        # Формирование JSON
+        json_data = {
+            "user": {
+                "email": email_d,
+                "phone": phone_d,
+                "first_name": name_d,
+                "addfields": {
+                    "pr1": pr1_d,
+                    "pr2": pr2_d,
+                    "pr3": pr3_d
+                }
+            },
+            "system": {
+                "refresh_if_exists": 1
+            },
+            "session": {
+                "utm_source": "",
+                "utm_medium": "",
+                "utm_content": "",
+                "utm_campaign": "",
+                "utm_group": "",
+                "gcpc": "",
+                "gcao": "",
+                "referer": ""
+            }
+        }
 
-# Переменные с данными
+        # Конвертация JSON в Base64
+        json_str = json.dumps(json_data)
+        params_d = base64.b64encode(json_str.encode('utf-8')).decode('utf-8')
 
-action_d = "add"
-params_d = ""
-name_d = ""
-email_d = ""
-phone_d = ""
-pr1_d = ""
-pr2_d = ""
-pr3_d = ""
+        # Данные для отправки в теле запроса
+        data = {
+            'key': gc_api,
+            'action': 'add',
+            'params': params_d
+        }
 
-@app.route('/gc_db', methods=['GET'])
-def gc_db():
-    # Чтение параметров из GET-запроса
-    name_d = request.args.get('name', '')
-    email_d = request.args.get('email', '')
-    phone_d = request.args.get('phone', '')
-    pr1_d = request.args.get('pr1', '')
-    pr2_d = request.args.get('pr2', '')
-    pr3_d = request.args.get('pr3', '')
+        # Отправка POST-запроса с данными в формате "form-data"
+        response = requests.post(gc_url, data=data)
 
-    # Формирование JSON
-    json_data = {
-        "user": {
-            "email": email_d,
-            "phone": phone_d,
-            "first_name": name_d,
-            "addfields": {
-                "pr1": pr1_d,
-                "pr2": pr2_d,
-                "pr3": pr3_d
-            }
-        },
-        "system": {
-            "refresh_if_exists": 1
-        },
-        "session": {
-            "utm_source": "",
-            "utm_medium": "",
-            "utm_content": "",
-            "utm_campaign": "",
-            "utm_group": "",
-            "gcpc": "",
-            "gcao": "",
-            "referer": ""
+        # Возвращаем ответ от тестового адреса
+        return {
+            'status_code': response.status_code,
+            'response_body': response.text
         }
-    }
+    except Exception as e:
+        print(f"Error in gc_db_no_email: {e}")
+        return "Internal Server Error", 500
 
-    # Конвертация JSON в Base64
-    json_str = json.dumps(json_data)
-    params_d = base64.b64encode(json_str.encode('utf-8')).decode('utf-8')
 
-    # Данные для отправки в теле запроса
-    data = {
-        'key': key_d,
-        'action': action_d,
-        'params': params_d
-    }
 
-    # Отправка POST-запроса с данными в формате "form-data"
-    response = requests.post(gc_url, data=data)
 
-    # Возвращаем ответ от тестового адреса
-    return {
-        'status_code': response.status_code,
-        'response_body': response.text
-    }
 
+@app.route('/gc_db_email', methods=['GET'])
+def gc_db_email():
+    try:
+        api_sys_control = request.args.get('api_sys')
+
+        if api_sys_control != api_key_sys:
+            return "EUR 22", 200
+
+        # Чтение параметров из GET-запроса
+        name_d = request.args.get('name', '')
+        email_d = request.args.get('email', '')
+        phone_d = request.args.get('phone', '')
+        pr1_d = request.args.get('pr1', '')
+        pr2_d = request.args.get('pr2', '')
+        pr3_d = request.args.get('pr3', '')
+
+        # Формирование JSON
+        json_data = {
+            "user": {
+                "email": email_d,
+                "phone": phone_d,
+                "first_name": name_d,
+                "addfields": {
+                    "pr1": pr1_d,
+                    "pr2": pr2_d,
+                    "pr3": pr3_d
+                }
+            },
+            "system": {
+                "refresh_if_exists": 1
+            },
+            "session": {
+                "utm_source": "",
+                "utm_medium": "",
+                "utm_content": "",
+                "utm_campaign": "",
+                "utm_group": "",
+                "gcpc": "",
+                "gcao": "",
+                "referer": ""
+            }
+        }
+
+        # Конвертация JSON в Base64
+        json_str = json.dumps(json_data)
+        params_d = base64.b64encode(json_str.encode('utf-8')).decode('utf-8')
+
+        # Данные для отправки в теле запроса
+        data = {
+            'key': gc_api,
+            'action': action_d,
+            'params': params_d
+        }
 
+        # Отправка POST-запроса с данными в формате "form-data"
+        response = requests.post(gc_url, data=data)
 
+        # Возвращаем ответ от тестового адреса
+        return {
+            'status_code': response.status_code,
+            'response_body': response.text
+        }
+    except Exception as e:
+        print(f"Error in gc_db_email: {e}")
+        return "Internal Server Error", 500
 
 
 
@@ -346,7 +605,6 @@ def gc_db():
 
 
 
-        
 
 if __name__ == '__main__':
-    app.run(host='0.0.0.0', port=int(os.environ.get('PORT', 7860)))
+    app.run(host='0.0.0.0', port=int(os.environ.get('PORT', 7860)))