pre-deploy commit

scripts/legacy/checkCallbackHandlers.js

@@ -0,0 +1,88 @@
+// Скрипт для анализа и отладки проблем с обработчиками коллбэков
+require('dotenv').config();
+const fs = require('fs');
+const path = require('path');
+
+function analyzeCallbackHandlers() {
+    const filePath = path.join(__dirname, '..', 'src', 'handlers', 'callbackHandlers.ts');
+    const content = fs.readFileSync(filePath, 'utf-8');
+
+    // Проверяем наличие реализаций методов
+    const methodsToCheck = [
+        'handleCreateProfile',
+        'handleGenderSelection',
+        'handleViewMyProfile',
+        'handleEditProfile',
+        'handleManagePhotos',
+        'handleStartBrowsing',
+        'handleSettings'
+    ];
+
+    const issues = [];
+    let debugInfo = [];
+
+    methodsToCheck.forEach(method => {
+        debugInfo.push(`Проверяем метод: ${method}`);
+        
+        // Проверяем наличие полной реализации метода (не только сигнатуры)
+        const methodSignatureRegex = new RegExp(`async\\s+${method}\\s*\\([^)]*\\)\\s*:\\s*Promise<void>\\s*{`, 'g');
+        const hasSignature = methodSignatureRegex.test(content);
+        
+        const methodBodyRegex = new RegExp(`async\\s+${method}\\s*\\([^)]*\\)\\s*:\\s*Promise<void>\\s*{[\\s\\S]+?}`, 'g');
+        const methodMatch = content.match(methodBodyRegex);
+        
+        debugInfo.push(`  Сигнатура найдена: ${hasSignature}`);
+        debugInfo.push(`  Реализация найдена: ${methodMatch !== null}`);
+        
+        if (methodMatch) {
+            const methodContent = methodMatch[0];
+            debugInfo.push(`  Длина метода: ${methodContent.length} символов`);
+            
+            // Проверяем, содержит ли метод только заглушку
+            const isStub = methodContent.includes('// Заглушка метода') || 
+                         (!methodContent.includes('await') && methodContent.split('\n').length <= 3);
+            
+            if (isStub) {
+                issues.push(`❌ Метод ${method} содержит только заглушку, нет реальной реализации`);
+            } else {
+                debugInfo.push(`  Метод ${method} имеет полную реализацию`);
+            }
+        } else if (hasSignature) {
+            issues.push(`❌ Метод ${method} имеет только сигнатуру, но нет реализации`);
+        } else {
+            issues.push(`❌ Метод ${method} не найден в файле`);
+        }
+    });
+
+    // Проверяем регистрацию обработчиков для NotificationHandlers
+    const notificationHandlersRegex = /this\.notificationHandlers\s*=\s*new\s+NotificationHandlers\(bot\);/g;
+    const hasNotificationHandlers = notificationHandlersRegex.test(content);
+    debugInfo.push(`NotificationHandlers инициализирован: ${hasNotificationHandlers}`);
+
+    // Проверяем обработку коллбэка notifications
+    const notificationsCallbackRegex = /if\s*\(data\s*===\s*['"]notifications['"].*?\)/g;
+    const hasNotificationsCallback = notificationsCallbackRegex.test(content);
+    debugInfo.push(`Обработчик для callback 'notifications' найден: ${hasNotificationsCallback}`);
+
+    // Выводим результаты
+    console.log('\n=== Анализ CallbackHandlers.ts ===\n');
+    if (issues.length > 0) {
+        console.log('НАЙДЕНЫ ПРОБЛЕМЫ:');
+        issues.forEach(issue => console.log(issue));
+        console.log('\nРЕКОМЕНДАЦИИ:');
+        console.log('1. Восстановите оригинальные реализации методов вместо заглушек');
+        console.log('2. Убедитесь, что методы содержат необходимую бизнес-логику');
+        console.log('3. Проверьте, что все коллбэки правильно обрабатываются');
+    } else {
+        console.log('✅ Проблем не обнаружено');
+    }
+
+    console.log('\n=== Отладочная информация ===\n');
+    debugInfo.forEach(info => console.log(info));
+
+    // Проверяем количество методов в файле
+    const asyncMethodsCount = (content.match(/async\s+handle[A-Za-z]+\s*\(/g) || []).length;
+    console.log(`\nВсего async методов в файле: ${asyncMethodsCount}`);
+}
+
+analyzeCallbackHandlers();

scripts/legacy/checkDatabase.js

@@ -0,0 +1,66 @@
+const { Pool } = require('pg');
+require('dotenv').config();
+
+const pool = new Pool({
+    host: process.env.DB_HOST,
+    port: parseInt(process.env.DB_PORT || '5432'),
+    database: process.env.DB_NAME,
+    user: process.env.DB_USERNAME,
+    password: process.env.DB_PASSWORD
+});
+
+async function checkDatabase() {
+    const client = await pool.connect();
+    try {
+        console.log('\n===== ПРОВЕРКА СОСТОЯНИЯ БАЗЫ ДАННЫХ =====');
+
+        // Проверка таблицы users
+        const usersResult = await client.query('SELECT COUNT(*) as count FROM users');
+        console.log(`Пользователей в БД: ${usersResult.rows[0].count}`);
+        if (parseInt(usersResult.rows[0].count) > 0) {
+            const users = await client.query('SELECT id, telegram_id, username, first_name FROM users LIMIT 10');
+            console.log('Последние пользователи:');
+            users.rows.forEach(user => {
+                console.log(`  - ID: ${user.id.substring(0, 8)}... | Telegram: ${user.telegram_id} | Имя: ${user.first_name || user.username}`);
+            });
+        }
+
+        // Проверка таблицы profiles
+        const profilesResult = await client.query('SELECT COUNT(*) as count FROM profiles');
+        console.log(`\nПрофилей в БД: ${profilesResult.rows[0].count}`);
+        if (parseInt(profilesResult.rows[0].count) > 0) {
+            const profiles = await client.query(`
+                SELECT p.id, p.user_id, p.name, p.age, p.gender, p.interested_in, p.is_visible
+                FROM profiles p
+                ORDER BY p.created_at DESC
+                LIMIT 10
+            `);
+            console.log('Последние профили:');
+            profiles.rows.forEach(profile => {
+                console.log(`  - ID: ${profile.id.substring(0, 8)}... | UserID: ${profile.user_id.substring(0, 8)}... | Имя: ${profile.name} | Возраст: ${profile.age} | Пол: ${profile.gender} | Интересы: ${profile.interested_in} | Виден: ${profile.is_visible}`);
+            });
+        }
+
+        // Проверка таблицы swipes
+        const swipesResult = await client.query('SELECT COUNT(*) as count FROM swipes');
+        console.log(`\nСвайпов в БД: ${swipesResult.rows[0].count}`);
+
+        // Проверка таблицы profile_views
+        const viewsResult = await client.query('SELECT COUNT(*) as count FROM profile_views');
+        console.log(`Просмотров профилей в БД: ${viewsResult.rows[0].count}`);
+
+        // Проверка таблицы matches
+        const matchesResult = await client.query('SELECT COUNT(*) as count FROM matches');
+        console.log(`Матчей в БД: ${matchesResult.rows[0].count}`);
+
+        console.log('\n===== ПРОВЕРКА ЗАВЕРШЕНА =====\n');
+    } catch (e) {
+        console.error('Ошибка при проверке базы данных:', e);
+    } finally {
+        client.release();
+        await pool.end();
+    }
+}
+
+// Запускаем проверку
+checkDatabase();

scripts/legacy/checkProfileViews.js

@@ -0,0 +1,64 @@
+// Скрипт для проверки таблицы profile_views
+const { Pool } = require('pg');
+require('dotenv').config();
+
+const pool = new Pool({
+    host: process.env.DB_HOST,
+    port: parseInt(process.env.DB_PORT || '5432'),
+    database: process.env.DB_NAME,
+    user: process.env.DB_USERNAME,
+    password: process.env.DB_PASSWORD
+});
+
+async function checkProfileViewsTable() {
+    const client = await pool.connect();
+    try {
+        console.log('Проверка таблицы profile_views...');
+        
+        // Проверяем наличие таблицы
+        const tableCheck = await client.query(`
+            SELECT EXISTS (
+                SELECT FROM information_schema.tables 
+                WHERE table_schema = 'public' 
+                AND table_name = 'profile_views'
+            );
+        `);
+        
+        const tableExists = tableCheck.rows[0].exists;
+        console.log(`Таблица profile_views ${tableExists ? 'существует' : 'не существует'}`);
+        
+        if (tableExists) {
+            // Проверяем количество записей в таблице
+            const countResult = await client.query('SELECT COUNT(*) FROM profile_views');
+            console.log(`Количество записей в таблице: ${countResult.rows[0].count}`);
+            
+            // Получаем данные из таблицы
+            const dataResult = await client.query(`
+                SELECT pv.*, 
+                       v.telegram_id as viewer_telegram_id, 
+                       vp.telegram_id as viewed_telegram_id
+                FROM profile_views pv
+                LEFT JOIN users v ON pv.viewer_id = v.id
+                LEFT JOIN users vp ON pv.viewed_profile_id = vp.id
+                LIMIT 10
+            `);
+            
+            if (dataResult.rows.length > 0) {
+                console.log('Данные из таблицы profile_views:');
+                dataResult.rows.forEach((row, index) => {
+                    console.log(`${index + 1}. Просмотр: ${row.viewer_telegram_id || 'Неизвестно'} → ${row.viewed_telegram_id || 'Неизвестно'}, дата: ${row.view_date}`);
+                });
+            } else {
+                console.log('Таблица profile_views пуста');
+            }
+        }
+    } catch (error) {
+        console.error('Ошибка при проверке таблицы profile_views:', error);
+    } finally {
+        client.release();
+        await pool.end();
+    }
+}
+
+// Запускаем проверку
+checkProfileViewsTable();

scripts/legacy/checkUserTable.js

@@ -0,0 +1,74 @@
+const { Pool } = require('pg');
+require('dotenv').config();
+
+const pool = new Pool({
+  user: process.env.DB_USER || 'postgres',
+  host: process.env.DB_HOST || 'localhost',
+  database: process.env.DB_NAME || 'telegram_tinder_db',
+  password: process.env.DB_PASSWORD || 'postgres',
+  port: parseInt(process.env.DB_PORT || '5432')
+});
+
+async function checkUserTableStructure() {
+  try {
+    // Получаем информацию о структуре таблицы users
+    const result = await pool.query(`
+      SELECT column_name, data_type, is_nullable
+      FROM information_schema.columns
+      WHERE table_name = 'users'
+      ORDER BY ordinal_position;
+    `);
+    
+    console.log('=== Структура таблицы users ===');
+    console.table(result.rows);
+    
+    // Проверяем наличие столбцов state и state_data
+    const stateColumn = result.rows.find(row => row.column_name === 'state');
+    const stateDataColumn = result.rows.find(row => row.column_name === 'state_data');
+    
+    if (!stateColumn) {
+      console.log('❌ Столбец state отсутствует в таблице users');
+    } else {
+      console.log('✅ Столбец state присутствует в таблице users');
+    }
+    
+    if (!stateDataColumn) {
+      console.log('❌ Столбец state_data отсутствует в таблице users');
+    } else {
+      console.log('✅ Столбец state_data присутствует в таблице users');
+    }
+    
+    // Добавляем эти столбцы, если их нет
+    if (!stateColumn || !stateDataColumn) {
+      console.log('🔄 Добавление отсутствующих столбцов...');
+      
+      await pool.query(`
+        ALTER TABLE users 
+        ADD COLUMN IF NOT EXISTS state VARCHAR(255) NULL,
+        ADD COLUMN IF NOT EXISTS state_data JSONB DEFAULT '{}'::jsonb;
+      `);
+      
+      console.log('✅ Столбцы успешно добавлены');
+    }
+    
+    // Проверяем наличие других таблиц, связанных с уведомлениями
+    const tablesResult = await pool.query(`
+      SELECT tablename
+      FROM pg_catalog.pg_tables
+      WHERE schemaname = 'public'
+      AND tablename IN ('notifications', 'notification_settings', 'scheduled_notifications');
+    `);
+    
+    console.log('\n=== Таблицы для уведомлений ===');
+    console.table(tablesResult.rows);
+    
+    // Закрываем соединение
+    await pool.end();
+    
+  } catch (error) {
+    console.error('Ошибка при проверке структуры таблицы:', error);
+    await pool.end();
+  }
+}
+
+checkUserTableStructure();

scripts/legacy/cleanDatabase.js

@@ -0,0 +1,55 @@
+const { Pool } = require('pg');
+require('dotenv').config();
+
+const pool = new Pool({
+    host: process.env.DB_HOST,
+    port: parseInt(process.env.DB_PORT || '5432'),
+    database: process.env.DB_NAME,
+    user: process.env.DB_USERNAME,
+    password: process.env.DB_PASSWORD
+});
+
+async function cleanDatabase() {
+    const client = await pool.connect();
+    try {
+        console.log('Очистка базы данных...');
+        await client.query('BEGIN');
+
+        // Отключаем временно foreign key constraints
+        await client.query('SET CONSTRAINTS ALL DEFERRED');
+
+        // Очищаем таблицы в правильном порядке
+        console.log('Очистка таблицы messages...');
+        await client.query('DELETE FROM messages');
+        
+        console.log('Очистка таблицы profile_views...');
+        await client.query('DELETE FROM profile_views');
+        
+        console.log('Очистка таблицы matches...');
+        await client.query('DELETE FROM matches');
+        
+        console.log('Очистка таблицы swipes...');
+        await client.query('DELETE FROM swipes');
+        
+        console.log('Очистка таблицы profiles...');
+        await client.query('DELETE FROM profiles');
+        
+        console.log('Очистка таблицы users...');
+        await client.query('DELETE FROM users');
+
+        // Возвращаем foreign key constraints
+        await client.query('SET CONSTRAINTS ALL IMMEDIATE');
+
+        await client.query('COMMIT');
+        console.log('✅ База данных успешно очищена');
+    } catch (e) {
+        await client.query('ROLLBACK');
+        console.error('❌ Ошибка при очистке базы данных:', e);
+    } finally {
+        client.release();
+        await pool.end();
+    }
+}
+
+// Запускаем функцию очистки
+cleanDatabase();

scripts/legacy/clearDatabase.js

@@ -0,0 +1,66 @@
+// Скрипт для очистки всех таблиц в базе данных
+import { Pool } from 'pg';
+import dotenv from 'dotenv';
+
+// Загружаем переменные окружения из .env файла
+dotenv.config();
+
+const pool = new Pool({
+    host: process.env.DB_HOST,
+    port: parseInt(process.env.DB_PORT || '5432'),
+    database: process.env.DB_NAME,
+    user: process.env.DB_USERNAME,
+    password: process.env.DB_PASSWORD
+});
+
+async function clearDatabase() {
+    const client = await pool.connect();
+    try {
+        console.log('Начинаем очистку базы данных...');
+
+        // Начинаем транзакцию
+        await client.query('BEGIN');
+
+        // Отключаем внешние ключи на время выполнения (если они используются)
+        // await client.query('SET session_replication_role = \'replica\'');
+
+        // Очистка таблиц в порядке, учитывающем зависимости
+        console.log('Очистка таблицы сообщений...');
+        await client.query('TRUNCATE TABLE messages CASCADE');
+
+        console.log('Очистка таблицы просмотров профилей...');
+        await client.query('TRUNCATE TABLE profile_views CASCADE');
+
+        console.log('Очистка таблицы свайпов...');
+        await client.query('TRUNCATE TABLE swipes CASCADE');
+
+        console.log('Очистка таблицы матчей...');
+        await client.query('TRUNCATE TABLE matches CASCADE');
+
+        console.log('Очистка таблицы профилей...');
+        await client.query('TRUNCATE TABLE profiles CASCADE');
+
+        console.log('Очистка таблицы пользователей...');
+        await client.query('TRUNCATE TABLE users CASCADE');
+
+        // Возвращаем внешние ключи (если они использовались)
+        // await client.query('SET session_replication_role = \'origin\'');
+
+        // Фиксируем транзакцию
+        await client.query('COMMIT');
+        
+        console.log('Все таблицы успешно очищены!');
+    } catch (error) {
+        // В случае ошибки откатываем транзакцию
+        await client.query('ROLLBACK');
+        console.error('Произошла ошибка при очистке базы данных:', error);
+    } finally {
+        // Освобождаем клиента
+        client.release();
+        // Закрываем пул соединений
+        await pool.end();
+    }
+}
+
+// Запускаем функцию очистки
+clearDatabase();

scripts/legacy/clearDatabase.mjs

@@ -0,0 +1,81 @@
+// Скрипт для очистки всех таблиц в базе данных
+import { Pool } from 'pg';
+import dotenv from 'dotenv';
+
+// Загружаем переменные окружения из .env файла
+dotenv.config();
+
+const pool = new Pool({
+    host: process.env.DB_HOST,
+    port: parseInt(process.env.DB_PORT || '5432'),
+    database: process.env.DB_NAME,
+    user: process.env.DB_USERNAME,
+    password: process.env.DB_PASSWORD
+});
+
+async function clearDatabase() {
+    const client = await pool.connect();
+    try {
+        console.log('Начинаем очистку базы данных...');
+
+        // Начинаем транзакцию
+        await client.query('BEGIN');
+
+        // Получаем список существующих таблиц
+        const tablesResult = await client.query(`
+            SELECT table_name 
+            FROM information_schema.tables 
+            WHERE table_schema = 'public' 
+            AND table_type = 'BASE TABLE'
+        `);
+        
+        const tables = tablesResult.rows.map(row => row.table_name);
+        console.log('Найдены таблицы:', tables.join(', '));
+
+        // Очистка таблиц в порядке, учитывающем зависимости
+        if (tables.includes('messages')) {
+            console.log('Очистка таблицы messages...');
+            await client.query('TRUNCATE TABLE messages CASCADE');
+        }
+
+        if (tables.includes('swipes')) {
+            console.log('Очистка таблицы swipes...');
+            await client.query('TRUNCATE TABLE swipes CASCADE');
+        }
+
+        if (tables.includes('matches')) {
+            console.log('Очистка таблицы matches...');
+            await client.query('TRUNCATE TABLE matches CASCADE');
+        }
+
+        if (tables.includes('profiles')) {
+            console.log('Очистка таблицы profiles...');
+            await client.query('TRUNCATE TABLE profiles CASCADE');
+        }
+
+        if (tables.includes('users')) {
+            console.log('Очистка таблицы users...');
+            await client.query('TRUNCATE TABLE users CASCADE');
+        }
+
+        // Возвращаем внешние ключи (если они использовались)
+        // await client.query('SET session_replication_role = \'origin\'');
+
+        // Фиксируем транзакцию
+        await client.query('COMMIT');
+        
+        console.log('Все таблицы успешно очищены!');
+    } catch (error) {
+        // В случае ошибки откатываем транзакцию
+        await client.query('ROLLBACK');
+        console.error('Произошла ошибка при очистке базы данных:', error);
+    } finally {
+        // Освобождаем клиента
+        client.release();
+        // Закрываем пул соединений
+        await pool.end();
+    }
+}
+
+// Запускаем функцию очистки
+clearDatabase();

scripts/legacy/clear_database.sql

@@ -0,0 +1,26 @@
+-- Скрипт для очистки всех таблиц в базе данных
+-- Важно: таблицы очищаются в порядке, учитывающем зависимости между ними
+
+-- Отключаем внешние ключи на время выполнения (если они используются)
+-- SET session_replication_role = 'replica';
+
+-- Очистка таблицы сообщений
+TRUNCATE TABLE messages CASCADE;
+
+-- Очистка таблицы просмотров профилей
+TRUNCATE TABLE profile_views CASCADE;
+
+-- Очистка таблицы свайпов
+TRUNCATE TABLE swipes CASCADE;
+
+-- Очистка таблицы матчей
+TRUNCATE TABLE matches CASCADE;
+
+-- Очистка таблицы профилей
+TRUNCATE TABLE profiles CASCADE;
+
+-- Очистка таблицы пользователей
+TRUNCATE TABLE users CASCADE;
+
+-- Возвращаем внешние ключи (если они использовались)
+-- SET session_replication_role = 'origin';

scripts/legacy/createProfileViewsTable.ts

@@ -0,0 +1,70 @@
+// Скрипт для создания таблицы profile_views
+
+// Функция для ручного запуска создания таблицы profile_views
+async function createProfileViewsTable() {
+    const client = await require('../database/connection').pool.connect();
+    try {
+        console.log('Создание таблицы profile_views...');
+
+        // Проверяем, существует ли уже таблица profile_views
+        const tableCheck = await client.query(`
+            SELECT EXISTS (
+                SELECT FROM information_schema.tables 
+                WHERE table_schema = 'public' 
+                AND table_name = 'profile_views'
+            );
+        `);
+
+        if (tableCheck.rows[0].exists) {
+            console.log('Таблица profile_views уже существует, пропускаем создание');
+            return;
+        }
+
+        // Начинаем транзакцию
+        await client.query('BEGIN');
+
+        // Создаем таблицу profile_views
+        await client.query(`
+            CREATE TABLE profile_views (
+                id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+                viewer_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+                viewed_profile_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+                view_date TIMESTAMP NOT NULL DEFAULT NOW(),
+                view_type VARCHAR(20) NOT NULL DEFAULT 'browse'
+            );
+        `);
+
+        // Создаем индекс для быстрого поиска по паре (просмотревший - просмотренный)
+        await client.query(`
+            CREATE UNIQUE INDEX profile_views_viewer_viewed_idx ON profile_views (viewer_id, viewed_profile_id);
+        `);
+
+        // Индекс для быстрого поиска по viewer_id
+        await client.query(`
+            CREATE INDEX profile_views_viewer_idx ON profile_views (viewer_id);
+        `);
+
+        // Индекс для быстрого поиска по viewed_profile_id
+        await client.query(`
+            CREATE INDEX profile_views_viewed_idx ON profile_views (viewed_profile_id);
+        `);
+
+        // Фиксируем транзакцию
+        await client.query('COMMIT');
+        
+        console.log('Таблица profile_views успешно создана!');
+    } catch (error) {
+        // В случае ошибки откатываем транзакцию
+        await client.query('ROLLBACK');
+        console.error('Произошла ошибка при создании таблицы profile_views:', error);
+    } finally {
+        // Освобождаем клиента
+        client.release();
+    }
+}
+
+// Запускаем функцию создания таблицы
+createProfileViewsTable()
+    .then(() => console.log('Скрипт выполнен'))
+    .catch(err => console.error('Ошибка выполнения скрипта:', err))
+    .finally(() => process.exit());

scripts/legacy/fixCallbackHandlers.js

@@ -0,0 +1,142 @@
+// Скрипт для восстановления оригинальной функциональности callbackHandlers.ts
+const fs = require('fs');
+const path = require('path');
+
+// Находим самую последнюю версию файла callbackHandlers.ts в репозитории
+const { execSync } = require('child_process');
+
+try {
+    console.log('Поиск оригинальной версии CallbackHandlers.ts с полной функциональностью...');
+    
+    // Находим коммиты, содержащие значительные изменения в файле (более 1000 символов)
+    const commits = execSync('git log --format="%H" -- src/handlers/callbackHandlers.ts')
+        .toString()
+        .trim()
+        .split('\n');
+    
+    console.log(`Найдено ${commits.length} коммитов с изменениями файла`);
+    
+    // Пробуем разные коммиты, начиная с последнего, чтобы найти полную реализацию
+    let foundFullImplementation = false;
+    let fullImplementationContent = '';
+    
+    for (const commit of commits) {
+        console.log(`Проверяем коммит ${commit.substring(0, 8)}...`);
+        
+        try {
+            const fileContent = execSync(`git show ${commit}:src/handlers/callbackHandlers.ts`).toString();
+            
+            // Проверяем, содержит ли файл полные реализации методов
+            const hasFullImplementations = !fileContent.includes('// Заглушка метода') && 
+                                         fileContent.includes('await this.bot.sendMessage');
+            
+            if (hasFullImplementations) {
+                console.log(`✅ Найдена полная реализация в коммите ${commit.substring(0, 8)}`);
+                fullImplementationContent = fileContent;
+                foundFullImplementation = true;
+                break;
+            } else {
+                console.log(`❌ Коммит ${commit.substring(0, 8)} не содержит полной реализации`);
+            }
+        } catch (error) {
+            console.error(`Ошибка при проверке коммита ${commit}:`, error.message);
+        }
+    }
+    
+    if (!foundFullImplementation) {
+        console.error('❌ Не удалось найти полную реализацию в истории коммитов');
+        process.exit(1);
+    }
+    
+    // Теперь получаем текущую версию файла с поддержкой уведомлений
+    console.log('Получаем текущую версию с поддержкой уведомлений...');
+    const currentFilePath = path.join(__dirname, '..', 'src', 'handlers', 'callbackHandlers.ts');
+    const currentContent = fs.readFileSync(currentFilePath, 'utf-8');
+    
+    // Сначала создаем бэкап текущего файла
+    const backupPath = currentFilePath + '.backup-' + Date.now();
+    fs.writeFileSync(backupPath, currentContent);
+    console.log(`✅ Создан бэкап текущей версии: ${path.basename(backupPath)}`);
+    
+    // Извлекаем код для поддержки уведомлений из текущей версии
+    console.log('Извлекаем код для поддержки уведомлений...');
+    
+    // Находим импорт NotificationHandlers
+    const notificationImportRegex = /import\s+{\s*NotificationHandlers\s*}\s*from\s*['"]\.\/notificationHandlers['"]\s*;/;
+    const notificationImport = currentContent.match(notificationImportRegex)?.[0] || '';
+    
+    // Находим объявление поля notificationHandlers
+    const notificationFieldRegex = /private\s+notificationHandlers\?\s*:\s*NotificationHandlers\s*;/;
+    const notificationField = currentContent.match(notificationFieldRegex)?.[0] || '';
+    
+    // Находим инициализацию notificationHandlers в конструкторе
+    const notificationInitRegex = /\/\/\s*Создаем экземпляр NotificationHandlers[\s\S]*?try\s*{[\s\S]*?this\.notificationHandlers\s*=\s*new\s*NotificationHandlers[\s\S]*?}\s*catch[\s\S]*?}/;
+    const notificationInit = currentContent.match(notificationInitRegex)?.[0] || '';
+    
+    // Находим метод handleNotificationSettings
+    const notificationSettingsMethodRegex = /async\s+handleNotificationSettings[\s\S]*?}\s*}/;
+    const notificationSettingsMethod = currentContent.match(notificationSettingsMethodRegex)?.[0] || '';
+    
+    // Находим обработку callback для notifications в handleCallback
+    const notificationCallbackRegex = /\/\/\s*Настройки уведомлений[\s\S]*?else\s+if\s*\(data\s*===\s*['"]notifications['"][\s\S]*?}\s*}/;
+    const notificationCallback = currentContent.match(notificationCallbackRegex)?.[0] || '';
+    
+    // Получаем часть обработки коллбэков для уведомлений
+    const notificationToggleRegex = /\/\/\s*Обработка переключения настроек уведомлений[\s\S]*?else\s+if[\s\S]*?notif_[\s\S]*?}\s*}/;
+    const notificationToggle = currentContent.match(notificationToggleRegex)?.[0] || '';
+    
+    console.log(`✅ Извлечены блоки кода для уведомлений`);
+    
+    // Интегрируем код уведомлений в оригинальную версию
+    console.log('Интегрируем код уведомлений в оригинальную версию...');
+    
+    // 1. Добавляем импорт
+    let newContent = fullImplementationContent;
+    if (notificationImport) {
+        newContent = newContent.replace(/import\s*{[^}]*}\s*from\s*['"]\.\/messageHandlers['"]\s*;/, 
+            match => match + '\n' + notificationImport);
+    }
+    
+    // 2. Добавляем объявление поля
+    if (notificationField) {
+        newContent = newContent.replace(/private\s+translationController\s*:\s*TranslationController\s*;/, 
+            match => match + '\n    ' + notificationField);
+    }
+    
+    // 3. Добавляем инициализацию в конструкторе
+    if (notificationInit) {
+        newContent = newContent.replace(/this\.translationController\s*=\s*new\s*TranslationController\(\);/, 
+            match => match + '\n        ' + notificationInit);
+    }
+    
+    // 4. Добавляем обработку коллбэков для уведомлений
+    if (notificationCallback) {
+        newContent = newContent.replace(/else\s+{\s*await\s+this\.bot\.answerCallbackQuery\(query\.id[\s\S]*?return;/, 
+            match => notificationCallback + '\n            ' + match);
+    }
+    
+    // 5. Добавляем обработку переключения настроек уведомлений
+    if (notificationToggle) {
+        newContent = newContent.replace(/else\s+{\s*await\s+this\.bot\.answerCallbackQuery\(query\.id[\s\S]*?return;/, 
+            match => notificationToggle + '\n            ' + match);
+    }
+    
+    // 6. Добавляем метод handleNotificationSettings в конец класса
+    if (notificationSettingsMethod) {
+        newContent = newContent.replace(/}(\s*)$/, notificationSettingsMethod + '\n}$1');
+    }
+    
+    // Сохраняем обновленный файл
+    const outputPath = currentFilePath + '.fixed';
+    fs.writeFileSync(outputPath, newContent);
+    console.log(`✅ Создана исправленная версия файла: ${path.basename(outputPath)}`);
+    
+    console.log('\nИнструкция по восстановлению:');
+    console.log(`1. Проверьте файл ${path.basename(outputPath)}`);
+    console.log('2. Если все выглядит правильно, выполните команду:');
+    console.log(`   Move-Item -Force "${path.basename(outputPath)}" "${path.basename(currentFilePath)}"`);
+    console.log('3. Перезапустите бота');
+    
+} catch (error) {
+    console.error('Произошла ошибка:', error);
+}

scripts/legacy/fixDatabaseStructure.js

@@ -0,0 +1,170 @@
+// Скрипт для исправления проблемы с ботом
+require('dotenv').config();
+const { Pool } = require('pg');
+
+// Получаем данные подключения из .env
+console.log('Параметры подключения к БД:');
+console.log('DB_USERNAME:', process.env.DB_USERNAME);
+console.log('DB_HOST:', process.env.DB_HOST);
+console.log('DB_NAME:', process.env.DB_NAME);
+console.log('DB_PASSWORD:', process.env.DB_PASSWORD ? '[указан]' : '[не указан]');
+console.log('DB_PORT:', process.env.DB_PORT);
+
+// Создаем пул соединений
+const pool = new Pool({
+  user: process.env.DB_USERNAME,
+  host: process.env.DB_HOST,
+  database: process.env.DB_NAME,
+  password: process.env.DB_PASSWORD,
+  port: parseInt(process.env.DB_PORT || '5432')
+});
+
+async function fixDatabase() {
+  try {
+    console.log('Начинаем исправление базы данных...');
+    
+    // Проверяем существование таблицы users
+    const tableResult = await pool.query(`
+      SELECT EXISTS (
+        SELECT FROM information_schema.tables 
+        WHERE table_schema = 'public' 
+        AND table_name = 'users'
+      );
+    `);
+    
+    if (!tableResult.rows[0].exists) {
+      console.error('Таблица users не найдена!');
+      return;
+    }
+    
+    console.log('✅ Таблица users существует');
+    
+    // Проверяем и добавляем столбцы state и state_data, если они отсутствуют
+    console.log('Проверяем наличие столбцов state и state_data...');
+    
+    const stateColumnResult = await pool.query(`
+      SELECT EXISTS (
+        SELECT FROM information_schema.columns 
+        WHERE table_schema = 'public' 
+        AND table_name = 'users' 
+        AND column_name = 'state'
+      );
+    `);
+    
+    const stateDataColumnResult = await pool.query(`
+      SELECT EXISTS (
+        SELECT FROM information_schema.columns 
+        WHERE table_schema = 'public' 
+        AND table_name = 'users' 
+        AND column_name = 'state_data'
+      );
+    `);
+    
+    if (!stateColumnResult.rows[0].exists) {
+      console.log('🔄 Добавляем столбец state...');
+      await pool.query(`ALTER TABLE users ADD COLUMN state VARCHAR(255) NULL;`);
+      console.log('✅ Столбец state успешно добавлен');
+    } else {
+      console.log('✅ Столбец state уже существует');
+    }
+    
+    if (!stateDataColumnResult.rows[0].exists) {
+      console.log('🔄 Добавляем столбец state_data...');
+      await pool.query(`ALTER TABLE users ADD COLUMN state_data JSONB DEFAULT '{}'::jsonb;`);
+      console.log('✅ Столбец state_data успешно добавлен');
+    } else {
+      console.log('✅ Столбец state_data уже существует');
+    }
+    
+    // Проверка наличия таблиц для уведомлений
+    console.log('Проверяем наличие таблиц для уведомлений...');
+    
+    const tablesCheck = await Promise.all([
+      checkTableExists('notifications'),
+      checkTableExists('notification_settings'),
+      checkTableExists('scheduled_notifications')
+    ]);
+    
+    // Создаем отсутствующие таблицы
+    if (!tablesCheck[0]) {
+      console.log('🔄 Создаем таблицу notifications...');
+      await pool.query(`
+        CREATE TABLE notifications (
+          id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+          user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+          type VARCHAR(50) NOT NULL,
+          content JSONB NOT NULL DEFAULT '{}',
+          is_read BOOLEAN DEFAULT false,
+          created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+        );
+        CREATE INDEX idx_notifications_user_id ON notifications(user_id);
+        CREATE INDEX idx_notifications_type ON notifications(type);
+        CREATE INDEX idx_notifications_created_at ON notifications(created_at);
+      `);
+      console.log('✅ Таблица notifications успешно создана');
+    }
+    
+    if (!tablesCheck[1]) {
+      console.log('🔄 Создаем таблицу notification_settings...');
+      await pool.query(`
+        CREATE TABLE notification_settings (
+          user_id UUID PRIMARY KEY REFERENCES users(id) ON DELETE CASCADE,
+          new_matches BOOLEAN DEFAULT true,
+          new_messages BOOLEAN DEFAULT true,
+          new_likes BOOLEAN DEFAULT true,
+          reminders BOOLEAN DEFAULT true,
+          daily_summary BOOLEAN DEFAULT false,
+          time_preference VARCHAR(20) DEFAULT 'evening',
+          do_not_disturb BOOLEAN DEFAULT false,
+          do_not_disturb_start TIME,
+          do_not_disturb_end TIME,
+          updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+        );
+      `);
+      console.log('✅ Таблица notification_settings успешно создана');
+    }
+    
+    if (!tablesCheck[2]) {
+      console.log('🔄 Создаем таблицу scheduled_notifications...');
+      await pool.query(`
+        CREATE TABLE scheduled_notifications (
+          id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+          user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+          type VARCHAR(50) NOT NULL,
+          content JSONB NOT NULL DEFAULT '{}',
+          scheduled_at TIMESTAMP WITH TIME ZONE NOT NULL,
+          processed BOOLEAN DEFAULT false,
+          created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+        );
+        CREATE INDEX idx_scheduled_notifications_user_id ON scheduled_notifications(user_id);
+        CREATE INDEX idx_scheduled_notifications_scheduled_at ON scheduled_notifications(scheduled_at);
+        CREATE INDEX idx_scheduled_notifications_processed ON scheduled_notifications(processed);
+      `);
+      console.log('✅ Таблица scheduled_notifications успешно создана');
+    }
+    
+    console.log('✅ Исправление базы данных завершено успешно');
+    
+  } catch (error) {
+    console.error('Ошибка при исправлении базы данных:', error);
+  } finally {
+    await pool.end();
+  }
+}
+
+async function checkTableExists(tableName) {
+  const result = await pool.query(`
+    SELECT EXISTS (
+      SELECT FROM information_schema.tables 
+      WHERE table_schema = 'public' 
+      AND table_name = $1
+    );
+  `, [tableName]);
+  
+  const exists = result.rows[0].exists;
+  console.log(`${exists ? '✅' : '❌'} Таблица ${tableName} ${exists ? 'существует' : 'отсутствует'}`);
+  
+  return exists;
+}
+
+fixDatabase();

scripts/legacy/fix_all_notifications.js

@@ -0,0 +1,48 @@
+/**
+ * Комплексный скрипт для исправления всех проблем с уведомлениями
+ * Запускает последовательно оба скрипта исправления
+ */
+
+const { exec } = require('child_process');
+const path = require('path');
+
+console.log('🔧 Запуск комплексного исправления проблем с уведомлениями...');
+
+// Путь к скриптам
+const fixNotificationCallbacksScript = path.join(__dirname, 'fix_notification_callbacks.js');
+const updateBotWithNotificationsScript = path.join(__dirname, 'update_bot_with_notifications.js');
+
+// Запуск первого скрипта для исправления таблиц и колонок
+console.log('\n📊 Шаг 1/2: Проверка и исправление таблиц базы данных...');
+exec(`node ${fixNotificationCallbacksScript}`, (error, stdout, stderr) => {
+  if (error) {
+    console.error(`❌ Ошибка при запуске скрипта исправления таблиц: ${error}`);
+    return;
+  }
+  
+  console.log(stdout);
+  
+  if (stderr) {
+    console.error(`❌ Ошибки при выполнении скрипта: ${stderr}`);
+  }
+  
+  // Запуск второго скрипта для обновления bot.ts
+  console.log('\n📝 Шаг 2/2: Обновление файла bot.ts для регистрации обработчиков уведомлений...');
+  exec(`node ${updateBotWithNotificationsScript}`, (error2, stdout2, stderr2) => {
+    if (error2) {
+      console.error(`❌ Ошибка при запуске скрипта обновления bot.ts: ${error2}`);
+      return;
+    }
+    
+    console.log(stdout2);
+    
+    if (stderr2) {
+      console.error(`❌ Ошибки при выполнении скрипта: ${stderr2}`);
+    }
+    
+    console.log('\n✅ Все исправления успешно выполнены!');
+    console.log('🔄 Пожалуйста, перезапустите бота для применения изменений:');
+    console.log('   npm run start');
+    console.log('\n💡 Уведомления должны теперь работать корректно!');
+  });
+});

scripts/legacy/fix_notification_callbacks.js

@@ -0,0 +1,332 @@
+/**
+ * Скрипт для проверки и исправления проблем с обработчиками уведомлений в боте
+ */
+
+const { Client } = require('pg');
+const fs = require('fs');
+
+// Конфигурация базы данных
+const dbConfig = {
+  host: 'localhost',
+  port: 5432,
+  database: 'telegram_tinder',
+  user: 'postgres',
+  password: 'postgres'
+};
+
+// Подключение к базе данных
+const client = new Client(dbConfig);
+
+async function main() {
+  try {
+    console.log('Подключение к базе данных...');
+    await client.connect();
+    console.log('Успешно подключено к базе данных');
+
+    // Шаг 1: Проверка существования необходимых таблиц для уведомлений
+    console.log('\n=== Проверка таблиц для уведомлений ===');
+    
+    // Проверяем таблицу notifications
+    let notificationsTableExists = await checkTableExists('notifications');
+    if (!notificationsTableExists) {
+      console.log('Таблица notifications не найдена. Создаем...');
+      await createNotificationsTable();
+      console.log('Таблица notifications успешно создана');
+    } else {
+      console.log('Таблица notifications уже существует');
+    }
+    
+    // Проверяем таблицу scheduled_notifications
+    let scheduledNotificationsTableExists = await checkTableExists('scheduled_notifications');
+    if (!scheduledNotificationsTableExists) {
+      console.log('Таблица scheduled_notifications не найдена. Создаем...');
+      await createScheduledNotificationsTable();
+      console.log('Таблица scheduled_notifications успешно создана');
+    } else {
+      console.log('Таблица scheduled_notifications уже существует');
+    }
+    
+    // Проверяем таблицу notification_templates
+    let notificationTemplatesTableExists = await checkTableExists('notification_templates');
+    if (!notificationTemplatesTableExists) {
+      console.log('Таблица notification_templates не найдена. Создаем...');
+      await createNotificationTemplatesTable();
+      console.log('Таблица notification_templates успешно создана');
+      console.log('Заполняем таблицу базовыми шаблонами...');
+      await populateDefaultTemplates();
+      console.log('Шаблоны успешно добавлены');
+    } else {
+      console.log('Таблица notification_templates уже существует');
+    }
+
+    // Шаг 2: Проверка существования столбца notification_settings в таблице users
+    console.log('\n=== Проверка столбца notification_settings в таблице users ===');
+    
+    const notificationSettingsColumnExists = await checkColumnExists('users', 'notification_settings');
+    if (!notificationSettingsColumnExists) {
+      console.log('Столбец notification_settings не найден. Добавляем...');
+      await addNotificationSettingsColumn();
+      console.log('Столбец notification_settings успешно добавлен');
+    } else {
+      console.log('Столбец notification_settings уже существует');
+    }
+
+    // Шаг 3: Проверка существования столбцов state и state_data в таблице users
+    console.log('\n=== Проверка столбцов state и state_data в таблице users ===');
+    
+    const stateColumnExists = await checkColumnExists('users', 'state');
+    if (!stateColumnExists) {
+      console.log('Столбец state не найден. Добавляем...');
+      await addStateColumn();
+      console.log('Столбец state успешно добавлен');
+    } else {
+      console.log('Столбец state уже существует');
+    }
+    
+    const stateDataColumnExists = await checkColumnExists('users', 'state_data');
+    if (!stateDataColumnExists) {
+      console.log('Столбец state_data не найден. Добавляем...');
+      await addStateDataColumn();
+      console.log('Столбец state_data успешно добавлен');
+    } else {
+      console.log('Столбец state_data уже существует');
+    }
+
+    console.log('\nВсе таблицы и столбцы успешно проверены и созданы при необходимости.');
+    console.log('Механизм уведомлений должен работать корректно.');
+
+    console.log('\n=== Проверка регистрации обработчиков уведомлений ===');
+    console.log('Подсказка: убедитесь, что в файле bot.ts создается экземпляр NotificationHandlers и регистрируются его обработчики:');
+    console.log(`
+    // Настройка обработчиков уведомлений
+    const notificationHandlers = new NotificationHandlers(bot);
+    notificationHandlers.register();
+    
+    // Запуск обработчика запланированных уведомлений
+    setInterval(() => {
+      const notificationService = new NotificationService(bot);
+      notificationService.processScheduledNotifications();
+    }, 60000); // Проверяем каждую минуту
+    `);
+
+  } catch (error) {
+    console.error('Ошибка выполнения скрипта:', error);
+  } finally {
+    await client.end();
+    console.log('\nСоединение с базой данных закрыто.');
+  }
+}
+
+async function checkTableExists(tableName) {
+  const query = `
+    SELECT EXISTS (
+      SELECT FROM information_schema.tables 
+      WHERE table_name = $1
+    ) as exists
+  `;
+  
+  const result = await client.query(query, [tableName]);
+  return result.rows[0].exists;
+}
+
+async function checkColumnExists(tableName, columnName) {
+  const query = `
+    SELECT EXISTS (
+      SELECT FROM information_schema.columns
+      WHERE table_name = $1 AND column_name = $2
+    ) as exists
+  `;
+  
+  const result = await client.query(query, [tableName, columnName]);
+  return result.rows[0].exists;
+}
+
+async function createNotificationsTable() {
+  await client.query(`
+    CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
+    
+    CREATE TABLE notifications (
+      id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+      user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+      type VARCHAR(50) NOT NULL,
+      data JSONB,
+      is_read BOOLEAN DEFAULT FALSE,
+      created_at TIMESTAMP DEFAULT NOW()
+    )
+  `);
+}
+
+async function createScheduledNotificationsTable() {
+  await client.query(`
+    CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
+    
+    CREATE TABLE scheduled_notifications (
+      id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+      user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+      type VARCHAR(50) NOT NULL,
+      data JSONB,
+      scheduled_at TIMESTAMP NOT NULL,
+      processed BOOLEAN DEFAULT FALSE,
+      created_at TIMESTAMP DEFAULT NOW()
+    )
+  `);
+}
+
+async function createNotificationTemplatesTable() {
+  await client.query(`
+    CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
+    
+    CREATE TABLE notification_templates (
+      id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+      type VARCHAR(50) NOT NULL UNIQUE,
+      title TEXT NOT NULL,
+      message_template TEXT NOT NULL,
+      button_template JSONB,
+      created_at TIMESTAMP DEFAULT NOW(),
+      updated_at TIMESTAMP DEFAULT NOW()
+    )
+  `);
+}
+
+async function addNotificationSettingsColumn() {
+  await client.query(`
+    ALTER TABLE users
+    ADD COLUMN notification_settings JSONB DEFAULT '{
+      "newMatches": true,
+      "newMessages": true,
+      "newLikes": true,
+      "reminders": true,
+      "dailySummary": true,
+      "timePreference": "evening",
+      "doNotDisturb": false
+    }'::jsonb
+  `);
+}
+
+async function addStateColumn() {
+  await client.query(`
+    ALTER TABLE users ADD COLUMN state VARCHAR(255) NULL
+  `);
+}
+
+async function addStateDataColumn() {
+  await client.query(`
+    ALTER TABLE users ADD COLUMN state_data JSONB DEFAULT '{}'::jsonb
+  `);
+}
+
+async function populateDefaultTemplates() {
+  const templates = [
+    {
+      type: 'new_like',
+      title: 'Новый лайк!',
+      message_template: '❤️ *{{name}}* поставил(а) вам лайк!\n\nВозраст: {{age}}\n{{city}}\n\nОтветьте взаимностью или посмотрите профиль.',
+      button_template: {
+        inline_keyboard: [
+          [{ text: '👀 Посмотреть профиль', callback_data: 'view_profile:{{userId}}' }],
+          [
+            { text: '❤️ Лайк в ответ', callback_data: 'like_back:{{userId}}' },
+            { text: '⛔️ Пропустить', callback_data: 'dislike_profile:{{userId}}' }
+          ],
+          [{ text: '💕 Открыть все лайки', callback_data: 'view_likes' }]
+        ]
+      }
+    },
+    {
+      type: 'super_like',
+      title: 'Супер-лайк!',
+      message_template: '⭐️ *{{name}}* отправил(а) вам супер-лайк!\n\nВозраст: {{age}}\n{{city}}\n\nВы произвели особое впечатление! Ответьте взаимностью или посмотрите профиль.',
+      button_template: {
+        inline_keyboard: [
+          [{ text: '👀 Посмотреть профиль', callback_data: 'view_profile:{{userId}}' }],
+          [
+            { text: '❤️ Лайк в ответ', callback_data: 'like_back:{{userId}}' },
+            { text: '⛔️ Пропустить', callback_data: 'dislike_profile:{{userId}}' }
+          ],
+          [{ text: '💕 Открыть все лайки', callback_data: 'view_likes' }]
+        ]
+      }
+    },
+    {
+      type: 'new_match',
+      title: 'Новый матч!',
+      message_template: '🎊 *Ура! Это взаимно!* 🎊\n\nВы и *{{name}}* понравились друг другу!\nВозраст: {{age}}\n{{city}}\n\nСделайте первый шаг - напишите сообщение!',
+      button_template: {
+        inline_keyboard: [
+          [{ text: '💬 Начать общение', callback_data: 'open_chat:{{matchId}}' }],
+          [
+            { text: '👀 Посмотреть профиль', callback_data: 'view_profile:{{userId}}' },
+            { text: '📋 Все матчи', callback_data: 'view_matches' }
+          ]
+        ]
+      }
+    },
+    {
+      type: 'new_message',
+      title: 'Новое сообщение!',
+      message_template: '💌 *Новое сообщение!*\n\nОт: *{{name}}*\n\n"{{message}}"\n\nОтветьте на сообщение прямо сейчас!',
+      button_template: {
+        inline_keyboard: [
+          [{ text: '📩 Ответить', callback_data: 'open_chat:{{matchId}}' }],
+          [
+            { text: '👤 Профиль', callback_data: 'view_profile:{{userId}}' },
+            { text: '📋 Все чаты', callback_data: 'view_matches' }
+          ]
+        ]
+      }
+    },
+    {
+      type: 'match_reminder',
+      title: 'Напоминание о матче',
+      message_template: '💕 У вас есть матч с *{{name}}*, но вы еще не начали общение!\n\nНе упустите шанс познакомиться поближе!',
+      button_template: {
+        inline_keyboard: [
+          [{ text: '💬 Начать общение', callback_data: 'open_chat:{{matchId}}' }],
+          [{ text: '👀 Посмотреть профиль', callback_data: 'view_profile:{{userId}}' }]
+        ]
+      }
+    },
+    {
+      type: 'inactive_matches',
+      title: 'Неактивные матчи',
+      message_template: '⏰ У вас {{count}} неактивных матчей!\n\nПродолжите общение, чтобы не упустить интересные знакомства!',
+      button_template: {
+        inline_keyboard: [
+          [{ text: '📋 Открыть матчи', callback_data: 'view_matches' }],
+          [{ text: '💕 Смотреть новые анкеты', callback_data: 'start_browsing' }]
+        ]
+      }
+    },
+    {
+      type: 'like_summary',
+      title: 'Сводка лайков',
+      message_template: '💖 У вас {{count}} новых лайков!\n\nПосмотрите, кто проявил к вам интерес сегодня!',
+      button_template: {
+        inline_keyboard: [
+          [{ text: '👀 Посмотреть лайки', callback_data: 'view_likes' }],
+          [{ text: '💕 Начать знакомиться', callback_data: 'start_browsing' }]
+        ]
+      }
+    }
+  ];
+  
+  for (const template of templates) {
+    await client.query(`
+      INSERT INTO notification_templates (type, title, message_template, button_template)
+      VALUES ($1, $2, $3, $4)
+      ON CONFLICT (type) DO UPDATE
+      SET title = EXCLUDED.title,
+          message_template = EXCLUDED.message_template,
+          button_template = EXCLUDED.button_template,
+          updated_at = NOW()
+    `, [
+      template.type,
+      template.title,
+      template.message_template,
+      JSON.stringify(template.button_template)
+    ]);
+  }
+}
+
+// Запуск скрипта
+main();

scripts/legacy/testCallbacks.js

@@ -0,0 +1,85 @@
+// Скрипт для проверки работы callback-хэндлеров и уведомлений
+require('dotenv').config();
+const TelegramBot = require('node-telegram-bot-api');
+const { Pool } = require('pg');
+
+// Создаем пул соединений
+const pool = new Pool({
+  user: process.env.DB_USERNAME,
+  host: process.env.DB_HOST,
+  database: process.env.DB_NAME,
+  password: process.env.DB_PASSWORD,
+  port: parseInt(process.env.DB_PORT || '5432')
+});
+
+// Функция для имитации callback-запроса к боту
+async function testCallback() {
+  try {
+    console.log('Начинаем тестирование callback-хэндлеров и уведомлений...');
+    
+    // Используем последнего пользователя из базы данных
+    const userResult = await pool.query(`
+      SELECT * FROM users ORDER BY last_active_at DESC NULLS LAST LIMIT 1
+    `);
+    
+    if (userResult.rows.length === 0) {
+      console.error('❌ Пользователи не найдены в базе данных');
+      return;
+    }
+    
+    const user = userResult.rows[0];
+    console.log(`Выбран тестовый пользователь: ${user.first_name || 'Без имени'} (ID: ${user.telegram_id})`);
+    
+    // Получаем токен бота из переменных окружения
+    const token = process.env.TELEGRAM_BOT_TOKEN;
+    if (!token) {
+      console.error('❌ Токен бота не найден в переменных окружения');
+      return;
+    }
+    
+    // Создаем экземпляр бота
+    const bot = new TelegramBot(token);
+    
+    // Отправляем тестовое уведомление пользователю
+    console.log(`Отправляем тестовое уведомление пользователю ID: ${user.telegram_id}...`);
+    
+    try {
+      const result = await bot.sendMessage(
+        user.telegram_id,
+        `🔔 *Тестовое уведомление*\n\nЭто проверка работы уведомлений и callback-хэндлеров.\n\nВаш премиум-статус: ${user.premium ? '✅ Активен' : '❌ Не активен'}`,
+        { 
+          parse_mode: 'Markdown',
+          reply_markup: {
+            inline_keyboard: [
+              [
+                { text: '🔔 Уведомления', callback_data: 'notification_settings' },
+                { text: '❤️ Профиль', callback_data: 'view_profile' }
+              ],
+              [
+                { text: '⚙️ Настройки', callback_data: 'settings' }
+              ]
+            ]
+          }
+        }
+      );
+      
+      console.log('✅ Тестовое сообщение успешно отправлено!');
+      console.log('Информация о сообщении:', JSON.stringify(result, null, 2));
+    } catch (error) {
+      console.error('❌ Ошибка при отправке тестового сообщения:', error.message);
+      if (error.response && error.response.body) {
+        console.error('Детали ошибки:', JSON.stringify(error.response.body, null, 2));
+      }
+    }
+    
+  } catch (error) {
+    console.error('❌ Ошибка при тестировании:', error);
+  } finally {
+    await pool.end();
+    console.log('Соединение с базой данных закрыто');
+    console.log('Тестирование завершено!');
+  }
+}
+
+// Запускаем тестирование
+testCallback();

scripts/legacy/testMatching.js

@@ -0,0 +1,102 @@
+require('dotenv').config();
+const { MatchingService } = require('../dist/services/matchingService');
+const { ProfileService } = require('../dist/services/profileService');
+
+// Функция для создания тестовых пользователей
+async function createTestUsers() {
+    const profileService = new ProfileService();
+    
+    console.log('Создание тестовых пользователей...');
+    
+    // Создаем мужской профиль
+    const maleUserId = await profileService.ensureUser('123456', {
+        username: 'test_male',
+        first_name: 'Иван',
+        last_name: 'Тестов'
+    });
+    
+    await profileService.createProfile(maleUserId, {
+        name: 'Иван',
+        age: 30,
+        gender: 'male',
+        interestedIn: 'female',
+        bio: 'Тестовый мужской профиль',
+        photos: ['photo1.jpg'],
+        city: 'Москва',
+        searchPreferences: {
+            minAge: 18,
+            maxAge: 45,
+            maxDistance: 50
+        }
+    });
+    console.log(`Создан мужской профиль: userId=${maleUserId}, telegramId=123456`);
+    
+    // Создаем женский профиль
+    const femaleUserId = await profileService.ensureUser('654321', {
+        username: 'test_female',
+        first_name: 'Анна',
+        last_name: 'Тестова'
+    });
+    
+    await profileService.createProfile(femaleUserId, {
+        name: 'Анна',
+        age: 28,
+        gender: 'female',
+        interestedIn: 'male',
+        bio: 'Тестовый женский профиль',
+        photos: ['photo2.jpg'],
+        city: 'Москва',
+        searchPreferences: {
+            minAge: 25,
+            maxAge: 40,
+            maxDistance: 30
+        }
+    });
+    console.log(`Создан женский профиль: userId=${femaleUserId}, telegramId=654321`);
+    
+    console.log('Тестовые пользователи созданы успешно');
+}
+
+// Функция для тестирования подбора анкет
+async function testMatching() {
+    console.log('\n===== ТЕСТИРОВАНИЕ ПОДБОРА АНКЕТ =====');
+    
+    const matchingService = new MatchingService();
+    
+    console.log('\nТест 1: Получение анкеты для мужского профиля (должна вернуться женская анкета)');
+    const femaleProfile = await matchingService.getNextCandidate('123456', true);
+    if (femaleProfile) {
+        console.log(`✓ Получена анкета: ${femaleProfile.name}, возраст: ${femaleProfile.age}, пол: ${femaleProfile.gender}`);
+    } else {
+        console.log('✗ Анкета не найдена');
+    }
+    
+    console.log('\nТест 2: Получение анкеты для женского профиля (должна вернуться мужская анкета)');
+    const maleProfile = await matchingService.getNextCandidate('654321', true);
+    if (maleProfile) {
+        console.log(`✓ Получена анкета: ${maleProfile.name}, возраст: ${maleProfile.age}, пол: ${maleProfile.gender}`);
+    } else {
+        console.log('✗ Анкета не найдена');
+    }
+    
+    console.log('\n===== ТЕСТИРОВАНИЕ ЗАВЕРШЕНО =====\n');
+    
+    // Завершение работы скрипта
+    process.exit(0);
+}
+
+// Главная функция
+async function main() {
+    try {
+        // Создаем тестовых пользователей
+        await createTestUsers();
+        
+        // Тестируем подбор анкет
+        await testMatching();
+    } catch (error) {
+        console.error('Ошибка при выполнении тестов:', error);
+        process.exit(1);
+    }
+}
+
+main();

scripts/legacy/testProfileViews.js

@@ -0,0 +1,98 @@
+// Тестирование работы с таблицей profile_views
+const { Pool } = require('pg');
+require('dotenv').config();
+
+const pool = new Pool({
+    host: process.env.DB_HOST,
+    port: parseInt(process.env.DB_PORT || '5432'),
+    database: process.env.DB_NAME,
+    user: process.env.DB_USERNAME,
+    password: process.env.DB_PASSWORD
+});
+
+// Функция для тестирования записи просмотра профиля
+async function testRecordProfileView(viewerId, viewedProfileId) {
+    const client = await pool.connect();
+    try {
+        console.log(`Запись просмотра профиля: ${viewerId} просмотрел ${viewedProfileId}`);
+        
+        // Получаем UUID пользователей
+        const viewerResult = await client.query('SELECT id FROM users WHERE telegram_id = $1', [viewerId]);
+        if (viewerResult.rows.length === 0) {
+            console.log(`Пользователь с telegram_id ${viewerId} не найден, создаём нового пользователя`);
+            const newUserResult = await client.query(`
+                INSERT INTO users (telegram_id, username, first_name, last_name)
+                VALUES ($1, $2, $3, $4) RETURNING id
+            `, [viewerId, `user_${viewerId}`, `Имя ${viewerId}`, `Фамилия ${viewerId}`]);
+            
+            var viewerUuid = newUserResult.rows[0].id;
+        } else {
+            var viewerUuid = viewerResult.rows[0].id;
+        }
+        
+        const viewedResult = await client.query('SELECT id FROM users WHERE telegram_id = $1', [viewedProfileId]);
+        if (viewedResult.rows.length === 0) {
+            console.log(`Пользователь с telegram_id ${viewedProfileId} не найден, создаём нового пользователя`);
+            const newUserResult = await client.query(`
+                INSERT INTO users (telegram_id, username, first_name, last_name)
+                VALUES ($1, $2, $3, $4) RETURNING id
+            `, [viewedProfileId, `user_${viewedProfileId}`, `Имя ${viewedProfileId}`, `Фамилия ${viewedProfileId}`]);
+            
+            var viewedUuid = newUserResult.rows[0].id;
+        } else {
+            var viewedUuid = viewedResult.rows[0].id;
+        }
+
+        console.log(`UUID просматривающего: ${viewerUuid}`);
+        console.log(`UUID просматриваемого: ${viewedUuid}`);
+        
+        // Записываем просмотр
+        await client.query(`
+            INSERT INTO profile_views (viewer_id, viewed_profile_id, view_type, view_date)
+            VALUES ($1, $2, $3, NOW())
+            ON CONFLICT (viewer_id, viewed_profile_id) DO UPDATE
+            SET view_date = NOW(), view_type = $3
+        `, [viewerUuid, viewedUuid, 'browse']);
+        
+        console.log('Просмотр профиля успешно записан');
+        
+        // Получаем список просмотренных профилей
+        const viewedProfiles = await client.query(`
+            SELECT v.viewed_profile_id, v.view_date, u.telegram_id
+            FROM profile_views v
+            JOIN users u ON u.id = v.viewed_profile_id
+            WHERE v.viewer_id = $1
+            ORDER BY v.view_date DESC
+        `, [viewerUuid]);
+        
+        console.log('Список просмотренных профилей:');
+        viewedProfiles.rows.forEach((row, index) => {
+            console.log(`${index + 1}. ID: ${row.telegram_id}, просмотрен: ${row.view_date}`);
+        });
+        
+        return true;
+    } catch (error) {
+        console.error('Ошибка записи просмотра профиля:', error);
+        return false;
+    } finally {
+        client.release();
+    }
+}
+
+// Запускаем тест
+async function runTest() {
+    try {
+        // Тестируем запись просмотра профиля
+        await testRecordProfileView(123456, 789012);
+        await testRecordProfileView(123456, 345678);
+        await testRecordProfileView(789012, 123456);
+        
+        console.log('Тесты завершены успешно');
+    } catch (error) {
+        console.error('Ошибка при выполнении тестов:', error);
+    } finally {
+        await pool.end();
+    }
+}
+
+runTest();

scripts/legacy/testVipMethod.js

@@ -0,0 +1,81 @@
+// Скрипт для тестирования метода checkPremiumStatus
+require('dotenv').config();
+const { Pool } = require('pg');
+
+// Создаем пул соединений
+const pool = new Pool({
+  user: process.env.DB_USERNAME,
+  host: process.env.DB_HOST,
+  database: process.env.DB_NAME,
+  password: process.env.DB_PASSWORD,
+  port: parseInt(process.env.DB_PORT || '5432')
+});
+
+async function testCheckPremiumMethod() {
+  try {
+    console.log('Тестирование метода checkPremiumStatus...');
+    
+    // Получаем пользователя для тестирования
+    const userResult = await pool.query(`
+      SELECT id, telegram_id, first_name, username, premium
+      FROM users
+      ORDER BY last_active_at DESC NULLS LAST
+      LIMIT 1
+    `);
+    
+    if (userResult.rows.length === 0) {
+      console.error('❌ Пользователи не найдены в базе данных');
+      return;
+    }
+    
+    const user = userResult.rows[0];
+    console.log(`Выбран тестовый пользователь: ${user.first_name || user.username || 'Без имени'} (Telegram ID: ${user.telegram_id})`);
+    console.log(`Текущий премиум-статус: ${user.premium ? '✅ Активен' : '❌ Не активен'}`);
+    
+    // Проверка работы метода checkPremiumStatus
+    console.log('\nЭмулируем вызов метода checkPremiumStatus из vipService:');
+    const result = await pool.query(`
+      SELECT id, premium 
+      FROM users 
+      WHERE telegram_id = $1
+    `, [user.telegram_id]);
+    
+    if (result.rows.length === 0) {
+      console.log('❌ Пользователь не найден');
+    } else {
+      const isPremium = result.rows[0].premium || false;
+      console.log(`Результат метода: isPremium = ${isPremium ? '✅ true' : '❌ false'}`);
+      
+      if (!isPremium) {
+        console.log('\nПремиум-статус отсутствует. Устанавливаем премиум...');
+        await pool.query(`
+          UPDATE users
+          SET premium = true
+          WHERE telegram_id = $1
+        `, [user.telegram_id]);
+        
+        // Проверяем обновление
+        const updatedResult = await pool.query(`
+          SELECT premium 
+          FROM users 
+          WHERE telegram_id = $1
+        `, [user.telegram_id]);
+        
+        const updatedPremium = updatedResult.rows[0].premium;
+        console.log(`Обновленный статус: isPremium = ${updatedPremium ? '✅ true' : '❌ false'}`);
+      }
+    }
+    
+    console.log('\n✅ Тестирование завершено');
+    console.log('🔧 Теперь проверьте функциональность VIP поиска в боте');
+    
+  } catch (error) {
+    console.error('❌ Ошибка при тестировании:', error);
+  } finally {
+    await pool.end();
+    console.log('Соединение с базой данных закрыто');
+  }
+}
+
+// Запускаем тест
+testCheckPremiumMethod();

scripts/legacy/testVipStatus.js

@@ -0,0 +1,75 @@
+// Скрипт для тестирования VIP функционала
+require('dotenv').config();
+const { Pool } = require('pg');
+
+// Создаем пул соединений
+const pool = new Pool({
+  user: process.env.DB_USERNAME,
+  host: process.env.DB_HOST,
+  database: process.env.DB_NAME,
+  password: process.env.DB_PASSWORD,
+  port: parseInt(process.env.DB_PORT || '5432')
+});
+
+async function testVipStatus() {
+  try {
+    console.log('Тестирование функционала VIP статуса...');
+    
+    // Получаем список пользователей с информацией о premium статусе
+    const users = await pool.query(`
+      SELECT id, telegram_id, username, first_name, premium
+      FROM users
+      ORDER BY last_active_at DESC
+      LIMIT 5
+    `);
+    
+    console.log('Список пользователей и их премиум статус:');
+    users.rows.forEach(user => {
+      console.log(`ID: ${user.id.substr(0, 8)}... | Telegram ID: ${user.telegram_id} | Имя: ${user.first_name || user.username || 'Не указано'} | Premium: ${user.premium ? '✅' : '❌'}`);
+    });
+    
+    // Если premium у всех false, устанавливаем premium = true
+    const nonPremiumUsers = users.rows.filter(user => !user.premium);
+    if (nonPremiumUsers.length > 0) {
+      console.log('\nОбнаружены пользователи без премиум статуса. Устанавливаем премиум...');
+      
+      for (const user of nonPremiumUsers) {
+        await pool.query(`
+          UPDATE users
+          SET premium = true
+          WHERE id = $1
+          RETURNING id, telegram_id, premium
+        `, [user.id]);
+        
+        console.log(`✅ Установлен премиум для пользователя ${user.first_name || user.username || user.telegram_id}`);
+      }
+    } else {
+      console.log('\nВсе пользователи уже имеют премиум-статус!');
+    }
+    
+    // Проверяем результат
+    const updatedUsers = await pool.query(`
+      SELECT id, telegram_id, username, first_name, premium
+      FROM users
+      ORDER BY last_active_at DESC
+      LIMIT 5
+    `);
+    
+    console.log('\nОбновленный список пользователей и их премиум статус:');
+    updatedUsers.rows.forEach(user => {
+      console.log(`ID: ${user.id.substr(0, 8)}... | Telegram ID: ${user.telegram_id} | Имя: ${user.first_name || user.username || 'Не указано'} | Premium: ${user.premium ? '✅' : '❌'}`);
+    });
+    
+    console.log('\n✅ Тестирование VIP функционала завершено');
+    console.log('🔧 Проверьте доступность VIP поиска в боте через меню или команды');
+    
+  } catch (error) {
+    console.error('❌ Ошибка при тестировании VIP статуса:', error);
+  } finally {
+    await pool.end();
+    console.log('Соединение с базой данных закрыто');
+  }
+}
+
+// Запускаем тест
+testVipStatus();