v. 1.1

scripts/exe/mobile_devices.py

@@ -0,0 +1,938 @@
+# main.py
+import sys
+import logging
+from PyQt6.QtWidgets import QApplication
+from PyQt6.QtCore import Qt
+
+# ui/main_window.py
+import sys
+from PyQt6.QtWidgets import (
+    QApplication, QMainWindow, QWidget, QVBoxLayout, QHBoxLayout,
+    QTableWidget, QTableWidgetItem, QPushButton, QTabWidget,
+    QLabel, QLineEdit, QComboBox, QSpinBox, QMessageBox,
+    QDialog, QFormLayout, QDialogButtonBox, QHeaderView,
+    QToolBar, QStatusBar, QGroupBox, QTextEdit, QInputDialog
+)
+from PyQt6.QtCore import Qt, QTimer, pyqtSignal
+from PyQt6.QtGui import QAction, QIcon, QFont
+from typing import Optional, Dict, Any
+import logging
+
+# db/database.py
+import psycopg2
+from psycopg2.extras import RealDictCursor
+from typing import List, Dict, Any, Optional
+import logging
+from contextlib import contextmanager
+
+logger = logging.getLogger(__name__)
+
+CURRENCY_MAP = {
+    'Pakistan': ('PKR', '₨'),
+    'India': ('INR', '₹'),
+    'China': ('CNY', '¥'),
+    'USA': ('USD', '$'),
+    'Dubai': ('AED', 'د.إ')
+}
+
+class Database:
+    """
+    Класс для управления подключением к PostgreSQL и выполнения операций
+    Использует паттерн Singleton для единственного экземпляра подключения
+    """
+    
+    _instance = None
+    
+    def __new__(cls, *args, **kwargs):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+    
+    def __init__(self, host='localhost', port=5432, database='mobile_devices_db', 
+                 user='admin', password='password'):
+        if not hasattr(self, 'initialized'):
+            self.connection_params = {
+                'host': host,
+                'port': port,
+                'database': database,
+                'user': user,
+                'password': password
+            }
+            self.connection = None
+            self.initialized = True
+    
+    def connect(self):
+        """Установка соединения с БД"""
+        try:
+            self.connection = psycopg2.connect(**self.connection_params)
+            logger.info("✅ Подключение к БД установлено")
+            return True
+        except Exception as e:
+            logger.error(f"❌ Ошибка подключения к БД: {e}")
+            return False
+    
+    def disconnect(self):
+        """Закрытие соединения с БД"""
+        if self.connection:
+            self.connection.close()
+            logger.info("🔒 Соединение с БД закрыто")
+    
+    @contextmanager
+    def get_cursor(self, dict_cursor=True):
+        """
+        Контекстный менеджер для безопасной работы с курсором
+        """
+        cursor_factory = RealDictCursor if dict_cursor else None
+        cursor = self.connection.cursor(cursor_factory=cursor_factory)
+        try:
+            yield cursor
+            self.connection.commit()
+        except Exception as e:
+            self.connection.rollback()
+            logger.error(f"❌ Ошибка выполнения запроса: {e}")
+            raise
+        finally:
+            cursor.close()
+    
+    # === CRUD операции для Companies ===
+    
+    def get_all_companies(self) -> List[Dict[str, Any]]:
+        """Получение всех компаний"""
+        with self.get_cursor() as cursor:
+            cursor.execute("""
+                SELECT c.company_id, c.company_name, COUNT(m.model_id) as models_count
+                FROM companies c
+                LEFT JOIN models m ON c.company_id = m.company_id
+                GROUP BY c.company_id, c.company_name
+                ORDER BY c.company_name
+            """)
+            return cursor.fetchall()
+    
+    def add_company(self, company_name: str) -> int:
+        """Добавление новой компании"""
+        with self.get_cursor() as cursor:
+            cursor.execute(
+                "INSERT INTO companies (company_name) VALUES (%s) RETURNING company_id",
+                (company_name,)
+            )
+            return cursor.fetchone()['company_id']
+    
+    def update_company(self, company_id: int, company_name: str):
+        """Обновление названия компании"""
+        with self.get_cursor() as cursor:
+            cursor.execute(
+                "UPDATE companies SET company_name = %s WHERE company_id = %s",
+                (company_name, company_id)
+            )
+    
+    def delete_company(self, company_id: int):
+        """Удаление компании (каскадно удалит все модели)"""
+        with self.get_cursor() as cursor:
+            cursor.execute("DELETE FROM companies WHERE company_id = %s", (company_id,))
+    
+    # === CRUD операции для Models ===
+    
+    def get_all_models(self, company_id: Optional[int] = None) -> List[Dict[str, Any]]:
+        """Получение всех моделей (опционально по компании)"""
+        query = """
+            SELECT 
+                m.model_id, m.model_name, c.company_name, 
+                m.mobile_weight, m.ram, m.front_camera, 
+                m.back_camera, pr.processor_name, m.battery_capacity, 
+                m.screen_size, m.launched_year,
+                COUNT(DISTINCT p.region_id) as price_regions
+            FROM models m
+            JOIN companies c ON m.company_id = c.company_id
+            LEFT JOIN processors pr ON m.processor_id = pr.processor_id
+            LEFT JOIN prices p ON m.model_id = p.model_id
+        """
+        
+        params = []
+        if company_id:
+            query += " WHERE m.company_id = %s"
+            params.append(company_id)
+        
+        query += " GROUP BY m.model_id, c.company_name, pr.processor_name ORDER BY c.company_name, m.model_name"
+        
+        with self.get_cursor() as cursor:
+            cursor.execute(query, params)
+            return cursor.fetchall()
+    
+    def get_model_by_id(self, model_id: int) -> Dict[str, Any]:
+        """Получение модели по ID"""
+        with self.get_cursor() as cursor:
+            cursor.execute("""
+                SELECT m.*, c.company_name, pr.processor_name
+                FROM models m
+                JOIN companies c ON m.company_id = c.company_id
+                LEFT JOIN processors pr ON m.processor_id = pr.processor_id
+                WHERE m.model_id = %s
+            """, (model_id,))
+            return cursor.fetchone()
+    
+    def add_model(self, model_data: Dict[str, Any]) -> int:
+        """Добавление новой модели"""
+        # Сначала получаем или создаем процессор
+        processor_id = None
+        if model_data.get('processor_name'):
+            processor_id = self.get_or_create_processor(model_data['processor_name'])
+        
+        with self.get_cursor() as cursor:
+            cursor.execute("""
+                INSERT INTO models 
+                (model_name, company_id, processor_id, mobile_weight, 
+                 ram, front_camera, back_camera, battery_capacity, 
+                 screen_size, launched_year)
+                VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
+                RETURNING model_id
+            """, (
+                model_data['model_name'],
+                model_data['company_id'],
+                processor_id,
+                model_data.get('mobile_weight'),
+                model_data.get('ram'),
+                model_data.get('front_camera'),
+                model_data.get('back_camera'),
+                model_data.get('battery_capacity'),
+                model_data.get('screen_size'),
+                model_data.get('launched_year')
+            ))
+            return cursor.fetchone()['model_id']
+    
+    def update_model(self, model_id: int, model_data: Dict[str, Any]):
+        """Обновление модели"""
+        # Получаем или создаем процессор
+        processor_id = None
+        if model_data.get('processor_name'):
+            processor_id = self.get_or_create_processor(model_data['processor_name'])
+        
+        with self.get_cursor() as cursor:
+            cursor.execute("""
+                UPDATE models SET
+                    model_name = %s,
+                    company_id = %s,
+                    processor_id = %s,
+                    mobile_weight = %s,
+                    ram = %s,
+                    front_camera = %s,
+                    back_camera = %s,
+                    battery_capacity = %s,
+                    screen_size = %s,
+                    launched_year = %s
+                WHERE model_id = %s
+            """, (
+                model_data['model_name'],
+                model_data['company_id'],
+                processor_id,
+                model_data.get('mobile_weight'),
+                model_data.get('ram'),
+                model_data.get('front_camera'),
+                model_data.get('back_camera'),
+                model_data.get('battery_capacity'),
+                model_data.get('screen_size'),
+                model_data.get('launched_year'),
+                model_id
+            ))
+    
+    def delete_model(self, model_id: int):
+        """Удаление модели"""
+        with self.get_cursor() as cursor:
+            cursor.execute("DELETE FROM models WHERE model_id = %s", (model_id,))
+    
+    # === CRUD операции для Prices ===
+    
+    def get_model_prices(self, model_id: int) -> List[Dict[str, Any]]:
+        """Получение всех цен для модели"""
+        with self.get_cursor() as cursor:
+            cursor.execute("""
+                SELECT p.price_id, p.model_id, p.region_id, 
+                       r.region_name, p.price, p.currency
+                FROM prices p
+                JOIN regions r ON p.region_id = r.region_id
+                WHERE p.model_id = %s
+                ORDER BY r.region_name
+            """, (model_id,))
+            return cursor.fetchall()
+    
+    def add_or_update_price(self, model_id: int, region_id: int, price: float):
+        """Добавление или обновление цены"""
+        with self.get_cursor() as cursor:
+            cursor.execute("""
+                INSERT INTO prices (model_id, region_id, price)
+                VALUES (%s, %s, %s)
+                ON CONFLICT (model_id, region_id) 
+                DO UPDATE SET price = EXCLUDED.price
+            """, (model_id, region_id, price))
+    
+    def delete_price(self, price_id: int):
+        """Удаление цены"""
+        with self.get_cursor() as cursor:
+            cursor.execute("DELETE FROM prices WHERE price_id = %s", (price_id,))
+    
+    # === Вспомогательные методы ===
+    
+    def get_or_create_processor(self, processor_name: str) -> int:
+        """Получение или создание процессора"""
+        with self.get_cursor() as cursor:
+            cursor.execute(
+                "SELECT processor_id FROM processors WHERE processor_name = %s",
+                (processor_name,)
+            )
+            result = cursor.fetchone()
+            
+            if result:
+                return result['processor_id']
+            else:
+                cursor.execute(
+                    "INSERT INTO processors (processor_name) VALUES (%s) RETURNING processor_id",
+                    (processor_name,)
+                )
+                return cursor.fetchone()['processor_id']
+    
+    def get_all_regions(self) -> List[Dict[str, Any]]:
+        """Получение всех регионов"""
+        with self.get_cursor() as cursor:
+            cursor.execute("SELECT * FROM regions ORDER BY region_name")
+            return cursor.fetchall()
+    
+    def get_all_processors(self) -> List[Dict[str, Any]]:
+        """Получение всех процессоров"""
+        with self.get_cursor() as cursor:
+            cursor.execute("SELECT * FROM processors ORDER BY processor_name")
+            return cursor.fetchall()
+    
+    # === Методы для аналитики ===
+    
+    def get_price_statistics(self) -> List[Dict[str, Any]]:
+        """Получение статистики цен по регионам"""
+        with self.get_cursor() as cursor:
+            cursor.execute("""
+                SELECT 
+                    r.region_name,
+                    COUNT(p.price_id) as models_count,
+                    AVG(p.price) as avg_price,
+                    MIN(p.price) as min_price,
+                    MAX(p.price) as max_price
+                FROM prices p
+                JOIN regions r ON p.region_id = r.region_id
+                GROUP BY r.region_name
+                ORDER BY avg_price DESC
+            """)
+            return cursor.fetchall()
+    
+    def search_models(self, search_text: str) -> List[Dict[str, Any]]:
+        """Поиск моделей по тексту"""
+        search_pattern = f"%{search_text}%"
+        with self.get_cursor() as cursor:
+            cursor.execute("""
+                SELECT DISTINCT
+                    m.model_id, m.model_name, c.company_name,
+                    m.ram, m.battery_capacity, m.launched_year
+                FROM models m
+                JOIN companies c ON m.company_id = c.company_id
+                WHERE 
+                    m.model_name ILIKE %s OR
+                    c.company_name ILIKE %s OR
+                    m.ram ILIKE %s OR
+                    m.battery_capacity ILIKE %s
+                ORDER BY c.company_name, m.model_name
+                LIMIT 100
+            """, (search_pattern, search_pattern, search_pattern, search_pattern))
+            return cursor.fetchall()
+
+class ModelDialog(QDialog):
+    """Диалог для добавления/редактирования модели"""
+    
+    def __init__(self, parent=None, model_data=None):
+        super().__init__(parent)
+        self.model_data = model_data
+        self.db = Database()
+        self.init_ui()
+        
+    def init_ui(self):
+        self.setWindowTitle("Добавить модель" if not self.model_data else "Редактировать модель")
+        self.setModal(True)
+        self.setMinimumWidth(500)
+        
+        layout = QFormLayout()
+        
+        # Поля формы
+        self.company_combo = QComboBox()
+        companies = self.db.get_all_companies()
+        for company in companies:
+            self.company_combo.addItem(company['company_name'], company['company_id'])
+        
+        self.model_name_edit = QLineEdit()
+        self.weight_edit = QLineEdit()
+        self.ram_edit = QLineEdit()
+        self.front_camera_edit = QLineEdit()
+        self.back_camera_edit = QLineEdit()
+        self.processor_edit = QLineEdit()
+        self.battery_edit = QLineEdit()
+        self.screen_edit = QLineEdit()
+        self.year_spin = QSpinBox()
+        self.year_spin.setRange(2000, 2030)
+        self.year_spin.setValue(2024)
+        
+        # Добавляем поля в форму
+        layout.addRow("Компания:", self.company_combo)
+        layout.addRow("Название модели:", self.model_name_edit)
+        layout.addRow("Вес:", self.weight_edit)
+        layout.addRow("RAM:", self.ram_edit)
+        layout.addRow("Фронтальная камера:", self.front_camera_edit)
+        layout.addRow("Основная камера:", self.back_camera_edit)
+        layout.addRow("Процессор:", self.processor_edit)
+        layout.addRow("Батарея:", self.battery_edit)
+        layout.addRow("Размер экрана:", self.screen_edit)
+        layout.addRow("Год выпуска:", self.year_spin)
+        
+        # Заполняем данные при редактировании
+        if self.model_data:
+            self.model_name_edit.setText(self.model_data.get('model_name', ''))
+            self.weight_edit.setText(self.model_data.get('mobile_weight', ''))
+            self.ram_edit.setText(self.model_data.get('ram', ''))
+            self.front_camera_edit.setText(self.model_data.get('front_camera', ''))
+            self.back_camera_edit.setText(self.model_data.get('back_camera', ''))
+            self.processor_edit.setText(self.model_data.get('processor_name', ''))
+            self.battery_edit.setText(self.model_data.get('battery_capacity', ''))
+            self.screen_edit.setText(self.model_data.get('screen_size', ''))
+            if self.model_data.get('launched_year'):
+                self.year_spin.setValue(self.model_data['launched_year'])
+            
+            # Устанавливаем компанию
+            for i in range(self.company_combo.count()):
+                if self.company_combo.itemData(i) == self.model_data.get('company_id'):
+                    self.company_combo.setCurrentIndex(i)
+                    break
+        
+        # Кнопки
+        buttons = QDialogButtonBox(
+            QDialogButtonBox.StandardButton.Ok | 
+            QDialogButtonBox.StandardButton.Cancel
+        )
+        buttons.accepted.connect(self.accept)
+        buttons.rejected.connect(self.reject)
+        
+        layout.addRow(buttons)
+        self.setLayout(layout)
+    
+    def get_data(self) -> Dict[str, Any]:
+        """Получение данных из формы"""
+        return {
+            'company_id': self.company_combo.currentData(),
+            'model_name': self.model_name_edit.text(),
+            'mobile_weight': self.weight_edit.text() or None,
+            'ram': self.ram_edit.text() or None,
+            'front_camera': self.front_camera_edit.text() or None,
+            'back_camera': self.back_camera_edit.text() or None,
+            'processor_name': self.processor_edit.text() or None,
+            'battery_capacity': self.battery_edit.text() or None,
+            'screen_size': self.screen_edit.text() or None,
+            'launched_year': self.year_spin.value()
+        }
+
+class PriceDialog(QDialog):
+    """Диалог для управления ценами модели"""
+    
+    def __init__(self, parent=None, model_id=None, model_name=""):
+        super().__init__(parent)
+        self.model_id = model_id
+        self.model_name = model_name
+        self.db = Database()
+        self.init_ui()
+        self.load_prices()
+        
+    def init_ui(self):
+        self.setWindowTitle(f"Цены для: {self.model_name}")
+        self.setModal(True)
+        self.setMinimumSize(600, 400)
+        
+        layout = QVBoxLayout()
+        
+        # Таблица цен
+        self.prices_table = QTableWidget()
+        self.prices_table.setColumnCount(4)
+        self.prices_table.setHorizontalHeaderLabels(["Регион", "Цена", "Валюта", "Действия"])
+        self.prices_table.setSortingEnabled(True)
+        
+        # Настройка размеров столбцов
+        header = self.prices_table.horizontalHeader()
+        header.setSectionResizeMode(0, QHeaderView.ResizeMode.ResizeToContents)
+        header.setSectionResizeMode(1, QHeaderView.ResizeMode.ResizeToContents)
+        header.setSectionResizeMode(2, QHeaderView.ResizeMode.ResizeToContents)
+        header.setSectionResizeMode(3, QHeaderView.ResizeMode.Stretch)
+        
+        layout.addWidget(self.prices_table)
+        
+        # Форма добавления цены
+        add_group = QGroupBox("Добавить/Обновить цену")
+        add_layout = QHBoxLayout()
+        
+        self.region_combo = QComboBox()
+        regions = self.db.get_all_regions()
+        for region in regions:
+            self.region_combo.addItem(region['region_name'], region['region_id'])
+        
+        self.price_edit = QLineEdit()
+        self.price_edit.setPlaceholderText("Цена")
+        
+        add_btn = QPushButton("Добавить/Обновить")
+        add_btn.clicked.connect(self.add_update_price)
+        
+        add_layout.addWidget(QLabel("Регион:"))
+        add_layout.addWidget(self.region_combo)
+        add_layout.addWidget(QLabel("Цена:"))
+        add_layout.addWidget(self.price_edit)
+        add_layout.addWidget(add_btn)
+        
+        add_group.setLayout(add_layout)
+        layout.addWidget(add_group)
+        
+        # Кнопка закрытия
+        close_btn = QPushButton("Закрыть")
+        close_btn.clicked.connect(self.close)
+        layout.addWidget(close_btn)
+        
+        self.setLayout(layout)
+    
+    def format_price(self, price: float, region_name: str) -> str:
+        """Форматирование цены с правильным символом валюты"""
+        currency_code, currency_symbol = CURRENCY_MAP.get(region_name, ('USD', '$'))
+        return f"{currency_symbol}{price:,.2f}"
+    
+    def load_prices(self):
+        """Загрузка цен из БД"""
+        prices = self.db.get_model_prices(self.model_id)
+        self.prices_table.setRowCount(len(prices))
+        
+        for row, price_data in enumerate(prices):
+            # Регион
+            region_item = QTableWidgetItem(price_data['region_name'])
+            region_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
+            self.prices_table.setItem(row, 0, region_item)
+            
+            # Цена с правильной валютой
+            price_str = self.format_price(price_data['price'], price_data['region_name'])
+            price_item = QTableWidgetItem(price_str)
+            price_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
+            self.prices_table.setItem(row, 1, price_item)
+            
+            # Код валюты
+            currency_code, _ = CURRENCY_MAP.get(price_data['region_name'], ('USD', '$'))
+            currency_item = QTableWidgetItem(currency_code)
+            currency_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
+            self.prices_table.setItem(row, 2, currency_item)
+            
+            # Кнопка удаления
+            delete_btn = QPushButton("Удалить")
+            delete_btn.clicked.connect(lambda checked, pid=price_data['price_id']: self.delete_price(pid))
+            self.prices_table.setCellWidget(row, 3, delete_btn)
+    
+    def add_update_price(self):
+        """Добавление или обновление цены"""
+        try:
+            region_id = self.region_combo.currentData()
+            price = float(self.price_edit.text())
+            
+            self.db.add_or_update_price(self.model_id, region_id, price)
+            self.load_prices()
+            self.price_edit.clear()
+            
+            QMessageBox.information(self, "Успех", "Цена успешно обновлена!")
+        except ValueError:
+            QMessageBox.warning(self, "Ошибка", "Введите корректную цену!")
+        except Exception as e:
+            QMessageBox.critical(self, "Ошибка", f"Ошибка при обновлении цены: {str(e)}")
+    
+    def delete_price(self, price_id):
+        """Удаление цены"""
+        reply = QMessageBox.question(
+            self, "Подтверждение",
+            "Вы уверены, что хотите удалить эту цену?",
+            QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No
+        )
+        
+        if reply == QMessageBox.StandardButton.Yes:
+            try:
+                self.db.delete_price(price_id)
+                self.load_prices()
+                QMessageBox.information(self, "Успех", "Цена удалена!")
+            except Exception as e:
+                QMessageBox.critical(self, "Ошибка", f"Ошибка при удалении: {str(e)}")
+
+class MainWindow(QMainWindow):
+    """Главное окно приложения"""
+    
+    def __init__(self):
+        super().__init__()
+        self.db = Database()
+        self.init_ui()
+        self.connect_to_db()
+        
+    def init_ui(self):
+        self.setWindowTitle("Датасет мобильных устройств")
+        self.setGeometry(100, 100, 1200, 600)
+        
+        # Центральный виджет
+        central_widget = QWidget()
+        self.setCentralWidget(central_widget)
+        
+        # Основной layout
+        layout = QVBoxLayout(central_widget)
+        
+        # Создаем панель инструментов
+        self.create_toolbar()
+        
+        # Создаем вкладки
+        self.tabs = QTabWidget()
+        
+        # Вкладка компаний
+        self.companies_tab = self.create_companies_tab()
+        self.tabs.addTab(self.companies_tab, "🏢 Компании")
+        
+        # Вкладка моделей
+        self.models_tab = self.create_models_tab()
+        self.tabs.addTab(self.models_tab, "📱 Модели")
+        
+        # Вкладка аналитики
+        self.analytics_tab = self.create_analytics_tab()
+        self.tabs.addTab(self.analytics_tab, "📊 Аналитика")
+        
+        layout.addWidget(self.tabs)
+        
+        # Статусная строка
+        self.status_bar = QStatusBar()
+        self.setStatusBar(self.status_bar)
+        self.status_bar.showMessage("Готов к работе")
+        
+    def create_toolbar(self):
+        """Создание панели инструментов"""
+        toolbar = QToolBar()
+        self.addToolBar(toolbar)
+        
+        # Действия
+        refresh_action = QAction("🔄 Обновить", self)
+        refresh_action.triggered.connect(self.refresh_data)
+        toolbar.addAction(refresh_action)
+        
+        toolbar.addSeparator()
+        
+        add_company_action = QAction("➕ Добавить компанию", self)
+        add_company_action.triggered.connect(self.add_company)
+        toolbar.addAction(add_company_action)
+        
+        toolbar.addSeparator()
+        
+        add_model_action = QAction("➕ Добавить модель", self)
+        add_model_action.triggered.connect(self.add_model)
+        toolbar.addAction(add_model_action)
+        
+    def create_companies_tab(self) -> QWidget:
+        """Создание вкладки компаний"""
+        widget = QWidget()
+        layout = QVBoxLayout(widget)
+        
+        # Панель управления
+        control_panel = QHBoxLayout()
+        control_panel.addStretch()
+        layout.addLayout(control_panel)
+        
+        # Таблица компаний
+        self.companies_table = QTableWidget()
+        self.companies_table.setColumnCount(3)
+        self.companies_table.setHorizontalHeaderLabels(["ID", "Название компании", "Кол-во моделей"])
+        self.companies_table.setSortingEnabled(True)
+        
+        # Настройка размеров столбцов
+        header = self.companies_table.horizontalHeader()
+        header.setSectionResizeMode(0, QHeaderView.ResizeMode.ResizeToContents)
+        header.setSectionResizeMode(1, QHeaderView.ResizeMode.Stretch)
+        header.setSectionResizeMode(2, QHeaderView.ResizeMode.ResizeToContents)
+        
+        layout.addWidget(self.companies_table)
+        
+        return widget
+    
+    def create_models_tab(self) -> QWidget:
+        """Создание вкладки моделей"""
+        widget = QWidget()
+        layout = QVBoxLayout(widget)
+        
+        # Панель поиска
+        search_panel = QHBoxLayout()
+        
+        self.search_edit = QLineEdit()
+        self.search_edit.setPlaceholderText("🔍 Поиск по названию, компании, RAM...")
+        self.search_edit.textChanged.connect(self.search_models)
+        search_panel.addWidget(self.search_edit)
+        
+        layout.addLayout(search_panel)
+        
+        # Таблица моделей
+        self.models_table = QTableWidget()
+        self.models_table.setColumnCount(11)
+        self.models_table.setHorizontalHeaderLabels([
+            "ID", "Компания", "Модель", "RAM", "Батарея", 
+            "Экран", "Год", "Регионов с ценами", "Действия", "", ""
+        ])
+        self.models_table.setSortingEnabled(True)
+        
+        # Настройка размеров столбцов
+        header = self.models_table.horizontalHeader()
+        # ID - минимальный размер
+        header.setSectionResizeMode(0, QHeaderView.ResizeMode.ResizeToContents)
+        # Компания и Модель - расширяемые
+        header.setSectionResizeMode(1, QHeaderView.ResizeMode.Stretch)
+        header.setSectionResizeMode(2, QHeaderView.ResizeMode.Stretch)
+        # Характеристики - по содержимому
+        for i in range(3, 8):
+            header.setSectionResizeMode(i, QHeaderView.ResizeMode.ResizeToContents)
+        # Кнопки действий - фиксированные
+        for i in range(8, 11):
+            header.setSectionResizeMode(i, QHeaderView.ResizeMode.Fixed)
+            header.resizeSection(i, 120)
+        
+        layout.addWidget(self.models_table)
+        
+        return widget
+    
+    def create_analytics_tab(self) -> QWidget:
+        """Создание вкладки аналитики"""
+        widget = QWidget()
+        layout = QVBoxLayout(widget)
+        
+        # Статистика по регионам
+        stats_group = QGroupBox("📊 Статистика цен по регионам")
+        stats_layout = QVBoxLayout()
+        
+        self.stats_text = QTextEdit()
+        self.stats_text.setReadOnly(True)
+        self.stats_text.setFont(QFont("Consolas", 10))
+        stats_layout.addWidget(self.stats_text)
+        
+        refresh_stats_btn = QPushButton("🔄 Обновить статистику")
+        refresh_stats_btn.clicked.connect(self.update_statistics)
+        stats_layout.addWidget(refresh_stats_btn)
+        
+        stats_group.setLayout(stats_layout)
+        layout.addWidget(stats_group)
+        
+        return widget
+    
+    def connect_to_db(self):
+        """Подключение к БД"""
+        if self.db.connect():
+            self.status_bar.showMessage("✅ Подключено к БД")
+            self.refresh_data()
+        else:
+            QMessageBox.critical(self, "Ошибка", "Не удалось подключиться к БД!")
+    
+    def refresh_data(self):
+        """Обновление всех данных"""
+        self.load_companies()
+        self.load_models()
+        self.update_statistics()
+        self.status_bar.showMessage("✅ Данные обновлены")
+    
+    def load_companies(self):
+        """Загрузка списка компаний"""
+        companies = self.db.get_all_companies()
+        self.companies_table.setRowCount(len(companies))
+        
+        for row, company in enumerate(companies):
+            # ID
+            id_item = QTableWidgetItem(str(company['company_id']))
+            id_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
+            self.companies_table.setItem(row, 0, id_item)
+            
+            # Название
+            name_item = QTableWidgetItem(company['company_name'])
+            name_item.setTextAlignment(Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter)
+            self.companies_table.setItem(row, 1, name_item)
+            
+            # Количество моделей
+            count_item = QTableWidgetItem(str(company['models_count']))
+            count_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
+            self.companies_table.setItem(row, 2, count_item)
+    
+    def load_models(self, search_text=""):
+        """Загрузка списка моделей"""
+        if search_text:
+            models = self.db.search_models(search_text)
+        else:
+            models = self.db.get_all_models()
+        
+        self.models_table.setRowCount(len(models))
+        
+        for row, model in enumerate(models):
+            # ID
+            id_item = QTableWidgetItem(str(model['model_id']))
+            id_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
+            self.models_table.setItem(row, 0, id_item)
+            
+            # Компания
+            company_item = QTableWidgetItem(model['company_name'])
+            company_item.setTextAlignment(Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter)
+            self.models_table.setItem(row, 1, company_item)
+            
+            # Модель
+            model_item = QTableWidgetItem(model['model_name'])
+            model_item.setTextAlignment(Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter)
+            self.models_table.setItem(row, 2, model_item)
+            
+            # RAM
+            ram_item = QTableWidgetItem(model.get('ram', ''))
+            ram_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
+            self.models_table.setItem(row, 3, ram_item)
+            
+            # Батарея
+            battery_item = QTableWidgetItem(model.get('battery_capacity', ''))
+            battery_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
+            self.models_table.setItem(row, 4, battery_item)
+            
+            # Экран
+            screen_item = QTableWidgetItem(model.get('screen_size', ''))
+            screen_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
+            self.models_table.setItem(row, 5, screen_item)
+            
+            # Год
+            year_item = QTableWidgetItem(str(model.get('launched_year', '')))
+            year_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
+            self.models_table.setItem(row, 6, year_item)
+            
+            # Регионов с ценами
+            regions_item = QTableWidgetItem(str(model.get('price_regions', 0)))
+            regions_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
+            self.models_table.setItem(row, 7, regions_item)
+            
+            # Кнопки действий
+            edit_btn = QPushButton("✏️ Редакт.")
+            edit_btn.clicked.connect(lambda checked, mid=model['model_id']: self.edit_model(mid))
+            self.models_table.setCellWidget(row, 8, edit_btn)
+            
+            price_btn = QPushButton("💰 Цены")
+            price_btn.clicked.connect(
+                lambda checked, mid=model['model_id'], name=model['model_name']: 
+                self.manage_prices(mid, name)
+            )
+            self.models_table.setCellWidget(row, 9, price_btn)
+            
+            delete_btn = QPushButton("🗑️ Удалить")
+            delete_btn.clicked.connect(lambda checked, mid=model['model_id']: self.delete_model(mid))
+            self.models_table.setCellWidget(row, 10, delete_btn)
+    
+    def add_company(self):
+        """Добавление новой компании"""
+        name, ok = QInputDialog.getText(self, "Новая компания", "Введите название компании:")
+        if ok and name:
+            try:
+                self.db.add_company(name)
+                self.refresh_data()
+                QMessageBox.information(self, "Успех", f"Компания '{name}' добавлена!")
+            except Exception as e:
+                QMessageBox.critical(self, "Ошибка", f"Ошибка при добавлении: {str(e)}")
+    
+    def add_model(self):
+        """Добавление новой модели"""
+        dialog = ModelDialog(self)
+        if dialog.exec() == QDialog.DialogCode.Accepted:
+            try:
+                model_data = dialog.get_data()
+                self.db.add_model(model_data)
+                self.refresh_data()
+                QMessageBox.information(self, "Успех", "Модель добавлена!")
+            except Exception as e:
+                QMessageBox.critical(self, "Ошибка", f"Ошибка при добавлении: {str(e)}")
+    
+    def edit_model(self, model_id):
+        """Редактирование модели"""
+        model_data = self.db.get_model_by_id(model_id)
+        dialog = ModelDialog(self, model_data)
+        
+        if dialog.exec() == QDialog.DialogCode.Accepted:
+            try:
+                updated_data = dialog.get_data()
+                self.db.update_model(model_id, updated_data)
+                self.refresh_data()
+                QMessageBox.information(self, "Успех", "Модель обновлена!")
+            except Exception as e:
+                QMessageBox.critical(self, "Ошибка", f"Ошибка при обновлении: {str(e)}")
+    
+    def delete_model(self, model_id):
+        """Удаление модели"""
+        reply = QMessageBox.question(
+            self, "Подтверждение",
+            "Вы уверены, что хотите удалить эту модель?",
+            QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No
+        )
+        
+        if reply == QMessageBox.StandardButton.Yes:
+            try:
+                self.db.delete_model(model_id)
+                self.refresh_data()
+                QMessageBox.information(self, "Успех", "Модель удалена!")
+            except Exception as e:
+                QMessageBox.critical(self, "Ошибка", f"Ошибка при удалении: {str(e)}")
+    
+    def manage_prices(self, model_id, model_name):
+        """Управление ценами модели"""
+        dialog = PriceDialog(self, model_id, model_name)
+        dialog.exec()
+        self.refresh_data()
+    
+    def search_models(self, text):
+        """Поиск моделей"""
+        self.load_models(text)
+    
+    def update_statistics(self):
+        """Обновление статистики"""
+        try:
+            stats = self.db.get_price_statistics()
+            
+            stats_text = "📊 СТАТИСТИКА ЦЕН ПО РЕГИОНАМ\n" + "="*60 + "\n\n"
+            
+            for stat in stats:
+                region_name = stat['region_name']
+                currency_code, currency_symbol = CURRENCY_MAP.get(region_name, ('USD', '$'))
+                
+                stats_text += f"🌍 {region_name} ({currency_code}):\n"
+                stats_text += f"   • Моделей с ценами: {stat['models_count']}\n"
+                stats_text += f"   • Средняя цена: {currency_symbol}{stat['avg_price']:,.2f}\n"
+                stats_text += f"   • Минимальная цена: {currency_symbol}{stat['min_price']:,.2f}\n"
+                stats_text += f"   • Максимальная цена: {currency_symbol}{stat['max_price']:,.2f}\n\n"
+            
+            self.stats_text.setText(stats_text)
+        except Exception as e:
+            self.stats_text.setText(f"Ошибка при загрузке статистики: {str(e)}")
+    
+    def closeEvent(self, event):
+        """Обработка закрытия окна"""
+        self.db.disconnect()
+        event.accept()
+
+
+# Настройка логирования
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+
+def main():
+    app = QApplication(sys.argv)
+    
+    # Настройки приложения
+    app.setApplicationName("Mobile Devices Manager")
+    app.setOrganizationName("Moscow Polytech")
+    
+    # Устанавливаем стиль
+    app.setStyle('Fusion')
+    
+    # Создаем и показываем главное окно
+    window = MainWindow()
+    window.show()
+    
+    # Запускаем цикл обработки событий
+    sys.exit(app.exec())
+
+if __name__ == "__main__":
+    main()