Описание изменений
This commit is contained in:
29
.cursor/rules/hb3a.mdc
Normal file
29
.cursor/rules/hb3a.mdc
Normal file
@@ -0,0 +1,29 @@
|
||||
---
|
||||
description: >
|
||||
Это правило предназначено для управления поведением AI в проекте HB3A.
|
||||
Оно учитывает специфику работы с различными каналами аутентификации и управления ролями.
|
||||
globs:
|
||||
- '**/*.js' # Применять ко всем JavaScript файлам
|
||||
- '**/*.vue' # Применять ко всем Vue файлам
|
||||
- '!node_modules/**' # Исключить node_modules
|
||||
---
|
||||
|
||||
# Правила для проекта HB3A
|
||||
|
||||
- Учитывайте мультиканальную архитектуру аутентификации (веб, Telegram, Email).
|
||||
- Проверяйте наличие токенов управления на балансе крипто кошелька для определения роли пользователя.
|
||||
- Обеспечивайте безопасность данных, включая защиту от атак повторного воспроизведения и подделки подписей.
|
||||
- Поддерживайте обновленную модель ролей: администратор и клиент, с соответствующими правами и возможностями.
|
||||
- Учитывайте дорожную карту разработки и текущие этапы проекта при предложении новых функций или изменений.
|
||||
|
||||
# Ссылки на файлы
|
||||
|
||||
- @file ../services/auth-service.js
|
||||
- @file ../routes/auth.js
|
||||
- @file ../middleware/auth.js
|
||||
|
||||
# Дополнительные указания
|
||||
|
||||
- Используйте комментарии для объяснения сложных участков кода.
|
||||
- Предлагайте оптимизации, если код можно улучшить по производительности или безопасности.
|
||||
- Объясняйте концепции простым и понятным языком, особенно для новичков.
|
||||
27
.cursor/rules/vue-components.mdc
Normal file
27
.cursor/rules/vue-components.mdc
Normal file
@@ -0,0 +1,27 @@
|
||||
---
|
||||
description: >
|
||||
Это правило предназначено для управления поведением AI при работе с компонентами Vue.js.
|
||||
Оно учитывает специфику работы с Vue и помогает поддерживать единообразие в проекте.
|
||||
globs:
|
||||
- '**/*.vue' # Применять ко всем Vue файлам
|
||||
- '!node_modules/**' # Исключить node_modules
|
||||
---
|
||||
|
||||
# Правила для компонентов Vue.js
|
||||
|
||||
- Следуйте соглашениям об именовании компонентов (PascalCase для имен файлов и компонентов).
|
||||
- Используйте шаблоны, скрипты и стили в одном файле для каждого компонента.
|
||||
- Обеспечивайте реактивность данных с помощью Vue Composition API или Options API.
|
||||
- Используйте директивы Vue (v-if, v-for, v-bind и т.д.) для управления отображением.
|
||||
- Поддерживайте чистоту и читаемость кода, используя комментарии для сложных участков.
|
||||
|
||||
# Ссылки на файлы
|
||||
|
||||
- @file ../components/ExampleComponent.vue
|
||||
- @file ../views/ExampleView.vue
|
||||
|
||||
# Дополнительные указания
|
||||
|
||||
- Объясняйте концепции Vue.js простым и понятным языком.
|
||||
- Предлагайте оптимизации, если код можно улучшить по производительности или безопасности.
|
||||
- Учитывайте лучшие практики Vue.js при предложении изменений.
|
||||
448
backend/app.js
448
backend/app.js
@@ -1,405 +1,101 @@
|
||||
const express = require('express');
|
||||
const cors = require('cors');
|
||||
const session = require('express-session');
|
||||
const { verifySignature, findOrCreateUser } = require('./utils/auth');
|
||||
const pgSession = require('connect-pg-simple')(session);
|
||||
const { requireRole } = require('./middleware/auth');
|
||||
const crypto = require('crypto');
|
||||
const path = require('path');
|
||||
const fs = require('fs');
|
||||
const { router: authRouter } = require('./routes/auth');
|
||||
const { pool } = require('./db');
|
||||
const FileStore = require('session-file-store')(session);
|
||||
const helmet = require('helmet');
|
||||
const sessionMiddleware = require('./middleware/session');
|
||||
const chatRouter = require('./routes/chat');
|
||||
const path = require('path');
|
||||
const logger = require('./utils/logger');
|
||||
const authService = require('./services/auth-service');
|
||||
|
||||
// Импорт маршрутов
|
||||
const authRoutes = require('./routes/auth');
|
||||
const accessRoutes = require('./routes/access');
|
||||
const usersRoutes = require('./routes/users');
|
||||
const contractsRoutes = require('./routes/contracts');
|
||||
const rolesRoutes = require('./routes/roles');
|
||||
const identitiesRoutes = require('./routes/identities');
|
||||
// const conversationsRoutes = require('./routes/conversations');
|
||||
const messagesRoutes = require('./routes/messages');
|
||||
const chatRoutes = require('./routes/chat');
|
||||
const healthRoutes = require('./routes/health');
|
||||
const debugRoutes = require('./routes/debug');
|
||||
|
||||
const app = express();
|
||||
|
||||
// Функция для генерации nonce
|
||||
function generateNonce() {
|
||||
return crypto.randomBytes(16).toString('hex');
|
||||
}
|
||||
// Настройка middleware для сессий
|
||||
app.use(session({
|
||||
store: new pgSession({
|
||||
pool,
|
||||
tableName: 'session',
|
||||
createTableIfMissing: true,
|
||||
}),
|
||||
secret: process.env.SESSION_SECRET || 'your-secret-key',
|
||||
resave: false,
|
||||
saveUninitialized: true,
|
||||
cookie: {
|
||||
maxAge: 30 * 24 * 60 * 60 * 1000, // 30 дней
|
||||
httpOnly: true,
|
||||
secure: false,
|
||||
sameSite: 'lax',
|
||||
},
|
||||
}));
|
||||
|
||||
// Парсинг JSON - должен быть до всех роутов
|
||||
// Настройка парсеров
|
||||
app.use(express.json());
|
||||
app.use(express.urlencoded({ extended: true }));
|
||||
|
||||
// Настройка CORS
|
||||
app.use(
|
||||
cors({
|
||||
origin: function(origin, callback) {
|
||||
// Разрешаем запросы с любого источника в режиме разработки
|
||||
const allowedOrigins = ['http://localhost:3000', 'http://127.0.0.1:5173', 'http://localhost:5173'];
|
||||
if (!origin || allowedOrigins.indexOf(origin) !== -1) {
|
||||
callback(null, true);
|
||||
} else {
|
||||
callback(new Error('Not allowed by CORS'));
|
||||
}
|
||||
},
|
||||
credentials: true,
|
||||
methods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
|
||||
allowedHeaders: ['Content-Type', 'Authorization', 'X-Auth-Nonce'],
|
||||
})
|
||||
);
|
||||
// Настройка CORS (должна быть после настройки сессий)
|
||||
app.use(cors({
|
||||
origin: function(origin, callback) {
|
||||
// Разрешаем запросы с localhost и 127.0.0.1
|
||||
const allowedOrigins = [
|
||||
'http://localhost:5173',
|
||||
'http://127.0.0.1:5173',
|
||||
'http://localhost:3000',
|
||||
'http://127.0.0.1:3000',
|
||||
process.env.CORS_ORIGIN
|
||||
].filter(Boolean);
|
||||
|
||||
// Настройка сессий
|
||||
app.use(
|
||||
session({
|
||||
store: new pgSession({
|
||||
pool: pool,
|
||||
tableName: 'sessions',
|
||||
createTableIfMissing: false,
|
||||
}),
|
||||
secret: process.env.SESSION_SECRET || 'your-secret-key',
|
||||
resave: false,
|
||||
saveUninitialized: true,
|
||||
name: 'dapp.sid',
|
||||
cookie: {
|
||||
secure: false,
|
||||
httpOnly: true,
|
||||
maxAge: 30 * 24 * 60 * 60 * 1000,
|
||||
sameSite: 'lax',
|
||||
},
|
||||
})
|
||||
);
|
||||
|
||||
// Middleware для безопасности
|
||||
app.use(
|
||||
helmet({
|
||||
contentSecurityPolicy: false, // Отключаем CSP для разработки
|
||||
})
|
||||
);
|
||||
|
||||
// Middleware для логирования
|
||||
app.use((req, res, next) => {
|
||||
console.log(`${req.method} ${req.path}`, {
|
||||
headers: req.headers,
|
||||
body: req.body,
|
||||
session: req.session,
|
||||
});
|
||||
next();
|
||||
});
|
||||
|
||||
// Middleware для сохранения сессии после каждого запроса
|
||||
app.use((req, res, next) => {
|
||||
const originalEnd = res.end;
|
||||
|
||||
res.end = function () {
|
||||
if (req.session && req.session.save) {
|
||||
req.session.save((err) => {
|
||||
if (err) {
|
||||
console.error('Ошибка при сохранении сессии:', err);
|
||||
}
|
||||
originalEnd.apply(res, arguments);
|
||||
});
|
||||
if (!origin || allowedOrigins.includes(origin)) {
|
||||
callback(null, true);
|
||||
} else {
|
||||
originalEnd.apply(res, arguments);
|
||||
callback(new Error('Not allowed by CORS'));
|
||||
}
|
||||
};
|
||||
},
|
||||
credentials: true
|
||||
}));
|
||||
|
||||
// Настройка безопасности
|
||||
app.use(helmet({
|
||||
contentSecurityPolicy: false // Отключаем CSP для разработки
|
||||
}));
|
||||
|
||||
// Логирование запросов
|
||||
app.use((req, res, next) => {
|
||||
logger.info(`${req.method} ${req.url}`);
|
||||
next();
|
||||
});
|
||||
|
||||
// Middleware для проверки авторизации
|
||||
const requireAuth = (req, res, next) => {
|
||||
console.log('Auth check:', {
|
||||
session: req.session,
|
||||
authenticated: req.session.authenticated,
|
||||
address: req.session.address,
|
||||
});
|
||||
|
||||
if (!req.session.authenticated || !req.session.address) {
|
||||
return res.status(401).json({ error: 'Unauthorized' });
|
||||
}
|
||||
next();
|
||||
};
|
||||
|
||||
// Миддлвар для обновления дополнительных полей в таблице sessions
|
||||
app.use(async (req, res, next) => {
|
||||
try {
|
||||
// Если есть адрес, но нет userId, найдем или создадим пользователя
|
||||
if (req.session && req.session.authenticated && req.session.address && !req.session.userId) {
|
||||
try {
|
||||
const user = await findOrCreateUser(req.session.address, 'wallet');
|
||||
req.session.userId = user.id;
|
||||
req.session.role = user.role;
|
||||
req.session.isAdmin = user.is_admin;
|
||||
|
||||
// Стандартизируем данные сессии
|
||||
standardizeSessionData(req);
|
||||
|
||||
// Сохраняем обновленную сессию
|
||||
await new Promise((resolve, reject) => {
|
||||
req.session.save(err => {
|
||||
if (err) reject(err);
|
||||
else resolve();
|
||||
});
|
||||
});
|
||||
} catch (err) {
|
||||
console.error('Ошибка при обновлении userId в сессии:', err);
|
||||
}
|
||||
}
|
||||
|
||||
// Обновляем поля в таблице sessions
|
||||
if (req.session && (req.session.userId || req.session.address)) {
|
||||
db.query(
|
||||
'UPDATE sessions SET last_activity = NOW(), user_id = $1, auth_channel = $2, language = $3 WHERE sid = $4',
|
||||
[
|
||||
req.session.userId || null,
|
||||
req.session.authChannel || 'web',
|
||||
req.session.language || 'en',
|
||||
req.sessionID
|
||||
]
|
||||
).catch(err => console.error('Error updating session data:', err));
|
||||
}
|
||||
} catch (err) {
|
||||
console.error('Ошибка в middleware сессий:', err);
|
||||
}
|
||||
|
||||
next();
|
||||
});
|
||||
|
||||
// Функция для стандартизации данных сессии
|
||||
function standardizeSessionData(req) {
|
||||
if (req.session.authenticated) {
|
||||
// Убедимся, что все необходимые поля присутствуют
|
||||
req.session.authType = req.session.authType || 'wallet';
|
||||
req.session.role = req.session.role || 'USER';
|
||||
req.session.isAdmin = !!req.session.isAdmin;
|
||||
req.session.authChannel = req.session.authChannel || 'web';
|
||||
req.session.language = req.session.language || 'en';
|
||||
}
|
||||
}
|
||||
|
||||
// API роуты
|
||||
const apiRouter = express.Router();
|
||||
|
||||
// Удалите или закомментируйте этот блок кода
|
||||
/*
|
||||
apiRouter.post('/refresh-session', async (req, res) => {
|
||||
try {
|
||||
const { address, signature } = req.body;
|
||||
|
||||
if (!address || !signature) {
|
||||
return res.status(400).json({ error: 'Missing required fields' });
|
||||
}
|
||||
|
||||
// Проверяем подпись
|
||||
const verified = await verifySignature(
|
||||
{ address }, // упрощенное сообщение для проверки
|
||||
signature,
|
||||
address
|
||||
);
|
||||
|
||||
if (!verified) {
|
||||
return res.status(401).json({ error: 'Invalid signature' });
|
||||
}
|
||||
|
||||
// Обновляем сессию
|
||||
req.session.authenticated = true;
|
||||
req.session.address = address;
|
||||
req.session.lastSignature = signature;
|
||||
|
||||
// Сохраняем сессию
|
||||
req.session.save((err) => {
|
||||
if (err) {
|
||||
console.error('Session refresh error:', err);
|
||||
return res.status(500).json({ error: 'Session refresh failed' });
|
||||
}
|
||||
|
||||
console.log('Session refreshed:', {
|
||||
id: req.sessionID,
|
||||
address: address,
|
||||
authenticated: true
|
||||
});
|
||||
|
||||
res.json({ success: true });
|
||||
});
|
||||
} catch (error) {
|
||||
console.error('Session refresh error:', error);
|
||||
res.status(500).json({ error: 'Internal server error' });
|
||||
}
|
||||
});
|
||||
*/
|
||||
|
||||
apiRouter.get('/session', (req, res) => {
|
||||
console.log('Session check:', {
|
||||
session: req.session,
|
||||
authenticated: req.session.authenticated,
|
||||
address: req.session.address,
|
||||
});
|
||||
|
||||
res.json({
|
||||
authenticated: !!req.session.authenticated,
|
||||
address: req.session.address || null,
|
||||
});
|
||||
});
|
||||
|
||||
// Обновим роут для выхода
|
||||
apiRouter.post('/signout', (req, res) => {
|
||||
try {
|
||||
req.session.destroy();
|
||||
res.clearCookie('connect.sid'); // Теперь это правильное имя cookie
|
||||
res.json({ success: true });
|
||||
} catch (error) {
|
||||
console.error('Signout error:', error);
|
||||
res.status(500).json({ error: 'Internal server error' });
|
||||
}
|
||||
});
|
||||
|
||||
// Проверка прав администратора
|
||||
apiRouter.get('/admin/check', async (req, res) => {
|
||||
try {
|
||||
if (!req.session || !req.session.address) {
|
||||
return res.json({ isAdmin: false });
|
||||
}
|
||||
|
||||
// Проверяем является ли адрес владельцем контракта
|
||||
const ethers = require('ethers');
|
||||
const provider = new ethers.JsonRpcProvider(process.env.ETHEREUM_NETWORK_URL);
|
||||
const contractABI = require('./artifacts/contracts/MyContract.sol/MyContract.json').abi;
|
||||
const contract = new ethers.Contract(process.env.CONTRACT_ADDRESS, contractABI, provider);
|
||||
|
||||
const contractOwner = await contract.owner();
|
||||
const isAdmin = req.session.address.toLowerCase() === contractOwner.toLowerCase();
|
||||
|
||||
res.json({ isAdmin });
|
||||
} catch (error) {
|
||||
console.error('Admin check error:', error);
|
||||
res.status(500).json({ error: error.message });
|
||||
}
|
||||
});
|
||||
|
||||
// Только для админов
|
||||
apiRouter.post('/api/admin/action', requireRole('ADMIN'), (req, res) => {
|
||||
// ...
|
||||
});
|
||||
|
||||
// Для модераторов и админов
|
||||
apiRouter.post('/api/moderate/action', requireRole('MODERATOR'), (req, res) => {
|
||||
// ...
|
||||
});
|
||||
|
||||
// Для всех с токеном
|
||||
apiRouter.post('/api/protected/action', requireRole(), (req, res) => {
|
||||
// ...
|
||||
});
|
||||
|
||||
// Обновим роут для верификации
|
||||
apiRouter.post('/verify', async (req, res) => {
|
||||
try {
|
||||
console.log('Получен запрос на верификацию в app.js:', req.body);
|
||||
const { message, signature } = req.body;
|
||||
|
||||
if (!message || !signature) {
|
||||
console.error('Отсутствуют необходимые поля:', {
|
||||
message: !!message,
|
||||
signature: !!signature,
|
||||
});
|
||||
return res.status(400).json({ success: false, error: 'Missing required fields' });
|
||||
}
|
||||
|
||||
// Проверяем, что message содержит адрес
|
||||
if (!message.address) {
|
||||
console.error('Отсутствует адрес в сообщении');
|
||||
return res.status(400).json({ success: false, error: 'Missing address in message' });
|
||||
}
|
||||
|
||||
// Получаем адрес из сообщения напрямую
|
||||
const address = message.address;
|
||||
console.log('Адрес из сообщения:', address);
|
||||
|
||||
// Устанавливаем сессию без проверки подписи
|
||||
req.session.authenticated = true;
|
||||
req.session.address = address;
|
||||
req.session.lastSignature = signature;
|
||||
|
||||
// Сохраняем сессию
|
||||
req.session.save((err) => {
|
||||
if (err) {
|
||||
console.error('Ошибка при сохранении сессии:', err);
|
||||
return res.status(500).json({
|
||||
success: false,
|
||||
error: 'Session save failed',
|
||||
message: err.message,
|
||||
});
|
||||
}
|
||||
|
||||
console.log('Сессия сохранена успешно:', req.sessionID);
|
||||
return res.json({ success: true, address, isAdmin: true });
|
||||
});
|
||||
} catch (error) {
|
||||
console.error('Подробная ошибка при верификации:', error.stack);
|
||||
console.error('Verification error:', error);
|
||||
res.status(500).json({
|
||||
success: false,
|
||||
error: 'Verification failed',
|
||||
message: error.message || 'Unknown error',
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
// Монтируем API роуты
|
||||
app.use('/api', apiRouter);
|
||||
|
||||
// Подключаем маршруты аутентификации
|
||||
app.use('/api/auth', authRouter);
|
||||
// Маршруты API
|
||||
app.use('/api/auth', authRoutes);
|
||||
app.use('/api/access', accessRoutes);
|
||||
app.use('/api/users', usersRoutes);
|
||||
app.use('/api/contracts', contractsRoutes);
|
||||
app.use('/api/chat', chatRouter);
|
||||
app.use('/api/roles', rolesRoutes);
|
||||
app.use('/api/identities', identitiesRoutes);
|
||||
// app.use('/api/conversations', conversationsRoutes);
|
||||
app.use('/api/messages', messagesRoutes);
|
||||
app.use('/api/chat', chatRoutes);
|
||||
app.use('/api/health', healthRoutes);
|
||||
|
||||
apiRouter.get('/nonce', (req, res) => {
|
||||
const nonce = generateNonce();
|
||||
console.log('Generated new nonce:', nonce);
|
||||
// Маршруты для отладки (только в режиме разработки)
|
||||
if (process.env.NODE_ENV !== 'production') {
|
||||
app.use('/api/debug', debugRoutes);
|
||||
}
|
||||
|
||||
// Сохраняем nonce в сессии
|
||||
if (!req.session.nonces) {
|
||||
req.session.nonces = [];
|
||||
}
|
||||
req.session.nonces.push(nonce);
|
||||
const nonceStore = new Map(); // или любая другая реализация хранилища nonce
|
||||
|
||||
// Ограничиваем количество nonce в сессии
|
||||
if (req.session.nonces.length > 5) {
|
||||
req.session.nonces.shift();
|
||||
}
|
||||
console.log('SESSION_SECRET:', process.env.SESSION_SECRET);
|
||||
|
||||
console.log('Nonces in session:', req.session.nonces);
|
||||
|
||||
res.json({ nonce });
|
||||
});
|
||||
|
||||
// Добавьте после настройки сессий
|
||||
app.use(sessionMiddleware);
|
||||
|
||||
// Обработка ошибок сессий
|
||||
app.use((err, req, res, next) => {
|
||||
if (err.code === 'ENOENT' && err.message.includes('sessions')) {
|
||||
console.error('Session error:', err);
|
||||
// Пересоздаем сессию
|
||||
req.session.regenerate((regenerateErr) => {
|
||||
if (regenerateErr) {
|
||||
console.error('Failed to regenerate session:', regenerateErr);
|
||||
return res.status(500).json({ error: 'Session error' });
|
||||
}
|
||||
next();
|
||||
});
|
||||
} else {
|
||||
next(err);
|
||||
}
|
||||
});
|
||||
|
||||
// Обработка ошибок
|
||||
app.use((err, req, res, next) => {
|
||||
console.error(err.stack);
|
||||
res.status(500).json({ error: 'Something broke!' });
|
||||
});
|
||||
|
||||
// Подключаем маршруты для отладки
|
||||
const debugRouter = require('./routes/debug');
|
||||
app.use('/api/debug', debugRouter);
|
||||
|
||||
module.exports = { app };
|
||||
module.exports = { app, nonceStore };
|
||||
|
||||
@@ -10,7 +10,7 @@ contract AccessToken is ERC721, Ownable {
|
||||
Counters.Counter private _tokenIds;
|
||||
|
||||
// Роли для токенов
|
||||
enum Role { ADMIN, MODERATOR, SUPPORT }
|
||||
enum Role { USER, ADMIN }
|
||||
|
||||
// Маппинг токен ID => роль
|
||||
mapping(uint256 => Role) public tokenRoles;
|
||||
@@ -24,6 +24,8 @@ contract AccessToken is ERC721, Ownable {
|
||||
|
||||
// Создание нового токена доступа
|
||||
function mintAccessToken(address to, Role role) public onlyOwner {
|
||||
require(role == Role.USER || role == Role.ADMIN, "Invalid role");
|
||||
|
||||
_tokenIds.increment();
|
||||
uint256 newTokenId = _tokenIds.current();
|
||||
|
||||
@@ -51,10 +53,9 @@ contract AccessToken is ERC721, Ownable {
|
||||
function _beforeTokenTransfer(
|
||||
address from,
|
||||
address to,
|
||||
uint256 tokenId,
|
||||
uint256 batchSize
|
||||
uint256 tokenId
|
||||
) internal override {
|
||||
require(from == address(0) || to == address(0), "Token transfer not allowed");
|
||||
super._beforeTokenTransfer(from, to, tokenId, batchSize);
|
||||
super._beforeTokenTransfer(from, to, tokenId);
|
||||
}
|
||||
}
|
||||
63
backend/db/init.js
Normal file
63
backend/db/init.js
Normal file
@@ -0,0 +1,63 @@
|
||||
// Инициализация таблицы roles
|
||||
async function initRoles() {
|
||||
try {
|
||||
// Проверяем, существует ли таблица roles
|
||||
const tableExists = await db.query(`
|
||||
SELECT EXISTS (
|
||||
SELECT FROM information_schema.tables
|
||||
WHERE table_name = 'roles'
|
||||
);
|
||||
`);
|
||||
|
||||
if (!tableExists.rows[0].exists) {
|
||||
// Создаем таблицу roles
|
||||
await db.query(`
|
||||
CREATE TABLE roles (
|
||||
id SERIAL PRIMARY KEY,
|
||||
name VARCHAR(50) NOT NULL UNIQUE,
|
||||
description TEXT,
|
||||
created_at TIMESTAMP NOT NULL DEFAULT NOW()
|
||||
);
|
||||
`);
|
||||
|
||||
// Добавляем роли
|
||||
await db.query(`
|
||||
INSERT INTO roles (id, name, description) VALUES
|
||||
(3, 'user', 'Обычный пользователь'),
|
||||
(4, 'admin', 'Администратор с полным доступом');
|
||||
`);
|
||||
|
||||
console.log('Таблица roles создана и заполнена');
|
||||
} else {
|
||||
// Проверяем наличие ролей
|
||||
const rolesExist = await db.query(`
|
||||
SELECT COUNT(*) FROM roles WHERE id IN (3, 4);
|
||||
`);
|
||||
|
||||
if (rolesExist.rows[0].count < 2) {
|
||||
// Добавляем недостающие роли
|
||||
const userRoleExists = await db.query(`SELECT EXISTS (SELECT FROM roles WHERE name = 'user');`);
|
||||
const adminRoleExists = await db.query(`SELECT EXISTS (SELECT FROM roles WHERE name = 'admin');`);
|
||||
|
||||
if (!userRoleExists.rows[0].exists) {
|
||||
await db.query(`
|
||||
INSERT INTO roles (id, name, description) VALUES
|
||||
(3, 'user', 'Обычный пользователь');
|
||||
`);
|
||||
}
|
||||
|
||||
if (!adminRoleExists.rows[0].exists) {
|
||||
await db.query(`
|
||||
INSERT INTO roles (id, name, description) VALUES
|
||||
(4, 'admin', 'Администратор с полным доступом');
|
||||
`);
|
||||
}
|
||||
|
||||
console.log('Таблица roles обновлена');
|
||||
}
|
||||
}
|
||||
} catch (error) {
|
||||
console.error('Ошибка при инициализации таблицы roles:', error);
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
@@ -1,10 +1,121 @@
|
||||
{"level":"info","message":"Running scheduled token balance check","timestamp":"2025-03-04T20:30:00.970Z"}
|
||||
{"level":"info","message":"Checking token balances for 1 users","timestamp":"2025-03-04T20:30:00.982Z"}
|
||||
{"level":"error","message":"Ошибка при получении контракта AccessToken: Адрес контракта AccessToken не найден в переменных окружения","timestamp":"2025-03-04T20:30:00.983Z"}
|
||||
{"level":"error","message":"Error checking token balance for 0x0000000000000000000000000000000000000000: Адрес контракта AccessToken не найден в переменных окружения","timestamp":"2025-03-04T20:30:00.983Z"}
|
||||
{"level":"info","message":"User 10 with address 0x0000000000000000000000000000000000000000: admin=false","timestamp":"2025-03-04T20:30:00.984Z"}
|
||||
{"level":"info","message":"Running scheduled token balance check","timestamp":"2025-03-04T21:30:00.777Z"}
|
||||
{"level":"info","message":"Checking token balances for 1 users","timestamp":"2025-03-04T21:30:00.793Z"}
|
||||
{"level":"error","message":"Ошибка при получении контракта AccessToken: Адрес контракта AccessToken не найден в переменных окружения","timestamp":"2025-03-04T21:30:00.794Z"}
|
||||
{"level":"error","message":"Error checking token balance for 0x0000000000000000000000000000000000000000: Адрес контракта AccessToken не найден в переменных окружения","timestamp":"2025-03-04T21:30:00.795Z"}
|
||||
{"level":"info","message":"User 10 with address 0x0000000000000000000000000000000000000000: admin=false","timestamp":"2025-03-04T21:30:00.795Z"}
|
||||
{"level":"info","message":"POST /api/auth/logout","timestamp":"2025-03-06T17:11:53.698Z"}
|
||||
{"level":"info","message":"GET /api/auth/check","timestamp":"2025-03-06T17:11:55.816Z"}
|
||||
{"level":"info","message":"POST /api/auth/logout","timestamp":"2025-03-06T17:11:55.835Z"}
|
||||
{"level":"info","message":"GET /api/auth/check","timestamp":"2025-03-06T17:11:55.845Z"}
|
||||
{"level":"info","message":"POST /api/auth/refresh-session","timestamp":"2025-03-06T17:11:55.864Z"}
|
||||
{"level":"info","message":"Получен запрос на обновление сессии для адреса: 0xf45aa4917b3775ba37f48aeb3dc1a943561e9e0b","timestamp":"2025-03-06T17:11:55.865Z"}
|
||||
{"level":"error","message":"Ошибка при получении контракта AccessToken: abi is not iterable","timestamp":"2025-03-06T17:11:55.866Z"}
|
||||
{"level":"error","message":"Error checking admin token: abi is not iterable","timestamp":"2025-03-06T17:11:55.867Z"}
|
||||
{"level":"error","message":"Ошибка при получении контракта AccessToken: abi is not iterable","timestamp":"2025-03-06T17:11:55.877Z"}
|
||||
{"level":"error","message":"Error checking admin token: abi is not iterable","timestamp":"2025-03-06T17:11:55.878Z"}
|
||||
{"level":"info","message":"POST /api/auth/logout","timestamp":"2025-03-06T17:12:11.487Z"}
|
||||
{"level":"info","message":"GET /api/auth/nonce?address=0xf45aa4917b3775ba37f48aeb3dc1a943561e9e0b","timestamp":"2025-03-06T17:12:12.981Z"}
|
||||
{"level":"info","message":"POST /api/auth/verify","timestamp":"2025-03-06T17:12:16.205Z"}
|
||||
{"level":"error","message":"Ошибка при получении контракта AccessToken: abi is not iterable","timestamp":"2025-03-06T17:12:16.262Z"}
|
||||
{"level":"error","message":"Error checking admin token: abi is not iterable","timestamp":"2025-03-06T17:12:16.263Z"}
|
||||
{"level":"info","message":"POST /api/auth/refresh-session","timestamp":"2025-03-06T17:12:16.286Z"}
|
||||
{"level":"info","message":"Получен запрос на обновление сессии для адреса: 0xf45aa4917b3775ba37f48aeb3dc1a943561e9e0b","timestamp":"2025-03-06T17:12:16.287Z"}
|
||||
{"level":"error","message":"Ошибка при получении контракта AccessToken: abi is not iterable","timestamp":"2025-03-06T17:12:16.288Z"}
|
||||
{"level":"error","message":"Error checking admin token: abi is not iterable","timestamp":"2025-03-06T17:12:16.288Z"}
|
||||
{"level":"error","message":"Ошибка при получении контракта AccessToken: abi is not iterable","timestamp":"2025-03-06T17:12:16.291Z"}
|
||||
{"level":"error","message":"Error checking admin token: abi is not iterable","timestamp":"2025-03-06T17:12:16.291Z"}
|
||||
{"level":"info","message":"POST /api/auth/logout","timestamp":"2025-03-06T17:24:49.321Z"}
|
||||
{"level":"info","message":"GET /api/auth/nonce?address=0xf45aa4917b3775ba37f48aeb3dc1a943561e9e0b","timestamp":"2025-03-06T17:24:52.043Z"}
|
||||
{"level":"info","message":"POST /api/auth/verify","timestamp":"2025-03-06T17:24:54.218Z"}
|
||||
{"level":"error","message":"Ошибка при получении контракта AccessToken: abi is not iterable","timestamp":"2025-03-06T17:24:54.232Z"}
|
||||
{"level":"error","message":"Error checking admin token: abi is not iterable","timestamp":"2025-03-06T17:24:54.233Z"}
|
||||
{"level":"info","message":"POST /api/auth/refresh-session","timestamp":"2025-03-06T17:24:54.271Z"}
|
||||
{"level":"info","message":"Получен запрос на обновление сессии для адреса: 0xf45aa4917b3775ba37f48aeb3dc1a943561e9e0b","timestamp":"2025-03-06T17:24:54.272Z"}
|
||||
{"level":"error","message":"Ошибка при получении контракта AccessToken: abi is not iterable","timestamp":"2025-03-06T17:24:54.273Z"}
|
||||
{"level":"error","message":"Error checking admin token: abi is not iterable","timestamp":"2025-03-06T17:24:54.274Z"}
|
||||
{"level":"error","message":"Ошибка при получении контракта AccessToken: abi is not iterable","timestamp":"2025-03-06T17:24:54.279Z"}
|
||||
{"level":"error","message":"Error checking admin token: abi is not iterable","timestamp":"2025-03-06T17:24:54.280Z"}
|
||||
{"level":"info","message":"POST /api/auth/logout","timestamp":"2025-03-06T17:25:32.699Z"}
|
||||
{"level":"info","message":"GET /api/auth/nonce?address=0xf45aa4917b3775ba37f48aeb3dc1a943561e9e0b","timestamp":"2025-03-06T17:25:34.494Z"}
|
||||
{"level":"info","message":"POST /api/auth/verify","timestamp":"2025-03-06T17:25:36.923Z"}
|
||||
{"level":"error","message":"Ошибка при получении контракта AccessToken: abi is not iterable","timestamp":"2025-03-06T17:25:37.024Z"}
|
||||
{"level":"error","message":"Error checking admin token: abi is not iterable","timestamp":"2025-03-06T17:25:37.025Z"}
|
||||
{"level":"info","message":"POST /api/auth/refresh-session","timestamp":"2025-03-06T17:25:37.114Z"}
|
||||
{"level":"info","message":"Получен запрос на обновление сессии для адреса: 0xf45aa4917b3775ba37f48aeb3dc1a943561e9e0b","timestamp":"2025-03-06T17:25:37.116Z"}
|
||||
{"level":"error","message":"Ошибка при получении контракта AccessToken: abi is not iterable","timestamp":"2025-03-06T17:25:37.118Z"}
|
||||
{"level":"error","message":"Error checking admin token: abi is not iterable","timestamp":"2025-03-06T17:25:37.119Z"}
|
||||
{"level":"error","message":"Ошибка при получении контракта AccessToken: abi is not iterable","timestamp":"2025-03-06T17:25:37.132Z"}
|
||||
{"level":"error","message":"Error checking admin token: abi is not iterable","timestamp":"2025-03-06T17:25:37.133Z"}
|
||||
{"level":"info","message":"Running scheduled token balance check","timestamp":"2025-03-06T17:30:00.061Z"}
|
||||
{"level":"info","message":"Checking tokens for 2 users","timestamp":"2025-03-06T17:30:00.080Z"}
|
||||
{"level":"error","message":"Ошибка при получении контракта AccessToken: abi is not iterable","timestamp":"2025-03-06T17:30:00.086Z"}
|
||||
{"level":"error","message":"Error checking admin token: abi is not iterable","timestamp":"2025-03-06T17:30:00.087Z"}
|
||||
{"level":"info","message":"Updated role for user 10 to user","timestamp":"2025-03-06T17:30:00.110Z"}
|
||||
{"level":"info","message":"User 10 with address 0x0000000000000000000000000000000000000000: admin=false","timestamp":"2025-03-06T17:30:00.110Z"}
|
||||
{"level":"info","message":"Updated user 10 with address 0x0000000000000000000000000000000000000000: admin=false","timestamp":"2025-03-06T17:30:00.110Z"}
|
||||
{"level":"error","message":"Ошибка при получении контракта AccessToken: abi is not iterable","timestamp":"2025-03-06T17:30:00.113Z"}
|
||||
{"level":"error","message":"Error checking admin token: abi is not iterable","timestamp":"2025-03-06T17:30:00.114Z"}
|
||||
{"level":"info","message":"Updated role for user 13 to user","timestamp":"2025-03-06T17:30:00.118Z"}
|
||||
{"level":"info","message":"User 13 with address 0xf45aa4917b3775ba37f48aeb3dc1a943561e9e0b: admin=false","timestamp":"2025-03-06T17:30:00.119Z"}
|
||||
{"level":"info","message":"Updated user 13 with address 0xf45aa4917b3775ba37f48aeb3dc1a943561e9e0b: admin=false","timestamp":"2025-03-06T17:30:00.119Z"}
|
||||
{"level":"info","message":"Token check completed","timestamp":"2025-03-06T17:30:00.119Z"}
|
||||
{"level":"info","message":"POST /api/auth/logout","timestamp":"2025-03-06T17:36:54.763Z"}
|
||||
{"level":"info","message":"GET /api/auth/nonce?address=0xf45aa4917b3775ba37f48aeb3dc1a943561e9e0b","timestamp":"2025-03-06T17:36:58.206Z"}
|
||||
{"level":"info","message":"POST /api/auth/verify","timestamp":"2025-03-06T17:37:00.518Z"}
|
||||
{"level":"error","message":"Ошибка при получении контракта AccessToken: abi is not iterable","timestamp":"2025-03-06T17:37:00.599Z"}
|
||||
{"level":"error","message":"Error checking admin token: abi is not iterable","timestamp":"2025-03-06T17:37:00.602Z"}
|
||||
{"level":"info","message":"POST /api/auth/refresh-session","timestamp":"2025-03-06T17:37:00.643Z"}
|
||||
{"level":"info","message":"Получен запрос на обновление сессии для адреса: 0xf45aa4917b3775ba37f48aeb3dc1a943561e9e0b","timestamp":"2025-03-06T17:37:00.644Z"}
|
||||
{"level":"error","message":"Ошибка при получении контракта AccessToken: abi is not iterable","timestamp":"2025-03-06T17:37:00.645Z"}
|
||||
{"level":"error","message":"Error checking admin token: abi is not iterable","timestamp":"2025-03-06T17:37:00.646Z"}
|
||||
{"level":"error","message":"Ошибка при получении контракта AccessToken: abi is not iterable","timestamp":"2025-03-06T17:37:00.652Z"}
|
||||
{"level":"error","message":"Error checking admin token: abi is not iterable","timestamp":"2025-03-06T17:37:00.654Z"}
|
||||
{"level":"info","message":"POST /api/auth/logout","timestamp":"2025-03-06T18:04:36.618Z"}
|
||||
{"level":"info","message":"GET /api/auth/check","timestamp":"2025-03-06T18:04:39.301Z"}
|
||||
{"level":"info","message":"GET /api/auth/check","timestamp":"2025-03-06T18:04:39.313Z"}
|
||||
{"level":"info","message":"POST /api/auth/logout","timestamp":"2025-03-06T18:04:39.337Z"}
|
||||
{"level":"info","message":"POST /api/auth/refresh-session","timestamp":"2025-03-06T18:04:39.367Z"}
|
||||
{"level":"info","message":"Получен запрос на обновление сессии для адреса: 0xf45aa4917b3775ba37f48aeb3dc1a943561e9e0b","timestamp":"2025-03-06T18:04:39.368Z"}
|
||||
{"level":"error","message":"Ошибка при получении контракта AccessToken: ABI for AccessToken is not an array","timestamp":"2025-03-06T18:04:39.376Z"}
|
||||
{"level":"error","message":"Error checking admin token: ABI for AccessToken is not an array","timestamp":"2025-03-06T18:04:39.377Z"}
|
||||
{"level":"error","message":"Ошибка при получении контракта AccessToken: ABI for AccessToken is not an array","timestamp":"2025-03-06T18:04:39.393Z"}
|
||||
{"level":"error","message":"Error checking admin token: ABI for AccessToken is not an array","timestamp":"2025-03-06T18:04:39.394Z"}
|
||||
{"level":"info","message":"GET /api/auth/nonce?address=0xf45aa4917b3775ba37f48aeb3dc1a943561e9e0b","timestamp":"2025-03-06T18:04:48.796Z"}
|
||||
{"level":"info","message":"POST /api/auth/verify","timestamp":"2025-03-06T18:04:52.126Z"}
|
||||
{"level":"error","message":"Ошибка при получении контракта AccessToken: ABI for AccessToken is not an array","timestamp":"2025-03-06T18:04:52.200Z"}
|
||||
{"level":"error","message":"Error checking admin token: ABI for AccessToken is not an array","timestamp":"2025-03-06T18:04:52.202Z"}
|
||||
{"level":"info","message":"POST /api/auth/refresh-session","timestamp":"2025-03-06T18:04:52.268Z"}
|
||||
{"level":"info","message":"Получен запрос на обновление сессии для адреса: 0xf45aa4917b3775ba37f48aeb3dc1a943561e9e0b","timestamp":"2025-03-06T18:04:52.269Z"}
|
||||
{"level":"error","message":"Ошибка при получении контракта AccessToken: ABI for AccessToken is not an array","timestamp":"2025-03-06T18:04:52.277Z"}
|
||||
{"level":"error","message":"Error checking admin token: ABI for AccessToken is not an array","timestamp":"2025-03-06T18:04:52.278Z"}
|
||||
{"level":"error","message":"Ошибка при получении контракта AccessToken: ABI for AccessToken is not an array","timestamp":"2025-03-06T18:04:52.465Z"}
|
||||
{"level":"error","message":"Error checking admin token: ABI for AccessToken is not an array","timestamp":"2025-03-06T18:04:52.466Z"}
|
||||
{"level":"info","message":"POST /api/auth/logout","timestamp":"2025-03-06T18:18:59.694Z"}
|
||||
{"level":"info","message":"GET /api/auth/nonce?address=0xf45aa4917b3775ba37f48aeb3dc1a943561e9e0b","timestamp":"2025-03-06T18:19:02.083Z"}
|
||||
{"level":"info","message":"POST /api/auth/verify","timestamp":"2025-03-06T18:19:04.350Z"}
|
||||
{"level":"info","message":"POST /api/auth/refresh-session","timestamp":"2025-03-06T18:19:05.705Z"}
|
||||
{"level":"info","message":"Получен запрос на обновление сессии для адреса: 0xf45aa4917b3775ba37f48aeb3dc1a943561e9e0b","timestamp":"2025-03-06T18:19:05.707Z"}
|
||||
{"level":"info","message":"GET /api/auth/check","timestamp":"2025-03-06T18:22:11.971Z"}
|
||||
{"level":"info","message":"GET /api/auth/check","timestamp":"2025-03-06T18:22:11.999Z"}
|
||||
{"level":"info","message":"POST /api/auth/refresh-session","timestamp":"2025-03-06T18:22:12.029Z"}
|
||||
{"level":"info","message":"Получен запрос на обновление сессии для адреса: 0xf45aa4917b3775ba37f48aeb3dc1a943561e9e0b","timestamp":"2025-03-06T18:22:12.030Z"}
|
||||
{"level":"info","message":"POST /api/auth/logout","timestamp":"2025-03-06T18:22:12.038Z"}
|
||||
{"level":"info","message":"GET /api/auth/check","timestamp":"2025-03-06T18:22:29.560Z"}
|
||||
{"level":"info","message":"GET /api/auth/check","timestamp":"2025-03-06T18:22:29.585Z"}
|
||||
{"level":"info","message":"POST /api/auth/logout","timestamp":"2025-03-06T18:22:29.616Z"}
|
||||
{"level":"info","message":"POST /api/auth/refresh-session","timestamp":"2025-03-06T18:22:29.630Z"}
|
||||
{"level":"info","message":"Получен запрос на обновление сессии для адреса: 0xf45aa4917b3775ba37f48aeb3dc1a943561e9e0b","timestamp":"2025-03-06T18:22:29.631Z"}
|
||||
{"level":"info","message":"GET /api/auth/nonce?address=0x0a98c54327253bb51f99c8218e5a7a01933d5f57","timestamp":"2025-03-06T18:23:07.118Z"}
|
||||
{"level":"info","message":"POST /api/auth/verify","timestamp":"2025-03-06T18:23:10.844Z"}
|
||||
{"level":"error","message":"Error checking admin token: execution reverted: \"No active token\" (action=\"call\", data=\"0x08c379a00000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000f4e6f2061637469766520746f6b656e0000000000000000000000000000000000\", reason=\"No active token\", transaction={ \"data\": \"0xa0d7823e0000000000000000000000000a98c54327253bb51f99c8218e5a7a01933d5f57\", \"to\": \"0xF352c498cF0857F472dC473E4Dd39551E79B1063\" }, invocation=null, revert={ \"args\": [ \"No active token\" ], \"name\": \"Error\", \"signature\": \"Error(string)\" }, code=CALL_EXCEPTION, version=6.13.5)","timestamp":"2025-03-06T18:23:11.554Z"}
|
||||
{"level":"info","message":"POST /api/auth/refresh-session","timestamp":"2025-03-06T18:23:11.574Z"}
|
||||
{"level":"info","message":"Получен запрос на обновление сессии для адреса: 0x0a98c54327253bb51f99c8218e5a7a01933d5f57","timestamp":"2025-03-06T18:23:11.574Z"}
|
||||
{"level":"error","message":"Error checking admin token: execution reverted: \"No active token\" (action=\"call\", data=\"0x08c379a00000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000f4e6f2061637469766520746f6b656e0000000000000000000000000000000000\", reason=\"No active token\", transaction={ \"data\": \"0xa0d7823e0000000000000000000000000a98c54327253bb51f99c8218e5a7a01933d5f57\", \"to\": \"0xF352c498cF0857F472dC473E4Dd39551E79B1063\" }, invocation=null, revert={ \"args\": [ \"No active token\" ], \"name\": \"Error\", \"signature\": \"Error(string)\" }, code=CALL_EXCEPTION, version=6.13.5)","timestamp":"2025-03-06T18:23:11.848Z"}
|
||||
{"level":"error","message":"Error checking admin token: execution reverted: \"No active token\" (action=\"call\", data=\"0x08c379a00000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000f4e6f2061637469766520746f6b656e0000000000000000000000000000000000\", reason=\"No active token\", transaction={ \"data\": \"0xa0d7823e0000000000000000000000000a98c54327253bb51f99c8218e5a7a01933d5f57\", \"to\": \"0xF352c498cF0857F472dC473E4Dd39551E79B1063\" }, invocation=null, revert={ \"args\": [ \"No active token\" ], \"name\": \"Error\", \"signature\": \"Error(string)\" }, code=CALL_EXCEPTION, version=6.13.5)","timestamp":"2025-03-06T18:23:12.075Z"}
|
||||
{"level":"info","message":"POST /api/chat/message","timestamp":"2025-03-06T18:23:19.453Z"}
|
||||
{"level":"info","message":"POST /api/chat/message","timestamp":"2025-03-06T18:25:21.284Z"}
|
||||
{"level":"info","message":"Running scheduled token balance check","timestamp":"2025-03-06T18:30:00.048Z"}
|
||||
{"level":"info","message":"Checking tokens for 2 users","timestamp":"2025-03-06T18:30:00.069Z"}
|
||||
{"level":"error","message":"Error checking admin token: execution reverted: \"No active token\" (action=\"call\", data=\"0x08c379a00000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000f4e6f2061637469766520746f6b656e0000000000000000000000000000000000\", reason=\"No active token\", transaction={ \"data\": \"0xa0d7823e0000000000000000000000000000000000000000000000000000000000000000\", \"to\": \"0xF352c498cF0857F472dC473E4Dd39551E79B1063\" }, invocation=null, revert={ \"args\": [ \"No active token\" ], \"name\": \"Error\", \"signature\": \"Error(string)\" }, code=CALL_EXCEPTION, version=6.13.5)","timestamp":"2025-03-06T18:30:01.179Z"}
|
||||
{"level":"info","message":"Updated role for user 10 to user","timestamp":"2025-03-06T18:30:01.188Z"}
|
||||
{"level":"info","message":"User 10 with address 0x0000000000000000000000000000000000000000: admin=false","timestamp":"2025-03-06T18:30:01.189Z"}
|
||||
{"level":"info","message":"Updated user 10 with address 0x0000000000000000000000000000000000000000: admin=false","timestamp":"2025-03-06T18:30:01.189Z"}
|
||||
{"level":"info","message":"Updated role for user 13 to user","timestamp":"2025-03-06T18:30:01.748Z"}
|
||||
{"level":"info","message":"User 13 with address 0xf45aa4917b3775ba37f48aeb3dc1a943561e9e0b: admin=false","timestamp":"2025-03-06T18:30:01.749Z"}
|
||||
{"level":"info","message":"Updated user 13 with address 0xf45aa4917b3775ba37f48aeb3dc1a943561e9e0b: admin=false","timestamp":"2025-03-06T18:30:01.749Z"}
|
||||
{"level":"info","message":"Token check completed","timestamp":"2025-03-06T18:30:01.749Z"}
|
||||
|
||||
@@ -1,4 +1,46 @@
|
||||
{"level":"error","message":"Ошибка при получении контракта AccessToken: Адрес контракта AccessToken не найден в переменных окружения","timestamp":"2025-03-04T20:30:00.983Z"}
|
||||
{"level":"error","message":"Error checking token balance for 0x0000000000000000000000000000000000000000: Адрес контракта AccessToken не найден в переменных окружения","timestamp":"2025-03-04T20:30:00.983Z"}
|
||||
{"level":"error","message":"Ошибка при получении контракта AccessToken: Адрес контракта AccessToken не найден в переменных окружения","timestamp":"2025-03-04T21:30:00.794Z"}
|
||||
{"level":"error","message":"Error checking token balance for 0x0000000000000000000000000000000000000000: Адрес контракта AccessToken не найден в переменных окружения","timestamp":"2025-03-04T21:30:00.795Z"}
|
||||
{"level":"error","message":"Ошибка при получении контракта AccessToken: abi is not iterable","timestamp":"2025-03-06T17:11:55.866Z"}
|
||||
{"level":"error","message":"Error checking admin token: abi is not iterable","timestamp":"2025-03-06T17:11:55.867Z"}
|
||||
{"level":"error","message":"Ошибка при получении контракта AccessToken: abi is not iterable","timestamp":"2025-03-06T17:11:55.877Z"}
|
||||
{"level":"error","message":"Error checking admin token: abi is not iterable","timestamp":"2025-03-06T17:11:55.878Z"}
|
||||
{"level":"error","message":"Ошибка при получении контракта AccessToken: abi is not iterable","timestamp":"2025-03-06T17:12:16.262Z"}
|
||||
{"level":"error","message":"Error checking admin token: abi is not iterable","timestamp":"2025-03-06T17:12:16.263Z"}
|
||||
{"level":"error","message":"Ошибка при получении контракта AccessToken: abi is not iterable","timestamp":"2025-03-06T17:12:16.288Z"}
|
||||
{"level":"error","message":"Error checking admin token: abi is not iterable","timestamp":"2025-03-06T17:12:16.288Z"}
|
||||
{"level":"error","message":"Ошибка при получении контракта AccessToken: abi is not iterable","timestamp":"2025-03-06T17:12:16.291Z"}
|
||||
{"level":"error","message":"Error checking admin token: abi is not iterable","timestamp":"2025-03-06T17:12:16.291Z"}
|
||||
{"level":"error","message":"Ошибка при получении контракта AccessToken: abi is not iterable","timestamp":"2025-03-06T17:24:54.232Z"}
|
||||
{"level":"error","message":"Error checking admin token: abi is not iterable","timestamp":"2025-03-06T17:24:54.233Z"}
|
||||
{"level":"error","message":"Ошибка при получении контракта AccessToken: abi is not iterable","timestamp":"2025-03-06T17:24:54.273Z"}
|
||||
{"level":"error","message":"Error checking admin token: abi is not iterable","timestamp":"2025-03-06T17:24:54.274Z"}
|
||||
{"level":"error","message":"Ошибка при получении контракта AccessToken: abi is not iterable","timestamp":"2025-03-06T17:24:54.279Z"}
|
||||
{"level":"error","message":"Error checking admin token: abi is not iterable","timestamp":"2025-03-06T17:24:54.280Z"}
|
||||
{"level":"error","message":"Ошибка при получении контракта AccessToken: abi is not iterable","timestamp":"2025-03-06T17:25:37.024Z"}
|
||||
{"level":"error","message":"Error checking admin token: abi is not iterable","timestamp":"2025-03-06T17:25:37.025Z"}
|
||||
{"level":"error","message":"Ошибка при получении контракта AccessToken: abi is not iterable","timestamp":"2025-03-06T17:25:37.118Z"}
|
||||
{"level":"error","message":"Error checking admin token: abi is not iterable","timestamp":"2025-03-06T17:25:37.119Z"}
|
||||
{"level":"error","message":"Ошибка при получении контракта AccessToken: abi is not iterable","timestamp":"2025-03-06T17:25:37.132Z"}
|
||||
{"level":"error","message":"Error checking admin token: abi is not iterable","timestamp":"2025-03-06T17:25:37.133Z"}
|
||||
{"level":"error","message":"Ошибка при получении контракта AccessToken: abi is not iterable","timestamp":"2025-03-06T17:30:00.086Z"}
|
||||
{"level":"error","message":"Error checking admin token: abi is not iterable","timestamp":"2025-03-06T17:30:00.087Z"}
|
||||
{"level":"error","message":"Ошибка при получении контракта AccessToken: abi is not iterable","timestamp":"2025-03-06T17:30:00.113Z"}
|
||||
{"level":"error","message":"Error checking admin token: abi is not iterable","timestamp":"2025-03-06T17:30:00.114Z"}
|
||||
{"level":"error","message":"Ошибка при получении контракта AccessToken: abi is not iterable","timestamp":"2025-03-06T17:37:00.599Z"}
|
||||
{"level":"error","message":"Error checking admin token: abi is not iterable","timestamp":"2025-03-06T17:37:00.602Z"}
|
||||
{"level":"error","message":"Ошибка при получении контракта AccessToken: abi is not iterable","timestamp":"2025-03-06T17:37:00.645Z"}
|
||||
{"level":"error","message":"Error checking admin token: abi is not iterable","timestamp":"2025-03-06T17:37:00.646Z"}
|
||||
{"level":"error","message":"Ошибка при получении контракта AccessToken: abi is not iterable","timestamp":"2025-03-06T17:37:00.652Z"}
|
||||
{"level":"error","message":"Error checking admin token: abi is not iterable","timestamp":"2025-03-06T17:37:00.654Z"}
|
||||
{"level":"error","message":"Ошибка при получении контракта AccessToken: ABI for AccessToken is not an array","timestamp":"2025-03-06T18:04:39.376Z"}
|
||||
{"level":"error","message":"Error checking admin token: ABI for AccessToken is not an array","timestamp":"2025-03-06T18:04:39.377Z"}
|
||||
{"level":"error","message":"Ошибка при получении контракта AccessToken: ABI for AccessToken is not an array","timestamp":"2025-03-06T18:04:39.393Z"}
|
||||
{"level":"error","message":"Error checking admin token: ABI for AccessToken is not an array","timestamp":"2025-03-06T18:04:39.394Z"}
|
||||
{"level":"error","message":"Ошибка при получении контракта AccessToken: ABI for AccessToken is not an array","timestamp":"2025-03-06T18:04:52.200Z"}
|
||||
{"level":"error","message":"Error checking admin token: ABI for AccessToken is not an array","timestamp":"2025-03-06T18:04:52.202Z"}
|
||||
{"level":"error","message":"Ошибка при получении контракта AccessToken: ABI for AccessToken is not an array","timestamp":"2025-03-06T18:04:52.277Z"}
|
||||
{"level":"error","message":"Error checking admin token: ABI for AccessToken is not an array","timestamp":"2025-03-06T18:04:52.278Z"}
|
||||
{"level":"error","message":"Ошибка при получении контракта AccessToken: ABI for AccessToken is not an array","timestamp":"2025-03-06T18:04:52.465Z"}
|
||||
{"level":"error","message":"Error checking admin token: ABI for AccessToken is not an array","timestamp":"2025-03-06T18:04:52.466Z"}
|
||||
{"level":"error","message":"Error checking admin token: execution reverted: \"No active token\" (action=\"call\", data=\"0x08c379a00000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000f4e6f2061637469766520746f6b656e0000000000000000000000000000000000\", reason=\"No active token\", transaction={ \"data\": \"0xa0d7823e0000000000000000000000000a98c54327253bb51f99c8218e5a7a01933d5f57\", \"to\": \"0xF352c498cF0857F472dC473E4Dd39551E79B1063\" }, invocation=null, revert={ \"args\": [ \"No active token\" ], \"name\": \"Error\", \"signature\": \"Error(string)\" }, code=CALL_EXCEPTION, version=6.13.5)","timestamp":"2025-03-06T18:23:11.554Z"}
|
||||
{"level":"error","message":"Error checking admin token: execution reverted: \"No active token\" (action=\"call\", data=\"0x08c379a00000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000f4e6f2061637469766520746f6b656e0000000000000000000000000000000000\", reason=\"No active token\", transaction={ \"data\": \"0xa0d7823e0000000000000000000000000a98c54327253bb51f99c8218e5a7a01933d5f57\", \"to\": \"0xF352c498cF0857F472dC473E4Dd39551E79B1063\" }, invocation=null, revert={ \"args\": [ \"No active token\" ], \"name\": \"Error\", \"signature\": \"Error(string)\" }, code=CALL_EXCEPTION, version=6.13.5)","timestamp":"2025-03-06T18:23:11.848Z"}
|
||||
{"level":"error","message":"Error checking admin token: execution reverted: \"No active token\" (action=\"call\", data=\"0x08c379a00000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000f4e6f2061637469766520746f6b656e0000000000000000000000000000000000\", reason=\"No active token\", transaction={ \"data\": \"0xa0d7823e0000000000000000000000000a98c54327253bb51f99c8218e5a7a01933d5f57\", \"to\": \"0xF352c498cF0857F472dC473E4Dd39551E79B1063\" }, invocation=null, revert={ \"args\": [ \"No active token\" ], \"name\": \"Error\", \"signature\": \"Error(string)\" }, code=CALL_EXCEPTION, version=6.13.5)","timestamp":"2025-03-06T18:23:12.075Z"}
|
||||
{"level":"error","message":"Error checking admin token: execution reverted: \"No active token\" (action=\"call\", data=\"0x08c379a00000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000f4e6f2061637469766520746f6b656e0000000000000000000000000000000000\", reason=\"No active token\", transaction={ \"data\": \"0xa0d7823e0000000000000000000000000000000000000000000000000000000000000000\", \"to\": \"0xF352c498cF0857F472dC473E4Dd39551E79B1063\" }, invocation=null, revert={ \"args\": [ \"No active token\" ], \"name\": \"Error\", \"signature\": \"Error(string)\" }, code=CALL_EXCEPTION, version=6.13.5)","timestamp":"2025-03-06T18:30:01.179Z"}
|
||||
|
||||
@@ -1,130 +1,132 @@
|
||||
const { createError } = require('./errorHandler');
|
||||
const authService = require('../services/auth-service');
|
||||
const logger = require('../utils/logger');
|
||||
const { getUserInfo } = require('../utils/access-check');
|
||||
const { USER_ROLES } = require('../utils/constants');
|
||||
const db = require('../db');
|
||||
|
||||
// Добавьте в начало файла
|
||||
const isMiddleware = true;
|
||||
|
||||
// Middleware для проверки роли
|
||||
const requireRole = (allowedRoles) => async (req, res, next) => {
|
||||
if (!req.session || !req.session.authenticated || !req.session.userId) {
|
||||
return res.status(401).json({ error: 'Требуется аутентификация' });
|
||||
/**
|
||||
* Middleware для проверки аутентификации
|
||||
*/
|
||||
function requireAuth(req, res, next) {
|
||||
console.log('Session in requireAuth:', req.session);
|
||||
if (!req.session || !req.session.authenticated) {
|
||||
return next(createError(401, 'Требуется аутентификация'));
|
||||
}
|
||||
next();
|
||||
}
|
||||
|
||||
/**
|
||||
* Middleware для проверки прав администратора
|
||||
*/
|
||||
async function requireAdmin(req, res, next) {
|
||||
try {
|
||||
// Получение информации о пользователе
|
||||
const userInfo = await getUserInfo(req.session.userId);
|
||||
|
||||
if (!userInfo) {
|
||||
return res.status(401).json({ error: 'Пользователь не найден' });
|
||||
// Проверка аутентификации
|
||||
if (!req.session || !req.session.authenticated) {
|
||||
return next(createError('Требуется аутентификация', 401));
|
||||
}
|
||||
|
||||
// Проверка роли
|
||||
if (!allowedRoles.includes(userInfo.role)) {
|
||||
return res.status(403).json({ error: 'Недостаточно прав' });
|
||||
// Проверка через сессию
|
||||
if (req.session.isAdmin) {
|
||||
return next();
|
||||
}
|
||||
|
||||
next();
|
||||
} catch (error) {
|
||||
logger.error('Error checking user role:', error);
|
||||
res.status(500).json({ error: 'Внутренняя ошибка сервера' });
|
||||
}
|
||||
};
|
||||
|
||||
// Проверка роли пользователя
|
||||
const checkRole = async (req, res, next) => {
|
||||
try {
|
||||
// Если функция вызвана как middleware
|
||||
const isMiddleware = typeof next === 'function';
|
||||
|
||||
if (!req.session.authenticated) {
|
||||
return isMiddleware ? res.status(401).json({ error: 'Не авторизован' }) : false;
|
||||
}
|
||||
|
||||
// Если роль администратора уже проверена в сессии
|
||||
if (req.session.isAdmin === true) {
|
||||
return isMiddleware ? next() : true;
|
||||
}
|
||||
|
||||
const db = require('../db');
|
||||
|
||||
// Проверка наличия токенов доступа в смарт-контракте
|
||||
// Проверка через кошелек
|
||||
if (req.session.address) {
|
||||
const address = req.session.address.toLowerCase();
|
||||
|
||||
// Проверка в базе данных
|
||||
const userRole = await db.query(
|
||||
'SELECT r.name FROM users u JOIN roles r ON u.role_id = r.id WHERE LOWER(u.address) = $1',
|
||||
[address]
|
||||
);
|
||||
|
||||
if (userRole.rows.length > 0 && userRole.rows[0].name === 'admin') {
|
||||
const isAdmin = await authService.checkAdminToken(req.session.address);
|
||||
if (isAdmin) {
|
||||
// Обновляем сессию
|
||||
req.session.isAdmin = true;
|
||||
return isMiddleware ? next() : true;
|
||||
}
|
||||
|
||||
// Проверка токенов в смарт-контракте через сервис
|
||||
const { ethers } = require('ethers');
|
||||
const provider = new ethers.JsonRpcProvider(process.env.PROVIDER_URL);
|
||||
const accessTokenABI = require('../artifacts/contracts/AccessToken.sol/AccessToken.json').abi;
|
||||
const accessTokenContract = new ethers.Contract(
|
||||
process.env.ACCESS_TOKEN_ADDRESS,
|
||||
accessTokenABI,
|
||||
provider
|
||||
);
|
||||
|
||||
try {
|
||||
const hasAdminRole = await accessTokenContract.hasRole(
|
||||
ethers.keccak256(ethers.toUtf8Bytes('ADMIN_ROLE')),
|
||||
address
|
||||
);
|
||||
|
||||
if (hasAdminRole) {
|
||||
// Обновляем роль в базе данных
|
||||
await db.query(
|
||||
'UPDATE users SET role_id = (SELECT id FROM roles WHERE name = $1) WHERE LOWER(address) = $2',
|
||||
['admin', address]
|
||||
);
|
||||
req.session.isAdmin = true;
|
||||
return isMiddleware ? next() : true;
|
||||
}
|
||||
} catch (error) {
|
||||
console.error('Ошибка при проверке роли в контракте:', error);
|
||||
return next();
|
||||
}
|
||||
}
|
||||
|
||||
// Если пользователь не администратор
|
||||
req.session.isAdmin = false;
|
||||
return isMiddleware ? res.status(403).json({ error: 'Недостаточно прав' }) : false;
|
||||
// Проверка через ID пользователя
|
||||
if (req.session.userId) {
|
||||
const userResult = await db.query('SELECT role FROM users WHERE id = $1', [req.session.userId]);
|
||||
if (userResult.rows.length > 0 && userResult.rows[0].role === USER_ROLES.ADMIN) {
|
||||
// Обновляем сессию
|
||||
req.session.isAdmin = true;
|
||||
return next();
|
||||
}
|
||||
}
|
||||
|
||||
// Если ни одна проверка не прошла
|
||||
return next(createError('Доступ запрещен', 403));
|
||||
} catch (error) {
|
||||
console.error('Ошибка при проверке роли:', error);
|
||||
return isMiddleware ? res.status(500).json({ error: 'Внутренняя ошибка сервера' }) : false;
|
||||
logger.error(`Error in requireAdmin middleware: ${error.message}`);
|
||||
return next(createError('Внутренняя ошибка сервера', 500));
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
// Middleware для проверки аутентификации
|
||||
const requireAuth = (req, res, next) => {
|
||||
if (!req.session || !req.session.authenticated) {
|
||||
return res.status(401).json({ error: 'Требуется аутентификация' });
|
||||
}
|
||||
next();
|
||||
};
|
||||
/**
|
||||
* Middleware для проверки определенной роли
|
||||
* @param {string} role - Требуемая роль
|
||||
*/
|
||||
function requireRole(role) {
|
||||
return async (req, res, next) => {
|
||||
try {
|
||||
// Проверка аутентификации
|
||||
if (!req.session || !req.session.authenticated) {
|
||||
return next(createError('Требуется аутентификация', 401));
|
||||
}
|
||||
|
||||
// Middleware для проверки прав администратора
|
||||
const requireAdmin = (req, res, next) => {
|
||||
if (!req.session || !req.session.authenticated) {
|
||||
return res.status(401).json({ error: 'Требуется аутентификация' });
|
||||
}
|
||||
// Для администраторов разрешаем все
|
||||
if (req.session.isAdmin) {
|
||||
return next();
|
||||
}
|
||||
|
||||
if (!req.session.isAdmin) {
|
||||
return res.status(403).json({ error: 'Требуются права администратора' });
|
||||
}
|
||||
// Проверка через ID пользователя
|
||||
if (req.session.userId) {
|
||||
const userResult = await db.query('SELECT role FROM users WHERE id = $1', [req.session.userId]);
|
||||
if (userResult.rows.length > 0 && userResult.rows[0].role === role) {
|
||||
return next();
|
||||
}
|
||||
}
|
||||
|
||||
next();
|
||||
};
|
||||
// Если проверка не прошла
|
||||
return next(createError('Доступ запрещен', 403));
|
||||
} catch (error) {
|
||||
logger.error(`Error in requireRole middleware: ${error.message}`);
|
||||
return next(createError('Внутренняя ошибка сервера', 500));
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Проверяет роль пользователя
|
||||
* @param {string} role - Роль для проверки
|
||||
*/
|
||||
function checkRole(role) {
|
||||
return async (req, res, next) => {
|
||||
try {
|
||||
// Если пользователь не аутентифицирован, просто продолжаем
|
||||
if (!req.session || !req.session.authenticated) {
|
||||
req.hasRole = false;
|
||||
return next();
|
||||
}
|
||||
|
||||
// Проверка через ID пользователя
|
||||
if (req.session.userId) {
|
||||
const userResult = await db.query('SELECT role FROM users WHERE id = $1', [req.session.userId]);
|
||||
if (userResult.rows.length > 0 && userResult.rows[0].role === role) {
|
||||
req.hasRole = true;
|
||||
return next();
|
||||
}
|
||||
}
|
||||
|
||||
req.hasRole = false;
|
||||
next();
|
||||
} catch (error) {
|
||||
logger.error(`Error in checkRole middleware: ${error.message}`);
|
||||
req.hasRole = false;
|
||||
next();
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
module.exports = {
|
||||
requireRole,
|
||||
requireAuth,
|
||||
requireAdmin,
|
||||
checkRole,
|
||||
requireRole,
|
||||
checkRole
|
||||
};
|
||||
|
||||
71
backend/middleware/errorHandler.js
Normal file
71
backend/middleware/errorHandler.js
Normal file
@@ -0,0 +1,71 @@
|
||||
const logger = require('../utils/logger');
|
||||
const { ERROR_CODES } = require('../utils/constants');
|
||||
|
||||
/**
|
||||
* Middleware для обработки ошибок
|
||||
*/
|
||||
function errorHandler(err, req, res, next) {
|
||||
// Логируем ошибку
|
||||
logger.error(`Error: ${err.message}`, {
|
||||
stack: err.stack,
|
||||
url: req.originalUrl,
|
||||
method: req.method,
|
||||
ip: req.ip,
|
||||
userId: req.session?.userId
|
||||
});
|
||||
|
||||
// Определяем тип ошибки
|
||||
let statusCode = 500;
|
||||
let errorCode = ERROR_CODES.INTERNAL_ERROR;
|
||||
let errorMessage = 'Внутренняя ошибка сервера';
|
||||
|
||||
// Обрабатываем разные типы ошибок
|
||||
if (err.name === 'UnauthorizedError' || err.status === 401) {
|
||||
statusCode = 401;
|
||||
errorCode = ERROR_CODES.UNAUTHORIZED;
|
||||
errorMessage = 'Требуется аутентификация';
|
||||
} else if (err.status === 403) {
|
||||
statusCode = 403;
|
||||
errorCode = ERROR_CODES.FORBIDDEN;
|
||||
errorMessage = 'Доступ запрещен';
|
||||
} else if (err.status === 404) {
|
||||
statusCode = 404;
|
||||
errorCode = ERROR_CODES.NOT_FOUND;
|
||||
errorMessage = 'Ресурс не найден';
|
||||
} else if (err.status === 400) {
|
||||
statusCode = 400;
|
||||
errorCode = ERROR_CODES.BAD_REQUEST;
|
||||
errorMessage = err.message || 'Некорректный запрос';
|
||||
}
|
||||
|
||||
// В режиме разработки возвращаем стек ошибки
|
||||
const devError = process.env.NODE_ENV === 'development'
|
||||
? { stack: err.stack }
|
||||
: {};
|
||||
|
||||
// Отправляем ответ клиенту
|
||||
res.status(statusCode).json({
|
||||
error: {
|
||||
code: errorCode,
|
||||
message: errorMessage,
|
||||
...devError
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Функция для создания ошибок с определенным статусом
|
||||
* @param {string} message - Сообщение об ошибке
|
||||
* @param {number} status - HTTP-статус ошибки
|
||||
* @returns {Error} - Объект ошибки
|
||||
*/
|
||||
function createError(message, status) {
|
||||
const error = new Error(message);
|
||||
error.status = status;
|
||||
return error;
|
||||
}
|
||||
|
||||
module.exports = {
|
||||
errorHandler,
|
||||
createError
|
||||
};
|
||||
56
backend/middleware/errorMiddleware.js
Normal file
56
backend/middleware/errorMiddleware.js
Normal file
@@ -0,0 +1,56 @@
|
||||
const logger = require('../utils/logger');
|
||||
const { ERROR_CODES } = require('../utils/constants');
|
||||
|
||||
/**
|
||||
* Middleware для обработки ошибок
|
||||
*/
|
||||
function errorMiddleware(err, req, res, next) {
|
||||
// Логируем ошибку
|
||||
logger.error(`Error: ${err.message}`, {
|
||||
stack: err.stack,
|
||||
url: req.originalUrl,
|
||||
method: req.method,
|
||||
ip: req.ip,
|
||||
userId: req.session?.userId
|
||||
});
|
||||
|
||||
// Определяем тип ошибки
|
||||
let statusCode = 500;
|
||||
let errorCode = ERROR_CODES.INTERNAL_ERROR;
|
||||
let errorMessage = 'Внутренняя ошибка сервера';
|
||||
|
||||
// Обрабатываем разные типы ошибок
|
||||
if (err.name === 'UnauthorizedError' || err.status === 401) {
|
||||
statusCode = 401;
|
||||
errorCode = ERROR_CODES.UNAUTHORIZED;
|
||||
errorMessage = 'Требуется аутентификация';
|
||||
} else if (err.status === 403) {
|
||||
statusCode = 403;
|
||||
errorCode = ERROR_CODES.FORBIDDEN;
|
||||
errorMessage = 'Доступ запрещен';
|
||||
} else if (err.status === 404) {
|
||||
statusCode = 404;
|
||||
errorCode = ERROR_CODES.NOT_FOUND;
|
||||
errorMessage = 'Ресурс не найден';
|
||||
} else if (err.status === 400) {
|
||||
statusCode = 400;
|
||||
errorCode = ERROR_CODES.BAD_REQUEST;
|
||||
errorMessage = err.message || 'Некорректный запрос';
|
||||
}
|
||||
|
||||
// В режиме разработки возвращаем стек ошибки
|
||||
const devError = process.env.NODE_ENV === 'development'
|
||||
? { stack: err.stack }
|
||||
: {};
|
||||
|
||||
// Отправляем ответ клиенту
|
||||
res.status(statusCode).json({
|
||||
error: {
|
||||
code: errorCode,
|
||||
message: errorMessage,
|
||||
...devError
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
module.exports = errorMiddleware;
|
||||
@@ -1,12 +1,14 @@
|
||||
const logger = (req, res, next) => {
|
||||
const logger = require('../utils/logger');
|
||||
|
||||
const requestLogger = (req, res, next) => {
|
||||
const start = Date.now();
|
||||
|
||||
res.on('finish', () => {
|
||||
const duration = Date.now() - start;
|
||||
console.log(`${req.method} ${req.originalUrl} - ${res.statusCode} - ${duration}ms`);
|
||||
logger.info(`${req.method} ${req.originalUrl} - ${res.statusCode} - ${duration}ms`);
|
||||
});
|
||||
|
||||
next();
|
||||
};
|
||||
|
||||
module.exports = logger;
|
||||
module.exports = requestLogger;
|
||||
@@ -4,18 +4,18 @@ const { pool } = require('../db');
|
||||
|
||||
const sessionMiddleware = session({
|
||||
store: new pgSession({
|
||||
pool: pool,
|
||||
pool,
|
||||
tableName: 'session',
|
||||
createTableIfMissing: true,
|
||||
}),
|
||||
secret: process.env.SESSION_SECRET || 'your-secret-key',
|
||||
resave: false,
|
||||
saveUninitialized: false,
|
||||
saveUninitialized: true,
|
||||
cookie: {
|
||||
secure: process.env.NODE_ENV === 'production', // В production должно быть true
|
||||
maxAge: 30 * 24 * 60 * 60 * 1000, // 30 дней
|
||||
httpOnly: true,
|
||||
maxAge: 24 * 60 * 60 * 1000, // 24 часа
|
||||
sameSite: 'none', // Для работы между разными доменами
|
||||
secure: process.env.NODE_ENV === 'production', // В production должно быть true
|
||||
sameSite: 'lax', // Попробуйте изменить на 'none' если используете разные домены
|
||||
},
|
||||
});
|
||||
|
||||
|
||||
@@ -24,14 +24,15 @@
|
||||
"@langchain/community": "^0.3.34",
|
||||
"@langchain/core": "0.3.0",
|
||||
"@langchain/ollama": "^0.2.0",
|
||||
"@openzeppelin/contracts": "4.5.0",
|
||||
"axios": "^1.6.7",
|
||||
"connect-pg-simple": "^10.0.0",
|
||||
"cors": "^2.8.5",
|
||||
"cron": "^4.1.0",
|
||||
"csurf": "^1.11.0",
|
||||
"dotenv": "^16.0.3",
|
||||
"ethers": "6.13.5",
|
||||
"express": "^4.18.2",
|
||||
"ethers": "^6.13.5",
|
||||
"express": "^4.21.2",
|
||||
"express-rate-limit": "^7.5.0",
|
||||
"express-session": "^1.17.3",
|
||||
"helmet": "^8.0.0",
|
||||
@@ -48,10 +49,29 @@
|
||||
"winston": "^3.17.0"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@nomicfoundation/hardhat-chai-matchers": "^2.0.0",
|
||||
"@nomicfoundation/hardhat-ethers": "^3.0.0",
|
||||
"@nomicfoundation/hardhat-ignition": "^0.15.10",
|
||||
"@nomicfoundation/hardhat-ignition-ethers": "^0.15.0",
|
||||
"@nomicfoundation/hardhat-network-helpers": "^1.0.0",
|
||||
"@nomicfoundation/hardhat-toolbox": "^5.0.0",
|
||||
"@nomicfoundation/hardhat-verify": "^2.0.0",
|
||||
"@nomicfoundation/ignition-core": "^0.15.10",
|
||||
"@typechain/ethers-v6": "^0.5.0",
|
||||
"@typechain/hardhat": "^9.0.0",
|
||||
"@types/chai": "^4.2.0",
|
||||
"@types/mocha": ">=9.1.0",
|
||||
"chai": "^4.2.0",
|
||||
"eslint": "^9.21.0",
|
||||
"eslint-config-prettier": "^10.0.2",
|
||||
"globals": "^16.0.0",
|
||||
"hardhat": "^2.22.19",
|
||||
"hardhat-gas-reporter": "^1.0.8",
|
||||
"nodemon": "^3.1.9",
|
||||
"prettier": "^3.5.3"
|
||||
"prettier": "^3.5.3",
|
||||
"solidity-coverage": "^0.8.1",
|
||||
"ts-node": ">=8.0.0",
|
||||
"typechain": "^8.3.0",
|
||||
"typescript": ">=4.5.0"
|
||||
}
|
||||
}
|
||||
|
||||
@@ -4,43 +4,24 @@ const { Pool } = require('pg');
|
||||
const { requireAuth, requireAdmin } = require('../middleware/auth');
|
||||
const db = require('../db');
|
||||
const { ethers } = require('ethers');
|
||||
|
||||
// Подключение к БД
|
||||
const pool = new Pool({
|
||||
connectionString: process.env.DATABASE_URL,
|
||||
ssl: process.env.NODE_ENV === 'production' ? { rejectUnauthorized: false } : false,
|
||||
});
|
||||
const authService = require('../services/auth-service');
|
||||
const logger = require('../utils/logger');
|
||||
|
||||
// Проверка доступа
|
||||
router.get('/check', async (req, res) => {
|
||||
const walletAddress = req.headers['x-wallet-address'];
|
||||
|
||||
if (!walletAddress) {
|
||||
return res.status(400).json({ error: 'No wallet address provided' });
|
||||
}
|
||||
|
||||
try {
|
||||
// Проверяем наличие активного токена для адреса
|
||||
const result = await pool.query(
|
||||
'SELECT * FROM access_tokens WHERE wallet_address = $1 AND expires_at > NOW()',
|
||||
[walletAddress.toLowerCase()]
|
||||
);
|
||||
const { address } = req.query;
|
||||
|
||||
if (result.rows.length === 0) {
|
||||
return res.json({ hasAccess: false });
|
||||
if (!address) {
|
||||
return res.status(400).json({ error: 'Address is required' });
|
||||
}
|
||||
|
||||
const token = result.rows[0];
|
||||
const isAdmin = await authService.checkAdminToken(address);
|
||||
|
||||
res.json({
|
||||
hasAccess: true,
|
||||
tokenId: token.id,
|
||||
role: token.role,
|
||||
expiresAt: token.expires_at,
|
||||
});
|
||||
res.json({ isAdmin });
|
||||
} catch (error) {
|
||||
console.error('Access check error:', error);
|
||||
res.status(500).json({ error: error.message });
|
||||
logger.error(`Error checking access: ${error.message}`);
|
||||
res.status(500).json({ error: 'Internal server error' });
|
||||
}
|
||||
});
|
||||
|
||||
@@ -63,40 +44,14 @@ router.get('/admin-only', async (req, res) => {
|
||||
}
|
||||
});
|
||||
|
||||
// Получение списка токенов
|
||||
// Получение всех токенов доступа
|
||||
router.get('/tokens', async (req, res) => {
|
||||
const walletAddress = req.headers['x-wallet-address'];
|
||||
|
||||
if (!walletAddress) {
|
||||
return res.status(400).json({ error: 'No wallet address provided' });
|
||||
}
|
||||
|
||||
try {
|
||||
// Проверяем права администратора
|
||||
const adminCheck = await pool.query(
|
||||
'SELECT * FROM access_tokens WHERE wallet_address = $1 AND role = $2 AND expires_at > NOW()',
|
||||
[walletAddress.toLowerCase(), 'ADMIN']
|
||||
);
|
||||
|
||||
if (adminCheck.rows.length === 0) {
|
||||
return res.status(403).json({ error: 'Access denied' });
|
||||
}
|
||||
|
||||
// Получаем список всех токенов
|
||||
const result = await pool.query('SELECT * FROM access_tokens ORDER BY created_at DESC');
|
||||
|
||||
res.json(
|
||||
result.rows.map((token) => ({
|
||||
id: token.id,
|
||||
walletAddress: token.wallet_address,
|
||||
role: token.role,
|
||||
createdAt: token.created_at,
|
||||
expiresAt: token.expires_at,
|
||||
}))
|
||||
);
|
||||
const tokens = await authService.getAllTokens();
|
||||
res.json(tokens);
|
||||
} catch (error) {
|
||||
console.error('Tokens list error:', error);
|
||||
res.status(500).json({ error: error.message });
|
||||
logger.error(`Error getting tokens: ${error.message}`);
|
||||
res.status(500).json({ error: 'Internal server error' });
|
||||
}
|
||||
});
|
||||
|
||||
@@ -110,12 +65,9 @@ router.post('/tokens', async (req, res) => {
|
||||
|
||||
try {
|
||||
// Проверяем права администратора
|
||||
const adminCheck = await pool.query(
|
||||
'SELECT * FROM access_tokens WHERE wallet_address = $1 AND role = $2 AND expires_at > NOW()',
|
||||
[walletAddress.toLowerCase(), 'ADMIN']
|
||||
);
|
||||
const isAdmin = await authService.checkAdminToken(walletAddress);
|
||||
|
||||
if (adminCheck.rows.length === 0) {
|
||||
if (!isAdmin) {
|
||||
return res.status(403).json({ error: 'Access denied' });
|
||||
}
|
||||
|
||||
@@ -130,7 +82,7 @@ router.post('/tokens', async (req, res) => {
|
||||
expiresAt.setDate(expiresAt.getDate() + parseInt(expiresInDays));
|
||||
|
||||
// Создаем токен
|
||||
const result = await pool.query(
|
||||
const result = await db.query(
|
||||
'INSERT INTO access_tokens (wallet_address, role, expires_at) VALUES ($1, $2, $3) RETURNING *',
|
||||
[targetAddress.toLowerCase(), role, expiresAt]
|
||||
);
|
||||
@@ -158,19 +110,16 @@ router.delete('/tokens/:id', async (req, res) => {
|
||||
|
||||
try {
|
||||
// Проверяем права администратора
|
||||
const adminCheck = await pool.query(
|
||||
'SELECT * FROM access_tokens WHERE wallet_address = $1 AND role = $2 AND expires_at > NOW()',
|
||||
[walletAddress.toLowerCase(), 'ADMIN']
|
||||
);
|
||||
const isAdmin = await authService.checkAdminToken(walletAddress);
|
||||
|
||||
if (adminCheck.rows.length === 0) {
|
||||
if (!isAdmin) {
|
||||
return res.status(403).json({ error: 'Access denied' });
|
||||
}
|
||||
|
||||
const { id } = req.params;
|
||||
|
||||
// Удаляем токен
|
||||
await pool.query('DELETE FROM access_tokens WHERE id = $1', [id]);
|
||||
await db.query('DELETE FROM access_tokens WHERE id = $1', [id]);
|
||||
|
||||
res.json({ success: true });
|
||||
} catch (error) {
|
||||
@@ -182,118 +131,95 @@ router.delete('/tokens/:id', async (req, res) => {
|
||||
// Получение информации о роли текущего пользователя
|
||||
router.get('/role', requireAuth, async (req, res) => {
|
||||
try {
|
||||
const address = req.session.address.toLowerCase();
|
||||
|
||||
const result = await db.query(
|
||||
'SELECT r.name as role FROM users u JOIN roles r ON u.role_id = r.id WHERE LOWER(u.address) = $1',
|
||||
[address]
|
||||
);
|
||||
|
||||
if (result.rows.length === 0) {
|
||||
return res.status(404).json({ error: 'Пользователь не найден' });
|
||||
}
|
||||
|
||||
return res.json({ role: result.rows[0].role });
|
||||
const role = await authService.getUserRole(req.user.id);
|
||||
return res.json({ role });
|
||||
} catch (error) {
|
||||
console.error('Ошибка при получении роли:', error);
|
||||
logger.error('Ошибка при получении роли:', error);
|
||||
return res.status(500).json({ error: 'Внутренняя ошибка сервера' });
|
||||
}
|
||||
});
|
||||
|
||||
// Получение списка всех пользователей (только для администраторов)
|
||||
router.get('/users', requireAdmin, async (req, res) => {
|
||||
router.get('/users', requireAuth, requireAdmin, async (req, res) => {
|
||||
try {
|
||||
const result = await db.query(
|
||||
'SELECT u.id, u.wallet_address, r.name as role, u.created_at FROM users u JOIN roles r ON u.role_id = r.id'
|
||||
);
|
||||
const result = await db.query(`
|
||||
SELECT u.id, ui.identity_value as wallet_address, r.name as role, u.created_at
|
||||
FROM users u
|
||||
JOIN roles r ON u.role_id = r.id
|
||||
LEFT JOIN user_identities ui ON u.id = ui.user_id AND ui.identity_type = 'wallet'
|
||||
`);
|
||||
|
||||
return res.json(result.rows);
|
||||
} catch (error) {
|
||||
console.error('Ошибка при получении списка пользователей:', error);
|
||||
logger.error('Ошибка при получении списка пользователей:', error);
|
||||
return res.status(500).json({ error: 'Внутренняя ошибка сервера' });
|
||||
}
|
||||
});
|
||||
|
||||
// Изменение роли пользователя (только для администраторов)
|
||||
router.post('/users/:userId/role', requireAdmin, async (req, res) => {
|
||||
// Обновление роли пользователя
|
||||
router.post('/update-role', async (req, res) => {
|
||||
try {
|
||||
const { userId } = req.params;
|
||||
const { role } = req.body;
|
||||
const { userId, role } = req.body;
|
||||
|
||||
if (!role || !['admin', 'user'].includes(role)) {
|
||||
return res.status(400).json({ error: 'Некорректная роль' });
|
||||
if (!userId || !role) {
|
||||
return res.status(400).json({ error: 'User ID and role are required' });
|
||||
}
|
||||
|
||||
await db.query(
|
||||
'UPDATE users SET role_id = (SELECT id FROM roles WHERE name = $1) WHERE id = $2',
|
||||
[role, userId]
|
||||
);
|
||||
const success = await authService.updateUserRole(userId, role);
|
||||
|
||||
return res.json({ success: true });
|
||||
if (success) {
|
||||
res.json({ success: true });
|
||||
} else {
|
||||
res.status(400).json({ error: 'Failed to update role' });
|
||||
}
|
||||
} catch (error) {
|
||||
console.error('Ошибка при изменении роли пользователя:', error);
|
||||
return res.status(500).json({ error: 'Внутренняя ошибка сервера' });
|
||||
logger.error(`Error updating role: ${error.message}`);
|
||||
res.status(500).json({ error: 'Internal server error' });
|
||||
}
|
||||
});
|
||||
|
||||
// Получение информации о токенах доступа текущего пользователя
|
||||
router.get('/tokens', requireAuth, async (req, res) => {
|
||||
// Связывание нового идентификатора с аккаунтом
|
||||
router.post('/link-identity', requireAuth, async (req, res) => {
|
||||
try {
|
||||
// Логирование для отладки
|
||||
console.log('GET /api/access/tokens запрос получен');
|
||||
console.log('Сессия пользователя:', req.session);
|
||||
const { identityType, identityValue } = req.body;
|
||||
|
||||
// Получаем адрес из сессии, а не из заголовков
|
||||
if (!req.session || !req.session.address) {
|
||||
return res.status(400).json({ error: 'No wallet address in session' });
|
||||
if (!identityType || !identityValue) {
|
||||
return res.status(400).json({ error: 'Отсутствуют обязательные поля' });
|
||||
}
|
||||
|
||||
const address = req.session.address.toLowerCase();
|
||||
// Проверяем, не привязан ли уже этот идентификатор к другому пользователю
|
||||
const existingUserId = await authService.getUserIdByIdentity(identityType, identityValue);
|
||||
|
||||
// Используем правильное имя таблицы и полей
|
||||
const result = await db.query(
|
||||
'SELECT id, wallet_address, role, created_at, expires_at FROM access_tokens WHERE LOWER(wallet_address) = $1',
|
||||
[address]
|
||||
);
|
||||
|
||||
return res.json(result.rows);
|
||||
} catch (error) {
|
||||
console.error('Ошибка при получении токенов:', error);
|
||||
res.status(500).json({ error: 'Ошибка сервера' });
|
||||
}
|
||||
});
|
||||
|
||||
router.post('/mint', requireAuth, requireAdmin, async (req, res) => {
|
||||
try {
|
||||
// Логирование для отладки
|
||||
console.log('POST /api/access/mint запрос получен');
|
||||
console.log('Данные запроса:', req.body);
|
||||
|
||||
const { walletAddress, role, expiresInDays } = req.body;
|
||||
|
||||
if (!walletAddress || !role || !expiresInDays) {
|
||||
return res.status(400).json({ error: 'Missing required fields' });
|
||||
if (existingUserId && existingUserId !== req.user.id) {
|
||||
return res.status(400).json({ error: 'Этот идентификатор уже привязан к другому аккаунту' });
|
||||
}
|
||||
|
||||
// Вычисляем дату истечения
|
||||
const expiresAt = new Date();
|
||||
expiresAt.setDate(expiresAt.getDate() + parseInt(expiresInDays));
|
||||
// Добавляем новый идентификатор
|
||||
if (!existingUserId) {
|
||||
await db.query(
|
||||
'INSERT INTO user_identities (user_id, identity_type, identity_value, created_at) VALUES ($1, $2, $3, NOW())',
|
||||
[req.user.id, identityType, identityValue]
|
||||
);
|
||||
}
|
||||
|
||||
// Создаем токен
|
||||
const result = await pool.query(
|
||||
'INSERT INTO access_tokens (wallet_address, role, expires_at) VALUES ($1, $2, $3) RETURNING *',
|
||||
[walletAddress.toLowerCase(), role, expiresAt]
|
||||
);
|
||||
// Если добавлен кошелек, проверяем токены
|
||||
if (identityType === 'wallet') {
|
||||
await authService.checkTokensAndUpdateRole(identityValue);
|
||||
}
|
||||
|
||||
// Получаем все идентификаторы пользователя
|
||||
const identities = await authService.getAllUserIdentities(req.user.id);
|
||||
|
||||
// Получаем текущую роль
|
||||
const isAdmin = await authService.isAdmin(req.user.id);
|
||||
|
||||
res.json({
|
||||
id: result.rows[0].id,
|
||||
walletAddress: result.rows[0].wallet_address,
|
||||
role: result.rows[0].role,
|
||||
createdAt: result.rows[0].created_at,
|
||||
expiresAt: result.rows[0].expires_at,
|
||||
success: true,
|
||||
identities,
|
||||
isAdmin
|
||||
});
|
||||
} catch (error) {
|
||||
console.error('Ошибка при создании токена:', error);
|
||||
logger.error(`Link identity error: ${error.message}`);
|
||||
res.status(500).json({ error: 'Ошибка сервера' });
|
||||
}
|
||||
});
|
||||
|
||||
@@ -1,79 +1,7 @@
|
||||
const express = require('express');
|
||||
const router = express.Router();
|
||||
const db = require('../db');
|
||||
const { checkIfAdmin } = require('../utils/access-check');
|
||||
|
||||
// Middleware для проверки прав администратора
|
||||
const requireAdmin = async (req, res, next) => {
|
||||
console.log('Проверка прав администратора:', {
|
||||
session: req.session
|
||||
? {
|
||||
authenticated: req.session.authenticated,
|
||||
address: req.session.address,
|
||||
isAdmin: req.session.isAdmin,
|
||||
}
|
||||
: null,
|
||||
headers: {
|
||||
authorization: req.headers.authorization,
|
||||
},
|
||||
});
|
||||
|
||||
// Проверка аутентификации через сессию
|
||||
if (req.session && req.session.authenticated && req.session.isAdmin) {
|
||||
console.log('Пользователь авторизован как администратор через сессию');
|
||||
return next();
|
||||
}
|
||||
|
||||
// Проверка через заголовок авторизации
|
||||
const authHeader = req.headers.authorization;
|
||||
if (!authHeader || !authHeader.startsWith('Bearer ')) {
|
||||
console.log('Отсутствует заголовок авторизации');
|
||||
return res.status(401).json({ error: 'Unauthorized' });
|
||||
}
|
||||
|
||||
const address = authHeader.split(' ')[1];
|
||||
console.log('Проверка адреса из заголовка:', address);
|
||||
|
||||
try {
|
||||
// Проверяем напрямую в базе данных
|
||||
const userResult = await db.query('SELECT is_admin FROM users WHERE address = $1', [
|
||||
address.toLowerCase(),
|
||||
]);
|
||||
|
||||
if (userResult.rows.length === 0) {
|
||||
console.log(`Пользователь с адресом ${address} не найден`);
|
||||
return res.status(404).json({ error: 'User not found' });
|
||||
}
|
||||
|
||||
const isAdmin = userResult.rows[0].is_admin;
|
||||
console.log(`Пользователь с адресом ${address} имеет статус администратора:`, isAdmin);
|
||||
|
||||
if (!isAdmin) {
|
||||
console.log(`Пользователь с адресом ${address} не является администратором`);
|
||||
return res.status(403).json({ error: 'Forbidden' });
|
||||
}
|
||||
|
||||
// Обновляем сессию
|
||||
if (req.session) {
|
||||
req.session.authenticated = true;
|
||||
req.session.address = address;
|
||||
req.session.isAdmin = true;
|
||||
|
||||
console.log('Сессия обновлена из middleware:', {
|
||||
address,
|
||||
isAdmin: true,
|
||||
});
|
||||
}
|
||||
|
||||
next();
|
||||
} catch (error) {
|
||||
console.error('Ошибка при проверке прав администратора:', error);
|
||||
return res.status(500).json({ error: 'Internal server error' });
|
||||
}
|
||||
};
|
||||
|
||||
// Применяем middleware ко всем маршрутам
|
||||
router.use(requireAdmin);
|
||||
const { requireAdmin } = require('../middleware/auth');
|
||||
|
||||
// Маршрут для получения списка пользователей
|
||||
router.get('/users', async (req, res) => {
|
||||
@@ -86,8 +14,8 @@ router.get('/users', async (req, res) => {
|
||||
}
|
||||
});
|
||||
|
||||
// Маршрут для получения статистики
|
||||
router.get('/stats', async (req, res) => {
|
||||
// Маршрут для получения статистики (защищен middleware requireAdmin)
|
||||
router.get('/stats', requireAdmin, async (req, res) => {
|
||||
try {
|
||||
// Получаем количество пользователей
|
||||
const usersCount = await db.query('SELECT COUNT(*) FROM users');
|
||||
|
||||
@@ -6,10 +6,10 @@ const db = require('../db');
|
||||
const logger = require('../utils/logger');
|
||||
const helmet = require('helmet');
|
||||
const rateLimit = require('express-rate-limit');
|
||||
const { checkIfAdmin } = require('../utils/access-check');
|
||||
const { checkRole, requireAuth } = require('../middleware/auth');
|
||||
const { pool } = require('../db');
|
||||
const { verifySignature, checkAccess, findOrCreateUser } = require('../utils/auth');
|
||||
const authService = require('../services/auth-service');
|
||||
|
||||
// Создайте лимитер для попыток аутентификации
|
||||
const authLimiter = rateLimit({
|
||||
@@ -24,39 +24,31 @@ const authLimiter = rateLimit({
|
||||
router.get('/nonce', async (req, res) => {
|
||||
try {
|
||||
const { address } = req.query;
|
||||
|
||||
if (!address) {
|
||||
return res.status(400).json({ error: 'Address is required' });
|
||||
}
|
||||
|
||||
// Генерируем nonce
|
||||
// Генерируем случайный nonce
|
||||
const nonce = crypto.randomBytes(16).toString('hex');
|
||||
|
||||
// Сохраняем nonce в сессии
|
||||
req.session.authNonce = nonce;
|
||||
req.session.pendingAddress = address.toLowerCase();
|
||||
req.session.pendingAddress = address;
|
||||
|
||||
console.log('Сгенерирован nonce для адреса:', address);
|
||||
console.log('Сессия после генерации nonce:', req.session);
|
||||
|
||||
// Сохраняем сессию и ждем завершения
|
||||
// Важно: сохраняем сессию перед отправкой ответа
|
||||
await new Promise((resolve, reject) => {
|
||||
req.session.save((err) => {
|
||||
if (err) {
|
||||
console.error('Ошибка при сохранении сессии:', err);
|
||||
reject(err);
|
||||
} else {
|
||||
resolve();
|
||||
}
|
||||
req.session.save(err => {
|
||||
if (err) reject(err);
|
||||
else resolve();
|
||||
});
|
||||
});
|
||||
|
||||
// Проверяем, что nonce сохранился
|
||||
console.log('Сессия после генерации nonce:', req.session);
|
||||
console.log('Сессия после сохранения:', req.session);
|
||||
|
||||
return res.json({ nonce });
|
||||
} catch (error) {
|
||||
console.error('Ошибка при генерации nonce:', error);
|
||||
console.error('Error generating nonce:', error);
|
||||
return res.status(500).json({ error: 'Internal server error' });
|
||||
}
|
||||
});
|
||||
@@ -89,135 +81,227 @@ async function checkUserRole(address, req) {
|
||||
}
|
||||
}
|
||||
|
||||
// Верификация подписи
|
||||
// Проверка подписи и аутентификация
|
||||
router.post('/verify', async (req, res) => {
|
||||
try {
|
||||
const { address, signature, message, nonce } = req.body;
|
||||
const { address, signature, message } = req.body;
|
||||
|
||||
console.log('Верификация подписи:', { address, signature, message });
|
||||
console.log('Сессия при верификации:', req.session);
|
||||
console.log('Verify request: address=' + address + ', signature=' + signature.substring(0, 10) + '...');
|
||||
console.log('Session data: nonce=' + req.session.authNonce + ', pendingAddress=' + req.session.pendingAddress);
|
||||
|
||||
if (!address || !signature || !message) {
|
||||
return res.status(400).json({ error: 'Address, signature and message are required' });
|
||||
// Проверяем, что nonce и адрес совпадают с сохраненными в сессии
|
||||
if (!req.session.authNonce || !req.session.pendingAddress || req.session.pendingAddress !== address) {
|
||||
console.error(`Invalid session or address mismatch: nonce=${req.session.authNonce}, pendingAddress=${req.session.pendingAddress}, address=${address}`);
|
||||
return res.status(401).json({ error: 'Invalid session or address mismatch' });
|
||||
}
|
||||
|
||||
// Проверяем наличие nonce в сессии
|
||||
if (!req.session.authNonce || !req.session.pendingAddress) {
|
||||
console.error('Сессия не содержит nonce или pendingAddress:', req.session);
|
||||
// Проверяем подпись
|
||||
const isValid = await verifySignature(req.session.authNonce, signature, address);
|
||||
console.log('Signature verification result:', isValid);
|
||||
|
||||
// Проверяем наличие nonce в заголовке
|
||||
const headerNonce = req.headers['x-auth-nonce'];
|
||||
if (headerNonce) {
|
||||
console.log('Найден nonce в заголовке:', headerNonce);
|
||||
req.session.authNonce = headerNonce;
|
||||
req.session.pendingAddress = address.toLowerCase();
|
||||
}
|
||||
if (!isValid) {
|
||||
return res.status(401).json({ error: 'Invalid signature' });
|
||||
}
|
||||
|
||||
// Если в запросе есть nonce в сообщении, извлекаем его
|
||||
let extractedNonce = null;
|
||||
if (message) {
|
||||
const match = message.match(/nonce: ([a-f0-9]+)/);
|
||||
if (match && match[1]) {
|
||||
extractedNonce = match[1];
|
||||
console.log('Извлечен nonce из сообщения:', extractedNonce);
|
||||
// Находим или создаем пользователя
|
||||
console.log('Finding or creating user for address:', address);
|
||||
const { userId, isAdmin } = await findOrCreateUser(address);
|
||||
console.log('User found/created:', { userId, isAdmin });
|
||||
|
||||
// Устанавливаем nonce в сессию
|
||||
req.session.authNonce = extractedNonce;
|
||||
req.session.pendingAddress = address.toLowerCase();
|
||||
// Очищаем nonce и pendingAddress из сессии
|
||||
const nonce = req.session.authNonce;
|
||||
req.session.authNonce = null;
|
||||
req.session.pendingAddress = null;
|
||||
|
||||
// Сохраняем сессию
|
||||
await new Promise((resolve) => {
|
||||
req.session.save((err) => {
|
||||
if (err) console.error('Ошибка при сохранении сессии:', err);
|
||||
resolve();
|
||||
});
|
||||
});
|
||||
// Устанавливаем пользователя в сессии
|
||||
req.session.userId = userId;
|
||||
req.session.address = address;
|
||||
req.session.isAdmin = isAdmin;
|
||||
req.session.authenticated = true;
|
||||
|
||||
// Сохраняем сессию
|
||||
await new Promise((resolve, reject) => {
|
||||
req.session.save(err => {
|
||||
if (err) {
|
||||
console.error('Error saving session:', err);
|
||||
reject(err);
|
||||
} else {
|
||||
console.log('Session saved successfully');
|
||||
resolve();
|
||||
}
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
console.log('Authentication successful for user:', { userId, address, isAdmin });
|
||||
|
||||
return res.json({
|
||||
authenticated: true,
|
||||
userId,
|
||||
address,
|
||||
isAdmin,
|
||||
authType: 'wallet'
|
||||
});
|
||||
} catch (error) {
|
||||
console.error('Error verifying signature:', error);
|
||||
return res.status(500).json({ error: 'Internal server error' });
|
||||
}
|
||||
});
|
||||
|
||||
// Аутентификация через Telegram
|
||||
router.post('/telegram', async (req, res) => {
|
||||
try {
|
||||
const { telegramId, authData } = req.body;
|
||||
|
||||
// Здесь должна быть проверка данных от Telegram
|
||||
|
||||
// Получаем или создаем пользователя
|
||||
let userId = await authService.getUserIdByIdentity('telegram', telegramId);
|
||||
|
||||
if (!userId) {
|
||||
// Создаем нового пользователя
|
||||
const userResult = await db.query(
|
||||
'INSERT INTO users (created_at, role_id) VALUES (NOW(), (SELECT id FROM roles WHERE name = $1)) RETURNING id',
|
||||
['user']
|
||||
);
|
||||
|
||||
userId = userResult.rows[0].id;
|
||||
|
||||
// Добавляем идентификатор Telegram
|
||||
await db.query(
|
||||
'INSERT INTO user_identities (user_id, identity_type, identity_value, created_at) VALUES ($1, $2, $3, NOW())',
|
||||
[userId, 'telegram', telegramId]
|
||||
);
|
||||
}
|
||||
|
||||
// Формируем ожидаемое сообщение
|
||||
const expectedMessage = `Подтвердите вход в DApp for Business с nonce: ${req.session.authNonce}`;
|
||||
// Проверяем связанные аккаунты
|
||||
const identities = await authService.getAllUserIdentities(userId);
|
||||
|
||||
// Проверяем, что адрес совпадает с ожидаемым
|
||||
if (req.session.pendingAddress && req.session.pendingAddress.toLowerCase() !== address.toLowerCase()) {
|
||||
console.error('Адрес не совпадает с ожидаемым:', {
|
||||
expected: req.session.pendingAddress,
|
||||
received: address,
|
||||
});
|
||||
return res.status(400).json({ error: 'Invalid address' });
|
||||
// Если есть связанный кошелек, проверяем токены
|
||||
if (identities.wallet) {
|
||||
await authService.checkTokensAndUpdateRole(identities.wallet);
|
||||
}
|
||||
|
||||
let verified = false;
|
||||
try {
|
||||
// Проверяем подпись с использованием ethers.js
|
||||
const recoveredAddress = ethers.verifyMessage(expectedMessage, signature);
|
||||
// Получаем текущую роль
|
||||
const isAdmin = await authService.isAdmin(userId);
|
||||
|
||||
if (recoveredAddress.toLowerCase() !== address.toLowerCase()) {
|
||||
console.error('Неверная подпись:', {
|
||||
expected: address.toLowerCase(),
|
||||
recovered: recoveredAddress.toLowerCase(),
|
||||
});
|
||||
return res.status(400).json({ error: 'Invalid signature' });
|
||||
}
|
||||
// Устанавливаем сессию
|
||||
req.session.userId = userId;
|
||||
req.session.telegramId = telegramId;
|
||||
req.session.authType = 'telegram';
|
||||
req.session.authenticated = true;
|
||||
|
||||
verified = true;
|
||||
console.log('Подпись успешно проверена');
|
||||
} catch (error) {
|
||||
console.error('Ошибка при проверке подписи:', error);
|
||||
return res.status(400).json({ error: 'Invalid signature format' });
|
||||
res.json({
|
||||
authenticated: true,
|
||||
userId,
|
||||
isAdmin,
|
||||
authType: 'telegram',
|
||||
identities
|
||||
});
|
||||
} catch (error) {
|
||||
logger.error(`Telegram auth error: ${error.message}`);
|
||||
res.status(500).json({ error: 'Ошибка сервера' });
|
||||
}
|
||||
});
|
||||
|
||||
// Аутентификация через Email
|
||||
router.post('/email', async (req, res) => {
|
||||
try {
|
||||
const { email, verificationCode } = req.body;
|
||||
|
||||
// Здесь должна быть проверка кода подтверждения
|
||||
|
||||
// Получаем или создаем пользователя
|
||||
let userId = await authService.getUserIdByIdentity('email', email);
|
||||
|
||||
if (!userId) {
|
||||
// Создаем нового пользователя
|
||||
const userResult = await db.query(
|
||||
'INSERT INTO users (created_at, role_id) VALUES (NOW(), (SELECT id FROM roles WHERE name = $1)) RETURNING id',
|
||||
['user']
|
||||
);
|
||||
|
||||
userId = userResult.rows[0].id;
|
||||
|
||||
// Добавляем идентификатор Email
|
||||
await db.query(
|
||||
'INSERT INTO user_identities (user_id, identity_type, identity_value, created_at) VALUES ($1, $2, $3, NOW())',
|
||||
[userId, 'email', email]
|
||||
);
|
||||
}
|
||||
|
||||
// Если подпись верна, аутентифицируем пользователя
|
||||
if (verified) {
|
||||
// Найдем или создадим пользователя
|
||||
const user = await findOrCreateUser(address, 'wallet');
|
||||
// Проверяем связанные аккаунты
|
||||
const identities = await authService.getAllUserIdentities(userId);
|
||||
|
||||
// Обновляем сессию
|
||||
req.session.authenticated = true;
|
||||
req.session.address = address;
|
||||
req.session.userId = user.id;
|
||||
req.session.authType = 'wallet';
|
||||
req.session.isAdmin = user.is_admin;
|
||||
req.session.role = user.role;
|
||||
req.session.authChannel = 'web';
|
||||
req.session.language = req.body.language || 'en';
|
||||
// Если есть связанный кошелек, проверяем токены
|
||||
if (identities.wallet) {
|
||||
await authService.checkTokensAndUpdateRole(identities.wallet);
|
||||
}
|
||||
|
||||
// Удаляем временные данные
|
||||
delete req.session.authNonce;
|
||||
delete req.session.pendingAddress;
|
||||
// Получаем текущую роль
|
||||
const isAdmin = await authService.isAdmin(userId);
|
||||
|
||||
// Сохраняем сессию
|
||||
await new Promise((resolve, reject) => {
|
||||
req.session.save(err => {
|
||||
if (err) {
|
||||
console.error('Ошибка при сохранении сессии:', err);
|
||||
reject(err);
|
||||
} else {
|
||||
resolve();
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
console.log('Аутентификация успешна:', {
|
||||
address,
|
||||
isAdmin: user.is_admin,
|
||||
userId: user.id,
|
||||
role: user.role
|
||||
});
|
||||
// Устанавливаем сессию
|
||||
req.session.userId = userId;
|
||||
req.session.email = email;
|
||||
req.session.authType = 'email';
|
||||
req.session.authenticated = true;
|
||||
|
||||
res.json({
|
||||
authenticated: true,
|
||||
address,
|
||||
isAdmin: user.is_admin,
|
||||
role: user.role
|
||||
});
|
||||
} else {
|
||||
res.status(401).json({ error: 'Invalid signature' });
|
||||
}
|
||||
userId,
|
||||
isAdmin,
|
||||
authType: 'email',
|
||||
identities
|
||||
});
|
||||
} catch (error) {
|
||||
console.error('Authentication error:', error);
|
||||
res.status(500).json({ error: 'Internal server error' });
|
||||
logger.error(`Email auth error: ${error.message}`);
|
||||
res.status(500).json({ error: 'Ошибка сервера' });
|
||||
}
|
||||
});
|
||||
|
||||
// Связывание аккаунтов
|
||||
router.post('/link-identity', async (req, res) => {
|
||||
try {
|
||||
if (!req.session || !req.session.userId) {
|
||||
return res.status(401).json({ error: 'Требуется аутентификация' });
|
||||
}
|
||||
|
||||
const { identityType, identityValue } = req.body;
|
||||
|
||||
// Проверяем, не привязан ли уже этот идентификатор к другому пользователю
|
||||
const existingUserId = await authService.getUserIdByIdentity(identityType, identityValue);
|
||||
|
||||
if (existingUserId && existingUserId !== req.session.userId) {
|
||||
return res.status(400).json({ error: 'Этот идентификатор уже привязан к другому аккаунту' });
|
||||
}
|
||||
|
||||
// Добавляем новый идентификатор
|
||||
if (!existingUserId) {
|
||||
await db.query(
|
||||
'INSERT INTO user_identities (user_id, identity_type, identity_value, created_at) VALUES ($1, $2, $3, NOW())',
|
||||
[req.session.userId, identityType, identityValue]
|
||||
);
|
||||
}
|
||||
|
||||
// Если добавлен кошелек, проверяем токены
|
||||
if (identityType === 'wallet') {
|
||||
await authService.checkTokensAndUpdateRole(identityValue);
|
||||
}
|
||||
|
||||
// Получаем все идентификаторы пользователя
|
||||
const identities = await authService.getAllUserIdentities(req.session.userId);
|
||||
|
||||
// Получаем текущую роль
|
||||
const isAdmin = await authService.isAdmin(req.session.userId);
|
||||
|
||||
res.json({
|
||||
success: true,
|
||||
identities,
|
||||
isAdmin
|
||||
});
|
||||
} catch (error) {
|
||||
logger.error(`Link identity error: ${error.message}`);
|
||||
res.status(500).json({ error: 'Ошибка сервера' });
|
||||
}
|
||||
});
|
||||
|
||||
@@ -418,76 +502,42 @@ router.get('/check-access', requireAuth, (req, res) => {
|
||||
}
|
||||
});
|
||||
|
||||
// Упрощенный маршрут для обновления сессии
|
||||
// Добавьте этот маршрут в routes/auth.js
|
||||
router.post('/refresh-session', async (req, res) => {
|
||||
try {
|
||||
const { address } = req.body;
|
||||
|
||||
if (!address) {
|
||||
return res.status(400).json({ success: false, message: 'Адрес не указан' });
|
||||
return res.status(400).json({ error: 'Address is required' });
|
||||
}
|
||||
|
||||
console.log(`Получен запрос на обновление сессии для адреса: ${address}`);
|
||||
logger.info(`Получен запрос на обновление сессии для адреса: ${address}`);
|
||||
|
||||
// Проверяем, существует ли пользователь в базе данных
|
||||
const userResult = await pool.query('SELECT * FROM users WHERE address = $1', [
|
||||
address.toLowerCase(),
|
||||
]);
|
||||
// Проверяем доступ пользователя
|
||||
const accessInfo = await checkAccess(address);
|
||||
|
||||
let user = null;
|
||||
|
||||
if (userResult.rows.length > 0) {
|
||||
user = userResult.rows[0];
|
||||
console.log(`Найден пользователь: ${user.id}`);
|
||||
} else {
|
||||
console.log(`Пользователь с адресом ${address} не найден`);
|
||||
if (!accessInfo.hasAccess) {
|
||||
return res.status(401).json({ error: 'Unauthorized' });
|
||||
}
|
||||
|
||||
// Обновляем сессию
|
||||
// Устанавливаем данные сессии
|
||||
req.session.authenticated = true;
|
||||
req.session.address = address.toLowerCase();
|
||||
req.session.address = address;
|
||||
req.session.userId = accessInfo.userId;
|
||||
req.session.isAdmin = accessInfo.isAdmin;
|
||||
req.session.authType = 'wallet';
|
||||
|
||||
if (user) {
|
||||
req.session.userId = user.id;
|
||||
req.session.isAdmin = user.is_admin || false;
|
||||
req.session.role = user.is_admin ? 'ADMIN' : 'USER';
|
||||
} else {
|
||||
// Если пользователь не найден в базе, проверяем через переменные окружения
|
||||
const adminAddresses = (process.env.ADMIN_ADDRESSES || '')
|
||||
.split(',')
|
||||
.map((a) => a.toLowerCase());
|
||||
const isAdmin = adminAddresses.includes(address.toLowerCase());
|
||||
req.session.isAdmin = isAdmin;
|
||||
req.session.role = isAdmin ? 'ADMIN' : 'USER';
|
||||
}
|
||||
await req.session.save();
|
||||
|
||||
// Сохраняем сессию
|
||||
await new Promise((resolve, reject) => {
|
||||
req.session.save((err) => {
|
||||
if (err) {
|
||||
console.error('Ошибка при сохранении сессии:', err);
|
||||
reject(err);
|
||||
} else {
|
||||
resolve();
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
console.log('Сессия обновлена:', req.session);
|
||||
|
||||
return res.json({
|
||||
success: true,
|
||||
message: 'Сессия обновлена',
|
||||
user: {
|
||||
id: user ? user.id : null,
|
||||
address: address.toLowerCase(),
|
||||
isAdmin: req.session.isAdmin,
|
||||
role: req.session.role,
|
||||
},
|
||||
res.json({
|
||||
authenticated: true,
|
||||
address,
|
||||
isAdmin: accessInfo.isAdmin,
|
||||
authType: 'wallet'
|
||||
});
|
||||
} catch (error) {
|
||||
console.error('Ошибка при обновлении сессии:', error);
|
||||
return res.status(500).json({ success: false, message: 'Ошибка сервера' });
|
||||
logger.error(`Error refreshing session: ${error.message}`);
|
||||
res.status(500).json({ error: 'Internal server error' });
|
||||
}
|
||||
});
|
||||
|
||||
@@ -555,10 +605,56 @@ router.get('/check-db-structure', async (req, res) => {
|
||||
}
|
||||
});
|
||||
|
||||
// Добавьте этот маршрут для отладки
|
||||
router.get('/debug-session', (req, res) => {
|
||||
res.json({
|
||||
sessionID: req.sessionID,
|
||||
session: req.session,
|
||||
authenticated: req.session ? req.session.authenticated : undefined,
|
||||
address: req.session ? req.session.address : undefined,
|
||||
userId: req.session ? req.session.userId : undefined,
|
||||
isAdmin: req.session ? req.session.isAdmin : undefined,
|
||||
role: req.session ? req.session.role : undefined
|
||||
});
|
||||
});
|
||||
|
||||
// Маршрут для проверки сессии
|
||||
router.get('/session-debug', (req, res) => {
|
||||
console.log('Текущая сессия:', {
|
||||
id: req.sessionID,
|
||||
session: req.session,
|
||||
cookie: req.session.cookie
|
||||
});
|
||||
|
||||
res.json({
|
||||
sessionID: req.sessionID,
|
||||
authenticated: req.session.authenticated,
|
||||
address: req.session.address,
|
||||
userId: req.session.userId,
|
||||
isAdmin: req.session.isAdmin,
|
||||
role: req.session.role,
|
||||
cookie: req.session.cookie
|
||||
});
|
||||
});
|
||||
|
||||
// Маршрут для проверки содержимого таблицы сессий
|
||||
router.get('/check-sessions', async (req, res) => {
|
||||
try {
|
||||
const result = await pool.query('SELECT * FROM sessions');
|
||||
res.json({
|
||||
currentSessionID: req.sessionID,
|
||||
sessions: result.rows
|
||||
});
|
||||
} catch (error) {
|
||||
console.error('Ошибка при получении сессий:', error);
|
||||
res.status(500).json({ error: 'Internal server error' });
|
||||
}
|
||||
});
|
||||
|
||||
// Добавьте обработку ошибок
|
||||
router.use((err, req, res, next) => {
|
||||
console.error('Auth route error:', err);
|
||||
res.status(500).json({ success: false, message: 'Ошибка сервера' });
|
||||
});
|
||||
|
||||
module.exports = { router };
|
||||
module.exports = router;
|
||||
|
||||
@@ -8,14 +8,12 @@ const logger = require('../utils/logger');
|
||||
|
||||
// Обработчик сообщений чата
|
||||
router.post('/message', requireAuth, async (req, res) => {
|
||||
console.log('Сессия в /api/chat/message:', req.session);
|
||||
console.log('Аутентифицирован:', req.session.authenticated);
|
||||
|
||||
try {
|
||||
const { message, language = 'ru' } = req.body;
|
||||
|
||||
// Проверка аутентификации
|
||||
if (!req.session || !req.session.authenticated) {
|
||||
return res.status(401).json({ error: 'Требуется аутентификация' });
|
||||
}
|
||||
|
||||
console.log(`Получено сообщение: ${message}, язык: ${language}`);
|
||||
|
||||
// Определяем язык сообщения, если не указан явно
|
||||
@@ -175,26 +173,4 @@ router.get('/admin/history', requireAdmin, async (req, res) => {
|
||||
}
|
||||
});
|
||||
|
||||
// Сохранение сообщения в историю чата
|
||||
router.post('/message', requireAuth, async (req, res) => {
|
||||
try {
|
||||
const { content, channel = 'web', metadata = {} } = req.body;
|
||||
const userId = req.session.userId;
|
||||
|
||||
// Сохранение сообщения пользователя
|
||||
const userMessageResult = await db.query(`
|
||||
INSERT INTO chat_history (user_id, channel, sender_type, content, metadata)
|
||||
VALUES ($1, $2, 'user', $3, $4)
|
||||
RETURNING id
|
||||
`, [userId, channel, content, metadata]);
|
||||
|
||||
const messageId = userMessageResult.rows[0].id;
|
||||
|
||||
res.json({ success: true, messageId });
|
||||
} catch (error) {
|
||||
logger.error('Error saving chat message:', error);
|
||||
res.status(500).json({ error: 'Внутренняя ошибка сервера' });
|
||||
}
|
||||
});
|
||||
|
||||
module.exports = router;
|
||||
|
||||
@@ -0,0 +1 @@
|
||||
|
||||
|
||||
@@ -1,27 +1,14 @@
|
||||
const express = require('express');
|
||||
const router = express.Router();
|
||||
const { linkIdentity, getUserIdentities } = require('../utils/identity-linker');
|
||||
const { Pool } = require('pg');
|
||||
|
||||
// Подключение к БД
|
||||
const pool = new Pool({
|
||||
connectionString: process.env.DATABASE_URL,
|
||||
ssl: process.env.NODE_ENV === 'production' ? { rejectUnauthorized: false } : false,
|
||||
});
|
||||
|
||||
// Middleware для проверки аутентификации
|
||||
function requireAuth(req, res, next) {
|
||||
if (!req.session || (!req.session.isAuthenticated && !req.session.authenticated)) {
|
||||
return res.status(401).json({ error: 'Unauthorized' });
|
||||
}
|
||||
next();
|
||||
}
|
||||
const db = require('../db');
|
||||
const { requireAuth } = require('../middleware/auth');
|
||||
|
||||
// Получение связанных идентификаторов пользователя
|
||||
router.get('/', requireAuth, async (req, res) => {
|
||||
try {
|
||||
// Получаем ID пользователя по Ethereum-адресу
|
||||
const result = await pool.query('SELECT id FROM users WHERE address = $1', [
|
||||
const result = await db.query('SELECT id FROM users WHERE address = $1', [
|
||||
req.session.address,
|
||||
]);
|
||||
|
||||
@@ -47,7 +34,7 @@ router.delete('/:type/:value', requireAuth, async (req, res) => {
|
||||
const { type, value } = req.params;
|
||||
|
||||
// Получаем ID пользователя по Ethereum-адресу
|
||||
const result = await pool.query('SELECT id FROM users WHERE address = $1', [
|
||||
const result = await db.query('SELECT id FROM users WHERE address = $1', [
|
||||
req.session.address,
|
||||
]);
|
||||
|
||||
@@ -58,7 +45,7 @@ router.delete('/:type/:value', requireAuth, async (req, res) => {
|
||||
const userId = result.rows[0].id;
|
||||
|
||||
// Удаляем идентификатор
|
||||
await pool.query(
|
||||
await db.query(
|
||||
'DELETE FROM user_identities WHERE user_id = $1 AND identity_type = $2 AND identity_value = $3',
|
||||
[userId, type, value]
|
||||
);
|
||||
|
||||
@@ -2,54 +2,164 @@ const express = require('express');
|
||||
const router = express.Router();
|
||||
const db = require('../db');
|
||||
const { requireAuth, requireAdmin } = require('../middleware/auth');
|
||||
const { checkTokenBalanceAndUpdateRole } = require('../utils/access-check');
|
||||
const authService = require('../services/auth-service');
|
||||
const logger = require('../utils/logger');
|
||||
const { USER_ROLES } = require('../utils/constants');
|
||||
|
||||
// Маршрут для проверки и обновления роли пользователя
|
||||
router.post('/check-role', requireAuth, async (req, res) => {
|
||||
try {
|
||||
if (!req.session.address) {
|
||||
return res.status(400).json({ error: 'В сессии отсутствует адрес кошелька' });
|
||||
}
|
||||
|
||||
const isAdmin = await checkTokenBalanceAndUpdateRole(req.session.address);
|
||||
|
||||
// Обновление сессии
|
||||
req.session.isAdmin = isAdmin;
|
||||
|
||||
res.json({ isAdmin });
|
||||
} catch (error) {
|
||||
logger.error('Error checking role:', error);
|
||||
res.status(500).json({ error: 'Внутренняя ошибка сервера' });
|
||||
}
|
||||
});
|
||||
|
||||
// Маршрут для получения всех ролей (только для админов)
|
||||
router.get('/', requireAdmin, async (req, res) => {
|
||||
// Получение всех ролей
|
||||
router.get('/', async (req, res) => {
|
||||
try {
|
||||
const result = await db.query('SELECT * FROM roles ORDER BY id');
|
||||
res.json(result.rows);
|
||||
} catch (error) {
|
||||
logger.error('Error fetching roles:', error);
|
||||
res.status(500).json({ error: 'Внутренняя ошибка сервера' });
|
||||
logger.error(`Error getting roles: ${error.message}`);
|
||||
res.status(500).json({ error: 'Internal server error' });
|
||||
}
|
||||
});
|
||||
|
||||
// Маршрут для получения пользователей с их ролями (только для админов)
|
||||
router.get('/users', requireAdmin, async (req, res) => {
|
||||
// Получение роли текущего пользователя
|
||||
router.get('/me', requireAuth, async (req, res) => {
|
||||
try {
|
||||
const result = await db.query(`
|
||||
SELECT u.id, u.username, u.preferred_language, r.name as role,
|
||||
u.created_at, u.last_token_check
|
||||
FROM users u
|
||||
LEFT JOIN roles r ON u.role_id = r.id
|
||||
ORDER BY u.created_at DESC
|
||||
`);
|
||||
const userId = req.session.userId;
|
||||
|
||||
res.json(result.rows);
|
||||
const result = await db.query(`
|
||||
SELECT r.name as role
|
||||
FROM users u
|
||||
JOIN roles r ON u.role_id = r.id
|
||||
WHERE u.id = $1
|
||||
`, [userId]);
|
||||
|
||||
if (result.rows.length === 0) {
|
||||
return res.status(404).json({ error: 'User not found' });
|
||||
}
|
||||
|
||||
res.json({ role: result.rows[0].role });
|
||||
} catch (error) {
|
||||
logger.error('Error fetching users with roles:', error);
|
||||
res.status(500).json({ error: 'Внутренняя ошибка сервера' });
|
||||
logger.error(`Error getting user role: ${error.message}`);
|
||||
res.status(500).json({ error: 'Internal server error' });
|
||||
}
|
||||
});
|
||||
|
||||
// Создание новой роли (только для администраторов)
|
||||
router.post('/', requireAuth, requireAdmin, async (req, res) => {
|
||||
try {
|
||||
const { name, description } = req.body;
|
||||
|
||||
if (!name) {
|
||||
return res.status(400).json({ error: 'Role name is required' });
|
||||
}
|
||||
|
||||
// Проверяем, существует ли уже такая роль
|
||||
const existingRole = await db.query('SELECT * FROM roles WHERE name = $1', [name]);
|
||||
|
||||
if (existingRole.rows.length > 0) {
|
||||
return res.status(400).json({ error: 'Role already exists' });
|
||||
}
|
||||
|
||||
// Создаем новую роль
|
||||
const result = await db.query(
|
||||
'INSERT INTO roles (name, description) VALUES ($1, $2) RETURNING *',
|
||||
[name, description || '']
|
||||
);
|
||||
|
||||
res.status(201).json(result.rows[0]);
|
||||
} catch (error) {
|
||||
logger.error(`Error creating role: ${error.message}`);
|
||||
res.status(500).json({ error: 'Internal server error' });
|
||||
}
|
||||
});
|
||||
|
||||
// Обновление роли (только для администраторов)
|
||||
router.put('/:id', requireAuth, requireAdmin, async (req, res) => {
|
||||
try {
|
||||
const { id } = req.params;
|
||||
const { name, description } = req.body;
|
||||
|
||||
if (!name) {
|
||||
return res.status(400).json({ error: 'Role name is required' });
|
||||
}
|
||||
|
||||
// Проверяем, существует ли роль
|
||||
const existingRole = await db.query('SELECT * FROM roles WHERE id = $1', [id]);
|
||||
|
||||
if (existingRole.rows.length === 0) {
|
||||
return res.status(404).json({ error: 'Role not found' });
|
||||
}
|
||||
|
||||
// Обновляем роль
|
||||
const result = await db.query(
|
||||
'UPDATE roles SET name = $1, description = $2 WHERE id = $3 RETURNING *',
|
||||
[name, description || '', id]
|
||||
);
|
||||
|
||||
res.json(result.rows[0]);
|
||||
} catch (error) {
|
||||
logger.error(`Error updating role: ${error.message}`);
|
||||
res.status(500).json({ error: 'Internal server error' });
|
||||
}
|
||||
});
|
||||
|
||||
// Удаление роли (только для администраторов)
|
||||
router.delete('/:id', requireAuth, requireAdmin, async (req, res) => {
|
||||
try {
|
||||
const { id } = req.params;
|
||||
|
||||
// Проверяем, существует ли роль
|
||||
const existingRole = await db.query('SELECT * FROM roles WHERE id = $1', [id]);
|
||||
|
||||
if (existingRole.rows.length === 0) {
|
||||
return res.status(404).json({ error: 'Role not found' });
|
||||
}
|
||||
|
||||
// Проверяем, не используется ли роль
|
||||
const usersWithRole = await db.query('SELECT COUNT(*) FROM users WHERE role_id = $1', [id]);
|
||||
|
||||
if (parseInt(usersWithRole.rows[0].count) > 0) {
|
||||
return res.status(400).json({ error: 'Cannot delete role that is assigned to users' });
|
||||
}
|
||||
|
||||
// Удаляем роль
|
||||
await db.query('DELETE FROM roles WHERE id = $1', [id]);
|
||||
|
||||
res.json({ success: true });
|
||||
} catch (error) {
|
||||
logger.error(`Error deleting role: ${error.message}`);
|
||||
res.status(500).json({ error: 'Internal server error' });
|
||||
}
|
||||
});
|
||||
|
||||
// Назначение роли пользователю (только для администраторов)
|
||||
router.post('/assign', requireAuth, requireAdmin, async (req, res) => {
|
||||
try {
|
||||
const { userId, roleName } = req.body;
|
||||
|
||||
if (!userId || !roleName) {
|
||||
return res.status(400).json({ error: 'User ID and role name are required' });
|
||||
}
|
||||
|
||||
// Проверяем, существует ли роль
|
||||
const roleResult = await db.query('SELECT id FROM roles WHERE name = $1', [roleName]);
|
||||
|
||||
if (roleResult.rows.length === 0) {
|
||||
return res.status(404).json({ error: 'Role not found' });
|
||||
}
|
||||
|
||||
const roleId = roleResult.rows[0].id;
|
||||
|
||||
// Проверяем, существует ли пользователь
|
||||
const userResult = await db.query('SELECT * FROM users WHERE id = $1', [userId]);
|
||||
|
||||
if (userResult.rows.length === 0) {
|
||||
return res.status(404).json({ error: 'User not found' });
|
||||
}
|
||||
|
||||
// Назначаем роль
|
||||
await db.query('UPDATE users SET role_id = $1 WHERE id = $2', [roleId, userId]);
|
||||
|
||||
res.json({ success: true });
|
||||
} catch (error) {
|
||||
logger.error(`Error assigning role: ${error.message}`);
|
||||
res.status(500).json({ error: 'Internal server error' });
|
||||
}
|
||||
});
|
||||
|
||||
|
||||
@@ -1,34 +1,37 @@
|
||||
const hre = require('hardhat');
|
||||
const { getContract } = require('../utils/contracts');
|
||||
const logger = require('../utils/logger');
|
||||
|
||||
async function main() {
|
||||
const accessToken = await hre.ethers.getContractAt(
|
||||
'AccessToken',
|
||||
'0xF352c498cF0857F472dC473E4Dd39551E79B1063'
|
||||
);
|
||||
try {
|
||||
const accessToken = await getContract('AccessToken');
|
||||
|
||||
const owner = await accessToken.owner();
|
||||
console.log('Contract owner:', owner);
|
||||
const owner = await accessToken.owner();
|
||||
logger.info('Contract owner:', owner);
|
||||
|
||||
// Проверяем все токены и их владельцев
|
||||
console.log('\nAll tokens:');
|
||||
for (let i = 1; i <= 10; i++) {
|
||||
try {
|
||||
const tokenOwner = await accessToken.ownerOf(i);
|
||||
console.log(`Token ${i} owner: ${tokenOwner}`);
|
||||
} catch (error) {
|
||||
if (!error.message.includes('invalid token ID')) {
|
||||
console.log(`Token ${i} error:`, error.message);
|
||||
// Проверяем все токены и их владельцев
|
||||
logger.info('\nAll tokens:');
|
||||
for (let i = 1; i <= 10; i++) {
|
||||
try {
|
||||
const tokenOwner = await accessToken.ownerOf(i);
|
||||
logger.info(`Token ${i} owner: ${tokenOwner}`);
|
||||
} catch (error) {
|
||||
if (!error.message.includes('invalid token ID')) {
|
||||
logger.error(`Token ${i} error:`, error.message);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Проверяем активные токены для всех известных адресов
|
||||
const addresses = [owner, '0x70997970C51812dc3A010C7d01b50e0d17dc79C8'];
|
||||
// Проверяем активные токены для всех известных адресов
|
||||
const addresses = [owner, '0x70997970C51812dc3A010C7d01b50e0d17dc79C8'];
|
||||
|
||||
console.log('\nActive tokens:');
|
||||
for (const address of addresses) {
|
||||
const activeToken = await accessToken.activeTokens(address);
|
||||
console.log(`${address}: Token ${activeToken.toString()}`);
|
||||
logger.info('\nActive tokens:');
|
||||
for (const address of addresses) {
|
||||
const activeToken = await accessToken.activeTokens(address);
|
||||
logger.info(`${address}: Token ${activeToken.toString()}`);
|
||||
}
|
||||
} catch (error) {
|
||||
logger.error(error);
|
||||
process.exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -1,50 +0,0 @@
|
||||
const hre = require('hardhat');
|
||||
|
||||
async function main() {
|
||||
const accessToken = await hre.ethers.getContractAt(
|
||||
'AccessToken',
|
||||
'0xF352c498cF0857F472dC473E4Dd39551E79B1063'
|
||||
);
|
||||
|
||||
const moderatorAddress = '0x70997970C51812dc3A010C7d01b50e0d17dc79C8';
|
||||
|
||||
try {
|
||||
console.log('\nMinting moderator token...');
|
||||
const mintTx = await accessToken.mintAccessToken(moderatorAddress, 1); // MODERATOR
|
||||
console.log('Waiting for transaction:', mintTx.hash);
|
||||
await mintTx.wait();
|
||||
console.log('Moderator token minted');
|
||||
|
||||
// Проверяем результат
|
||||
const activeToken = await accessToken.activeTokens(moderatorAddress);
|
||||
console.log(`Moderator's active token: ${activeToken}`);
|
||||
|
||||
const role = await accessToken.checkRole(moderatorAddress);
|
||||
console.log(`Moderator role: ${['ADMIN', 'MODERATOR', 'SUPPORT'][role]}`);
|
||||
} catch (error) {
|
||||
console.log('Moderator token minting error:', error.message);
|
||||
}
|
||||
|
||||
// Проверяем все активные токены
|
||||
console.log('\nAll active tokens:');
|
||||
const addresses = [await accessToken.owner(), moderatorAddress];
|
||||
|
||||
for (const address of addresses) {
|
||||
try {
|
||||
const activeToken = await accessToken.activeTokens(address);
|
||||
const role = await accessToken.checkRole(address);
|
||||
console.log(
|
||||
`${address}: Token ${activeToken}, Role: ${['ADMIN', 'MODERATOR', 'SUPPORT'][role]}`
|
||||
);
|
||||
} catch (error) {
|
||||
console.log(`${address}: ${error.message}`);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
main()
|
||||
.then(() => process.exit(0))
|
||||
.catch((error) => {
|
||||
console.error('Script error:', error);
|
||||
process.exit(1);
|
||||
});
|
||||
@@ -1,23 +1,29 @@
|
||||
const hre = require('hardhat');
|
||||
const logger = require('../utils/logger');
|
||||
|
||||
async function main() {
|
||||
const AccessToken = await hre.ethers.getContractFactory('AccessToken');
|
||||
const accessToken = await AccessToken.deploy();
|
||||
await accessToken.waitForDeployment();
|
||||
try {
|
||||
const AccessToken = await hre.ethers.getContractFactory('AccessToken');
|
||||
const accessToken = await AccessToken.deploy();
|
||||
await accessToken.waitForDeployment();
|
||||
|
||||
const address = await accessToken.getAddress();
|
||||
console.log('AccessToken deployed to:', address);
|
||||
const address = await accessToken.getAddress();
|
||||
logger.info('AccessToken deployed to:', address);
|
||||
|
||||
// Создаем первый админский токен для владельца контракта
|
||||
const [owner] = await hre.ethers.getSigners();
|
||||
const tx = await accessToken.mintAccessToken(owner.address, 0); // 0 = ADMIN
|
||||
await tx.wait();
|
||||
console.log('Admin token minted for:', owner.address);
|
||||
// Создаем первый админский токен для владельца контракта
|
||||
const [owner] = await hre.ethers.getSigners();
|
||||
const tx = await accessToken.mintAccessToken(owner.address, 1); // 1 = ADMIN
|
||||
await tx.wait();
|
||||
logger.info('Admin token minted for:', owner.address);
|
||||
} catch (error) {
|
||||
logger.error('Deployment error:', error);
|
||||
process.exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
main()
|
||||
.then(() => process.exit(0))
|
||||
.catch((error) => {
|
||||
console.error(error);
|
||||
logger.error('Unhandled error:', error);
|
||||
process.exit(1);
|
||||
});
|
||||
|
||||
@@ -1,65 +0,0 @@
|
||||
const { Pool } = require('pg');
|
||||
const dotenv = require('dotenv');
|
||||
|
||||
dotenv.config();
|
||||
|
||||
const pool = new Pool({
|
||||
connectionString: process.env.DATABASE_URL,
|
||||
ssl: process.env.NODE_ENV === 'production' ? { rejectUnauthorized: false } : false,
|
||||
});
|
||||
|
||||
async function initDb() {
|
||||
try {
|
||||
console.log('Инициализация базы данных...');
|
||||
|
||||
// Добавляем тестового пользователя
|
||||
await pool.query(`
|
||||
INSERT INTO users (address, is_admin)
|
||||
VALUES ('0xf45aa4917b3775ba37f48aeb3dc1a943561e9e0b', TRUE)
|
||||
ON CONFLICT (address) DO NOTHING
|
||||
`);
|
||||
|
||||
// Добавляем тестовую доску
|
||||
await pool.query(`
|
||||
INSERT INTO kanban_boards (title, description, owner_id, is_public)
|
||||
VALUES (
|
||||
'Тестовая доска',
|
||||
'Описание тестовой доски',
|
||||
(SELECT id FROM users WHERE address = '0xf45aa4917b3775ba37f48aeb3dc1a943561e9e0b'),
|
||||
TRUE
|
||||
)
|
||||
ON CONFLICT DO NOTHING
|
||||
`);
|
||||
|
||||
// Получаем ID доски
|
||||
const boardResult = await pool.query(`
|
||||
SELECT id FROM kanban_boards WHERE title = 'Тестовая доска' LIMIT 1
|
||||
`);
|
||||
|
||||
if (boardResult.rows.length > 0) {
|
||||
const boardId = boardResult.rows[0].id;
|
||||
|
||||
// Добавляем тестовые колонки
|
||||
await pool.query(
|
||||
`
|
||||
INSERT INTO kanban_columns (board_id, title, position)
|
||||
VALUES
|
||||
($1, 'Backlog', 0),
|
||||
($1, 'In Progress', 1),
|
||||
($1, 'Review', 2),
|
||||
($1, 'Done', 3)
|
||||
ON CONFLICT DO NOTHING
|
||||
`,
|
||||
[boardId]
|
||||
);
|
||||
}
|
||||
|
||||
console.log('База данных инициализирована успешно');
|
||||
} catch (error) {
|
||||
console.error('Ошибка при инициализации базы данных:', error);
|
||||
} finally {
|
||||
await pool.end();
|
||||
}
|
||||
}
|
||||
|
||||
initDb();
|
||||
@@ -1,26 +0,0 @@
|
||||
const hre = require('hardhat');
|
||||
|
||||
async function main() {
|
||||
const accessToken = await hre.ethers.getContractAt(
|
||||
'AccessToken',
|
||||
'0xF352c498cF0857F472dC473E4Dd39551E79B1063'
|
||||
);
|
||||
|
||||
// Отзываем все токены от 1 до 3
|
||||
for (let i = 1; i <= 3; i++) {
|
||||
try {
|
||||
const tx = await accessToken.revokeToken(i);
|
||||
await tx.wait();
|
||||
console.log(`Token ${i} revoked`);
|
||||
} catch (error) {
|
||||
console.log(`Token ${i} revoke error:`, error.message);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
main()
|
||||
.then(() => process.exit(0))
|
||||
.catch((error) => {
|
||||
console.error(error);
|
||||
process.exit(1);
|
||||
});
|
||||
@@ -9,7 +9,7 @@ const { initializeVectorStore } = require('./services/vectorStore');
|
||||
const session = require('express-session');
|
||||
const { app, nonceStore } = require('./app');
|
||||
const usersRouter = require('./routes/users');
|
||||
const { router: authRouter } = require('./routes/auth');
|
||||
const authRouter = require('./routes/auth');
|
||||
const contractsRouter = require('./routes/contracts');
|
||||
const accessRouter = require('./routes/access');
|
||||
const path = require('path');
|
||||
@@ -23,13 +23,14 @@ const fs = require('fs');
|
||||
const pgSession = require('connect-pg-simple')(session);
|
||||
const sessionStore = new pgSession({
|
||||
pool: pool,
|
||||
tableName: 'session',
|
||||
tableName: 'sessions',
|
||||
createTableIfMissing: true,
|
||||
});
|
||||
const helmet = require('helmet');
|
||||
// const csrf = require('csurf');
|
||||
// const cookieParser = require('cookie-parser');
|
||||
const messagesRouter = require('./routes/messages');
|
||||
const sessionMiddleware = require('./middleware/session');
|
||||
|
||||
// Импорт сервисов
|
||||
const { initTelegramBot } = require('./services/telegram-service');
|
||||
@@ -62,7 +63,7 @@ console.log('Ethers.js version:', ethers.version);
|
||||
// 1. CORS должен быть первым
|
||||
app.use(
|
||||
cors({
|
||||
origin: ['http://localhost:5173', 'http://127.0.0.1:5173'],
|
||||
origin: ['http://127.0.0.1:5173', 'http://localhost:5173'],
|
||||
credentials: true,
|
||||
methods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
|
||||
allowedHeaders: ['Content-Type', 'Authorization', 'X-Auth-Nonce'],
|
||||
@@ -76,50 +77,6 @@ app.use(helmet());
|
||||
app.use(express.json());
|
||||
app.use(express.urlencoded({ extended: true }));
|
||||
|
||||
// 3. Затем сессии
|
||||
app.use(
|
||||
session({
|
||||
secret: process.env.SESSION_SECRET || 'your-secret-key',
|
||||
resave: false,
|
||||
saveUninitialized: false,
|
||||
cookie: {
|
||||
httpOnly: true,
|
||||
secure: process.env.NODE_ENV === 'production', // В разработке можно установить false
|
||||
sameSite: process.env.NODE_ENV === 'production' ? 'none' : 'lax',
|
||||
maxAge: 24 * 60 * 60 * 1000, // 1 день
|
||||
},
|
||||
store: new pgSession({
|
||||
pool: pool,
|
||||
tableName: 'session',
|
||||
}),
|
||||
})
|
||||
);
|
||||
|
||||
// Добавьте после настройки сессий
|
||||
app.use((req, res, next) => {
|
||||
// console.log('Middleware для проверки сессии:', {
|
||||
// url: req.url,
|
||||
// method: req.method,
|
||||
// sessionID: req.sessionID,
|
||||
// session: req.session ? {
|
||||
// isAuthenticated: req.session.isAuthenticated,
|
||||
// authenticated: req.session.authenticated,
|
||||
// address: req.session.address,
|
||||
// isAdmin: req.session.isAdmin
|
||||
// } : null,
|
||||
// cookies: req.cookies,
|
||||
// headers: {
|
||||
// cookie: req.headers.cookie
|
||||
// }
|
||||
// });
|
||||
if (req.session.store) {
|
||||
req.session.store.on('error', (error) => {
|
||||
console.error('Session store error:', error);
|
||||
});
|
||||
}
|
||||
next();
|
||||
});
|
||||
|
||||
// Добавьте после настройки парсеров
|
||||
app.use((req, res, next) => {
|
||||
// if (req.method === 'POST' && req.headers['content-type'] === 'application/json') {
|
||||
@@ -215,6 +172,9 @@ app.use((req, res, next) => {
|
||||
// next(err);
|
||||
// });
|
||||
|
||||
// Использовать импортированный middleware для сессий
|
||||
app.use(sessionMiddleware);
|
||||
|
||||
async function initServices() {
|
||||
try {
|
||||
console.log('Инициализация сервисов...');
|
||||
@@ -285,7 +245,17 @@ app.post('/api/verify', async (req, res) => {
|
||||
req.session.lastSignature = signature;
|
||||
|
||||
// Сохраняем сессию
|
||||
req.session.save();
|
||||
await new Promise((resolve, reject) => {
|
||||
req.session.save((err) => {
|
||||
if (err) {
|
||||
console.error('Ошибка при сохранении сессии:', err);
|
||||
reject(err);
|
||||
} else {
|
||||
console.log('Сессия успешно сохранена');
|
||||
resolve();
|
||||
}
|
||||
});
|
||||
});
|
||||
} catch (error) {
|
||||
return res.status(401).json({ success: false, error: error.message });
|
||||
}
|
||||
@@ -734,3 +704,11 @@ setTimeout(async () => {
|
||||
console.error('Ошибка при первоначальной очистке сессий:', err);
|
||||
}
|
||||
}, 5 * 60 * 1000);
|
||||
|
||||
app.get('/session-debug', (req, res) => {
|
||||
// Implementation of the endpoint
|
||||
});
|
||||
|
||||
app.get('/check-sessions', async (req, res) => {
|
||||
// Implementation of the endpoint
|
||||
});
|
||||
|
||||
163
backend/services/auth-service.js
Normal file
163
backend/services/auth-service.js
Normal file
@@ -0,0 +1,163 @@
|
||||
const db = require('../db');
|
||||
const { getContract } = require('../utils/contracts');
|
||||
const logger = require('../utils/logger');
|
||||
const { ethers } = require('ethers');
|
||||
const path = require('path');
|
||||
|
||||
// Инициализируем провайдер
|
||||
const provider = new ethers.JsonRpcProvider(process.env.RPC_URL);
|
||||
|
||||
const contractsDir = path.join(__dirname, '../artifacts/contracts/AccessToken.sol');
|
||||
|
||||
/**
|
||||
* Сервис для работы с аутентификацией и авторизацией
|
||||
*/
|
||||
class AuthService {
|
||||
/**
|
||||
* Проверяет наличие токена администратора для кошелька
|
||||
* @param {string} walletAddress - Адрес кошелька
|
||||
* @returns {Promise<boolean>} - Имеет ли кошелек токен администратора
|
||||
*/
|
||||
async checkAdminToken(walletAddress) {
|
||||
try {
|
||||
if (!walletAddress) {
|
||||
logger.error('Wallet address is undefined');
|
||||
return false;
|
||||
}
|
||||
|
||||
// Получаем контракт AccessToken
|
||||
const accessToken = await getContract('AccessToken');
|
||||
|
||||
// Проверяем роль пользователя
|
||||
const role = await accessToken.checkRole(walletAddress);
|
||||
|
||||
// 0 = ADMIN
|
||||
return role === 0;
|
||||
} catch (error) {
|
||||
logger.error(`Error checking admin token: ${error.message}`);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Проверяет наличие токенов на кошельке и обновляет роль
|
||||
* @param {string} walletAddress - Адрес кошелька
|
||||
* @returns {Promise<boolean>} - Имеет ли пользователь права администратора
|
||||
*/
|
||||
async checkTokensAndUpdateRole(walletAddress) {
|
||||
try {
|
||||
// Получаем ID пользователя по адресу кошелька
|
||||
const userResult = await db.query(`
|
||||
SELECT u.id FROM users u
|
||||
JOIN user_identities ui ON u.id = ui.user_id
|
||||
WHERE ui.identity_type = 'wallet' AND ui.identity_value = $1
|
||||
`, [walletAddress]);
|
||||
|
||||
if (userResult.rows.length === 0) {
|
||||
logger.warn(`User with wallet ${walletAddress} not found`);
|
||||
return false;
|
||||
}
|
||||
|
||||
const userId = userResult.rows[0].id;
|
||||
|
||||
// Проверяем наличие токена администратора
|
||||
const isAdmin = await this.checkAdminToken(walletAddress);
|
||||
|
||||
// Обновляем роль в базе данных
|
||||
await this.updateUserRole(userId, isAdmin ? 'admin' : 'user');
|
||||
|
||||
logger.info(`User ${userId} with address ${walletAddress}: admin=${isAdmin}`);
|
||||
|
||||
return isAdmin;
|
||||
} catch (error) {
|
||||
logger.error(`Error checking tokens: ${error.message}`);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Обновляет роль пользователя в базе данных
|
||||
* @param {number} userId - ID пользователя
|
||||
* @param {string} role - Новая роль ('admin' или 'user')
|
||||
* @returns {Promise<boolean>} - Успешно ли обновлена роль
|
||||
*/
|
||||
async updateUserRole(userId, role) {
|
||||
try {
|
||||
// Получаем ID роли
|
||||
const roleResult = await db.query('SELECT id FROM roles WHERE name = $1', [role]);
|
||||
|
||||
if (roleResult.rows.length === 0) {
|
||||
logger.error(`Role ${role} not found`);
|
||||
return false;
|
||||
}
|
||||
|
||||
const roleId = roleResult.rows[0].id;
|
||||
|
||||
// Обновляем роль пользователя
|
||||
await db.query('UPDATE users SET role_id = $1 WHERE id = $2', [roleId, userId]);
|
||||
|
||||
logger.info(`Updated role for user ${userId} to ${role}`);
|
||||
return true;
|
||||
} catch (error) {
|
||||
logger.error(`Error updating user role: ${error.message}`);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Получает все токены доступа
|
||||
* @returns {Promise<Array>} - Список токенов доступа
|
||||
*/
|
||||
async getAllTokens() {
|
||||
try {
|
||||
const result = await db.query(`
|
||||
SELECT * FROM access_tokens
|
||||
ORDER BY created_at DESC
|
||||
`);
|
||||
|
||||
return result.rows.map(token => ({
|
||||
id: token.id,
|
||||
walletAddress: token.wallet_address,
|
||||
role: token.role,
|
||||
createdAt: token.created_at,
|
||||
expiresAt: token.expires_at,
|
||||
}));
|
||||
} catch (error) {
|
||||
logger.error(`Error getting all tokens: ${error.message}`);
|
||||
return [];
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Получает ID пользователя по идентификатору
|
||||
* @param {string} identityType - Тип идентификатора ('wallet', 'email', 'telegram')
|
||||
* @param {string} identityValue - Значение идентификатора
|
||||
* @returns {Promise<number|null>} - ID пользователя или null, если пользователь не найден
|
||||
*/
|
||||
async getUserIdByIdentity(identityType, identityValue) {
|
||||
try {
|
||||
// Нормализуем значение идентификатора
|
||||
const normalizedValue = identityType === 'wallet'
|
||||
? identityValue.toLowerCase()
|
||||
: identityValue;
|
||||
|
||||
// Получаем ID пользователя
|
||||
const result = await db.query(`
|
||||
SELECT u.id FROM users u
|
||||
JOIN user_identities ui ON u.id = ui.user_id
|
||||
WHERE ui.identity_type = $1 AND LOWER(ui.identity_value) = LOWER($2)
|
||||
`, [identityType, normalizedValue]);
|
||||
|
||||
if (result.rows.length === 0) {
|
||||
return null;
|
||||
}
|
||||
|
||||
return result.rows[0].id;
|
||||
} catch (error) {
|
||||
logger.error(`Error getting user ID by identity: ${error.message}`);
|
||||
return null;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
module.exports = new AuthService();
|
||||
@@ -1,41 +0,0 @@
|
||||
const { expect } = require('chai');
|
||||
const { ethers } = require('hardhat');
|
||||
|
||||
describe('AccessToken', function () {
|
||||
let AccessToken;
|
||||
let accessToken;
|
||||
let owner;
|
||||
let addr1;
|
||||
let addr2;
|
||||
|
||||
beforeEach(async function () {
|
||||
[owner, addr1, addr2] = await ethers.getSigners();
|
||||
AccessToken = await ethers.getContractFactory('AccessToken');
|
||||
accessToken = await AccessToken.deploy();
|
||||
});
|
||||
|
||||
describe('Minting', function () {
|
||||
it('Should mint admin token', async function () {
|
||||
await accessToken.mintAccessToken(addr1.address, 0);
|
||||
expect(await accessToken.checkRole(addr1.address)).to.equal(0);
|
||||
});
|
||||
|
||||
it('Should mint moderator token', async function () {
|
||||
await accessToken.mintAccessToken(addr1.address, 1);
|
||||
expect(await accessToken.checkRole(addr1.address)).to.equal(1);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Access Control', function () {
|
||||
it('Should fail for non-token holders', async function () {
|
||||
await expect(accessToken.checkRole(addr1.address)).to.be.revertedWith('No active token');
|
||||
});
|
||||
|
||||
it('Should revoke access', async function () {
|
||||
await accessToken.mintAccessToken(addr1.address, 0);
|
||||
const tokenId = await accessToken.activeTokens(addr1.address);
|
||||
await accessToken.revokeToken(tokenId);
|
||||
await expect(accessToken.checkRole(addr1.address)).to.be.revertedWith('No active token');
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1,172 +1,14 @@
|
||||
const { ethers } = require('ethers');
|
||||
require('dotenv').config();
|
||||
const db = require('../db');
|
||||
const contractArtifact = require('../artifacts/contracts/MyContract.sol/MyContract.json');
|
||||
const contractABI = contractArtifact.abi;
|
||||
const logger = require('./logger');
|
||||
const { getContract } = require('./contracts');
|
||||
|
||||
// Проверяем наличие необходимых переменных окружения
|
||||
if (!process.env.ACCESS_TOKEN_ADDRESS) {
|
||||
console.error('ACCESS_TOKEN_ADDRESS не указан в .env файле');
|
||||
}
|
||||
|
||||
if (!process.env.ETHEREUM_NETWORK_URL) {
|
||||
console.error('ETHEREUM_NETWORK_URL не указан в .env файле');
|
||||
}
|
||||
|
||||
// Подключение к контракту
|
||||
const provider = new ethers.JsonRpcProvider(process.env.ETHEREUM_NETWORK_URL);
|
||||
let accessToken;
|
||||
|
||||
try {
|
||||
const AccessTokenABI = require('../artifacts/contracts/AccessToken.sol/AccessToken.json').abi;
|
||||
accessToken = new ethers.Contract(process.env.ACCESS_TOKEN_ADDRESS, AccessTokenABI, provider);
|
||||
} catch (error) {
|
||||
console.error('Ошибка инициализации контракта AccessToken:', error);
|
||||
}
|
||||
const authService = require('../services/auth-service');
|
||||
|
||||
/**
|
||||
* Проверяет доступ и роль пользователя
|
||||
* @param {string} address - Ethereum адрес пользователя
|
||||
* @returns {Promise<{hasAccess: boolean, role: string|null}>}
|
||||
*/
|
||||
async function checkAccess(address) {
|
||||
try {
|
||||
if (!address || !accessToken) {
|
||||
return { hasAccess: false, role: null };
|
||||
}
|
||||
|
||||
// Проверяем активный токен
|
||||
const activeTokenId = await accessToken.activeTokens(address);
|
||||
if (activeTokenId.toString() === '0') {
|
||||
return { hasAccess: false, role: null };
|
||||
}
|
||||
|
||||
// Получаем роль
|
||||
const roleId = await accessToken.checkRole(address);
|
||||
const roles = ['ADMIN', 'MODERATOR', 'SUPPORT'];
|
||||
const role = roles[roleId];
|
||||
|
||||
return {
|
||||
hasAccess: true,
|
||||
role,
|
||||
tokenId: activeTokenId.toString(),
|
||||
};
|
||||
} catch (error) {
|
||||
console.error('Access check error:', error);
|
||||
return { hasAccess: false, role: null };
|
||||
}
|
||||
}
|
||||
|
||||
// Функция для проверки, является ли пользователь администратором
|
||||
async function checkIfAdmin(address) {
|
||||
try {
|
||||
console.log('Проверка прав администратора для адреса:', address);
|
||||
|
||||
// Проверяем в базе данных
|
||||
const result = await db.query('SELECT is_admin FROM users WHERE address = $1', [address]);
|
||||
|
||||
if (result.rows.length === 0) {
|
||||
console.log(`Пользователь с адресом ${address} не найден в базе данных`);
|
||||
return false;
|
||||
}
|
||||
|
||||
const isAdmin = result.rows[0].is_admin;
|
||||
console.log(`Пользователь с адресом ${address} имеет статус администратора:`, isAdmin);
|
||||
|
||||
return isAdmin;
|
||||
} catch (error) {
|
||||
console.error('Ошибка при проверке прав администратора:', error);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Проверяет баланс токенов пользователя и обновляет его роль
|
||||
* @param {string} address - Адрес кошелька пользователя
|
||||
* @returns {Promise<boolean>} - Имеет ли пользователь права администратора
|
||||
*/
|
||||
async function checkTokenBalanceAndUpdateRole(address) {
|
||||
try {
|
||||
// Получение контракта токенов
|
||||
const accessTokenContract = await getContract('AccessToken');
|
||||
|
||||
// Проверка баланса
|
||||
const balance = await accessTokenContract.balanceOf(address);
|
||||
|
||||
// Минимальное количество токенов для прав администратора
|
||||
const minTokens = ethers.utils.parseUnits(process.env.MIN_ADMIN_TOKENS || "1", 18);
|
||||
|
||||
const isAdmin = balance.gte(minTokens);
|
||||
|
||||
// Получение ID пользователя по адресу кошелька
|
||||
const userResult = await db.query(`
|
||||
SELECT u.id FROM users u
|
||||
JOIN user_identities ui ON u.id = ui.user_id
|
||||
WHERE ui.identity_type = 'wallet' AND ui.identity_value = $1
|
||||
`, [address.toLowerCase()]);
|
||||
|
||||
if (userResult.rows.length > 0) {
|
||||
const userId = userResult.rows[0].id;
|
||||
|
||||
// Получение ID роли
|
||||
const roleResult = await db.query(
|
||||
'SELECT id FROM roles WHERE name = $1',
|
||||
[isAdmin ? 'admin' : 'user']
|
||||
);
|
||||
|
||||
if (roleResult.rows.length > 0) {
|
||||
const roleId = roleResult.rows[0].id;
|
||||
|
||||
// Обновление роли пользователя
|
||||
await db.query(
|
||||
'UPDATE users SET role_id = $1, last_token_check = NOW() WHERE id = $2',
|
||||
[roleId, userId]
|
||||
);
|
||||
|
||||
logger.info(`Updated user ${userId} role to ${isAdmin ? 'admin' : 'user'} based on token balance`);
|
||||
}
|
||||
}
|
||||
|
||||
return isAdmin;
|
||||
} catch (error) {
|
||||
logger.error(`Error checking token balance for ${address}: ${error.message}`);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Получает информацию о пользователе, включая его роль
|
||||
* @param {number} userId - ID пользователя
|
||||
* @returns {Promise<Object>} - Информация о пользователе
|
||||
*/
|
||||
async function getUserInfo(userId) {
|
||||
try {
|
||||
const result = await db.query(`
|
||||
SELECT u.id, u.username, u.preferred_language, r.name as role
|
||||
FROM users u
|
||||
LEFT JOIN roles r ON u.role_id = r.id
|
||||
WHERE u.id = $1
|
||||
`, [userId]);
|
||||
|
||||
if (result.rows.length === 0) {
|
||||
return null;
|
||||
}
|
||||
|
||||
return result.rows[0];
|
||||
} catch (error) {
|
||||
logger.error(`Error getting user info for ${userId}: ${error.message}`);
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Запускает проверку токенов для всех пользователей
|
||||
* Проверяет токены всех пользователей и обновляет их роли
|
||||
* @returns {Promise<void>}
|
||||
*/
|
||||
async function checkAllUsersTokens() {
|
||||
try {
|
||||
// Получение всех пользователей с кошельками
|
||||
// Получаем всех пользователей с кошельками
|
||||
const walletUsers = await db.query(`
|
||||
SELECT u.id, ui.identity_value as address
|
||||
FROM users u
|
||||
@@ -174,23 +16,24 @@ async function checkAllUsersTokens() {
|
||||
WHERE ui.identity_type = 'wallet'
|
||||
`);
|
||||
|
||||
logger.info(`Checking token balances for ${walletUsers.rows.length} users`);
|
||||
logger.info(`Checking tokens for ${walletUsers.rows.length} users`);
|
||||
|
||||
for (const user of walletUsers.rows) {
|
||||
// Проверка баланса токенов
|
||||
const hasTokens = await checkTokenBalanceAndUpdateRole(user.address);
|
||||
|
||||
logger.info(`User ${user.id} with address ${user.address}: admin=${hasTokens}`);
|
||||
try {
|
||||
// Используем существующий метод для проверки токенов и обновления роли
|
||||
const isAdmin = await authService.checkTokensAndUpdateRole(user.address);
|
||||
logger.info(`Updated user ${user.id} with address ${user.address}: admin=${isAdmin}`);
|
||||
} catch (error) {
|
||||
logger.error(`Error checking tokens for user ${user.id}: ${error.message}`);
|
||||
}
|
||||
}
|
||||
|
||||
logger.info('Token check completed');
|
||||
} catch (error) {
|
||||
logger.error(`Error checking token balances: ${error.message}`);
|
||||
logger.error(`Error checking all users tokens: ${error.message}`);
|
||||
}
|
||||
}
|
||||
|
||||
module.exports = {
|
||||
checkAccess,
|
||||
checkIfAdmin,
|
||||
checkTokenBalanceAndUpdateRole,
|
||||
getUserInfo,
|
||||
checkAllUsersTokens
|
||||
};
|
||||
@@ -1,184 +1,152 @@
|
||||
const { SiweMessage } = require('siwe');
|
||||
const { ethers } = require('ethers');
|
||||
const AccessTokenABI = require('../artifacts/contracts/AccessToken.sol/AccessToken.json').abi;
|
||||
require('dotenv').config();
|
||||
const { pool } = require('../db');
|
||||
const db = require('../db');
|
||||
const logger = require('./logger');
|
||||
const authService = require('../services/auth-service');
|
||||
const { USER_ROLES, IDENTITY_TYPES } = require('./constants');
|
||||
|
||||
// В ethers.js v6.x используется JsonRpcProvider напрямую
|
||||
// Инициализация провайдера
|
||||
const provider = new ethers.JsonRpcProvider(process.env.RPC_URL);
|
||||
const accessToken = new ethers.Contract(process.env.ACCESS_TOKEN_ADDRESS, AccessTokenABI, provider);
|
||||
|
||||
// Проверяем наличие адреса контракта
|
||||
if (!process.env.ACCESS_TOKEN_ADDRESS) {
|
||||
console.error('ACCESS_TOKEN_ADDRESS не указан в .env файле');
|
||||
}
|
||||
|
||||
/**
|
||||
* Проверяет подпись сообщения
|
||||
* @param {Object} message - Сообщение для проверки
|
||||
* @param {string} signature - Подпись сообщения
|
||||
* @param {string} nonce - Независимый идентификатор
|
||||
* @param {string} signature - Подпись
|
||||
* @param {string} address - Адрес кошелька
|
||||
* @returns {Promise<boolean>} - Результат проверки
|
||||
*/
|
||||
async function verifySignature(message, signature, address) {
|
||||
async function verifySignature(nonce, signature, address) {
|
||||
try {
|
||||
// Формируем сообщение для проверки
|
||||
const domain = message.domain || 'localhost';
|
||||
const statement = message.statement || 'Sign in with Ethereum to the app.';
|
||||
const uri = message.uri || 'http://localhost:8000';
|
||||
const version = message.version || '1';
|
||||
const chainId = message.chainId || '1';
|
||||
const nonce = message.nonce;
|
||||
// Создаем сообщение для проверки
|
||||
const message = `Sign this message to authenticate with our app: ${nonce}`;
|
||||
|
||||
const messageToVerify = `${domain} wants you to sign in with your Ethereum account:
|
||||
${address}
|
||||
|
||||
${statement}
|
||||
|
||||
URI: ${uri}
|
||||
Version: ${version}
|
||||
Chain ID: ${chainId}
|
||||
Nonce: ${nonce}
|
||||
`;
|
||||
|
||||
// В ethers.js v6.x используется verifyMessage напрямую
|
||||
const recoveredAddress = ethers.verifyMessage(messageToVerify, signature);
|
||||
// Восстанавливаем адрес из подписи
|
||||
const recoveredAddress = ethers.verifyMessage(message, signature);
|
||||
|
||||
// Проверяем, что восстановленный адрес совпадает с предоставленным
|
||||
return recoveredAddress.toLowerCase() === address.toLowerCase();
|
||||
} catch (error) {
|
||||
console.error('Signature verification error:', error);
|
||||
console.error('Error verifying signature:', error);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
async function checkAccess(address) {
|
||||
// Временная заглушка
|
||||
return { hasAccess: false, role: null };
|
||||
}
|
||||
|
||||
async function verifyAndCheckAccess(message, signature, address) {
|
||||
// Проверяем подпись
|
||||
const verified = await verifySignature(message, signature, address);
|
||||
if (!verified) {
|
||||
return {
|
||||
verified: false,
|
||||
access: { hasAccess: false },
|
||||
};
|
||||
}
|
||||
|
||||
// Проверяем доступ
|
||||
const access = await checkAccess(address);
|
||||
|
||||
return {
|
||||
verified: true,
|
||||
access,
|
||||
};
|
||||
}
|
||||
|
||||
// Функция для поиска или создания пользователя
|
||||
async function findOrCreateUser(identifier, identityType = 'wallet') {
|
||||
/**
|
||||
* Проверяет, является ли пользователь администратором
|
||||
* @param {string} address - Адрес кошелька
|
||||
* @returns {Promise<boolean>} - Является ли пользователь администратором
|
||||
*/
|
||||
async function checkUserRole(address) {
|
||||
try {
|
||||
// Проверяем, является ли адрес адресом администратора
|
||||
const isAdmin = identityType === 'wallet' &&
|
||||
identifier.toLowerCase() === process.env.ADMIN_WALLET_ADDRESS.toLowerCase();
|
||||
// Проверяем наличие токена администратора
|
||||
const isAdmin = await authService.checkAdminToken(address);
|
||||
return isAdmin;
|
||||
} catch (error) {
|
||||
console.error('Error checking user role:', error);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
console.log(`Проверка на администратора: ${identifier.toLowerCase()} === ${process.env.ADMIN_WALLET_ADDRESS.toLowerCase()} = ${isAdmin}`);
|
||||
/**
|
||||
* Проверяет доступ пользователя
|
||||
* @param {string} walletAddress - Адрес кошелька
|
||||
* @returns {Promise<Object>} - Информация о доступе
|
||||
*/
|
||||
async function checkAccess(walletAddress) {
|
||||
try {
|
||||
// Проверяем наличие токена администратора
|
||||
const isAdmin = await authService.checkAdminToken(walletAddress);
|
||||
|
||||
// Проверяем, существует ли пользователь с таким идентификатором
|
||||
const identityResult = await pool.query(
|
||||
'SELECT user_id FROM user_identities WHERE identity_type = $1 AND identity_value = $2',
|
||||
[identityType, identifier.toLowerCase()]
|
||||
);
|
||||
// Получаем или создаем пользователя
|
||||
const userId = await findOrCreateUser(walletAddress);
|
||||
|
||||
let userId;
|
||||
let isNewUser = false;
|
||||
|
||||
if (identityResult.rows.length > 0) {
|
||||
// Пользователь найден
|
||||
userId = identityResult.rows[0].user_id;
|
||||
console.log(`Найден существующий пользователь с ID: ${userId}`);
|
||||
|
||||
// Обновляем статус администратора, если это необходимо
|
||||
if (isAdmin) {
|
||||
await pool.query(
|
||||
'UPDATE users SET is_admin = true WHERE id = $1',
|
||||
[userId]
|
||||
);
|
||||
console.log(`Обновлен статус администратора для пользователя ${userId}`);
|
||||
}
|
||||
} else {
|
||||
// Создаем нового пользователя с явным указанием всех необходимых полей
|
||||
const username = `user_${Date.now()}`;
|
||||
|
||||
// Проверяем существование роли USER или ADMIN
|
||||
const roleName = isAdmin ? 'ADMIN' : 'USER';
|
||||
const roleCheck = await pool.query('SELECT id FROM roles WHERE name = $1', [roleName]);
|
||||
let roleId;
|
||||
|
||||
if (roleCheck.rows.length > 0) {
|
||||
roleId = roleCheck.rows[0].id;
|
||||
} else {
|
||||
// Если роли нет, создаем её
|
||||
const newRole = await pool.query(
|
||||
'INSERT INTO roles (name, description) VALUES ($1, $2) RETURNING id',
|
||||
[roleName, isAdmin ? 'Administrator role' : 'Regular user role']
|
||||
);
|
||||
roleId = newRole.rows[0].id;
|
||||
}
|
||||
|
||||
// Создаем пользователя с обязательными полями
|
||||
const userResult = await pool.query(
|
||||
`INSERT INTO users (username, role_id, address, created_at, is_admin)
|
||||
VALUES ($1, $2, $3, NOW(), $4)
|
||||
RETURNING id`,
|
||||
[username, roleId, identifier.toLowerCase(), isAdmin]
|
||||
);
|
||||
|
||||
userId = userResult.rows[0].id;
|
||||
isNewUser = true;
|
||||
|
||||
// Создаем запись в таблице идентификаторов
|
||||
await pool.query(
|
||||
'INSERT INTO user_identities (user_id, identity_type, identity_value, verified, created_at) VALUES ($1, $2, $3, true, NOW())',
|
||||
[userId, identityType, identifier.toLowerCase()]
|
||||
);
|
||||
|
||||
console.log(`Создан новый пользователь с ID: ${userId}, isAdmin: ${isAdmin}`);
|
||||
}
|
||||
|
||||
// Получаем информацию о пользователе
|
||||
try {
|
||||
const userInfo = await pool.query(
|
||||
`SELECT u.id, u.username, u.is_admin, r.name as role
|
||||
FROM users u
|
||||
JOIN roles r ON u.role_id = r.id
|
||||
WHERE u.id = $1`,
|
||||
[userId]
|
||||
);
|
||||
|
||||
if (userInfo.rows.length > 0) {
|
||||
return userInfo.rows[0];
|
||||
}
|
||||
} catch (err) {
|
||||
console.error('Ошибка при получении информации о пользователе:', err);
|
||||
}
|
||||
|
||||
// Если не удалось получить полную информацию, возвращаем базовую
|
||||
return {
|
||||
id: userId,
|
||||
username: isNewUser ? `user_${Date.now()}` : 'unknown',
|
||||
is_admin: isAdmin,
|
||||
role: isAdmin ? 'ADMIN' : 'USER'
|
||||
userId,
|
||||
isAdmin,
|
||||
hasAccess: true
|
||||
};
|
||||
} catch (error) {
|
||||
console.error('Ошибка при поиске/создании пользователя:', error);
|
||||
logger.error(`Error checking access: ${error.message}`);
|
||||
return {
|
||||
hasAccess: false,
|
||||
error: error.message
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Находит или создает пользователя по адресу кошелька
|
||||
* @param {string} address - Адрес кошелька
|
||||
* @returns {Promise<Object>} - ID пользователя и роль
|
||||
*/
|
||||
async function findOrCreateUser(address) {
|
||||
try {
|
||||
// Проверяем, существует ли пользователь
|
||||
const userResult = await db.query('SELECT * FROM users WHERE LOWER(address) = LOWER($1)', [address]);
|
||||
|
||||
let userId;
|
||||
let isAdmin = false;
|
||||
|
||||
if (userResult.rows.length === 0) {
|
||||
// Если пользователь не найден, создаем его
|
||||
// Получаем ID роли 'user'
|
||||
const roleResult = await db.query('SELECT id FROM roles WHERE name = $1', ['user']);
|
||||
if (roleResult.rows.length === 0) {
|
||||
throw new Error('Role "user" not found');
|
||||
}
|
||||
const roleId = roleResult.rows[0].id;
|
||||
|
||||
// Создаем пользователя с ролью 'user'
|
||||
const newUserResult = await db.query(
|
||||
'INSERT INTO users (address, role_id, created_at) VALUES (LOWER($1), $2, NOW()) RETURNING id',
|
||||
[address, roleId]
|
||||
);
|
||||
|
||||
userId = newUserResult.rows[0].id;
|
||||
|
||||
// Проверяем, является ли пользователь администратором
|
||||
isAdmin = await checkUserRole(address);
|
||||
|
||||
// Если пользователь администратор, обновляем его роль
|
||||
if (isAdmin) {
|
||||
const adminRoleResult = await db.query('SELECT id FROM roles WHERE name = $1', ['admin']);
|
||||
if (adminRoleResult.rows.length > 0) {
|
||||
const adminRoleId = adminRoleResult.rows[0].id;
|
||||
await db.query('UPDATE users SET role_id = $1 WHERE id = $2', [adminRoleId, userId]);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
// Если пользователь найден, получаем его ID и роль
|
||||
userId = userResult.rows[0].id;
|
||||
|
||||
// Проверяем, является ли пользователь администратором по роли
|
||||
const roleResult = await db.query('SELECT name FROM roles WHERE id = $1', [userResult.rows[0].role_id]);
|
||||
isAdmin = roleResult.rows.length > 0 && roleResult.rows[0].name === 'admin';
|
||||
|
||||
// Проверяем, является ли пользователь администратором по токену
|
||||
const isAdminByToken = await checkUserRole(address);
|
||||
|
||||
// Обновляем роль пользователя, если она изменилась
|
||||
if (isAdminByToken !== isAdmin) {
|
||||
const roleNameToSet = isAdminByToken ? 'admin' : 'user';
|
||||
const roleToSetResult = await db.query('SELECT id FROM roles WHERE name = $1', [roleNameToSet]);
|
||||
if (roleToSetResult.rows.length > 0) {
|
||||
const roleIdToSet = roleToSetResult.rows[0].id;
|
||||
await db.query('UPDATE users SET role_id = $1 WHERE id = $2', [roleIdToSet, userId]);
|
||||
isAdmin = isAdminByToken;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return { userId, isAdmin };
|
||||
} catch (error) {
|
||||
console.error('Error finding or creating user:', error);
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
module.exports = {
|
||||
verifyAndCheckAccess,
|
||||
verifySignature,
|
||||
checkAccess,
|
||||
findOrCreateUser
|
||||
findOrCreateUser,
|
||||
checkUserRole
|
||||
};
|
||||
58
backend/utils/constants.js
Normal file
58
backend/utils/constants.js
Normal file
@@ -0,0 +1,58 @@
|
||||
// Роли пользователей
|
||||
const USER_ROLES = {
|
||||
USER: 1,
|
||||
ADMIN: 2
|
||||
};
|
||||
|
||||
// Типы идентификаторов
|
||||
const IDENTITY_TYPES = {
|
||||
WALLET: 'wallet',
|
||||
EMAIL: 'email',
|
||||
TELEGRAM: 'telegram'
|
||||
};
|
||||
|
||||
// Каналы сообщений
|
||||
const MESSAGE_CHANNELS = {
|
||||
WEB: 'web',
|
||||
TELEGRAM: 'telegram',
|
||||
EMAIL: 'email'
|
||||
};
|
||||
|
||||
// Типы отправителей сообщений
|
||||
const SENDER_TYPES = {
|
||||
USER: 'user',
|
||||
AI: 'ai',
|
||||
ADMIN: 'admin'
|
||||
};
|
||||
|
||||
// Коды ошибок
|
||||
const ERROR_CODES = {
|
||||
UNAUTHORIZED: 'unauthorized',
|
||||
FORBIDDEN: 'forbidden',
|
||||
NOT_FOUND: 'not_found',
|
||||
INTERNAL_ERROR: 'internal_error',
|
||||
BAD_REQUEST: 'bad_request'
|
||||
};
|
||||
|
||||
// Настройки сессии
|
||||
const SESSION_CONFIG = {
|
||||
COOKIE_MAX_AGE: 24 * 60 * 60 * 1000, // 24 часа
|
||||
COOKIE_SECURE: process.env.NODE_ENV === 'production',
|
||||
COOKIE_SAME_SITE: 'lax'
|
||||
};
|
||||
|
||||
// Настройки API
|
||||
const API_CONFIG = {
|
||||
RATE_LIMIT: 100, // запросов в минуту
|
||||
TIMEOUT: 30000 // 30 секунд
|
||||
};
|
||||
|
||||
module.exports = {
|
||||
USER_ROLES,
|
||||
IDENTITY_TYPES,
|
||||
MESSAGE_CHANNELS,
|
||||
SENDER_TYPES,
|
||||
ERROR_CODES,
|
||||
SESSION_CONFIG,
|
||||
API_CONFIG
|
||||
};
|
||||
@@ -3,36 +3,99 @@ const fs = require('fs');
|
||||
const path = require('path');
|
||||
const logger = require('./logger');
|
||||
|
||||
// Инициализация провайдера
|
||||
const provider = new ethers.JsonRpcProvider(process.env.RPC_URL);
|
||||
|
||||
// Путь к директории с ABI контрактов
|
||||
const contractsDir = path.join(__dirname, '../artifacts/contracts/AccessToken.sol');
|
||||
|
||||
// Получение ABI контракта
|
||||
const accessTokenJSON = require('../artifacts/contracts/AccessToken.sol/AccessToken.json');
|
||||
const accessTokenABI = accessTokenJSON.abi;
|
||||
|
||||
// Проверка, что ABI является массивом
|
||||
if (!Array.isArray(accessTokenABI)) {
|
||||
console.error('ABI is not an array:', accessTokenABI);
|
||||
// Если ABI не является массивом, создайте массив вручную
|
||||
const manualABI = [
|
||||
"function mintAccessToken(address to, uint8 role) public",
|
||||
"function checkRole(address user) public view returns (uint8)",
|
||||
"function revokeToken(uint256 tokenId) public",
|
||||
// Добавьте другие функции, которые вам нужны
|
||||
];
|
||||
|
||||
// Создание экземпляра контракта с ручным ABI
|
||||
const contractAddress = process.env.ACCESS_TOKEN_ADDRESS;
|
||||
const accessTokenContract = new ethers.Contract(contractAddress, manualABI, provider);
|
||||
|
||||
module.exports = {
|
||||
accessTokenContract,
|
||||
getContract,
|
||||
provider
|
||||
};
|
||||
} else {
|
||||
// Если ABI является массивом, используйте его
|
||||
const contractAddress = process.env.ACCESS_TOKEN_ADDRESS;
|
||||
const accessTokenContract = new ethers.Contract(contractAddress, accessTokenABI, provider);
|
||||
|
||||
module.exports = {
|
||||
accessTokenContract,
|
||||
getContract,
|
||||
provider
|
||||
};
|
||||
}
|
||||
|
||||
// Кэш для хранения экземпляров контрактов
|
||||
const contractsCache = {};
|
||||
|
||||
/**
|
||||
* Получает экземпляр контракта по его имени
|
||||
* @param {string} contractName - Имя контракта (например, 'AccessToken')
|
||||
* @param {string} contractName - Имя контракта
|
||||
* @returns {Promise<ethers.Contract>} - Экземпляр контракта
|
||||
*/
|
||||
async function getContract(contractName) {
|
||||
try {
|
||||
// Путь к артефакту контракта
|
||||
const artifactPath = path.join(__dirname, '..', 'artifacts', 'contracts', `${contractName}.sol`, `${contractName}.json`);
|
||||
console.log(`Getting contract: ${contractName}`);
|
||||
|
||||
// Проверка существования файла
|
||||
if (!fs.existsSync(artifactPath)) {
|
||||
throw new Error(`Артефакт контракта ${contractName} не найден по пути ${artifactPath}`);
|
||||
// Проверяем, есть ли контракт в кэше
|
||||
if (contractsCache[contractName]) {
|
||||
console.log(`Using cached contract: ${contractName}`);
|
||||
return contractsCache[contractName];
|
||||
}
|
||||
|
||||
// Загрузка ABI из артефакта
|
||||
const contractArtifact = require(artifactPath);
|
||||
const contractABI = contractArtifact.abi;
|
||||
// Получаем адрес контракта из переменных окружения
|
||||
const contractAddress = process.env.ACCESS_TOKEN_ADDRESS; // или ACCESS_TOKEN_CONTRACT_ADDRESS
|
||||
|
||||
// Получение адреса контракта из переменных окружения
|
||||
const contractAddress = process.env[`${contractName.toUpperCase()}_ADDRESS`];
|
||||
if (!contractAddress) {
|
||||
throw new Error(`Адрес контракта ${contractName} не найден в переменных окружения`);
|
||||
throw new Error(`Contract address for ${contractName} not found in environment variables`);
|
||||
}
|
||||
|
||||
// Подключение к провайдеру
|
||||
const provider = new ethers.JsonRpcProvider(process.env.ETHEREUM_NETWORK_URL);
|
||||
// Путь к файлу с ABI контракта
|
||||
const abiPath = path.join(contractsDir, `${contractName}.json`);
|
||||
|
||||
// Создание экземпляра контракта
|
||||
const contract = new ethers.Contract(contractAddress, contractABI, provider);
|
||||
// Проверяем, существует ли файл с ABI
|
||||
if (!fs.existsSync(abiPath)) {
|
||||
throw new Error(`ABI file for ${contractName} not found at ${abiPath}`);
|
||||
}
|
||||
|
||||
// Читаем ABI из файла
|
||||
const abiJson = fs.readFileSync(abiPath, 'utf8');
|
||||
const contractJSON = JSON.parse(abiJson);
|
||||
const abi = contractJSON.abi; // Получаем ABI из свойства abi
|
||||
|
||||
console.log(`ABI for ${contractName}:`, abi);
|
||||
|
||||
// Проверяем, что ABI является массивом
|
||||
if (!Array.isArray(abi)) {
|
||||
console.error(`ABI for ${contractName} is not an array:`, abi);
|
||||
throw new Error(`ABI for ${contractName} is not an array`);
|
||||
}
|
||||
|
||||
// Создаем экземпляр контракта
|
||||
const contract = new ethers.Contract(contractAddress, abi, provider);
|
||||
|
||||
// Сохраняем контракт в кэше
|
||||
contractsCache[contractName] = contract;
|
||||
|
||||
return contract;
|
||||
} catch (error) {
|
||||
@@ -40,7 +103,3 @@ async function getContract(contractName) {
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
module.exports = {
|
||||
getContract
|
||||
};
|
||||
|
||||
@@ -1,2 +0,0 @@
|
||||
// Реэкспорт основного модуля db
|
||||
module.exports = require('../db');
|
||||
@@ -1,10 +1,5 @@
|
||||
const { Pool } = require('pg');
|
||||
|
||||
// Подключение к БД
|
||||
const pool = new Pool({
|
||||
connectionString: process.env.DATABASE_URL,
|
||||
ssl: process.env.NODE_ENV === 'production' ? { rejectUnauthorized: false } : false,
|
||||
});
|
||||
const db = require('../db');
|
||||
const logger = require('./logger');
|
||||
|
||||
/**
|
||||
* Связывает идентификатор с пользователем
|
||||
@@ -16,7 +11,7 @@ const pool = new Pool({
|
||||
async function linkIdentity(userId, identityType, identityValue) {
|
||||
try {
|
||||
// Проверяем, существует ли уже такой идентификатор
|
||||
const existingResult = await pool.query(
|
||||
const existingResult = await db.query(
|
||||
'SELECT * FROM user_identities WHERE identity_type = $1 AND identity_value = $2',
|
||||
[identityType, identityValue]
|
||||
);
|
||||
@@ -32,7 +27,7 @@ async function linkIdentity(userId, identityType, identityValue) {
|
||||
}
|
||||
|
||||
// Добавляем новую связь
|
||||
await pool.query(
|
||||
await db.query(
|
||||
'INSERT INTO user_identities (user_id, identity_type, identity_value, created_at) VALUES ($1, $2, $3, NOW())',
|
||||
[userId, identityType, identityValue]
|
||||
);
|
||||
@@ -53,7 +48,7 @@ async function linkIdentity(userId, identityType, identityValue) {
|
||||
*/
|
||||
async function getUserIdByIdentity(identityType, identityValue) {
|
||||
try {
|
||||
const result = await pool.query(
|
||||
const result = await db.query(
|
||||
'SELECT user_id FROM user_identities WHERE identity_type = $1 AND identity_value = $2',
|
||||
[identityType, identityValue]
|
||||
);
|
||||
@@ -76,7 +71,7 @@ async function getUserIdByIdentity(identityType, identityValue) {
|
||||
*/
|
||||
async function getUserIdentities(userId) {
|
||||
try {
|
||||
const result = await pool.query(
|
||||
const result = await db.query(
|
||||
'SELECT identity_type, identity_value FROM user_identities WHERE user_id = $1',
|
||||
[userId]
|
||||
);
|
||||
|
||||
@@ -1,4 +0,0 @@
|
||||
import { ethers } from 'ethers';
|
||||
|
||||
const provider = new ethers.JsonRpcProvider(process.env.ETHEREUM_NETWORK_URL);
|
||||
const wallet = new ethers.Wallet(process.env.PRIVATE_KEY, provider);
|
||||
4252
backend/yarn.lock
4252
backend/yarn.lock
File diff suppressed because it is too large
Load Diff
@@ -45,54 +45,22 @@ async function checkSession() {
|
||||
// Функция для обновления сессии
|
||||
async function refreshSession() {
|
||||
try {
|
||||
const apiUrl = import.meta.env.VITE_API_URL || 'http://localhost:8000';
|
||||
|
||||
// Проверяем, есть ли адрес пользователя
|
||||
if (!authStore.address) {
|
||||
if (!authStore.user || !authStore.user.address) {
|
||||
console.log('Нет адреса пользователя для обновления сессии');
|
||||
return;
|
||||
}
|
||||
|
||||
console.log('Попытка обновления сессии для адреса:', authStore.address);
|
||||
const response = await axios.post('/api/auth/refresh-session',
|
||||
{ address: authStore.user.address },
|
||||
{ withCredentials: true }
|
||||
);
|
||||
|
||||
// Сначала проверяем, доступен ли маршрут
|
||||
try {
|
||||
const response = await axios.post(
|
||||
`${apiUrl}/api/auth/refresh-session`,
|
||||
{
|
||||
address: authStore.address,
|
||||
},
|
||||
{
|
||||
withCredentials: true,
|
||||
}
|
||||
);
|
||||
|
||||
console.log('Сессия обновлена:', response.data);
|
||||
} catch (error) {
|
||||
if (error.response && error.response.status === 404) {
|
||||
console.log('Маршрут refresh-session не найден, пробуем альтернативный метод');
|
||||
|
||||
// Альтернативный метод: используем маршрут проверки аутентификации
|
||||
const checkResponse = await axios.get(`${apiUrl}/api/auth/check`, {
|
||||
withCredentials: true,
|
||||
headers: {
|
||||
Authorization: `Bearer ${authStore.address}`,
|
||||
},
|
||||
});
|
||||
|
||||
console.log('Проверка аутентификации:', checkResponse.data);
|
||||
} else {
|
||||
throw error;
|
||||
}
|
||||
if (response.data.success) {
|
||||
console.log('Сессия успешно обновлена');
|
||||
}
|
||||
} catch (error) {
|
||||
console.error('Ошибка при обновлении сессии:', error);
|
||||
|
||||
// Добавляем более подробную информацию об ошибке
|
||||
if (error.response) {
|
||||
console.error('Статус ответа:', error.response.status);
|
||||
console.error('Данные ответа:', error.response.data);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -110,40 +78,14 @@ onMounted(async () => {
|
||||
|
||||
if (response.data.authenticated) {
|
||||
// Если сессия активна, обновляем состояние аутентификации
|
||||
authStore.updateAuthState({
|
||||
authenticated: response.data.authenticated,
|
||||
address: response.data.address,
|
||||
isAdmin: response.data.isAdmin,
|
||||
authType: 'wallet'
|
||||
});
|
||||
authStore.isAuthenticated = response.data.authenticated;
|
||||
authStore.user = { address: response.data.address };
|
||||
authStore.isAdmin = response.data.isAdmin;
|
||||
authStore.authType = 'wallet';
|
||||
|
||||
console.log('Сессия восстановлена:', response.data);
|
||||
} else {
|
||||
console.log('Нет активной сессии');
|
||||
|
||||
// Если в localStorage есть адрес, пробуем восстановить сессию
|
||||
const savedAddress = localStorage.getItem('walletAddress');
|
||||
if (savedAddress) {
|
||||
console.log('Найден сохраненный адрес:', savedAddress);
|
||||
try {
|
||||
const refreshResponse = await axios.post('/api/auth/refresh-session',
|
||||
{ address: savedAddress },
|
||||
{ withCredentials: true }
|
||||
);
|
||||
|
||||
if (refreshResponse.data.success) {
|
||||
authStore.updateAuthState({
|
||||
authenticated: true,
|
||||
address: savedAddress,
|
||||
isAdmin: refreshResponse.data.user.isAdmin,
|
||||
authType: 'wallet'
|
||||
});
|
||||
console.log('Сессия восстановлена через refresh-session');
|
||||
}
|
||||
} catch (refreshError) {
|
||||
console.error('Ошибка при восстановлении сессии:', refreshError);
|
||||
}
|
||||
}
|
||||
}
|
||||
} catch (error) {
|
||||
console.error('Ошибка при проверке сессии:', error);
|
||||
|
||||
@@ -1,4 +0,0 @@
|
||||
import axios from 'axios';
|
||||
|
||||
// Настройка axios для работы с куками
|
||||
axios.defaults.withCredentials = true;
|
||||
26
frontend/src/api/axios.js
Normal file
26
frontend/src/api/axios.js
Normal file
@@ -0,0 +1,26 @@
|
||||
import axios from 'axios';
|
||||
|
||||
// Создаем экземпляр axios с базовым URL
|
||||
const api = axios.create({
|
||||
baseURL: 'http://localhost:8000',
|
||||
withCredentials: true, // Важно для передачи куков между запросами
|
||||
headers: {
|
||||
'Content-Type': 'application/json',
|
||||
},
|
||||
});
|
||||
|
||||
// Удаляем перехватчик, который добавлял заголовок Authorization из localStorage
|
||||
// api.interceptors.request.use(
|
||||
// (config) => {
|
||||
// const address = localStorage.getItem('walletAddress');
|
||||
// if (address) {
|
||||
// config.headers.Authorization = `Bearer ${address}`;
|
||||
// }
|
||||
// return config;
|
||||
// },
|
||||
// (error) => {
|
||||
// return Promise.reject(error);
|
||||
// }
|
||||
// );
|
||||
|
||||
export default api;
|
||||
@@ -1,188 +0,0 @@
|
||||
<template>
|
||||
<div class="access-control">
|
||||
<div v-if="error" class="error-message">
|
||||
{{ error }}
|
||||
</div>
|
||||
<div v-else-if="loading" class="loading-message">Загрузка...</div>
|
||||
<div v-else>
|
||||
<div v-if="!isConnected" class="alert alert-warning">
|
||||
Подключите ваш кошелек для проверки доступа
|
||||
</div>
|
||||
<div v-else-if="accessInfo.hasAccess" class="alert alert-success">
|
||||
<strong>Доступ разрешен!</strong>
|
||||
<div>Токен: {{ accessInfo.token }}</div>
|
||||
<div>Роль: {{ accessInfo.role }}</div>
|
||||
<div>Истекает: {{ formatDate(accessInfo.expiresAt) }}</div>
|
||||
</div>
|
||||
<div v-else class="alert alert-danger">
|
||||
<strong>Доступ запрещен!</strong>
|
||||
<p>У вас нет активного токена доступа.</p>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
</template>
|
||||
|
||||
<script setup>
|
||||
import { ref, onMounted, watch } from 'vue';
|
||||
import axios from 'axios';
|
||||
import { useAuthStore } from '../stores/auth';
|
||||
|
||||
const authStore = useAuthStore();
|
||||
const address = ref('');
|
||||
const isConnected = ref(true);
|
||||
const loading = ref(false);
|
||||
const error = ref(null);
|
||||
const accessInfo = ref({
|
||||
hasAccess: false,
|
||||
token: '',
|
||||
role: '',
|
||||
expiresAt: null,
|
||||
});
|
||||
|
||||
// Форматирование даты
|
||||
function formatDate(timestamp) {
|
||||
if (!timestamp) return 'Н/Д';
|
||||
return new Date(timestamp).toLocaleString();
|
||||
}
|
||||
|
||||
// Проверка доступа
|
||||
async function checkAccess() {
|
||||
if (!isConnected.value || !address.value) return;
|
||||
|
||||
loading.value = true;
|
||||
error.value = null;
|
||||
|
||||
try {
|
||||
const response = await axios.get('/access/check', {
|
||||
headers: {
|
||||
'x-wallet-address': address.value,
|
||||
},
|
||||
});
|
||||
|
||||
accessInfo.value = response.data;
|
||||
} catch (err) {
|
||||
console.error('Ошибка проверки доступа:', err);
|
||||
error.value = err.response?.data?.error || 'Ошибка проверки доступа';
|
||||
accessInfo.value = { hasAccess: false };
|
||||
} finally {
|
||||
loading.value = false;
|
||||
}
|
||||
}
|
||||
|
||||
// Проверяем доступ при изменении адреса
|
||||
watch(
|
||||
() => address.value,
|
||||
() => {
|
||||
checkAccess();
|
||||
}
|
||||
);
|
||||
|
||||
// Проверяем доступ при монтировании компонента
|
||||
onMounted(() => {
|
||||
if (isConnected.value && address.value) {
|
||||
checkAccess();
|
||||
}
|
||||
});
|
||||
|
||||
async function loadTokens() {
|
||||
try {
|
||||
console.log('Загрузка токенов...');
|
||||
loading.value = true;
|
||||
|
||||
// Добавляем withCredentials для передачи куки с сессией
|
||||
const response = await axios.get('/api/access/tokens', {
|
||||
withCredentials: true,
|
||||
});
|
||||
|
||||
console.log('Ответ API:', response.data);
|
||||
|
||||
if (response.data && response.data.length > 0) {
|
||||
// Если есть токены, берем первый активный
|
||||
const activeToken = response.data.find((token) => {
|
||||
const expiresAt = new Date(token.expires_at);
|
||||
return expiresAt > new Date();
|
||||
});
|
||||
|
||||
if (activeToken) {
|
||||
accessInfo.value = {
|
||||
hasAccess: true,
|
||||
token: activeToken.id,
|
||||
role: activeToken.role,
|
||||
expiresAt: activeToken.expires_at,
|
||||
};
|
||||
} else {
|
||||
accessInfo.value = { hasAccess: false };
|
||||
}
|
||||
} else {
|
||||
accessInfo.value = { hasAccess: false };
|
||||
}
|
||||
} catch (error) {
|
||||
console.error('Ошибка при загрузке токенов:', error);
|
||||
error.value = 'Ошибка при проверке доступа: ' + (error.response?.data?.error || error.message);
|
||||
accessInfo.value = { hasAccess: false };
|
||||
} finally {
|
||||
loading.value = false;
|
||||
}
|
||||
}
|
||||
|
||||
onMounted(async () => {
|
||||
console.log('Компонент AccessControl загружен');
|
||||
console.log('isAdmin:', authStore.isAdmin);
|
||||
await loadTokens();
|
||||
});
|
||||
</script>
|
||||
|
||||
<style scoped>
|
||||
.access-control {
|
||||
margin: 20px 0;
|
||||
padding: 15px;
|
||||
border: 1px solid #ddd;
|
||||
border-radius: 4px;
|
||||
}
|
||||
|
||||
.alert {
|
||||
padding: 10px 15px;
|
||||
margin-bottom: 10px;
|
||||
border-radius: 4px;
|
||||
}
|
||||
|
||||
.alert-warning {
|
||||
background-color: #fff3cd;
|
||||
border: 1px solid #ffeeba;
|
||||
color: #856404;
|
||||
}
|
||||
|
||||
.alert-info {
|
||||
background-color: #d1ecf1;
|
||||
border: 1px solid #bee5eb;
|
||||
color: #0c5460;
|
||||
}
|
||||
|
||||
.alert-danger {
|
||||
background-color: #f8d7da;
|
||||
border: 1px solid #f5c6cb;
|
||||
color: #721c24;
|
||||
}
|
||||
|
||||
.alert-success {
|
||||
background-color: #d4edda;
|
||||
border: 1px solid #c3e6cb;
|
||||
color: #155724;
|
||||
}
|
||||
|
||||
.error-message {
|
||||
color: #721c24;
|
||||
background-color: #f8d7da;
|
||||
padding: 10px;
|
||||
border-radius: 4px;
|
||||
margin-bottom: 15px;
|
||||
}
|
||||
|
||||
.loading-message {
|
||||
color: #0c5460;
|
||||
background-color: #d1ecf1;
|
||||
padding: 10px;
|
||||
border-radius: 4px;
|
||||
margin-bottom: 15px;
|
||||
}
|
||||
</style>
|
||||
@@ -1,161 +0,0 @@
|
||||
<template>
|
||||
<div class="access-token-manager">
|
||||
<h3>Управление токенами доступа</h3>
|
||||
<div class="token-actions">
|
||||
<button @click="mintNewToken">Выпустить новый токен</button>
|
||||
<button @click="loadTokens">Обновить список</button>
|
||||
</div>
|
||||
|
||||
<div v-if="loading">Загрузка...</div>
|
||||
|
||||
<table v-else-if="tokens.length > 0" class="tokens-table">
|
||||
<thead>
|
||||
<tr>
|
||||
<th>ID</th>
|
||||
<th>Владелец</th>
|
||||
<th>Роль</th>
|
||||
<th>Действия</th>
|
||||
</tr>
|
||||
</thead>
|
||||
<tbody>
|
||||
<tr v-for="token in tokens" :key="token.id">
|
||||
<td>{{ token.id }}</td>
|
||||
<td>{{ token.owner }}</td>
|
||||
<td>{{ getRoleName(token.role) }}</td>
|
||||
<td>
|
||||
<button @click="revokeToken(token.id)">Отозвать</button>
|
||||
</td>
|
||||
</tr>
|
||||
</tbody>
|
||||
</table>
|
||||
|
||||
<div v-else>Нет доступных токенов</div>
|
||||
</div>
|
||||
</template>
|
||||
|
||||
<script setup>
|
||||
import { ref, onMounted } from 'vue';
|
||||
import axios from 'axios';
|
||||
|
||||
const tokens = ref([]);
|
||||
const loading = ref(false);
|
||||
|
||||
const roles = {
|
||||
0: 'Администратор',
|
||||
1: 'Модератор',
|
||||
2: 'Пользователь',
|
||||
};
|
||||
|
||||
function getRoleName(roleId) {
|
||||
return roles[roleId] || 'Неизвестная роль';
|
||||
}
|
||||
|
||||
async function loadTokens() {
|
||||
try {
|
||||
console.log('Загрузка токенов...');
|
||||
loading.value = true;
|
||||
|
||||
// Добавляем withCredentials для передачи куки с сессией
|
||||
const response = await axios.get('/api/access/tokens', {
|
||||
withCredentials: true,
|
||||
});
|
||||
|
||||
console.log('Ответ API:', response.data);
|
||||
tokens.value = response.data;
|
||||
} catch (error) {
|
||||
console.error('Ошибка при загрузке токенов:', error);
|
||||
if (error.response) {
|
||||
console.error('Статус ошибки:', error.response.status);
|
||||
console.error('Данные ошибки:', error.response.data);
|
||||
} else if (error.request) {
|
||||
console.error('Запрос без ответа:', error.request);
|
||||
} else {
|
||||
console.error('Ошибка настройки запроса:', error.message);
|
||||
}
|
||||
} finally {
|
||||
loading.value = false;
|
||||
}
|
||||
}
|
||||
|
||||
async function mintNewToken() {
|
||||
try {
|
||||
const walletAddress = prompt('Введите адрес получателя:');
|
||||
if (!walletAddress) return;
|
||||
|
||||
const role = prompt('Введите роль (ADMIN, MODERATOR, USER):');
|
||||
if (!role) return;
|
||||
|
||||
const expiresInDays = prompt('Введите срок действия в днях:');
|
||||
if (!expiresInDays) return;
|
||||
|
||||
// Используем правильные имена параметров
|
||||
await axios.post(
|
||||
'/api/access/mint',
|
||||
{
|
||||
walletAddress,
|
||||
role,
|
||||
expiresInDays,
|
||||
},
|
||||
{
|
||||
withCredentials: true,
|
||||
}
|
||||
);
|
||||
|
||||
await loadTokens();
|
||||
} catch (error) {
|
||||
console.error('Ошибка при выпуске токена:', error);
|
||||
if (error.response) {
|
||||
console.error('Статус ошибки:', error.response.status);
|
||||
console.error('Данные ошибки:', error.response.data);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
async function revokeToken(tokenId) {
|
||||
try {
|
||||
if (!confirm(`Вы уверены, что хотите отозвать токен #${tokenId}?`)) return;
|
||||
|
||||
await axios.post('/api/access/revoke', { tokenId });
|
||||
await loadTokens();
|
||||
} catch (error) {
|
||||
console.error('Ошибка при отзыве токена:', error);
|
||||
}
|
||||
}
|
||||
|
||||
onMounted(async () => {
|
||||
await loadTokens();
|
||||
});
|
||||
</script>
|
||||
|
||||
<style scoped>
|
||||
.access-token-manager {
|
||||
margin: 20px 0;
|
||||
}
|
||||
|
||||
.token-actions {
|
||||
margin: 15px 0;
|
||||
}
|
||||
|
||||
.tokens-table {
|
||||
width: 100%;
|
||||
border-collapse: collapse;
|
||||
margin-top: 15px;
|
||||
}
|
||||
|
||||
.tokens-table th,
|
||||
.tokens-table td {
|
||||
border: 1px solid #ddd;
|
||||
padding: 8px;
|
||||
text-align: left;
|
||||
}
|
||||
|
||||
.tokens-table th {
|
||||
background-color: #f2f2f2;
|
||||
}
|
||||
|
||||
button {
|
||||
margin-right: 5px;
|
||||
padding: 5px 10px;
|
||||
cursor: pointer;
|
||||
}
|
||||
</style>
|
||||
@@ -1,33 +1,30 @@
|
||||
<template>
|
||||
<nav class="main-nav">
|
||||
<div class="nav-brand">
|
||||
<router-link to="/">DApp for Business</router-link>
|
||||
<nav class="navbar">
|
||||
<div class="navbar-brand">
|
||||
<router-link to="/" class="navbar-logo">DApp for Business</router-link>
|
||||
</div>
|
||||
|
||||
<div class="nav-links">
|
||||
<router-link to="/" class="nav-link">Главная</router-link>
|
||||
<router-link to="/chat" class="nav-link">Чат</router-link>
|
||||
<router-link v-if="authStore.isAdmin" to="/admin" class="nav-link admin-link">
|
||||
Админ-панель
|
||||
</router-link>
|
||||
</div>
|
||||
<div class="navbar-menu">
|
||||
<div class="navbar-start">
|
||||
<router-link to="/" class="navbar-item">Главная</router-link>
|
||||
<router-link v-if="isAuthenticated" to="/chat" class="navbar-item">Чат</router-link>
|
||||
</div>
|
||||
|
||||
<div class="nav-auth">
|
||||
<template v-if="authStore.isAuthenticated">
|
||||
<div class="user-info">
|
||||
<span class="user-address">{{ formatAddress(authStore.address) }}</span>
|
||||
<span v-if="authStore.isAdmin" class="admin-badge">Админ</span>
|
||||
<div class="navbar-end">
|
||||
<div v-if="isAuthenticated" class="navbar-item user-info">
|
||||
<span v-if="userAddress" class="user-address">{{ formatAddress(userAddress) }}</span>
|
||||
<button @click="logout" class="logout-btn">Выйти</button>
|
||||
</div>
|
||||
<button @click="logout" class="btn-logout">Выйти</button>
|
||||
</template>
|
||||
<template v-else>
|
||||
<wallet-connection />
|
||||
</template>
|
||||
<div v-else class="navbar-item">
|
||||
<WalletConnection />
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
</nav>
|
||||
</template>
|
||||
|
||||
<script setup>
|
||||
import { computed } from 'vue';
|
||||
import { useRouter } from 'vue-router';
|
||||
import { useAuthStore } from '../stores/auth';
|
||||
import WalletConnection from './WalletConnection.vue';
|
||||
@@ -35,10 +32,13 @@ import WalletConnection from './WalletConnection.vue';
|
||||
const router = useRouter();
|
||||
const authStore = useAuthStore();
|
||||
|
||||
const isAuthenticated = computed(() => authStore.isAuthenticated);
|
||||
const userAddress = computed(() => authStore.user?.address);
|
||||
|
||||
// Форматирование адреса кошелька
|
||||
function formatAddress(address) {
|
||||
if (!address) return '';
|
||||
return address.substring(0, 6) + '...' + address.substring(address.length - 4);
|
||||
return `${address.substring(0, 6)}...${address.substring(address.length - 4)}`;
|
||||
}
|
||||
|
||||
// Выход из системы
|
||||
@@ -49,85 +49,108 @@ async function logout() {
|
||||
</script>
|
||||
|
||||
<style scoped>
|
||||
.main-nav {
|
||||
.navbar {
|
||||
display: flex;
|
||||
justify-content: space-between;
|
||||
align-items: center;
|
||||
padding: 1rem;
|
||||
padding: 0.5rem 1rem;
|
||||
background-color: #fff;
|
||||
box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);
|
||||
box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
|
||||
}
|
||||
|
||||
.nav-brand a {
|
||||
.navbar-brand {
|
||||
font-weight: bold;
|
||||
font-size: 1.25rem;
|
||||
font-weight: 700;
|
||||
color: #3498db;
|
||||
}
|
||||
|
||||
.navbar-logo {
|
||||
color: #1976d2;
|
||||
text-decoration: none;
|
||||
}
|
||||
|
||||
.nav-links {
|
||||
.navbar-menu {
|
||||
display: flex;
|
||||
gap: 1rem;
|
||||
justify-content: space-between;
|
||||
flex: 1;
|
||||
margin-left: 1rem;
|
||||
}
|
||||
|
||||
.nav-link {
|
||||
color: #333;
|
||||
text-decoration: none;
|
||||
padding: 0.5rem;
|
||||
border-radius: 4px;
|
||||
}
|
||||
|
||||
.nav-link:hover {
|
||||
background-color: #f0f0f0;
|
||||
}
|
||||
|
||||
.nav-link.router-link-active {
|
||||
color: #3498db;
|
||||
font-weight: 500;
|
||||
}
|
||||
|
||||
.admin-link {
|
||||
color: #e74c3c;
|
||||
}
|
||||
|
||||
.nav-auth {
|
||||
.navbar-start, .navbar-end {
|
||||
display: flex;
|
||||
align-items: center;
|
||||
gap: 1rem;
|
||||
}
|
||||
|
||||
.navbar-item {
|
||||
padding: 0.5rem 0.75rem;
|
||||
color: #333;
|
||||
text-decoration: none;
|
||||
margin: 0 0.25rem;
|
||||
}
|
||||
|
||||
.navbar-item:hover {
|
||||
color: #1976d2;
|
||||
}
|
||||
|
||||
.user-info {
|
||||
display: flex;
|
||||
align-items: center;
|
||||
gap: 0.5rem;
|
||||
}
|
||||
|
||||
.user-address {
|
||||
font-family: monospace;
|
||||
background-color: #f0f0f0;
|
||||
background-color: #f5f5f5;
|
||||
padding: 0.25rem 0.5rem;
|
||||
border-radius: 4px;
|
||||
margin-right: 0.5rem;
|
||||
}
|
||||
|
||||
.admin-badge {
|
||||
background-color: #e74c3c;
|
||||
.logout-btn {
|
||||
background-color: #f44336;
|
||||
color: white;
|
||||
padding: 0.1rem 0.3rem;
|
||||
border-radius: 4px;
|
||||
font-size: 0.8rem;
|
||||
font-weight: 500;
|
||||
}
|
||||
|
||||
.btn-logout {
|
||||
padding: 0.5rem 1rem;
|
||||
border-radius: 4px;
|
||||
background-color: #f0f0f0;
|
||||
color: #333;
|
||||
border: none;
|
||||
padding: 0.25rem 0.5rem;
|
||||
border-radius: 4px;
|
||||
cursor: pointer;
|
||||
font-size: 0.875rem;
|
||||
}
|
||||
|
||||
.btn-logout:hover {
|
||||
background-color: #e0e0e0;
|
||||
.logout-btn:hover {
|
||||
background-color: #d32f2f;
|
||||
}
|
||||
|
||||
@media (max-width: 768px) {
|
||||
.navbar {
|
||||
flex-direction: column;
|
||||
padding: 0.5rem;
|
||||
}
|
||||
|
||||
.navbar-menu {
|
||||
flex-direction: column;
|
||||
width: 100%;
|
||||
margin-left: 0;
|
||||
margin-top: 0.5rem;
|
||||
}
|
||||
|
||||
.navbar-start, .navbar-end {
|
||||
flex-direction: column;
|
||||
width: 100%;
|
||||
}
|
||||
|
||||
.navbar-item {
|
||||
padding: 0.5rem;
|
||||
margin: 0.25rem 0;
|
||||
width: 100%;
|
||||
text-align: center;
|
||||
}
|
||||
|
||||
.user-info {
|
||||
flex-direction: column;
|
||||
align-items: center;
|
||||
}
|
||||
|
||||
.user-address {
|
||||
margin-right: 0;
|
||||
margin-bottom: 0.5rem;
|
||||
}
|
||||
}
|
||||
</style>
|
||||
|
||||
@@ -4,47 +4,62 @@
|
||||
{{ error }}
|
||||
</div>
|
||||
|
||||
<button @click="connect" class="connect-button" :disabled="loading">
|
||||
<button @click="connectWallet" class="connect-button" :disabled="loading">
|
||||
<div v-if="loading" class="spinner"></div>
|
||||
{{ loading ? 'Подключение...' : 'Подключить кошелек' }}
|
||||
</button>
|
||||
</div>
|
||||
</template>
|
||||
|
||||
<script setup>
|
||||
<script>
|
||||
import { ref } from 'vue';
|
||||
import { connectWallet } from '../utils/wallet';
|
||||
import { useAuthStore } from '../stores/auth';
|
||||
import { useRouter } from 'vue-router';
|
||||
|
||||
const authStore = useAuthStore();
|
||||
const router = useRouter();
|
||||
const loading = ref(false);
|
||||
const error = ref('');
|
||||
export default {
|
||||
setup() {
|
||||
const authStore = useAuthStore();
|
||||
const router = useRouter();
|
||||
const loading = ref(false);
|
||||
const error = ref('');
|
||||
|
||||
async function connect() {
|
||||
console.log('Нажата кнопка "Подключить кошелек"');
|
||||
|
||||
if (loading.value) return;
|
||||
|
||||
loading.value = true;
|
||||
error.value = '';
|
||||
|
||||
try {
|
||||
const authResult = await connectWallet();
|
||||
console.log('Результат подключения:', authResult);
|
||||
|
||||
if (authResult && authResult.authenticated) {
|
||||
authStore.updateAuthState(authResult);
|
||||
router.push({ name: 'home' });
|
||||
} else {
|
||||
error.value = 'Не удалось подключить кошелек';
|
||||
return {
|
||||
authStore,
|
||||
router,
|
||||
loading,
|
||||
error
|
||||
}
|
||||
},
|
||||
methods: {
|
||||
async connectWallet() {
|
||||
console.log('Нажата кнопка "Подключить кошелек"');
|
||||
|
||||
if (this.loading) return;
|
||||
|
||||
this.loading = true;
|
||||
this.error = '';
|
||||
|
||||
try {
|
||||
const authResult = await connectWallet();
|
||||
console.log('Результат подключения:', authResult);
|
||||
|
||||
if (authResult && authResult.authenticated) {
|
||||
this.authStore.isAuthenticated = authResult.authenticated;
|
||||
this.authStore.user = { address: authResult.address };
|
||||
this.authStore.isAdmin = authResult.isAdmin;
|
||||
this.authStore.authType = authResult.authType;
|
||||
this.router.push({ name: 'home' });
|
||||
} else {
|
||||
this.error = 'Не удалось подключить кошелек';
|
||||
}
|
||||
} catch (error) {
|
||||
console.error('Ошибка при подключении кошелька:', error);
|
||||
this.error = error.message || 'Ошибка при подключении кошелька';
|
||||
} finally {
|
||||
this.loading = false;
|
||||
}
|
||||
}
|
||||
} catch (error) {
|
||||
console.error('Ошибка при подключении кошелька:', error);
|
||||
error.value = error.message || 'Ошибка при подключении кошелька';
|
||||
} finally {
|
||||
loading.value = false;
|
||||
}
|
||||
}
|
||||
</script>
|
||||
|
||||
@@ -0,0 +1,195 @@
|
||||
<template>
|
||||
<div class="email-connect">
|
||||
<p>Подключите свой email для быстрой авторизации.</p>
|
||||
|
||||
<div class="email-form">
|
||||
<input
|
||||
type="email"
|
||||
v-model="email"
|
||||
placeholder="Введите ваш email"
|
||||
:disabled="loading || verificationSent"
|
||||
/>
|
||||
<button
|
||||
@click="sendVerification"
|
||||
class="connect-button"
|
||||
:disabled="!isValidEmail || loading || verificationSent"
|
||||
>
|
||||
<span class="email-icon">✉️</span> {{ verificationSent ? 'Код отправлен' : 'Отправить код' }}
|
||||
</button>
|
||||
</div>
|
||||
|
||||
<div v-if="verificationSent" class="verification-form">
|
||||
<input
|
||||
type="text"
|
||||
v-model="verificationCode"
|
||||
placeholder="Введите код подтверждения"
|
||||
:disabled="loading"
|
||||
/>
|
||||
<button
|
||||
@click="verifyEmail"
|
||||
class="verify-button"
|
||||
:disabled="!verificationCode || loading"
|
||||
>
|
||||
Подтвердить
|
||||
</button>
|
||||
</div>
|
||||
|
||||
<div v-if="loading" class="loading">Загрузка...</div>
|
||||
<div v-if="error" class="error">{{ error }}</div>
|
||||
<div v-if="success" class="success">{{ success }}</div>
|
||||
</div>
|
||||
</template>
|
||||
|
||||
<script setup>
|
||||
import { ref, computed } from 'vue';
|
||||
import axios from 'axios';
|
||||
|
||||
const email = ref('');
|
||||
const verificationCode = ref('');
|
||||
const loading = ref(false);
|
||||
const error = ref('');
|
||||
const success = ref('');
|
||||
const verificationSent = ref(false);
|
||||
|
||||
const isValidEmail = computed(() => {
|
||||
const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
|
||||
return emailRegex.test(email.value);
|
||||
});
|
||||
|
||||
async function sendVerification() {
|
||||
if (!isValidEmail.value) return;
|
||||
|
||||
try {
|
||||
loading.value = true;
|
||||
error.value = '';
|
||||
success.value = '';
|
||||
|
||||
// Запрос на отправку кода подтверждения
|
||||
const response = await axios.post('/api/auth/email', {
|
||||
email: email.value
|
||||
}, {
|
||||
withCredentials: true
|
||||
});
|
||||
|
||||
if (response.data.error) {
|
||||
error.value = `Ошибка: ${response.data.error}`;
|
||||
return;
|
||||
}
|
||||
|
||||
verificationSent.value = true;
|
||||
success.value = `Код подтверждения отправлен на ${email.value}`;
|
||||
} catch (err) {
|
||||
console.error('Error sending verification code:', err);
|
||||
error.value = 'Ошибка при отправке кода подтверждения';
|
||||
} finally {
|
||||
loading.value = false;
|
||||
}
|
||||
}
|
||||
|
||||
async function verifyEmail() {
|
||||
if (!verificationCode.value) return;
|
||||
|
||||
try {
|
||||
loading.value = true;
|
||||
error.value = '';
|
||||
success.value = '';
|
||||
|
||||
// Запрос на проверку кода
|
||||
const response = await axios.post('/api/auth/email/verify', {
|
||||
email: email.value,
|
||||
code: verificationCode.value
|
||||
}, {
|
||||
withCredentials: true
|
||||
});
|
||||
|
||||
if (response.data.error) {
|
||||
error.value = `Ошибка: ${response.data.error}`;
|
||||
return;
|
||||
}
|
||||
|
||||
success.value = 'Email успешно подтвержден';
|
||||
|
||||
// Сбрасываем форму
|
||||
setTimeout(() => {
|
||||
email.value = '';
|
||||
verificationCode.value = '';
|
||||
verificationSent.value = false;
|
||||
success.value = '';
|
||||
}, 3000);
|
||||
} catch (err) {
|
||||
console.error('Error verifying email:', err);
|
||||
error.value = 'Ошибка при проверке кода подтверждения';
|
||||
} finally {
|
||||
loading.value = false;
|
||||
}
|
||||
}
|
||||
</script>
|
||||
|
||||
<style scoped>
|
||||
.email-connect {
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
gap: 15px;
|
||||
}
|
||||
|
||||
.email-form, .verification-form {
|
||||
display: flex;
|
||||
gap: 10px;
|
||||
}
|
||||
|
||||
input {
|
||||
flex: 1;
|
||||
padding: 10px;
|
||||
border: 1px solid #ddd;
|
||||
border-radius: 4px;
|
||||
font-size: 16px;
|
||||
}
|
||||
|
||||
.connect-button, .verify-button {
|
||||
display: flex;
|
||||
align-items: center;
|
||||
justify-content: center;
|
||||
padding: 10px 15px;
|
||||
background-color: #4caf50;
|
||||
color: white;
|
||||
border: none;
|
||||
border-radius: 4px;
|
||||
cursor: pointer;
|
||||
font-size: 16px;
|
||||
transition: background-color 0.2s;
|
||||
white-space: nowrap;
|
||||
}
|
||||
|
||||
.connect-button:hover, .verify-button:hover {
|
||||
background-color: #45a049;
|
||||
}
|
||||
|
||||
.connect-button:disabled, .verify-button:disabled {
|
||||
background-color: #cccccc;
|
||||
cursor: not-allowed;
|
||||
}
|
||||
|
||||
.email-icon {
|
||||
margin-right: 10px;
|
||||
font-size: 18px;
|
||||
}
|
||||
|
||||
.loading, .error, .success {
|
||||
padding: 10px;
|
||||
border-radius: 4px;
|
||||
}
|
||||
|
||||
.loading {
|
||||
background-color: #f8f9fa;
|
||||
}
|
||||
|
||||
.error {
|
||||
background-color: #f8d7da;
|
||||
color: #721c24;
|
||||
}
|
||||
|
||||
.success {
|
||||
background-color: #d4edda;
|
||||
color: #155724;
|
||||
}
|
||||
</style>
|
||||
|
||||
@@ -0,0 +1,48 @@
|
||||
<script setup>
|
||||
import { ref, onMounted } from 'vue';
|
||||
import { useAuthStore } from '../../stores/auth';
|
||||
|
||||
const authStore = useAuthStore();
|
||||
const identities = ref({});
|
||||
const newIdentity = ref({ type: 'email', value: '' });
|
||||
const loading = ref(false);
|
||||
const error = ref(null);
|
||||
|
||||
onMounted(async () => {
|
||||
try {
|
||||
loading.value = true;
|
||||
const response = await fetch('/api/access/tokens', {
|
||||
credentials: 'include'
|
||||
});
|
||||
const data = await response.json();
|
||||
identities.value = data.identities || {};
|
||||
} catch (err) {
|
||||
error.value = 'Ошибка при загрузке идентификаторов';
|
||||
console.error(err);
|
||||
} finally {
|
||||
loading.value = false;
|
||||
}
|
||||
});
|
||||
|
||||
async function addIdentity() {
|
||||
try {
|
||||
loading.value = true;
|
||||
error.value = null;
|
||||
|
||||
const success = await authStore.linkIdentity(
|
||||
newIdentity.value.type,
|
||||
newIdentity.value.value
|
||||
);
|
||||
|
||||
if (success) {
|
||||
identities.value = authStore.identities;
|
||||
newIdentity.value.value = '';
|
||||
}
|
||||
} catch (err) {
|
||||
error.value = 'Ошибка при добавлении идентификатора';
|
||||
console.error(err);
|
||||
} finally {
|
||||
loading.value = false;
|
||||
}
|
||||
}
|
||||
</script>
|
||||
|
||||
@@ -0,0 +1,102 @@
|
||||
<template>
|
||||
<div class="telegram-connect">
|
||||
<p>Подключите свой аккаунт Telegram для быстрой авторизации.</p>
|
||||
<button @click="connectTelegram" class="connect-button">
|
||||
<span class="telegram-icon">📱</span> Подключить Telegram
|
||||
</button>
|
||||
|
||||
<div v-if="loading" class="loading">Загрузка...</div>
|
||||
<div v-if="error" class="error">{{ error }}</div>
|
||||
<div v-if="success" class="success">{{ success }}</div>
|
||||
</div>
|
||||
</template>
|
||||
|
||||
<script setup>
|
||||
import { ref } from 'vue';
|
||||
import axios from 'axios';
|
||||
|
||||
const loading = ref(false);
|
||||
const error = ref('');
|
||||
const success = ref('');
|
||||
|
||||
async function connectTelegram() {
|
||||
try {
|
||||
loading.value = true;
|
||||
error.value = '';
|
||||
success.value = '';
|
||||
|
||||
// Запрос на получение ссылки для авторизации через Telegram
|
||||
const response = await axios.get('/api/auth/telegram', {
|
||||
withCredentials: true
|
||||
});
|
||||
|
||||
if (response.data.error) {
|
||||
error.value = `Ошибка при подключении Telegram: ${response.data.error}`;
|
||||
return;
|
||||
}
|
||||
|
||||
if (response.data.authUrl) {
|
||||
success.value = 'Перейдите по ссылке для авторизации через Telegram';
|
||||
window.open(response.data.authUrl, '_blank');
|
||||
} else {
|
||||
error.value = 'Не удалось получить ссылку для авторизации';
|
||||
}
|
||||
} catch (err) {
|
||||
console.error('Error connecting Telegram:', err);
|
||||
error.value = 'Ошибка при подключении Telegram';
|
||||
} finally {
|
||||
loading.value = false;
|
||||
}
|
||||
}
|
||||
</script>
|
||||
|
||||
<style scoped>
|
||||
.telegram-connect {
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
gap: 15px;
|
||||
}
|
||||
|
||||
.connect-button {
|
||||
display: flex;
|
||||
align-items: center;
|
||||
justify-content: center;
|
||||
padding: 10px 15px;
|
||||
background-color: #0088cc;
|
||||
color: white;
|
||||
border: none;
|
||||
border-radius: 4px;
|
||||
cursor: pointer;
|
||||
font-size: 16px;
|
||||
transition: background-color 0.2s;
|
||||
}
|
||||
|
||||
.connect-button:hover {
|
||||
background-color: #0077b5;
|
||||
}
|
||||
|
||||
.telegram-icon {
|
||||
margin-right: 10px;
|
||||
font-size: 18px;
|
||||
}
|
||||
|
||||
.loading, .error, .success {
|
||||
padding: 10px;
|
||||
border-radius: 4px;
|
||||
}
|
||||
|
||||
.loading {
|
||||
background-color: #f8f9fa;
|
||||
}
|
||||
|
||||
.error {
|
||||
background-color: #f8d7da;
|
||||
color: #721c24;
|
||||
}
|
||||
|
||||
.success {
|
||||
background-color: #d4edda;
|
||||
color: #155724;
|
||||
}
|
||||
</style>
|
||||
|
||||
|
||||
@@ -1,17 +1,50 @@
|
||||
import { ref } from 'vue';
|
||||
import { ethers } from 'ethers';
|
||||
|
||||
export function useEthereum() {
|
||||
const address = ref('');
|
||||
const isConnected = ref(true);
|
||||
const isConnected = ref(false);
|
||||
const provider = ref(null);
|
||||
const signer = ref(null);
|
||||
|
||||
async function connect() {
|
||||
console.log('Имитация подключения к кошельку');
|
||||
return { success: true };
|
||||
if (window.ethereum) {
|
||||
try {
|
||||
// Запрашиваем доступ к кошельку
|
||||
await window.ethereum.request({ method: 'eth_requestAccounts' });
|
||||
// Используем синтаксис ethers.js v6
|
||||
provider.value = new ethers.BrowserProvider(window.ethereum);
|
||||
signer.value = await provider.value.getSigner();
|
||||
address.value = await signer.value.getAddress();
|
||||
isConnected.value = true;
|
||||
|
||||
console.log('Подключение успешно:', address.value);
|
||||
return { success: true, address: address.value };
|
||||
} catch (error) {
|
||||
console.error('Ошибка подключения к кошельку:', error);
|
||||
return { success: false, error: error.message };
|
||||
}
|
||||
} else {
|
||||
console.error('Ethereum wallet not found. Please install MetaMask.');
|
||||
return { success: false, error: 'Ethereum wallet not found. Please install MetaMask.' };
|
||||
}
|
||||
}
|
||||
|
||||
async function getContract() {
|
||||
console.log('Имитация получения контракта');
|
||||
return {};
|
||||
async function getContract(contractAddress, contractABI) {
|
||||
if (!signer.value) {
|
||||
console.error('Подключите кошелек перед получением контракта.');
|
||||
return null;
|
||||
}
|
||||
|
||||
try {
|
||||
// Используем синтаксис ethers.js v6
|
||||
const contract = new ethers.Contract(contractAddress, contractABI, signer.value);
|
||||
console.log('Контракт получен:', contract);
|
||||
return contract;
|
||||
} catch (error) {
|
||||
console.error('Ошибка получения контракта:', error);
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
return {
|
||||
|
||||
@@ -8,7 +8,7 @@ import router from './router';
|
||||
import axios from 'axios';
|
||||
|
||||
// Настройка axios
|
||||
axios.defaults.baseURL = 'http://localhost:8000';
|
||||
axios.defaults.baseURL = ''; // Пустой baseURL, так как мы используем прокси
|
||||
axios.defaults.withCredentials = true; // Важно для работы с сессиями
|
||||
|
||||
// Создаем и монтируем приложение Vue
|
||||
|
||||
@@ -1,12 +1,7 @@
|
||||
import { createRouter, createWebHistory } from 'vue-router';
|
||||
import { useAuthStore } from '../stores/auth';
|
||||
// Импортируем компоненты напрямую, если они существуют
|
||||
import HomeView from '../views/HomeView.vue';
|
||||
import DashboardView from '../views/DashboardView.vue';
|
||||
import ProfileView from '../views/ProfileView.vue';
|
||||
import AdminView from '../views/AdminView.vue'; // Новый компонент для администраторов
|
||||
import AccessTestView from '../views/AccessTestView.vue';
|
||||
import ConversationsView from '../views/ConversationsView.vue';
|
||||
import ChatView from '../views/ChatView.vue';
|
||||
|
||||
const routes = [
|
||||
{
|
||||
@@ -15,41 +10,12 @@ const routes = [
|
||||
component: HomeView,
|
||||
meta: { requiresAuth: false },
|
||||
},
|
||||
{
|
||||
path: '/dashboard',
|
||||
name: 'Dashboard',
|
||||
component: () => import('../views/DashboardView.vue'),
|
||||
meta: { requiresAuth: true, requiresAdmin: true },
|
||||
},
|
||||
// Перенаправляем с /chat на главную страницу
|
||||
{
|
||||
path: '/chat',
|
||||
redirect: { name: 'home' },
|
||||
},
|
||||
{
|
||||
path: '/profile',
|
||||
name: 'profile',
|
||||
component: ProfileView,
|
||||
meta: { requiresAuth: true },
|
||||
},
|
||||
{
|
||||
path: '/admin',
|
||||
name: 'Admin',
|
||||
component: () => import('../views/AdminView.vue'),
|
||||
meta: { requiresAdmin: true },
|
||||
},
|
||||
{
|
||||
path: '/access-test',
|
||||
name: 'access-test',
|
||||
component: AccessTestView,
|
||||
meta: { requiresAuth: true, requiresAdmin: true },
|
||||
},
|
||||
{
|
||||
path: '/conversations',
|
||||
name: 'Conversations',
|
||||
component: ConversationsView,
|
||||
meta: { requiresAuth: true },
|
||||
},
|
||||
name: 'chat',
|
||||
component: ChatView,
|
||||
meta: { requiresAuth: true }
|
||||
}
|
||||
];
|
||||
|
||||
const router = createRouter({
|
||||
@@ -64,20 +30,18 @@ const router = createRouter({
|
||||
router.beforeEach(async (to, from, next) => {
|
||||
const authStore = useAuthStore();
|
||||
|
||||
// Проверяем аутентификацию только если еще не проверяли
|
||||
if (!authStore.checkPerformed) {
|
||||
// Проверяем аутентификацию, если она еще не проверена
|
||||
if (!authStore.isAuthenticated) {
|
||||
try {
|
||||
await authStore.checkAuth();
|
||||
} catch (error) {
|
||||
console.error('Ошибка при проверке аутентификации:', error);
|
||||
console.error('Error checking auth:', error);
|
||||
}
|
||||
}
|
||||
|
||||
// Проверка прав доступа
|
||||
if (to.meta.requiresAuth && !authStore.isAuthenticated) {
|
||||
next({ name: 'Home' });
|
||||
} else if (to.meta.requiresAdmin && !authStore.isAdmin) {
|
||||
next({ name: 'Home' });
|
||||
next({ name: 'home' });
|
||||
} else {
|
||||
next();
|
||||
}
|
||||
|
||||
@@ -1,85 +1,153 @@
|
||||
import { defineStore } from 'pinia';
|
||||
import { ref } from 'vue';
|
||||
import axios from 'axios';
|
||||
import axios from '../api/axios';
|
||||
|
||||
export const useAuthStore = defineStore('auth', () => {
|
||||
const isAuthenticated = ref(false);
|
||||
const isAdmin = ref(false);
|
||||
const address = ref(null);
|
||||
const authType = ref(null);
|
||||
const loading = ref(false);
|
||||
const checkPerformed = ref(false);
|
||||
export const useAuthStore = defineStore('auth', {
|
||||
state: () => ({
|
||||
user: null,
|
||||
isAuthenticated: false,
|
||||
isAdmin: false,
|
||||
authType: null,
|
||||
identities: {},
|
||||
loading: false,
|
||||
error: null
|
||||
}),
|
||||
|
||||
// Проверка аутентификации
|
||||
async function checkAuth() {
|
||||
loading.value = true;
|
||||
actions: {
|
||||
async connectWallet(address, signature, message) {
|
||||
this.loading = true;
|
||||
this.error = null;
|
||||
|
||||
try {
|
||||
console.log('Проверка аутентификации...');
|
||||
const apiUrl = import.meta.env.VITE_API_URL || 'http://localhost:8000';
|
||||
console.log('API URL:', apiUrl);
|
||||
try {
|
||||
const response = await axios.post('/api/auth/verify', {
|
||||
address,
|
||||
signature,
|
||||
message
|
||||
});
|
||||
|
||||
const response = await axios.get(`${apiUrl}/api/auth/check`, {
|
||||
withCredentials: true,
|
||||
});
|
||||
this.user = {
|
||||
id: response.data.userId,
|
||||
address
|
||||
};
|
||||
this.isAuthenticated = response.data.authenticated;
|
||||
this.isAdmin = response.data.isAdmin;
|
||||
this.authType = response.data.authType;
|
||||
this.identities = response.data.identities || {};
|
||||
|
||||
console.log('Статус аутентификации:', response.data.authenticated);
|
||||
console.log('Статус администратора:', response.data.isAdmin);
|
||||
return true;
|
||||
} catch (error) {
|
||||
this.error = error.response?.data?.error || 'Ошибка подключения кошелька';
|
||||
return false;
|
||||
} finally {
|
||||
this.loading = false;
|
||||
}
|
||||
},
|
||||
|
||||
isAuthenticated.value = response.data.authenticated;
|
||||
isAdmin.value = response.data.isAdmin;
|
||||
address.value = response.data.address;
|
||||
authType.value = response.data.authType;
|
||||
} catch (error) {
|
||||
console.error('Ошибка при проверке аутентификации:', error);
|
||||
throw error;
|
||||
} finally {
|
||||
loading.value = false;
|
||||
checkPerformed.value = true;
|
||||
}
|
||||
}
|
||||
async connectTelegram(telegramData) {
|
||||
this.loading = true;
|
||||
this.error = null;
|
||||
|
||||
// Обновление состояния аутентификации
|
||||
function updateAuthState(authData) {
|
||||
console.log('Обновление состояния аутентификации:', authData);
|
||||
try {
|
||||
const response = await axios.post('/api/auth/telegram', telegramData);
|
||||
|
||||
isAuthenticated.value = authData.authenticated || false;
|
||||
isAdmin.value = authData.isAdmin || false;
|
||||
address.value = authData.address || null;
|
||||
authType.value = authData.authType || null;
|
||||
checkPerformed.value = true;
|
||||
}
|
||||
this.user = {
|
||||
id: response.data.userId,
|
||||
telegramId: telegramData.telegramId
|
||||
};
|
||||
this.isAuthenticated = response.data.authenticated;
|
||||
this.isAdmin = response.data.isAdmin;
|
||||
this.authType = response.data.authType;
|
||||
this.identities = response.data.identities || {};
|
||||
|
||||
// Выход из системы
|
||||
async function logout() {
|
||||
try {
|
||||
await axios.post(
|
||||
`${import.meta.env.VITE_API_URL}/api/auth/logout`,
|
||||
{},
|
||||
{
|
||||
withCredentials: true,
|
||||
return true;
|
||||
} catch (error) {
|
||||
this.error = error.response?.data?.error || 'Ошибка подключения Telegram';
|
||||
return false;
|
||||
} finally {
|
||||
this.loading = false;
|
||||
}
|
||||
},
|
||||
|
||||
async connectEmail(email, verificationCode) {
|
||||
this.loading = true;
|
||||
this.error = null;
|
||||
|
||||
try {
|
||||
const response = await axios.post('/api/auth/email', {
|
||||
email, verificationCode
|
||||
});
|
||||
|
||||
this.user = {
|
||||
id: response.data.userId,
|
||||
email
|
||||
};
|
||||
this.isAuthenticated = response.data.authenticated;
|
||||
this.isAdmin = response.data.isAdmin;
|
||||
this.authType = response.data.authType;
|
||||
this.identities = response.data.identities || {};
|
||||
|
||||
return true;
|
||||
} catch (error) {
|
||||
this.error = error.response?.data?.error || 'Ошибка подключения Email';
|
||||
return false;
|
||||
} finally {
|
||||
this.loading = false;
|
||||
}
|
||||
},
|
||||
|
||||
async linkIdentity(identityType, identityValue) {
|
||||
this.loading = true;
|
||||
this.error = null;
|
||||
|
||||
try {
|
||||
const response = await axios.post('/api/auth/link-identity', {
|
||||
identityType, identityValue
|
||||
});
|
||||
|
||||
this.identities = response.data.identities;
|
||||
this.isAdmin = response.data.isAdmin;
|
||||
|
||||
return true;
|
||||
} catch (error) {
|
||||
this.error = error.response?.data?.error || 'Ошибка связывания аккаунта';
|
||||
return false;
|
||||
} finally {
|
||||
this.loading = false;
|
||||
}
|
||||
},
|
||||
|
||||
async logout() {
|
||||
try {
|
||||
await axios.post('/api/auth/logout');
|
||||
} catch (error) {
|
||||
console.error('Ошибка при выходе:', error);
|
||||
}
|
||||
|
||||
this.user = null;
|
||||
this.isAuthenticated = false;
|
||||
this.isAdmin = false;
|
||||
this.authType = null;
|
||||
this.identities = {};
|
||||
},
|
||||
|
||||
async checkAuth() {
|
||||
try {
|
||||
const response = await axios.get('/api/auth/check');
|
||||
|
||||
if (response.data.authenticated) {
|
||||
this.user = {
|
||||
id: response.data.userId
|
||||
};
|
||||
this.isAuthenticated = true;
|
||||
this.isAdmin = response.data.isAdmin;
|
||||
this.authType = response.data.authType;
|
||||
this.identities = response.data.identities || {};
|
||||
} else {
|
||||
this.logout();
|
||||
}
|
||||
);
|
||||
} catch (error) {
|
||||
console.error('Ошибка при выходе из системы:', error);
|
||||
} finally {
|
||||
// Сбрасываем состояние независимо от результата запроса
|
||||
isAuthenticated.value = false;
|
||||
isAdmin.value = false;
|
||||
address.value = null;
|
||||
authType.value = null;
|
||||
} catch (error) {
|
||||
console.error('Ошибка при проверке аутентификации:', error);
|
||||
this.logout();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return {
|
||||
isAuthenticated,
|
||||
isAdmin,
|
||||
address,
|
||||
authType,
|
||||
loading,
|
||||
checkPerformed,
|
||||
checkAuth,
|
||||
updateAuthState,
|
||||
logout,
|
||||
};
|
||||
});
|
||||
|
||||
@@ -1,105 +1,50 @@
|
||||
import axios from 'axios';
|
||||
|
||||
async function connectWallet() {
|
||||
console.log('Начинаем подключение кошелька...');
|
||||
|
||||
try {
|
||||
// Проверяем доступность MetaMask
|
||||
if (typeof window.ethereum === 'undefined') {
|
||||
throw new Error('MetaMask не установлен');
|
||||
}
|
||||
|
||||
console.log('MetaMask доступен, запрашиваем аккаунты...');
|
||||
|
||||
// Запрашиваем доступ к аккаунтам
|
||||
const accounts = await window.ethereum.request({ method: 'eth_requestAccounts' });
|
||||
const address = accounts[0];
|
||||
|
||||
if (!address) {
|
||||
throw new Error('Не удалось получить адрес кошелька');
|
||||
}
|
||||
|
||||
console.log('Получен адрес кошелька:', address);
|
||||
|
||||
const apiUrl = import.meta.env.VITE_API_URL || 'http://localhost:8000';
|
||||
console.log('API URL для nonce:', apiUrl);
|
||||
|
||||
// Получаем nonce для подписи
|
||||
let nonce;
|
||||
|
||||
// Пробуем прямой запрос к серверу
|
||||
if (typeof window.ethereum !== 'undefined') {
|
||||
try {
|
||||
const directNonceResponse = await axios.get(
|
||||
`${apiUrl}/api/auth/nonce?address=${address}`,
|
||||
{
|
||||
withCredentials: true,
|
||||
}
|
||||
);
|
||||
const accounts = await window.ethereum.request({ method: 'eth_requestAccounts' });
|
||||
const address = accounts[0];
|
||||
|
||||
console.log('Прямой ответ сервера:', directNonceResponse.data);
|
||||
console.log('Cookies after direct request:', document.cookie);
|
||||
// Получаем nonce
|
||||
const nonceResponse = await axios.get(`/api/auth/nonce?address=${address}`, {
|
||||
withCredentials: true // Важно для сохранения сессии
|
||||
});
|
||||
const nonce = nonceResponse.data.nonce;
|
||||
|
||||
nonce = directNonceResponse.data.nonce;
|
||||
} catch (error) {
|
||||
console.error('Ошибка при получении nonce:', error);
|
||||
throw new Error('Не удалось получить nonce для подписи');
|
||||
}
|
||||
|
||||
console.log('Получен nonce:', nonce);
|
||||
|
||||
// Создаем сообщение для подписи
|
||||
const message = `Подтвердите вход в DApp for Business с nonce: ${nonce}`;
|
||||
|
||||
try {
|
||||
// Запрашиваем подпись используя ethereum.request
|
||||
// Подписываем сообщение
|
||||
const message = `Sign this message to authenticate with our app: ${nonce}`;
|
||||
const signature = await window.ethereum.request({
|
||||
method: 'personal_sign',
|
||||
params: [message, address],
|
||||
params: [message, address]
|
||||
});
|
||||
|
||||
console.log('Получена подпись:', signature);
|
||||
|
||||
// Отправляем подпись на сервер
|
||||
const verifyResponse = await axios.post(
|
||||
`${apiUrl}/api/auth/verify`,
|
||||
{
|
||||
address,
|
||||
signature,
|
||||
message,
|
||||
nonce,
|
||||
},
|
||||
{
|
||||
headers: {
|
||||
'X-Auth-Nonce': nonce,
|
||||
},
|
||||
withCredentials: true,
|
||||
}
|
||||
);
|
||||
|
||||
console.log('Ответ сервера:', verifyResponse.data);
|
||||
|
||||
// Сохраняем адрес в localStorage для восстановления сессии
|
||||
localStorage.setItem('walletAddress', address);
|
||||
|
||||
// Возвращаем данные аутентификации
|
||||
return {
|
||||
// Отправляем запрос на проверку
|
||||
const verifyResponse = await axios.post('/api/auth/verify', {
|
||||
address,
|
||||
signature,
|
||||
message
|
||||
}, {
|
||||
withCredentials: true // Важно для сохранения сессии
|
||||
});
|
||||
|
||||
console.log('Успешно подключен:', verifyResponse.data);
|
||||
|
||||
// Возвращаем результат подключения
|
||||
return {
|
||||
success: true,
|
||||
authenticated: verifyResponse.data.authenticated,
|
||||
address: address,
|
||||
isAdmin: verifyResponse.data.isAdmin,
|
||||
authType: 'wallet',
|
||||
authType: 'wallet'
|
||||
};
|
||||
} catch (signError) {
|
||||
console.error('Ошибка при подписи сообщения:', signError);
|
||||
|
||||
if (signError.code === 4001) {
|
||||
throw new Error('Пользователь отклонил запрос на подпись');
|
||||
}
|
||||
|
||||
throw new Error('Не удалось подписать сообщение');
|
||||
} catch (error) {
|
||||
console.error('Ошибка при подключении кошелька:', error);
|
||||
return { success: false, error: error.message };
|
||||
}
|
||||
} catch (error) {
|
||||
console.error('Ошибка при подключении кошелька:', error);
|
||||
throw error;
|
||||
} else {
|
||||
console.error('MetaMask не установлен');
|
||||
return { success: false, error: 'MetaMask не установлен' };
|
||||
}
|
||||
}
|
||||
|
||||
@@ -114,9 +59,6 @@ async function disconnectWallet() {
|
||||
}
|
||||
);
|
||||
|
||||
// Удаляем адрес из localStorage
|
||||
localStorage.removeItem('walletAddress');
|
||||
|
||||
return { success: true };
|
||||
} catch (error) {
|
||||
console.error('Ошибка при отключении кошелька:', error);
|
||||
|
||||
@@ -1,27 +0,0 @@
|
||||
<template>
|
||||
<div class="access-test-view">
|
||||
<h1>Тестирование доступа</h1>
|
||||
<p>Эта страница предназначена для тестирования смарт-контрактов и управления доступом.</p>
|
||||
|
||||
<div class="access-test-container">
|
||||
<AccessControl />
|
||||
</div>
|
||||
</div>
|
||||
</template>
|
||||
|
||||
<script setup>
|
||||
import AccessControl from '../components/AccessControl.vue';
|
||||
</script>
|
||||
|
||||
<style scoped>
|
||||
.access-test-view {
|
||||
padding: 20px;
|
||||
}
|
||||
|
||||
.access-test-container {
|
||||
margin-top: 20px;
|
||||
padding: 15px;
|
||||
background-color: #f5f5f5;
|
||||
border-radius: 4px;
|
||||
}
|
||||
</style>
|
||||
@@ -1,279 +0,0 @@
|
||||
<template>
|
||||
<div class="admin-view">
|
||||
<h1>Панель администратора</h1>
|
||||
|
||||
<div v-if="!authStore.isAdmin" class="admin-error">
|
||||
<p>У вас нет прав администратора для доступа к этой странице.</p>
|
||||
<button @click="updateAdminStatus" class="btn btn-primary">
|
||||
Получить права администратора
|
||||
</button>
|
||||
</div>
|
||||
|
||||
<div v-else-if="loading" class="loading">Загрузка данных администратора...</div>
|
||||
|
||||
<div v-else-if="error" class="error-message">
|
||||
{{ error }}
|
||||
</div>
|
||||
|
||||
<div v-else class="admin-content">
|
||||
<div class="admin-section">
|
||||
<h2>Статистика</h2>
|
||||
<div class="stats-grid">
|
||||
<div class="stat-card">
|
||||
<h3>Пользователи</h3>
|
||||
<p class="stat-value">{{ stats.userCount || 0 }}</p>
|
||||
</div>
|
||||
<div class="stat-card">
|
||||
<h3>Доски</h3>
|
||||
<p class="stat-value">{{ stats.boardCount || 0 }}</p>
|
||||
</div>
|
||||
<div class="stat-card">
|
||||
<h3>Задачи</h3>
|
||||
<p class="stat-value">{{ stats.taskCount || 0 }}</p>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<div class="admin-section">
|
||||
<h2>Пользователи</h2>
|
||||
<table class="users-table">
|
||||
<thead>
|
||||
<tr>
|
||||
<th>ID</th>
|
||||
<th>Адрес</th>
|
||||
<th>Администратор</th>
|
||||
<th>Создан</th>
|
||||
</tr>
|
||||
</thead>
|
||||
<tbody>
|
||||
<tr v-for="user in users" :key="user.id">
|
||||
<td>{{ user.id }}</td>
|
||||
<td>{{ user.address }}</td>
|
||||
<td>{{ user.is_admin ? 'Да' : 'Нет' }}</td>
|
||||
<td>{{ new Date(user.created_at).toLocaleString() }}</td>
|
||||
</tr>
|
||||
</tbody>
|
||||
</table>
|
||||
</div>
|
||||
|
||||
<div class="admin-section">
|
||||
<h2>Логи</h2>
|
||||
<table class="logs-table">
|
||||
<thead>
|
||||
<tr>
|
||||
<th>ID</th>
|
||||
<th>Тип</th>
|
||||
<th>Сообщение</th>
|
||||
<th>Время</th>
|
||||
</tr>
|
||||
</thead>
|
||||
<tbody>
|
||||
<tr v-for="log in logs" :key="log.id">
|
||||
<td>{{ log.id }}</td>
|
||||
<td>{{ log.type }}</td>
|
||||
<td>{{ log.message }}</td>
|
||||
<td>{{ new Date(log.created_at).toLocaleString() }}</td>
|
||||
</tr>
|
||||
</tbody>
|
||||
</table>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
</template>
|
||||
|
||||
<script setup>
|
||||
import { ref, onMounted } from 'vue';
|
||||
import { useAuthStore } from '../stores/auth';
|
||||
import axios from 'axios';
|
||||
|
||||
const authStore = useAuthStore();
|
||||
const users = ref([]);
|
||||
const stats = ref({});
|
||||
const logs = ref([]);
|
||||
const loading = ref(true);
|
||||
const error = ref(null);
|
||||
|
||||
// Функция для обновления статуса администратора
|
||||
async function updateAdminStatus() {
|
||||
try {
|
||||
const apiUrl = import.meta.env.VITE_API_URL || 'http://localhost:8000';
|
||||
|
||||
console.log('Обновление статуса администратора для адреса:', authStore.address);
|
||||
|
||||
// Отправляем запрос на обновление статуса администратора
|
||||
const response = await axios.post(
|
||||
`${apiUrl}/api/auth/update-admin-status`,
|
||||
{
|
||||
address: authStore.address,
|
||||
isAdmin: true,
|
||||
},
|
||||
{
|
||||
withCredentials: true,
|
||||
}
|
||||
);
|
||||
|
||||
console.log('Статус администратора обновлен:', response.data);
|
||||
|
||||
// Обновляем сессию
|
||||
const refreshResponse = await axios.post(
|
||||
`${apiUrl}/api/auth/refresh-session`,
|
||||
{
|
||||
address: authStore.address,
|
||||
},
|
||||
{
|
||||
withCredentials: true,
|
||||
}
|
||||
);
|
||||
|
||||
console.log('Сессия обновлена после обновления статуса:', refreshResponse.data);
|
||||
|
||||
// Обновляем статус администратора в хранилище
|
||||
authStore.updateAuthState({
|
||||
...authStore.$state,
|
||||
isAdmin: refreshResponse.data.isAdmin,
|
||||
});
|
||||
|
||||
// Перезагружаем страницу
|
||||
window.location.reload();
|
||||
} catch (error) {
|
||||
console.error('Ошибка при обновлении статуса администратора:', error);
|
||||
|
||||
if (error.response) {
|
||||
console.error('Статус ответа:', error.response.status);
|
||||
console.error('Данные ответа:', error.response.data);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Загрузка данных администратора
|
||||
async function loadAdminData() {
|
||||
try {
|
||||
loading.value = true;
|
||||
error.value = null;
|
||||
|
||||
const apiUrl = import.meta.env.VITE_API_URL || 'http://localhost:8000';
|
||||
|
||||
// Заголовки для запросов
|
||||
const headers = {
|
||||
'Content-Type': 'application/json',
|
||||
Authorization: `Bearer ${authStore.address}`,
|
||||
};
|
||||
|
||||
console.log('Запрос к API администратора с заголовками:', headers);
|
||||
|
||||
// Загрузка пользователей
|
||||
const usersResponse = await axios.get(`${apiUrl}/api/admin/users`, {
|
||||
withCredentials: true,
|
||||
headers,
|
||||
});
|
||||
|
||||
users.value = usersResponse.data;
|
||||
|
||||
// Загрузка статистики
|
||||
const statsResponse = await axios.get(`${apiUrl}/api/admin/stats`, {
|
||||
withCredentials: true,
|
||||
headers,
|
||||
});
|
||||
|
||||
stats.value = statsResponse.data;
|
||||
|
||||
// Загрузка логов
|
||||
const logsResponse = await axios.get(`${apiUrl}/api/admin/logs`, {
|
||||
withCredentials: true,
|
||||
headers,
|
||||
});
|
||||
|
||||
logs.value = logsResponse.data;
|
||||
|
||||
loading.value = false;
|
||||
} catch (error) {
|
||||
console.error('Ошибка при загрузке данных администратора:', error);
|
||||
|
||||
if (error.response) {
|
||||
console.error('Статус ответа:', error.response.status);
|
||||
console.error('Данные ответа:', error.response.data);
|
||||
console.error('Заголовки ответа:', error.response.headers);
|
||||
}
|
||||
|
||||
error.value = 'Ошибка при загрузке данных администратора';
|
||||
loading.value = false;
|
||||
}
|
||||
}
|
||||
|
||||
onMounted(async () => {
|
||||
if (authStore.isAdmin) {
|
||||
await loadAdminData();
|
||||
}
|
||||
});
|
||||
</script>
|
||||
|
||||
<style scoped>
|
||||
.admin-view {
|
||||
padding: 1rem;
|
||||
}
|
||||
|
||||
.admin-error {
|
||||
text-align: center;
|
||||
padding: 2rem;
|
||||
background-color: #f8d7da;
|
||||
border-radius: 8px;
|
||||
margin-bottom: 1rem;
|
||||
}
|
||||
|
||||
.admin-section {
|
||||
background-color: white;
|
||||
border-radius: 8px;
|
||||
box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);
|
||||
padding: 1.5rem;
|
||||
margin-bottom: 2rem;
|
||||
}
|
||||
|
||||
.stats-grid {
|
||||
display: grid;
|
||||
grid-template-columns: repeat(auto-fill, minmax(200px, 1fr));
|
||||
gap: 1rem;
|
||||
}
|
||||
|
||||
.stat-card {
|
||||
background-color: #f8f9fa;
|
||||
border-radius: 8px;
|
||||
padding: 1rem;
|
||||
text-align: center;
|
||||
}
|
||||
|
||||
.stat-value {
|
||||
font-size: 2rem;
|
||||
font-weight: bold;
|
||||
color: #3498db;
|
||||
}
|
||||
|
||||
table {
|
||||
width: 100%;
|
||||
border-collapse: collapse;
|
||||
}
|
||||
|
||||
th,
|
||||
td {
|
||||
padding: 0.75rem;
|
||||
text-align: left;
|
||||
border-bottom: 1px solid #e9ecef;
|
||||
}
|
||||
|
||||
th {
|
||||
background-color: #f8f9fa;
|
||||
font-weight: bold;
|
||||
}
|
||||
|
||||
.loading,
|
||||
.error-message {
|
||||
text-align: center;
|
||||
padding: 2rem;
|
||||
background-color: white;
|
||||
border-radius: 8px;
|
||||
box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);
|
||||
}
|
||||
|
||||
.error-message {
|
||||
color: #e74c3c;
|
||||
}
|
||||
</style>
|
||||
@@ -1,282 +1,243 @@
|
||||
<template>
|
||||
<div class="chat-container">
|
||||
<ConversationList @select-conversation="handleSelectConversation" ref="conversationList" />
|
||||
|
||||
<div class="chat-main">
|
||||
<div v-if="!selectedConversationId" class="no-conversation">
|
||||
<p>Выберите диалог из списка или создайте новый, чтобы начать общение.</p>
|
||||
</div>
|
||||
|
||||
<template v-else>
|
||||
<div class="chat-header">
|
||||
<h2>{{ currentConversationTitle }}</h2>
|
||||
<div class="chat-actions">
|
||||
<button @click="showRenameDialog = true" class="action-button">Переименовать</button>
|
||||
<button @click="confirmDelete" class="action-button delete">Удалить</button>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<MessageThread :conversation-id="selectedConversationId" ref="messageThread" />
|
||||
|
||||
<MessageInput
|
||||
:conversation-id="selectedConversationId"
|
||||
@message-sent="handleMessageSent"
|
||||
ref="messageInput"
|
||||
/>
|
||||
</template>
|
||||
</div>
|
||||
|
||||
<!-- Диалог переименования -->
|
||||
<div v-if="showRenameDialog" class="dialog-overlay">
|
||||
<div class="dialog">
|
||||
<h3>Переименовать диалог</h3>
|
||||
<input
|
||||
v-model="newTitle"
|
||||
placeholder="Введите новое название"
|
||||
@keydown.enter="renameConversation"
|
||||
/>
|
||||
<div class="dialog-actions">
|
||||
<button @click="showRenameDialog = false" class="cancel-button">Отмена</button>
|
||||
<button @click="renameConversation" class="confirm-button">Сохранить</button>
|
||||
<div class="chat-view">
|
||||
<div class="chat-container">
|
||||
<h2>Чат с ИИ-ассистентом</h2>
|
||||
<div class="chat-messages" ref="chatMessages">
|
||||
<div
|
||||
v-for="(message, index) in messages"
|
||||
:key="index"
|
||||
:class="['message', message.sender === 'user' ? 'user-message' : 'ai-message']"
|
||||
>
|
||||
<div class="message-content" v-html="message.text"></div>
|
||||
<div class="message-time">{{ formatTime(message.timestamp) }}</div>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<!-- Диалог подтверждения удаления -->
|
||||
<div v-if="showDeleteDialog" class="dialog-overlay">
|
||||
<div class="dialog">
|
||||
<h3>Удалить диалог?</h3>
|
||||
<p>Вы уверены, что хотите удалить этот диалог? Это действие нельзя отменить.</p>
|
||||
<div class="dialog-actions">
|
||||
<button @click="showDeleteDialog = false" class="cancel-button">Отмена</button>
|
||||
<button @click="deleteConversation" class="delete-button">Удалить</button>
|
||||
</div>
|
||||
<div class="chat-input">
|
||||
<textarea
|
||||
v-model="userInput"
|
||||
placeholder="Введите ваше сообщение..."
|
||||
@keydown.enter.prevent="sendMessage"
|
||||
></textarea>
|
||||
<button class="send-btn" @click="sendMessage" :disabled="!userInput.trim() || isLoading">
|
||||
{{ isLoading ? 'Отправка...' : 'Отправить' }}
|
||||
</button>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
</template>
|
||||
|
||||
<script setup>
|
||||
import { ref, computed, nextTick } from 'vue';
|
||||
import ConversationList from '../components/chat/ConversationList.vue';
|
||||
import MessageThread from '../components/chat/MessageThread.vue';
|
||||
import MessageInput from '../components/chat/MessageInput.vue';
|
||||
import { ref, onMounted, watch, nextTick } from 'vue';
|
||||
import axios from 'axios';
|
||||
import { useAuthStore } from '../stores/auth';
|
||||
|
||||
const selectedConversationId = ref(null);
|
||||
const currentConversationTitle = ref('');
|
||||
const conversationList = ref(null);
|
||||
const messageThread = ref(null);
|
||||
const messageInput = ref(null);
|
||||
const userInput = ref('');
|
||||
const messages = ref([
|
||||
{
|
||||
sender: 'ai',
|
||||
text: 'Привет! Я ИИ-ассистент DApp for Business. Чем я могу помочь вам сегодня?',
|
||||
timestamp: new Date(),
|
||||
},
|
||||
]);
|
||||
const chatMessages = ref(null);
|
||||
const isLoading = ref(false);
|
||||
const authStore = useAuthStore();
|
||||
|
||||
// Диалоги
|
||||
const showRenameDialog = ref(false);
|
||||
const showDeleteDialog = ref(false);
|
||||
const newTitle = ref('');
|
||||
// Прокрутка чата вниз при добавлении новых сообщений
|
||||
watch(
|
||||
messages,
|
||||
() => {
|
||||
nextTick(() => {
|
||||
if (chatMessages.value) {
|
||||
chatMessages.value.scrollTop = chatMessages.value.scrollHeight;
|
||||
}
|
||||
});
|
||||
},
|
||||
{ deep: true }
|
||||
);
|
||||
|
||||
// Обработка выбора диалога
|
||||
const handleSelectConversation = (conversationId) => {
|
||||
selectedConversationId.value = conversationId;
|
||||
|
||||
// Получение заголовка диалога
|
||||
const conversation = conversationList.value.conversations.value.find(
|
||||
(c) => c.conversation_id === conversationId
|
||||
);
|
||||
|
||||
if (conversation) {
|
||||
currentConversationTitle.value = conversation.title;
|
||||
// Проверка прав администратора
|
||||
onMounted(async () => {
|
||||
if (authStore.isAdmin) {
|
||||
messages.value.push({
|
||||
sender: 'ai',
|
||||
text: 'Вы имеете права администратора.',
|
||||
timestamp: new Date(),
|
||||
});
|
||||
} else {
|
||||
messages.value.push({
|
||||
sender: 'ai',
|
||||
text: 'У вас нет прав администратора.',
|
||||
timestamp: new Date(),
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
// Фокус на поле ввода после загрузки сообщений
|
||||
nextTick(() => {
|
||||
messageInput.value?.focus();
|
||||
// Функция для отправки сообщения
|
||||
async function sendMessage() {
|
||||
if (!userInput.value.trim() || isLoading.value) return;
|
||||
|
||||
// Добавляем сообщение пользователя в чат
|
||||
const userMessage = userInput.value.trim();
|
||||
messages.value.push({
|
||||
sender: 'user',
|
||||
text: userMessage,
|
||||
timestamp: new Date(),
|
||||
});
|
||||
};
|
||||
|
||||
// Обработка отправки сообщения
|
||||
const handleMessageSent = (messages) => {
|
||||
messageThread.value.addMessages(messages);
|
||||
};
|
||||
|
||||
// Переименование диалога
|
||||
const renameConversation = async () => {
|
||||
if (!newTitle.value.trim()) return;
|
||||
userInput.value = '';
|
||||
isLoading.value = true;
|
||||
|
||||
try {
|
||||
const response = await axios.put(
|
||||
`/api/messages/conversations/${selectedConversationId.value}`,
|
||||
{ title: newTitle.value }
|
||||
console.log('Отправка сообщения:', userMessage);
|
||||
|
||||
// Отправляем запрос к API
|
||||
const response = await axios.post(
|
||||
'/api/chat/message',
|
||||
{
|
||||
message: userMessage,
|
||||
language: 'ru', // Укажите язык, если необходимо
|
||||
},
|
||||
{
|
||||
withCredentials: true, // Важно для передачи куков
|
||||
}
|
||||
);
|
||||
|
||||
// Обновление заголовка
|
||||
currentConversationTitle.value = response.data.title;
|
||||
console.log('Ответ от сервера:', response.data);
|
||||
|
||||
// Обновление списка диалогов
|
||||
conversationList.value.fetchConversations();
|
||||
|
||||
// Закрытие диалога
|
||||
showRenameDialog.value = false;
|
||||
newTitle.value = '';
|
||||
// Добавляем ответ от ИИ в чат
|
||||
messages.value.push({
|
||||
sender: 'ai',
|
||||
text: response.data.reply || 'Извините, я не смог обработать ваш запрос.',
|
||||
timestamp: new Date(),
|
||||
});
|
||||
} catch (error) {
|
||||
console.error('Error renaming conversation:', error);
|
||||
console.error('Error sending message:', error);
|
||||
messages.value.push({
|
||||
sender: 'ai',
|
||||
text: 'Извините, произошла ошибка при обработке вашего запроса. Пожалуйста, попробуйте позже.',
|
||||
timestamp: new Date(),
|
||||
});
|
||||
} finally {
|
||||
isLoading.value = false;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
// Подтверждение удаления
|
||||
const confirmDelete = () => {
|
||||
showDeleteDialog.value = true;
|
||||
};
|
||||
// Функция для форматирования времени
|
||||
function formatTime(timestamp) {
|
||||
if (!timestamp) return '';
|
||||
|
||||
// Удаление диалога
|
||||
const deleteConversation = async () => {
|
||||
try {
|
||||
await axios.delete(`/api/messages/conversations/${selectedConversationId.value}`);
|
||||
|
||||
// Обновление списка диалогов
|
||||
conversationList.value.fetchConversations();
|
||||
|
||||
// Сброс выбранного диалога
|
||||
selectedConversationId.value = null;
|
||||
currentConversationTitle.value = '';
|
||||
|
||||
// Закрытие диалога
|
||||
showDeleteDialog.value = false;
|
||||
} catch (error) {
|
||||
console.error('Error deleting conversation:', error);
|
||||
}
|
||||
};
|
||||
const date = new Date(timestamp);
|
||||
return date.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
|
||||
}
|
||||
</script>
|
||||
|
||||
<style scoped>
|
||||
.chat-container {
|
||||
.chat-view {
|
||||
height: 100%;
|
||||
display: flex;
|
||||
height: calc(100vh - 64px); /* Высота экрана минус высота шапки */
|
||||
position: relative;
|
||||
flex-direction: column;
|
||||
padding: 1rem;
|
||||
}
|
||||
|
||||
.chat-main {
|
||||
.chat-container {
|
||||
flex: 1;
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
background-color: #fff;
|
||||
}
|
||||
|
||||
.no-conversation {
|
||||
flex: 1;
|
||||
display: flex;
|
||||
justify-content: center;
|
||||
align-items: center;
|
||||
color: #666;
|
||||
padding: 2rem;
|
||||
text-align: center;
|
||||
}
|
||||
|
||||
.chat-header {
|
||||
display: flex;
|
||||
justify-content: space-between;
|
||||
align-items: center;
|
||||
padding: 1rem;
|
||||
border-bottom: 1px solid #e0e0e0;
|
||||
background-color: #f9f9f9;
|
||||
}
|
||||
|
||||
.chat-header h2 {
|
||||
margin: 0;
|
||||
font-size: 1.2rem;
|
||||
font-weight: 500;
|
||||
}
|
||||
|
||||
.chat-actions {
|
||||
display: flex;
|
||||
gap: 0.5rem;
|
||||
}
|
||||
|
||||
.action-button {
|
||||
padding: 0.5rem 0.75rem;
|
||||
background-color: #f0f0f0;
|
||||
border: none;
|
||||
border-radius: 4px;
|
||||
cursor: pointer;
|
||||
font-size: 0.9rem;
|
||||
transition: background-color 0.2s;
|
||||
}
|
||||
|
||||
.action-button:hover {
|
||||
background-color: #e0e0e0;
|
||||
}
|
||||
|
||||
.action-button.delete {
|
||||
color: #f44336;
|
||||
}
|
||||
|
||||
.action-button.delete:hover {
|
||||
background-color: #ffebee;
|
||||
}
|
||||
|
||||
/* Стили для диалогов */
|
||||
.dialog-overlay {
|
||||
position: fixed;
|
||||
top: 0;
|
||||
left: 0;
|
||||
right: 0;
|
||||
bottom: 0;
|
||||
background-color: rgba(0, 0, 0, 0.5);
|
||||
display: flex;
|
||||
justify-content: center;
|
||||
align-items: center;
|
||||
z-index: 1000;
|
||||
}
|
||||
|
||||
.dialog {
|
||||
background-color: #fff;
|
||||
background-color: white;
|
||||
border-radius: 8px;
|
||||
padding: 1.5rem;
|
||||
width: 400px;
|
||||
max-width: 90%;
|
||||
box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
|
||||
}
|
||||
|
||||
.dialog h3 {
|
||||
margin-top: 0;
|
||||
margin-bottom: 1rem;
|
||||
}
|
||||
|
||||
.dialog input {
|
||||
box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);
|
||||
overflow: hidden;
|
||||
max-width: 800px;
|
||||
margin: 0 auto;
|
||||
width: 100%;
|
||||
}
|
||||
|
||||
h2 {
|
||||
padding: 1rem;
|
||||
margin: 0;
|
||||
border-bottom: 1px solid #eee;
|
||||
font-size: 1.5rem;
|
||||
color: #333;
|
||||
}
|
||||
|
||||
.chat-messages {
|
||||
flex: 1;
|
||||
overflow-y: auto;
|
||||
padding: 1rem;
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
gap: 1rem;
|
||||
min-height: 400px;
|
||||
}
|
||||
|
||||
.message {
|
||||
max-width: 80%;
|
||||
padding: 0.75rem 1rem;
|
||||
border-radius: 8px;
|
||||
position: relative;
|
||||
}
|
||||
|
||||
.user-message {
|
||||
align-self: flex-end;
|
||||
background-color: #e3f2fd;
|
||||
color: #0d47a1;
|
||||
}
|
||||
|
||||
.ai-message {
|
||||
align-self: flex-start;
|
||||
background-color: #f5f5f5;
|
||||
color: #333;
|
||||
}
|
||||
|
||||
.message-content {
|
||||
word-break: break-word;
|
||||
}
|
||||
|
||||
.message-time {
|
||||
font-size: 0.75rem;
|
||||
color: #999;
|
||||
margin-top: 0.25rem;
|
||||
text-align: right;
|
||||
}
|
||||
|
||||
.chat-input {
|
||||
display: flex;
|
||||
padding: 1rem;
|
||||
border-top: 1px solid #eee;
|
||||
background-color: white;
|
||||
}
|
||||
|
||||
textarea {
|
||||
flex: 1;
|
||||
padding: 0.75rem;
|
||||
border: 1px solid #e0e0e0;
|
||||
border: 1px solid #ddd;
|
||||
border-radius: 4px;
|
||||
margin-bottom: 1rem;
|
||||
resize: none;
|
||||
height: 60px;
|
||||
font-family: inherit;
|
||||
font-size: 1rem;
|
||||
}
|
||||
|
||||
.dialog-actions {
|
||||
display: flex;
|
||||
justify-content: flex-end;
|
||||
gap: 0.75rem;
|
||||
}
|
||||
|
||||
.cancel-button,
|
||||
.confirm-button,
|
||||
.delete-button {
|
||||
padding: 0.5rem 1rem;
|
||||
.send-btn {
|
||||
margin-left: 0.5rem;
|
||||
padding: 0 1.5rem;
|
||||
background-color: #1976d2;
|
||||
color: white;
|
||||
border: none;
|
||||
border-radius: 4px;
|
||||
cursor: pointer;
|
||||
font-weight: 500;
|
||||
font-size: 1rem;
|
||||
transition: background-color 0.2s;
|
||||
}
|
||||
|
||||
.cancel-button {
|
||||
background-color: #f0f0f0;
|
||||
.send-btn:hover {
|
||||
background-color: #1565c0;
|
||||
}
|
||||
|
||||
.confirm-button {
|
||||
background-color: #4caf50;
|
||||
color: white;
|
||||
}
|
||||
|
||||
.delete-button {
|
||||
background-color: #f44336;
|
||||
color: white;
|
||||
.send-btn:disabled {
|
||||
background-color: #ccc;
|
||||
cursor: not-allowed;
|
||||
}
|
||||
</style>
|
||||
|
||||
@@ -1,27 +0,0 @@
|
||||
<template>
|
||||
<div class="dashboard-view">
|
||||
<h1>Дашборд</h1>
|
||||
<p>Добро пожаловать в панель управления!</p>
|
||||
|
||||
<!-- Добавьте проверку на администратора -->
|
||||
<div v-if="isAdmin">
|
||||
<h2>Административные функции</h2>
|
||||
<AccessTokenManager />
|
||||
<RoleManager />
|
||||
<AccessControl />
|
||||
</div>
|
||||
</div>
|
||||
</template>
|
||||
|
||||
<script setup>
|
||||
import { computed } from 'vue';
|
||||
import { useAuthStore } from '../stores/auth';
|
||||
import AccessTokenManager from '../components/AccessTokenManager.vue';
|
||||
import RoleManager from '../components/RoleManager.vue';
|
||||
import AccessControl from '../components/AccessControl.vue';
|
||||
|
||||
const authStore = useAuthStore();
|
||||
const isAdmin = computed(() => authStore.isAdmin);
|
||||
|
||||
console.log('Статус администратора:', isAdmin.value); // Для отладки
|
||||
</script>
|
||||
@@ -58,7 +58,6 @@ import { ref, computed, onMounted, watch, nextTick } from 'vue';
|
||||
import { useAuthStore } from '../stores/auth';
|
||||
import axios from 'axios';
|
||||
import WalletConnection from '../components/WalletConnection.vue';
|
||||
import { connectWallet } from '../utils/wallet';
|
||||
|
||||
const auth = useAuthStore();
|
||||
const userInput = ref('');
|
||||
@@ -72,9 +71,8 @@ const messages = ref([
|
||||
const chatMessages = ref(null);
|
||||
const isLoading = ref(false);
|
||||
const hasShownAuthMessage = ref(false);
|
||||
const userName = ref('');
|
||||
const userLanguage = ref('ru');
|
||||
const email = ref('');
|
||||
const userLanguage = ref('ru');
|
||||
|
||||
// Проверка валидности email
|
||||
const isValidEmail = computed(() => {
|
||||
@@ -130,6 +128,22 @@ async function sendMessage() {
|
||||
try {
|
||||
console.log('Отправка сообщения:', userMessage, 'язык:', userLanguage.value);
|
||||
|
||||
// Проверяем, авторизован ли пользователь
|
||||
if (!auth.isAuthenticated && !hasShownAuthMessage.value) {
|
||||
// Если пользователь не авторизован и мы еще не показывали сообщение с опциями авторизации
|
||||
setTimeout(() => {
|
||||
messages.value.push({
|
||||
sender: 'ai',
|
||||
text: 'Для продолжения общения и доступа ко всем функциям, пожалуйста, авторизуйтесь одним из способов:',
|
||||
timestamp: new Date(),
|
||||
showAuthOptions: true,
|
||||
});
|
||||
isLoading.value = false;
|
||||
hasShownAuthMessage.value = true;
|
||||
}, 1000);
|
||||
return;
|
||||
}
|
||||
|
||||
// Отправляем запрос к API
|
||||
const response = await axios.post(
|
||||
'/api/chat/message',
|
||||
@@ -153,12 +167,23 @@ async function sendMessage() {
|
||||
} catch (error) {
|
||||
console.error('Error sending message:', error);
|
||||
|
||||
// Добавляем сообщение об ошибке
|
||||
messages.value.push({
|
||||
sender: 'ai',
|
||||
text: 'Извините, произошла ошибка при обработке вашего запроса. Пожалуйста, попробуйте позже.',
|
||||
timestamp: new Date(),
|
||||
});
|
||||
// Если ошибка связана с авторизацией (401)
|
||||
if (error.response && error.response.status === 401 && !hasShownAuthMessage.value) {
|
||||
messages.value.push({
|
||||
sender: 'ai',
|
||||
text: 'Для продолжения общения и доступа ко всем функциям, пожалуйста, авторизуйтесь одним из способов:',
|
||||
timestamp: new Date(),
|
||||
showAuthOptions: true,
|
||||
});
|
||||
hasShownAuthMessage.value = true;
|
||||
} else {
|
||||
// Добавляем сообщение об ошибке
|
||||
messages.value.push({
|
||||
sender: 'ai',
|
||||
text: 'Извините, произошла ошибка при обработке вашего запроса. Пожалуйста, попробуйте позже.',
|
||||
timestamp: new Date(),
|
||||
});
|
||||
}
|
||||
} finally {
|
||||
isLoading.value = false;
|
||||
}
|
||||
@@ -176,9 +201,10 @@ function formatTime(timestamp) {
|
||||
async function connectTelegram() {
|
||||
try {
|
||||
// Отправляем запрос на получение ссылки для авторизации через Telegram
|
||||
const response = await axios.get('/api/auth/telegram');
|
||||
const response = await axios.get('/api/auth/telegram', {
|
||||
withCredentials: true
|
||||
});
|
||||
|
||||
// Если сервер вернул ошибку, показываем сообщение
|
||||
if (response.data.error) {
|
||||
messages.value.push({
|
||||
sender: 'ai',
|
||||
@@ -188,7 +214,6 @@ async function connectTelegram() {
|
||||
return;
|
||||
}
|
||||
|
||||
// Если сервер вернул ссылку для авторизации, показываем её пользователю
|
||||
if (response.data.authUrl) {
|
||||
messages.value.push({
|
||||
sender: 'ai',
|
||||
@@ -199,20 +224,15 @@ async function connectTelegram() {
|
||||
// Открываем ссылку в новом окне
|
||||
window.open(response.data.authUrl, '_blank');
|
||||
} else {
|
||||
// Временное решение для обхода ошибок сервера
|
||||
messages.value.push({
|
||||
sender: 'ai',
|
||||
text: 'Для подключения Telegram, перейдите по <a href="https://t.me/YourBotName" target="_blank">этой ссылке</a> и авторизуйтесь.',
|
||||
timestamp: new Date(),
|
||||
});
|
||||
|
||||
// Открываем ссылку на бота в новом окне
|
||||
window.open('https://t.me/YourBotName', '_blank');
|
||||
}
|
||||
} catch (error) {
|
||||
console.error('Error connecting with Telegram:', error);
|
||||
|
||||
// Показываем сообщение об ошибке
|
||||
messages.value.push({
|
||||
sender: 'ai',
|
||||
text: 'Извините, произошла ошибка при подключении Telegram. Пожалуйста, попробуйте позже.',
|
||||
@@ -226,129 +246,89 @@ async function connectEmail() {
|
||||
if (!isValidEmail.value) return;
|
||||
|
||||
try {
|
||||
// Отправляем запрос на авторизацию по email
|
||||
const response = await axios.post('/api/auth/email', { email: email.value });
|
||||
messages.value.push({
|
||||
sender: 'ai',
|
||||
text: `Отправляем код подтверждения на ${email.value}...`,
|
||||
timestamp: new Date(),
|
||||
});
|
||||
|
||||
// Отправляем запрос на отправку кода подтверждения
|
||||
const response = await axios.post('/api/auth/email', {
|
||||
email: email.value
|
||||
}, {
|
||||
withCredentials: true
|
||||
});
|
||||
|
||||
// Если сервер вернул ошибку, показываем сообщение
|
||||
if (response.data.error) {
|
||||
messages.value.push({
|
||||
sender: 'ai',
|
||||
text: `Ошибка при подключении Email: ${response.data.error}`,
|
||||
text: `Ошибка: ${response.data.error}`,
|
||||
timestamp: new Date(),
|
||||
});
|
||||
return;
|
||||
}
|
||||
|
||||
// Если сервер вернул код подтверждения или сообщение об отправке письма
|
||||
if (response.data.success) {
|
||||
messages.value.push({
|
||||
sender: 'ai',
|
||||
text: `На ваш email ${email.value} отправлено письмо с кодом подтверждения. Пожалуйста, проверьте вашу почту и введите код:`,
|
||||
timestamp: new Date(),
|
||||
});
|
||||
messages.value.push({
|
||||
sender: 'ai',
|
||||
text: `На ваш email ${email.value} отправлено письмо с кодом подтверждения. Пожалуйста, введите код:`,
|
||||
timestamp: new Date(),
|
||||
});
|
||||
|
||||
// Добавляем поле для ввода кода подтверждения
|
||||
messages.value.push({
|
||||
sender: 'ai',
|
||||
text: '<div class="verification-code"><input type="text" placeholder="Введите код подтверждения" id="verification-code" /><button onclick="verifyEmailCode()">Подтвердить</button></div>',
|
||||
timestamp: new Date(),
|
||||
});
|
||||
// Добавляем поле для ввода кода
|
||||
const verificationCode = prompt('Введите код подтверждения:');
|
||||
|
||||
// Добавляем функцию для проверки кода в глобальный объект window
|
||||
window.verifyEmailCode = async function () {
|
||||
const code = document.getElementById('verification-code').value;
|
||||
if (!code) return;
|
||||
|
||||
try {
|
||||
const verifyResponse = await axios.post('/api/auth/email/verify', {
|
||||
email: email.value,
|
||||
code,
|
||||
});
|
||||
|
||||
if (verifyResponse.data.authenticated) {
|
||||
auth.authenticated = true;
|
||||
auth.address = email.value;
|
||||
auth.isAdmin = verifyResponse.data.isAdmin;
|
||||
auth.authType = 'email';
|
||||
|
||||
// Перезагружаем страницу для обновления интерфейса
|
||||
window.location.reload();
|
||||
} else {
|
||||
messages.value.push({
|
||||
sender: 'ai',
|
||||
text: 'Неверный код подтверждения. Пожалуйста, попробуйте еще раз.',
|
||||
timestamp: new Date(),
|
||||
});
|
||||
}
|
||||
} catch (error) {
|
||||
console.error('Error verifying email code:', error);
|
||||
if (verificationCode) {
|
||||
try {
|
||||
// Отправляем запрос на проверку кода
|
||||
const verifyResponse = await axios.post('/api/auth/email/verify', {
|
||||
email: email.value,
|
||||
code: verificationCode
|
||||
}, {
|
||||
withCredentials: true
|
||||
});
|
||||
|
||||
if (verifyResponse.data.error) {
|
||||
messages.value.push({
|
||||
sender: 'ai',
|
||||
text: 'Произошла ошибка при проверке кода. Пожалуйста, попробуйте позже.',
|
||||
text: `Ошибка: ${verifyResponse.data.error}`,
|
||||
timestamp: new Date(),
|
||||
});
|
||||
return;
|
||||
}
|
||||
};
|
||||
} else {
|
||||
// Временное решение для обхода ошибок сервера
|
||||
messages.value.push({
|
||||
sender: 'ai',
|
||||
text: `На ваш email ${email.value} отправлено письмо с кодом подтверждения. Пожалуйста, проверьте вашу почту.`,
|
||||
timestamp: new Date(),
|
||||
});
|
||||
|
||||
// Имитируем успешную авторизацию через email
|
||||
setTimeout(() => {
|
||||
auth.authenticated = true;
|
||||
auth.address = email.value;
|
||||
auth.isAdmin = email.value.includes('admin');
|
||||
messages.value.push({
|
||||
sender: 'ai',
|
||||
text: 'Email успешно подтвержден! Теперь вы можете использовать все функции чата.',
|
||||
timestamp: new Date(),
|
||||
});
|
||||
|
||||
// Обновляем состояние аутентификации
|
||||
auth.isAuthenticated = true;
|
||||
auth.user = { email: email.value };
|
||||
auth.authType = 'email';
|
||||
|
||||
// Перезагружаем страницу для обновления интерфейса
|
||||
window.location.reload();
|
||||
}, 3000);
|
||||
// Сбрасываем флаг показа сообщения с опциями авторизации
|
||||
hasShownAuthMessage.value = false;
|
||||
} catch (error) {
|
||||
console.error('Error verifying email code:', error);
|
||||
|
||||
messages.value.push({
|
||||
sender: 'ai',
|
||||
text: 'Произошла ошибка при проверке кода. Пожалуйста, попробуйте позже.',
|
||||
timestamp: new Date(),
|
||||
});
|
||||
}
|
||||
}
|
||||
} catch (error) {
|
||||
console.error('Error connecting with email:', error);
|
||||
|
||||
// Показываем сообщение об ошибке
|
||||
messages.value.push({
|
||||
sender: 'ai',
|
||||
text: 'Извините, произошла ошибка при подключении Email. Пожалуйста, попробуйте позже.',
|
||||
timestamp: new Date(),
|
||||
});
|
||||
|
||||
// Временное решение для обхода ошибок сервера
|
||||
messages.value.push({
|
||||
sender: 'ai',
|
||||
text: `На ваш email ${email.value} отправлено письмо с кодом подтверждения. Пожалуйста, проверьте вашу почту.`,
|
||||
timestamp: new Date(),
|
||||
});
|
||||
|
||||
// Имитируем успешную авторизацию через email
|
||||
setTimeout(() => {
|
||||
auth.authenticated = true;
|
||||
auth.address = email.value;
|
||||
auth.isAdmin = email.value.includes('admin');
|
||||
auth.authType = 'email';
|
||||
|
||||
// Перезагружаем страницу для обновления интерфейса
|
||||
window.location.reload();
|
||||
}, 3000);
|
||||
}
|
||||
}
|
||||
|
||||
// В функции обработчика клика
|
||||
function handleConnectWallet() {
|
||||
connectWallet((errorMessage) => {
|
||||
messages.value.push({
|
||||
sender: 'ai',
|
||||
text: errorMessage,
|
||||
timestamp: new Date(),
|
||||
});
|
||||
});
|
||||
}
|
||||
</script>
|
||||
|
||||
<style scoped>
|
||||
@@ -387,6 +367,7 @@ h2 {
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
gap: 1rem;
|
||||
min-height: 400px;
|
||||
}
|
||||
|
||||
.message {
|
||||
@@ -485,22 +466,6 @@ textarea {
|
||||
cursor: not-allowed;
|
||||
}
|
||||
|
||||
.email-auth {
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
gap: 0.5rem;
|
||||
width: 100%;
|
||||
}
|
||||
|
||||
.email-auth input {
|
||||
padding: 0.75rem 1rem;
|
||||
border: 1px solid #ddd;
|
||||
border-radius: 4px;
|
||||
font-size: 1rem;
|
||||
width: 100%;
|
||||
box-sizing: border-box;
|
||||
}
|
||||
|
||||
/* Общие стили для всех кнопок аутентификации */
|
||||
.auth-btn {
|
||||
display: flex;
|
||||
@@ -546,31 +511,4 @@ textarea {
|
||||
background-color: #4caf50;
|
||||
color: white;
|
||||
}
|
||||
|
||||
/* Стили для поля ввода кода подтверждения */
|
||||
.verification-code {
|
||||
display: flex;
|
||||
gap: 0.5rem;
|
||||
margin-top: 0.5rem;
|
||||
}
|
||||
|
||||
.verification-code input {
|
||||
flex: 1;
|
||||
padding: 0.75rem 1rem;
|
||||
border: 1px solid #ddd;
|
||||
border-radius: 4px;
|
||||
font-size: 1rem;
|
||||
box-sizing: border-box;
|
||||
}
|
||||
|
||||
.verification-code button {
|
||||
padding: 0.75rem 1rem;
|
||||
background-color: #4caf50;
|
||||
color: white;
|
||||
border: none;
|
||||
border-radius: 4px;
|
||||
cursor: pointer;
|
||||
font-size: 1rem;
|
||||
font-weight: 500;
|
||||
}
|
||||
</style>
|
||||
|
||||
@@ -56,7 +56,9 @@ export default {
|
||||
const loadProfile = async () => {
|
||||
try {
|
||||
loading.value = true;
|
||||
const response = await axios.get('/api/users/profile');
|
||||
const response = await axios.get('/api/users/profile', {
|
||||
withCredentials: true
|
||||
});
|
||||
profile.value = response.data;
|
||||
selectedLanguage.value = response.data.preferred_language || 'ru';
|
||||
isAdmin.value = response.data.role === 'admin';
|
||||
@@ -73,6 +75,8 @@ export default {
|
||||
try {
|
||||
await axios.post('/api/users/update-language', {
|
||||
language: selectedLanguage.value
|
||||
}, {
|
||||
withCredentials: true
|
||||
});
|
||||
// Обновляем язык в профиле
|
||||
profile.value.preferred_language = selectedLanguage.value;
|
||||
|
||||
@@ -16,7 +16,7 @@ export default defineConfig({
|
||||
],
|
||||
resolve: {
|
||||
alias: {
|
||||
'@': path.resolve(__dirname, './src'),
|
||||
'@': path.resolve(__dirname, 'src'),
|
||||
buffer: 'buffer/',
|
||||
},
|
||||
},
|
||||
@@ -42,7 +42,7 @@ export default defineConfig({
|
||||
'/api': {
|
||||
target: 'http://localhost:8000',
|
||||
changeOrigin: true,
|
||||
cookieDomainRewrite: 'localhost',
|
||||
secure: false
|
||||
}
|
||||
},
|
||||
},
|
||||
|
||||
Reference in New Issue
Block a user