Update app.py

app.py

@@ -1,7 +1,7 @@
 import streamlit as st
 import pandas as pd
 import os
-import sqlite3
+import json
 import random
 import string
 from datetime import datetime, timedelta
@@ -12,205 +12,84 @@ from huggingface_hub import HfApi, hf_hub_download
 
 # --- Настройки Hugging Face ---
 REPO_ID = "Testbase1/testsett"  # Замените на ваш репозиторий
-DB_FILENAME = "auth_system.db"
+DB_FILENAME = "auth_system.json"  # JSON база данных
 HF_TOKEN_WRITE = os.getenv("HF_TOKEN")      # Токен для записи (загрузки)
 HF_TOKEN_READ = os.getenv("HF_TOKEN_READ")    # Токен для чтения (скачивания)
 
-# Глобальные переменные для подключения к базе данных
-conn = None
-c = None
-
-# Глобальный блокировщик для операций с базой данных
+# Глобальный блокировщик для доступа к JSON-файлу
 db_lock = threading.Lock()
 
-def init_db_connection():
-    """Открывает новое соединение с базой данных с увеличенным таймаутом."""
-    global conn, c
-    if conn is not None:
-        conn.close()
-    # Устанавливаем timeout=30 секунд, чтобы операции ожидали освобождения блокировки
-    conn = sqlite3.connect(DB_FILENAME, check_same_thread=False, timeout=30)
-    c = conn.cursor()
-
-# --- Создание таблиц, если они не существуют ---
-def create_tables():
-    with db_lock:
-        c.execute('''
-        CREATE TABLE IF NOT EXISTS users (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            username TEXT NOT NULL UNIQUE,
-            token TEXT NOT NULL
-        )
-        ''')
-        conn.commit()
-
-        c.execute('''
-        CREATE TABLE IF NOT EXISTS products (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            name TEXT NOT NULL,
-            description TEXT,
-            purchase_price REAL NOT NULL,
-            sale_price REAL NOT NULL,
-            quantity_in_stock INTEGER NOT NULL DEFAULT 0,
-            user_id INTEGER NOT NULL,
-            FOREIGN KEY(user_id) REFERENCES users(id)
-        )
-        ''')
-        conn.commit()
-
-        c.execute('''
-        CREATE TABLE IF NOT EXISTS cart (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            product_id INTEGER NOT NULL,
-            quantity INTEGER NOT NULL,
-            UNIQUE(product_id)
-        )
-        ''')
-        conn.commit()
-
-        c.execute('''
-        CREATE TABLE IF NOT EXISTS sales (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            sale_id TEXT NOT NULL,
-            product_id INTEGER NOT NULL,
-            quantity INTEGER NOT NULL,
-            sale_date TIMESTAMP NOT NULL,
-            total_amount REAL NOT NULL,
-            FOREIGN KEY(product_id) REFERENCES products(id)
+# Функция загрузки базы данных из JSON-файла
+def load_db():
+    if not os.path.exists(DB_FILENAME):
+        data = {"users": [], "products": [], "cart": [], "sales": []}
+        save_db(data)
+        return data
+    with open(DB_FILENAME, "r", encoding="utf8") as f:
+        try:
+            data = json.load(f)
+        except json.JSONDecodeError:
+            data = {"users": [], "products": [], "cart": [], "sales": []}
+            save_db(data)
+    return data
+
+# Функция сохранения базы данных в JSON-файл
+def save_db(data):
+    with open(DB_FILENAME, "w", encoding="utf8") as f:
+        json.dump(data, f, ensure_ascii=False, indent=4)
+
+# --- Функция резервного копирования (загрузка базы на Hugging Face) ---
+def upload_db_to_hf():
+    """Загружает JSON-файл базы данных в репозиторий Hugging Face."""
+    try:
+        api = HfApi()
+        api.upload_file(
+            path_or_fileobj=DB_FILENAME,
+            path_in_repo=DB_FILENAME,
+            repo_id=REPO_ID,
+            repo_type="dataset",
+            token=HF_TOKEN_WRITE
         )
-        ''')
-        conn.commit()
+        print("Резервная копия JSON базы успешно загружена на Hugging Face.")
+    except Exception as e:
+        print("Ошибка при загрузке резервной копии:", e)
 
-# --- Функция для скачивания базы данных из Hugging Face ---
+# --- Функция скачивания базы данных из Hugging Face ---
 def download_db_from_hf():
-    """Скачивает файл базы данных из репозитория Hugging Face."""
+    """Скачивает JSON-файл базы данных из репозитория Hugging Face."""
     try:
         hf_hub_download(
             repo_id=REPO_ID,
             filename=DB_FILENAME,
             repo_type="dataset",
             token=HF_TOKEN_READ,
-            local_dir=".",  # теку��ая директория
+            local_dir=".",
             local_dir_use_symlinks=False
         )
-        print("База данных успешно скачана из Hugging Face.")
+        print("JSON база успешно скачана из Hugging Face.")
         return True
     except Exception as e:
-        print("Ошибка при скачивании базы данных:", e)
+        print("Ошибка при скачивании JSON базы:", e)
         return False
 
-# --- Функция для загрузки базы данных в Hugging Face ---
-def upload_db_to_hf():
-    """Загружает файл базы данных в репозиторий Hugging Face."""
-    try:
-        api = HfApi()
-        api.upload_file(
-            path_or_fileobj=DB_FILENAME,
-            path_in_repo=DB_FILENAME,
-            repo_id=REPO_ID,
-            repo_type="dataset",
-            token=HF_TOKEN_WRITE
-        )
-        print("Резервная копия базы данных успешно загружена на Hugging Face.")
-    except Exception as e:
-        print("Ошибка при загрузке резервной копии:", e)
-
 # --- Функция периодического резервного копирования ---
 def periodic_backup():
     """
-    Запускает бесконечный цикл резервного копирования с интервалом в 30 минут.
-    Функция не использует глобальное подключение к БД, поэтому не конфликтует с основными операциями.
+    Каждые 30 минут (1800 секунд) вызывается функция upload_db_to_hf().
     """
     while True:
         upload_db_to_hf()
-        time.sleep(1800)  # 30 минут = 1800 секунд
+        time.sleep(1800)
 
 # --- Вспомогательные функции ---
 def generate_token():
     return ''.join(random.choices(string.ascii_letters + string.digits, k=13))
 
-def get_user_id_by_token(token):
-    c.execute("SELECT id FROM users WHERE token=?", (token,))
-    user = c.fetchone()
-    return user[0] if user else None
-
-def get_cart_summary(user_id):
-    c.execute('''
-    SELECT p.name, c.quantity, p.sale_price, c.quantity * p.sale_price
-    FROM cart c
-    JOIN products p ON c.product_id = p.id
-    WHERE p.user_id = ?
-    ''', (user_id,))
-    items = c.fetchall()
-    total_quantity = sum(item[1] for item in items)
-    total_price = sum(item[3] for item in items)
-    return items, total_quantity, total_price
-
-def record_sales():
-    sales_details = []
-    sale_id = ''.join(random.choices(string.ascii_letters + string.digits, k=8))
-    sale_date = datetime.now(pytz.timezone('Asia/Bishkek')).strftime('%Y-%m-%d %H:%M:%S')
-
-    c.execute('SELECT product_id, quantity FROM cart')
-    cart_items = c.fetchall()
-
-    total_amount = 0.0
-    with db_lock:
-        for product_id, quantity in cart_items:
-            c.execute('SELECT sale_price FROM products WHERE id=?', (product_id,))
-            sale_price = c.fetchone()[0]
-            amount = quantity * sale_price
-            total_amount += amount
-
-            c.execute('''
-            INSERT INTO sales (sale_id, product_id, quantity, sale_date, total_amount)
-            VALUES (?, ?, ?, ?, ?)
-            ''', (sale_id, product_id, quantity, sale_date, amount))
-            sales_details.append((product_id, quantity, amount, sale_date))
-        c.execute('DELETE FROM cart')
-        conn.commit()
-    return sales_details, sale_id, total_amount
-
-def generate_monthly_report(user_id):
-    start_date = (datetime.now().replace(day=1)).strftime('%Y-%m-%d')
-    end_date = (datetime.now() + timedelta(days=31)).replace(day=1).strftime('%Y-%m-%d')
-
-    c.execute('''
-    SELECT p.name, SUM(s.quantity) AS total_quantity, p.sale_price, SUM(s.quantity) * p.sale_price AS total_sales,
-           SUM(s.quantity) * (p.sale_price - p.purchase_price) AS profit
-    FROM sales s
-    JOIN products p ON s.product_id = p.id
-    WHERE s.sale_date BETWEEN ? AND ? AND p.user_id = ?
-    GROUP BY p.id
-    ''', (start_date, end_date, user_id))
-    sales_data = c.fetchall()
-    total_sales = sum(item[3] for item in sales_data)
-    total_profit = sum(item[4] for item in sales_data)
-    return sales_data, total_sales, total_profit
-
-def get_all_sales(user_id):
-    c.execute('''
-    SELECT DISTINCT sale_id, sale_date, SUM(total_amount) AS total_amount
-    FROM sales s
-    JOIN products p ON s.product_id = p.id
-    WHERE p.user_id = ?
-    GROUP BY sale_id, sale_date
-    ORDER BY sale_date DESC
-    ''', (user_id,))
-    sales_data = c.fetchall()
-    return sales_data
-
-def get_sale_details(sale_id):
-    c.execute('''
-    SELECT p.name, s.quantity, p.sale_price, s.sale_date
-    FROM sales s
-    JOIN products p ON s.product_id = p.id
-    WHERE s.sale_id = ?
-    ''', (sale_id,))
-    sale_details = c.fetchall()
-    return sale_details
+def get_new_id(items):
+    return max([item.get("id", 0) for item in items], default=0) + 1
 
 # --- Страницы приложения ---
+
 def register():
     st.title('Регистрация')
     username = st.text_input("Введите ваше имя пользователя")
@@ -219,13 +98,15 @@ def register():
     if st.button("Зарегистрироваться"):
         if admin_password == "morshenfullsumflpol":
             token = generate_token()
-            try:
-                with db_lock:
-                    c.execute("INSERT INTO users (username, token) VALUES (?, ?)", (username, token))
-                    conn.commit()
-                st.success(f"Регистрация успешна! Ваш токен: {token}")
-            except sqlite3.IntegrityError:
-                st.error("Это имя пользователя уже занято. Попробуйте другое.")
+            with db_lock:
+                data = load_db()
+                if any(u["username"] == username for u in data["users"]):
+                    st.error("Это имя пользователя уже занято. Попробуйте другое.")
+                else:
+                    new_id = get_new_id(data["users"])
+                    data["users"].append({"id": new_id, "username": username, "token": token})
+                    save_db(data)
+                    st.success(f"Регистрация успешна! Ваш токен: {token}")
         else:
             st.error("Неверный пароль администратора!")
 
@@ -234,11 +115,13 @@ def login():
     token_input = st.text_input("Введите ваш токен")
 
     if st.button("Войти"):
-        user_id = get_user_id_by_token(token_input)
-        if user_id:
+        with db_lock:
+            data = load_db()
+            user = next((u for u in data["users"] if u["token"] == token_input), None)
+        if user:
             st.session_state.logged_in = True
-            st.session_state.username = token_input
-            st.session_state.user_id = user_id
+            st.session_state.username = user["username"]
+            st.session_state.user_id = user["id"]
             st.success("Добро пожаловать!")
         else:
             st.error("Неверный токен!")
@@ -254,108 +137,136 @@ def add_product():
     if st.button("Добавить товар"):
         if product_name and sale_price:
             with db_lock:
-                c.execute(
-                    "INSERT INTO products (name, description, purchase_price, sale_price, quantity_in_stock, user_id) VALUES (?, ?, ?, ?, ?, ?)",
-                    (product_name, product_description, purchase_price, sale_price, product_quantity, st.session_state.user_id)
-                )
-                conn.commit()
+                data = load_db()
+                new_id = get_new_id(data["products"])
+                data["products"].append({
+                    "id": new_id,
+                    "name": product_name,
+                    "description": product_description,
+                    "purchase_price": purchase_price,
+                    "sale_price": sale_price,
+                    "quantity_in_stock": product_quantity,
+                    "user_id": st.session_state.user_id
+                })
+                save_db(data)
             st.success("Товар успешно добавлен!")
         else:
             st.error("Пожалуйста, введите все обязательные данные.")
 
 def edit_products():
     st.title("Редактирование товара")
-    products = c.execute("SELECT id, name, description, purchase_price, sale_price, quantity_in_stock FROM products WHERE user_id=?",
-                         (st.session_state.user_id,)).fetchall()
+    with db_lock:
+        data = load_db()
+        products = [p for p in data["products"] if p["user_id"] == st.session_state.user_id]
     if products:
-        product_names = [p[1] for p in products]
+        product_names = [p["name"] for p in products]
         selected_product_name = st.selectbox("Выберите товар", product_names)
-        product = next(p for p in products if p[1] == selected_product_name)
+        product = next(p for p in products if p["name"] == selected_product_name)
 
-        new_name = st.text_input("Новое название товара", product[1])
-        new_description = st.text_area("Новое описание товара", product[2])
-        new_purchase_price = st.number_input("Новая приходная цена", min_value=0.0, step=0.01, value=product[3])
-        new_sale_price = st.number_input("Новая отпускная цена", min_value=0.0, step=0.01, value=product[4])
-        new_quantity_in_stock = st.number_input("Новое количество на складе", min_value=0, step=1, value=product[5])
+        new_name = st.text_input("Новое название товара", product["name"])
+        new_description = st.text_area("Новое описание товара", product["description"])
+        new_purchase_price = st.number_input("Новая приходная цена", min_value=0.0, step=0.01, value=product["purchase_price"])
+        new_sale_price = st.number_input("Новая отпускная цена", min_value=0.0, step=0.01, value=product["sale_price"])
+        new_quantity_in_stock = st.number_input("Новое количество на складе", min_value=0, step=1, value=product["quantity_in_stock"])
 
         if st.button("Сохранить изменения"):
             with db_lock:
-                c.execute('''
-                UPDATE products
-                SET name = ?, description = ?, purchase_price = ?, sale_price = ?, quantity_in_stock = ?
-                WHERE id = ?
-                ''', (new_name, new_description, new_purchase_price, new_sale_price, new_quantity_in_stock, product[0]))
-                conn.commit()
+                data = load_db()
+                for p in data["products"]:
+                    if p["id"] == product["id"]:
+                        p["name"] = new_name
+                        p["description"] = new_description
+                        p["purchase_price"] = new_purchase_price
+                        p["sale_price"] = new_sale_price
+                        p["quantity_in_stock"] = new_quantity_in_stock
+                        break
+                save_db(data)
             st.success("Товар успешно обновлен!")
 
         if st.button("Удалить товар"):
             with db_lock:
-                c.execute("DELETE FROM products WHERE id=?", (product[0],))
-                conn.commit()
+                data = load_db()
+                data["products"] = [p for p in data["products"] if p["id"] != product["id"]]
+                save_db(data)
             st.success("Товар успешно удален!")
+    else:
+        st.info("У вас пока нет добавленных товаров.")
 
 def add_to_cart():
     st.title("Отпуск товара")
     search_term = st.text_input("Поиск товара").strip().lower()
-    c.execute("SELECT id, name, sale_price, quantity_in_stock FROM products WHERE user_id=? AND LOWER(name) LIKE ?",
-              (st.session_state.user_id, f"%{search_term}%"))
-    products = c.fetchall()
-
+    with db_lock:
+        data = load_db()
+        products = [p for p in data["products"] if p["user_id"] == st.session_state.user_id and search_term in p["name"].lower()]
     if products:
         for product in products:
             cols = st.columns(4)
             with cols[0]:
-                st.write(product[1])
-                st.write(f"**Отпускная цена**: {product[2]:.2f}")
-                st.write(f"**Остаток на складе**: {product[3]}")
+                st.write(product["name"])
+                st.write(f"**Отпускная цена**: {product['sale_price']:.2f}")
+                st.write(f"**Остаток на складе**: {product['quantity_in_stock']}")
             with cols[1]:
-                quantity = st.number_input(f"Количество для '{product[1]}'", min_value=0, max_value=product[3], key=f"quantity_{product[0]}")
+                quantity = st.number_input(f"Количество для '{product['name']}'", min_value=0, max_value=product["quantity_in_stock"], key=f"quantity_{product['id']}")
             with cols[2]:
-                add_button = st.button(f"Добавить в корзину", key=f"add_{product[0]}")
+                add_button = st.button(f"Добавить в корзину", key=f"add_{product['id']}")
                 if add_button:
-                    if quantity <= product[3]:
+                    if quantity <= product["quantity_in_stock"]:
                         with db_lock:
-                            c.execute('''
-                            INSERT INTO cart (product_id, quantity)
-                            VALUES (?, ?)
-                            ON CONFLICT(product_id)
-                            DO UPDATE SET quantity = quantity + excluded.quantity
-                            ''', (product[0], quantity))
-                            c.execute("UPDATE products SET quantity_in_stock = quantity_in_stock - ? WHERE id=?", (quantity, product[0]))
-                            conn.commit()
-                        st.success(f"Товар '{product[1]}' успешно добавлен в корзину!")
+                            data = load_db()
+                            # Обновляем корзину: если товар уже есть – увеличиваем количество, иначе добавляем новый
+                            cart = data["cart"]
+                            existing = next((item for item in cart if item["product_id"] == product["id"]), None)
+                            if existing:
+                                existing["quantity"] += quantity
+                            else:
+                                new_cart_id = get_new_id(cart)
+                                cart.append({"id": new_cart_id, "product_id": product["id"], "quantity": quantity})
+                            # Уменьшаем остаток товара
+                            for p in data["products"]:
+                                if p["id"] == product["id"]:
+                                    p["quantity_in_stock"] -= quantity
+                                    break
+                            save_db(data)
+                        st.success(f"Товар '{product['name']}' успешно добавлен в корзину!")
                     else:
-                        st.error(f"Недостаточное количество товара '{product[1]}' на складе!")
+                        st.error(f"Недостаточное количество товара '{product['name']}' на складе!")
             with cols[3]:
-                remove_button = st.button(f"Удалить из корзины", key=f"remove_{product[0]}")
+                remove_button = st.button(f"Удалить из корзины", key=f"remove_{product['id']}")
                 if remove_button:
                     if quantity > 0:
-                        current_quantity = c.execute("SELECT quantity FROM cart WHERE product_id=?", (product[0],)).fetchone()
-                        if current_quantity:
-                            new_quantity = current_quantity[0] - quantity
-                            with db_lock:
-                                if new_quantity > 0:
-                                    c.execute('''
-                                    INSERT INTO cart (product_id, quantity)
-                                    VALUES (?, ?)
-                                    ON CONFLICT(product_id)
-                                    DO UPDATE SET quantity = excluded.quantity
-                                    ''', (product[0], new_quantity))
+                        with db_lock:
+                            data = load_db()
+                            cart = data["cart"]
+                            existing = next((item for item in cart if item["product_id"] == product["id"]), None)
+                            if existing:
+                                if existing["quantity"] > quantity:
+                                    existing["quantity"] -= quantity
                                 else:
-                                    c.execute("DELETE FROM cart WHERE product_id=?", (product[0],))
-                                c.execute("UPDATE products SET quantity_in_stock = quantity_in_stock + ? WHERE id=?", (quantity, product[0]))
-                                conn.commit()
-                            st.success(f"Товар '{product[1]}' успешно удалён из корзины!")
-                        else:
-                            st.error(f"Товар '{product[1]}' не найден в корзине.")
+                                    cart.remove(existing)
+                                # Возвращаем товар на склад
+                                for p in data["products"]:
+                                    if p["id"] == product["id"]:
+                                        p["quantity_in_stock"] += quantity
+                                        break
+                                save_db(data)
+                        st.success(f"Товар '{product['name']}' успешно удалён из корзины!")
                     else:
-                        st.error(f"Введите количество для удаления товара '{product[1]}'.")
+                        st.error(f"Введите количество для удаления товара '{product['name']}'.")
 
         st.subheader("Состояние корзины")
-        items, total_quantity, total_price = get_cart_summary(st.session_state.user_id)
-        if items:
-            df = pd.DataFrame(items, columns=["Название", "Количество", "Цена за единицу", "Итого"])
+        with db_lock:
+            data = load_db()
+            cart_items = []
+            for item in data["cart"]:
+                prod = next((p for p in data["products"] if p["id"] == item["product_id"]), None)
+                if prod:
+                    total = item["quantity"] * prod["sale_price"]
+                    cart_items.append([prod["name"], item["quantity"], prod["sale_price"], total])
+        if cart_items:
+            df = pd.DataFrame(cart_items, columns=["Название", "Количество", "Цена за единицу", "Итого"])
             st.dataframe(df.style.format({"Цена за единицу": "{:.2f}", "Итого": "{:.2f}"}), use_container_width=True)
+            total_quantity = sum(item[1] for item in cart_items)
+            total_price = sum(item[3] for item in cart_items)
             st.write(f"Общее количество: {total_quantity}, Общая стоимость: {total_price:.2f}")
 
             if st.button("Пробить"):
@@ -363,49 +274,74 @@ def add_to_cart():
                 if sales_details:
                     st.write("**Детали сделок:**")
                     sale_details_df = pd.DataFrame(sales_details, columns=["ID товара", "Количество", "Сумма", "Дата и время"])
-                    st.dataframe(sale_details_df.style.format({"Сумма": "{:.2f}", "Дата и время": lambda x: pd.to_datetime(x).strftime('%d-%m-%Y %H:%M:%S')}), use_container_width=True)
+                    st.dataframe(sale_details_df.style.format({"Сумма": "{:.2f}", 
+                                                                 "Дата и время": lambda x: pd.to_datetime(x).strftime('%d-%m-%Y %H:%M:%S')}),
+                                 use_container_width=True)
                     st.write(f"**Общая сумма сделки:** {total_amount:.2f}")
                     st.success("Корзина успешно пробита! Все товары добавлены в отчет и корзина очищена.")
-
-            if st.button("Сделки"):
-                sales_data = get_all_sales(st.session_state.user_id)
-                if sales_data:
-                    for sale_id, sale_date, total_amount in sales_data:
-                        st.write(f"**Сделка ID:** {sale_id} ({sale_date}) - **Общая сумма:** {total_amount:.2f}")
-                        sale_details = get_sale_details(sale_id)
-                        if sale_details:
-                            df_sales = pd.DataFrame(sale_details, columns=["Название товара", "Количество", "Цена за единицу", "Дата и время"])
-                            st.dataframe(df_sales.style.format({"Дата и время": lambda x: pd.to_datetime(x).strftime('%d-%m-%Y %H:%M:%S')}), use_container_width=True)
-                        else:
-                            st.info("Нет деталей для отображения.")
-                else:
-                    st.info("Нет сделок для отображения.")
         else:
             st.info("Корзина пуста.")
+    else:
+        st.info("По вашему запросу товары не найдены.")
 
 def monthly_report():
     st.title("Отчет о продажах за месяц")
-    sales_data, total_sales, total_profit = generate_monthly_report(st.session_state.user_id)
-    if sales_data:
-        df = pd.DataFrame(sales_data, columns=["Название", "Общее количество", "Отпускная цена", "Общие продажи", "Прибыль"])
+    with db_lock:
+        data = load_db()
+        start_date = datetime.now().replace(day=1)
+        end_date = (datetime.now() + timedelta(days=31)).replace(day=1)
+        sales = []
+        # Для каждого проданного товара ищем информацию о продукте
+        for sale in data["sales"]:
+            sale_date = datetime.strptime(sale["sale_date"], "%Y-%m-%d %H:%M:%S")
+            if start_date <= sale_date < end_date:
+                prod = next((p for p in data["products"] if p["id"] == sale["product_id"]), None)
+                if prod and prod["user_id"] == st.session_state.user_id:
+                    sales.append({
+                        "name": prod["name"],
+                        "quantity": sale["quantity"],
+                        "sale_price": prod["sale_price"],
+                        "total_sales": sale["total_amount"],
+                        "profit": sale["quantity"] * (prod["sale_price"] - prod["purchase_price"])
+                    })
+        # Группировка по имени товара
+        report = {}
+        for s in sales:
+            key = s["name"]
+            if key not in report:
+                report[key] = {"quantity": 0, "sale_price": s["sale_price"], "total_sales": 0, "profit": 0}
+            report[key]["quantity"] += s["quantity"]
+            report[key]["total_sales"] += s["total_sales"]
+            report[key]["profit"] += s["profit"]
+        report_data = []
+        for name, values in report.items():
+            report_data.append([name, values["quantity"], values["sale_price"], values["total_sales"], values["profit"]])
+        total_sales = sum(item[3] for item in report_data)
+        total_profit = sum(item[4] for item in report_data)
+    if report_data:
+        df = pd.DataFrame(report_data, columns=["Название", "Общее количество", "Отпускная цена", "Общие продажи", "Прибыль"])
         st.write(f"Отчет за {datetime.now().strftime('%B %Y')}")
         st.dataframe(df.style.format({"Отпускная цена": "{:.2f}", "Общие продажи": "{:.2f}", "Прибыль": "{:.2f}"}), use_container_width=True)
         st.write(f"**Общая сумма продаж**: {total_sales:.2f}")
         st.write(f"**Общая сумма прибыли**: {total_profit:.2f}")
 
         if st.button("Сделки"):
-            sales_data = get_all_sales(st.session_state.user_id)
-            if sales_data:
-                for sale_id, sale_date, total_amount in sales_data:
-                    st.write(f"**Сделка ID:** {sale_id} ({sale_date}) - **Общая сумма:** {total_amount:.2f}")
-                    sale_details = get_sale_details(sale_id)
-                    if sale_details:
-                        df_sales = pd.DataFrame(sale_details, columns=["Название товара", "Количество", "Цена за единицу", "Дата и время"])
-                        st.dataframe(df_sales.style.format({"Дата и время": lambda x: pd.to_datetime(x).strftime('%d-%m-%Y %H:%M:%S')}), use_container_width=True)
-                    else:
-                        st.info("Нет деталей для отображения.")
-            else:
-                st.info("Нет сделок для отображения.")
+            with db_lock:
+                data = load_db()
+                sales_grouped = {}
+                for sale in data["sales"]:
+                    prod = next((p for p in data["products"] if p["id"] == sale["product_id"]), None)
+                    if prod and prod["user_id"] == st.session_state.user_id:
+                        key = sale["sale_id"]
+                        if key not in sales_grouped:
+                            sales_grouped[key] = {"sale_date": sale["sale_date"], "total_amount": 0, "details": []}
+                        sales_grouped[key]["total_amount"] += sale["total_amount"]
+                        sales_grouped[key]["details"].append([prod["name"], sale["quantity"], prod["sale_price"], sale["sale_date"]])
+            for key, group in sales_grouped.items():
+                st.write(f"**Сделка ID:** {key} ({group['sale_date']}) - **Общая сумма:** {group['total_amount']:.2f}")
+                df_sales = pd.DataFrame(group["details"], columns=["Название товара", "Количество", "Цена за единицу", "Дата и время"])
+                st.dataframe(df_sales.style.format({"Дата и время": lambda x: pd.to_datetime(x).strftime('%d-%m-%Y %H:%M:%S')}),
+                             use_container_width=True)
     else:
         st.info("Нет данных о продажах за этот месяц.")
 
@@ -414,37 +350,20 @@ def main():
     st.warning("Попытка скачивания базы данных из Hugging Face...")
     download_success = download_db_from_hf()
     if download_success:
-        st.success("База данных успешно скачана из Hugging Face!")
+        st.success("JSON база успешно скачана из Hugging Face!")
         try:
             os.chmod(DB_FILENAME, 0o666)
-            st.info("Права доступа к базе данных изменены (read-write).")
+            st.info("Права доступа к JSON базе изменены (read-write).")
         except Exception as e:
             st.error(f"Не удалось изменить права доступа: {e}")
     else:
         if os.path.exists(DB_FILENAME):
-            st.info("Не удалось скачать базу данных, используется локальная копия.")
+            st.info("Не удалось скачать JSON базу, используется локальная копия.")
         else:
-            st.error("Не удалось скачать базу данных и локальной базы нет. Будет создана новая база данных.")
-            open(DB_FILENAME, 'w').close()  # создаём пустой файл
-
-    # Переинициализируем соединение с базой данных после изменения прав доступа
-    init_db_connection()
-
-    # Проверка наличия таблицы "users". Если отсутствует, создаём таблицы.
-    try:
-        c.execute("SELECT * FROM users LIMIT 1")
-    except sqlite3.OperationalError as e:
-        if "readonly" in str(e).lower():
-            st.error("База данных находится в режиме только для чтения. Проверьте права доступа!")
-        else:
-            st.info("Таблицы не найдены в базе данных. Создание таблиц...")
-            try:
-                os.chmod(DB_FILENAME, 0o666)
-            except Exception as e:
-                st.error(f"Не удалось изменить права доступа: {e}")
-            create_tables()
-            st.success("Таблицы успешно созданы!")
-
+            st.error("Не удалось скачать JSON базу и локальной базы нет. Будет создана новая база.")
+            with open(DB_FILENAME, "w", encoding="utf8") as f:
+                json.dump({"users": [], "products": [], "cart": [], "sales": []}, f, ensure_ascii=False, indent=4)
+                
     if 'logged_in' not in st.session_state:
         st.session_state.logged_in = False
 
@@ -474,7 +393,7 @@ def main():
 
 if __name__ == "__main__":
     main()
-    # Ждем 15 секунд после инициализации базы данных, затем запускаем фоновый поток резервного копирования
+    # Ждем 15 секунд после инициализации, затем запускаем фоновый поток резервного копирования
     time.sleep(15)
     backup_thread = threading.Thread(target=periodic_backup, daemon=True)
     backup_thread.start()