app.py

from flask import Flask, request, render_template_string, render_template, jsonify, Response, send_from_directory, render_template
import sqlite3
import os
import random
import requests
import time
import re
import json
import base64
import logging
import csv
import io
from urllib.parse import quote
import string
from datetime import datetime
import pytz
import socket
from unidecode import unidecode


import psutil


from base import replace_null_with_empty_string




from ns import send_ns
api_key_sys = os.getenv('api_key_sys')  



import logging

logging.basicConfig(level=logging.DEBUG)



wa_url = os.getenv('wa_url') 
wa_api_key = os.getenv('wa_api_key') 
wa_ak = os.getenv('ws_ak') 
ws_url_mes = "/sendMessage/"
ws_url_ver = "/checkWhatsapp/"






app = Flask(__name__, template_folder="./")

app.config['DEBUG'] = True

UPLOAD_FOLDER = 'static'
HTML_FOLDER = 'html'

# Создание директорий, если они не существуют
if not os.path.exists(UPLOAD_FOLDER):
    os.makedirs(UPLOAD_FOLDER)

if not os.path.exists(HTML_FOLDER):
    os.makedirs(HTML_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,
            vk_id TEXT,
            chat_id TEXT,
            ws_st TEXT,
            ws_stop TEXT,
            web_st INTEGER,
            fin_prog INTEGER,
            b_city TEXT,
            b_fin TEXT, 
            b_ban TEXT,
            b_ign TEXT,
            b_baners TEXT,
            b_butt TEXT,
            b_mess TEXT,           
            orders TEXT,
            curator TEXT,
            pr1 TEXT,
            pr2 TEXT,
            pr3 TEXT,
            pr4 TEXT,
            pr5 TEXT,
            gc_url TEXT,
            key_pr TEXT,
            n_con TEXT,
            canal TEXT,
            data_on TEXT,
            data_t TEXT,
            utm_source TEXT,
            utm_medium TEXT,
            utm_campaign TEXT,
            utm_term TEXT,
            utm_content TEXT,
            gcpc TEXT
        )
    ''')
    conn.commit()
    conn.close()

for db in DATABASES:
    init_db(db)


DATABASE_NEW = 'data_gc.db'






# Отдаем дату онлайн
@app.route('/get_current_time', methods=['GET'])
def get_current_time():
    utc_now = datetime.utcnow()
    msk_tz = pytz.timezone('Europe/Moscow')
    msk_now = utc_now.replace(tzinfo=pytz.utc).astimezone(msk_tz)
    current_time = msk_now.strftime('%Y-%m-%d %H:%M:%S')
    return jsonify({'current_time': current_time})






# Функция для очистки номера телефона
def clean_phone_number_ss(phone_number):
    return re.sub(r'\D', '', phone_number)
# Работа с ордером из АП
@app.route('/order_new', methods=['GET'])
def shop_order_new():
    try:
        logging.debug("Starting shop_order_new")
        api_sys_control = request.args.get('api_sys')

        if api_sys_control != api_key_sys:
            logging.warning("Unauthorized access attempt")
            return json.dumps({"error": "Unauthorized access"}), 403

        name = request.args.get('name', '')
        email = request.args.get('email', '')
        phone = request.args.get('phone', '').lstrip('+')
        order = request.args.get('order', '')
        status = request.args.get('status', '')
        del_flag = request.args.get('del', '')
        n_con_flag = request.args.get('n_con', '')

        if not email or not phone:
            logging.error("Email and phone are required")
            return json.dumps({"error": "Email and phone are required"}), 400

        phone = clean_phone_number_ss(phone)

        conn = sqlite3.connect(DATABASE_NEW)
        cursor = conn.cursor()

        cursor.execute("SELECT * FROM contacts WHERE email = ? OR phone = ?", (email, phone))
        result = cursor.fetchone()

        if result:
            shop_st = result[17] if result[17] else '{}'
            shop_st_data = json.loads(shop_st)
            logging.debug(f"Existing record found. Loaded JSON: {shop_st_data}")
        else:
            shop_st_data = {}

        if del_flag == '1':
            if order in shop_st_data:
                del shop_st_data[order]
        elif order and status:
            shop_st_data[order] = status

        shop_st_json = json.dumps(shop_st_data)

        utc_now = datetime.utcnow()
        msk_tz = pytz.timezone('Europe/Moscow')
        msk_now = utc_now.replace(tzinfo=pytz.utc).astimezone(msk_tz)
        data_on = msk_now.strftime('%Y-%m-%d %H:%M:%S')

        columns_to_update = ['name', 'phone', 'email', 'orders', 'n_con', 'data_on']
        values_to_update = [name, phone, email, shop_st_json, n_con_flag, data_on]

        if result:
            set_clause = ', '.join([f"{col} = ?" for col in columns_to_update])
            query = f"UPDATE contacts SET {set_clause} WHERE email = ? OR phone = ?"
            cursor.execute(query, values_to_update + [email, phone])
        else:
            query = f"INSERT INTO contacts ({', '.join(columns_to_update)}) VALUES ({', '.join(['?' for _ in columns_to_update])})"
            cursor.execute(query, values_to_update)

        conn.commit()

        replace_null_with_empty_string(conn)

        conn.close()

        return json.dumps(shop_st_data), 200

    except Exception as e:
        logging.error(f"An error occurred: {str(e)}")
        return json.dumps({"error": str(e)}), 500







# Поднятие страницы с таблицей
@app.route('/data_gc_tab', methods=['GET'])
def data_gc_tab():
    api_sys_control = request.args.get('api_sys')
    if api_sys_control != api_key_sys:
        return "EUR 22", 200
    return render_template('data_gc_tab.html')

# Данные в таблицу
@app.route('/data_gc_tab_out', methods=['GET'])
def data_gc_tab_out():
    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 id, name, phone, email, vk_id, chat_id, ws_st, ws_stop, web_st, fin_prog,
            b_city, b_fin, b_ban, b_ign, b_baners, b_butt, b_mess, orders, curator,
            pr1, pr2, pr3, pr4, pr5, gc_url, key_pr, n_con, canal, data_on, data_t, utm_source, utm_medium, utm_campaign, utm_term, utm_content, gcpc
            FROM contacts
        ''')
        contacts = cursor.fetchall()
        conn.close()

        contacts_json = [{
            'id': contact[0], 'name': contact[1], 'phone': contact[2], 'email': contact[3],
            'vk_id': contact[4], 'chat_id': contact[5], 'ws_st': contact[6], 'ws_stop': contact[7],
            'web_st': contact[8], 'fin_prog': contact[9], 'b_city': contact[10], 'b_fin': contact[11],
            'b_ban': contact[12], 'b_ign': contact[13], 'b_baners': contact[14], 'b_butt': contact[15],
            'b_mess': contact[16], 'orders': contact[17], 'curator': contact[18], 'pr1': contact[19],
            'pr2': contact[20], 'pr3': contact[21], 'pr4': contact[22], 'pr5': contact[23],
            'gc_url': contact[24], 'key_pr': contact[25], 'n_con': contact[26], 'canal': contact[27],'data_on': contact[28],
            'data_t': contact[29],'utm_source': contact[30], 'utm_medium': contact[31], 'utm_campaign': contact[32],
            'utm_term': contact[33], 'utm_content': contact[34], 'gcpc': contact[34]
        } for contact in contacts]
        return jsonify(contacts_json), 200
    except Exception as e:
        error_message = f"Error getting data from data_gc: {e}"
        print(error_message)
        return error_message, 500








        

# Поднимаем страницу обновления базы
@app.route('/biz_v', methods=['GET'])
def biz_v():
    api_sys_control = request.args.get('api_sys')
    if api_sys_control != api_key_sys:
        return "EUR 22", 200
    return render_template('biz_v.html')





DATABASE2 = 'data_gc.db'

def verify_phone_number(phone_number):
    full_url_ver = f"{wa_url}{wa_ak}{ws_url_ver}{wa_api_key}"
    payload = {"phoneNumber": phone_number}
    headers = {'Content-Type': 'application/json'}
    response = requests.post(full_url_ver, headers=headers, json=payload)
    if response.status_code == 200:
        response_body = response.json()
        return response_body.get('existsWhatsapp', 'false')
    else:
        return "false"

def parse_csv_data(data):
    parsed_data = []
    for item in data:
        for key, value in item.items():
            headers = key.split(';')
            row = value.split(';')
            parsed_data.append(dict(zip(headers, row)))
    return parsed_data

def insert_data(data, verify_phone, add_curator):
    global current_curator_index
    with sqlite3.connect(DATABASE2) as conn:
        cursor = conn.cursor()

        for row in data:
            name = row.get('Name', '')
            phone = row.get('Phone', '').lstrip('+')
            email = row.get('Email', '')
            data_t = row.get('Date', '').strip('"')

            cursor.execute("SELECT 1 FROM contacts WHERE email = ? OR phone = ?", (email, phone))
            user_exists = cursor.fetchone()

            if user_exists:
                print(f"User with email {email} or phone {phone} already exists. Skipping insert.")
                continue

            if add_curator == "1":
                curator = curators[current_curator_index]
                current_curator_index = (current_curator_index + 1) % len(curators)
            else:
                curator = row.get('curator', '')

            if verify_phone == "1":
                ws_st = verify_phone_number(phone)
            else:
                ws_st = row.get('ws_st', '')

            columns = ['name', 'phone', 'email', 'vk_id', 'chat_id', 'ws_st', 'ws_stop', 'web_st', 'fin_prog', 'b_city', 'b_fin', 'b_ban', 'b_ign', 'b_baners', 'b_butt', 'b_mess', 'orders', 'curator', 'pr1', 'pr2', 'pr3', 'pr4', 'pr5', 'gc_url', 'key_pr', 'n_con', 'canal', 'data_on', 'data_t', 'utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content', 'gcpc']
            values = [name, phone, email, row.get('vk_id', ''), row.get('chat_id', ''), ws_st, row.get('ws_stop', ''), row.get('web_st', 0), row.get('fin_prog', 0), row.get('b_city', ''), row.get('b_fin', ''), row.get('b_ban', ''), row.get('b_ign', ''), row.get('b_baners', ''), row.get('b_butt', ''), row.get('b_mess', ''), row.get('orders', ''), curator, row.get('pr1', ''), row.get('pr2', ''), row.get('pr3', ''), row.get('pr4', ''), row.get('pr5', ''), row.get('gc_url', ''), row.get('key_pr', ''), row.get('n_con', ''), row.get('canal', ''), row.get('data_on', ''), row.get('data_t', ''), row.get('utm_source', ''), row.get('utm_medium', ''), row.get('utm_campaign', ''), row.get('utm_term', ''), row.get('utm_content', ''), row.get('gcpc', '')]

            placeholders = ', '.join(['?' for _ in columns])
            columns_str = ', '.join(columns)

            query = f'''
                INSERT INTO contacts ({columns_str})
                VALUES ({placeholders})
            '''

            try:
                cursor.execute(query, values)
            except Exception as e:
                print(f"Error inserting row: {row}")
                print(f"Error message: {str(e)}")
                conn.rollback()
                raise

        conn.commit()

@app.route('/upload_csv', methods=['POST'])
def upload_csv():
    if 'file' not in request.files:
        return jsonify({"error": "No file part"}), 400
    file = request.files['file']
    if file.filename == '':
        return jsonify({"error": "No selected file"}), 400
    if file and file.filename.endswith('.csv'):
        stream = io.StringIO(file.stream.read().decode("UTF8"), newline=None)
        csv_input = csv.DictReader(stream)
        data = [row for row in csv_input]
        parsed_data = parse_csv_data(data)
        verify_phone = request.form.get('verify_phone', '0')
        add_curator = request.form.get('add_curator', '0')
        print(f"Verify Phone: {verify_phone}")
        print(f"Add Curator: {add_curator}")
        insert_data(parsed_data, verify_phone, add_curator)
        return jsonify({"message": "Data uploaded and inserted successfully"})
    return jsonify({"error": "Invalid file format"}), 400

    

# Маршрут для загрузки JSON-файла
@app.route('/upload_json', methods=['POST'])
def upload_json():
    if 'file' not in request.files:
        return jsonify({"error": "No file part"}), 400
    file = request.files['file']
    if file.filename == '':
        return jsonify({"error": "No selected file"}), 400
    if file and file.filename.endswith('.json'):
        data = json.load(file)
        insert_data_j(data)
        return jsonify({"message": "Data uploaded and inserted successfully"})
    return jsonify({"error": "Invalid file format"}), 400

# Маршрут для отображения формы загрузки JSON
@app.route('/upl_json', methods=['GET'])
def display_form():
    return render_template('upload_json.html')






















# Отправка в НС1 в раб. дни нужно поправить нас групп
@app.route('/add_ns', methods=['GET'])
def handle_in1():
    name = request.args.get('name')
    email = request.args.get('email')
    phone = request.args.get('phone')
    base_url = 'https://api.notisend.ru/v1'
    token = request.args.get('token')
    list_id = request.args.get('list_id')
    phone_id = request.args.get('phone_id')
    name_id = request.args.get('name_id')

    # Проверка наличия всех необходимых параметров
    if not all([name, email, phone, token, list_id, phone_id, name_id]):
        return jsonify({'error': 'Missing required parameters'}), 400

    # Отправляем запросы в три разных места
    response_ns = send_ns(base_url, token, list_id, email, phone, name, phone_id, name_id)

    # Возвращаем список ответов
    return jsonify({'responses': [response_ns]})








@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')


@app.route('/ns_info', methods=['GET'])
def ns_info():
    return render_template('ns_info.html')
    
@app.route('/api/group/<int:group_id>/parameters', methods=['GET'])
def get_group_parameters(group_id):
    api_token = request.args.get('apiToken')

    if not api_token:
        return jsonify({'error': 'API Token is required'}), 400

    url = f'https://api.notisend.ru/v1/email/lists/{group_id}/parameters'
    headers = {
        'Content-Type': 'application/json',
        'Authorization': f'Bearer {api_token}'
    }

    try:
        response = requests.get(url, headers=headers)
        response.raise_for_status()
        data = response.json()
        return jsonify(data)
    except requests.RequestException as e:
        return jsonify({'error': str(e)}), 500





















    

@app.route('/up_page', methods=['POST'])
def upload_page():
    if 'file' not in request.files:
        return "No file part", 400
    file = request.files['file']
    if file.filename == '':
        return "No selected file", 400
    
    filename = request.form.get('filename')
    if not filename:
        return "Filename is required", 400
    
    save_path = os.path.join(HTML_FOLDER, filename + '.html')
    file.save(save_path)
    
    # Возвращаем полный URL загруженного файла с протоколом https
    full_url = request.url_root.replace('http://', 'https://') + filename
    return f"Page uploaded successfully and saved to {full_url}", 200

@app.route('/<path:filename>', methods=['GET'])
def serve_html(filename):
    if not filename.endswith('.html'):
        filename += '.html'
    return send_from_directory(HTML_FOLDER, filename)

@app.route('/up_page', methods=['GET'])
def up_page():
    return render_template('up_page.html')

@app.route('/monitor', methods=['GET'])
def monitor():
    # Получаем информацию о загруженных файлах
    files = os.listdir(UPLOAD_FOLDER)
    html_files = os.listdir(HTML_FOLDER)
    
    # Получаем информацию о дисковом пространстве
    total, used, free = shutil.disk_usage("/")
    
    # Преобразуем байты в гигабайты для удобства чтения
    total_gb = total // (2**30)
    used_gb = used // (2**30)
    free_gb = free // (2**30)
    
    # Получаем информацию об использовании оперативной памяти
    memory = psutil.virtual_memory()
    memory_total_gb = memory.total // (2**30)
    memory_used_gb = memory.used // (2**30)
    memory_free_gb = memory.free // (2**30)
    
    # Получаем информацию о количестве процессоров
    cpu_count = psutil.cpu_count(logical=True)
    
    return render_template('monitor.html', 
                           uploaded_files=files, 
                           uploaded_html_files=html_files, 
                           disk_space={
                               'total': f"{total_gb} GB",
                               'used': f"{used_gb} GB",
                               'free': f"{free_gb} GB"
                           },
                           memory_usage={
                               'total': f"{memory_total_gb} GB",
                               'used': f"{memory_used_gb} GB",
                               'free': f"{memory_free_gb} GB"
                           },
                           cpu_count=cpu_count)

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=int(os.environ.get('PORT', 7860)))