+
+**[⬆ Наверх](#-nakamaspace---telegram-mini-app)**
+
+Сделано с 🦊 и 🎌
+
+
+
diff --git a/SETUP.md b/SETUP.md
new file mode 100644
index 0000000..183c835
--- /dev/null
+++ b/SETUP.md
@@ -0,0 +1,260 @@
+# NakamaSpace - Инструкция по установке и запуску
+
+## 📋 Требования
+
+- Node.js 16+ и npm
+- MongoDB 5+
+- Telegram Bot Token (получить у [@BotFather](https://t.me/BotFather))
+
+## 🚀 Установка
+
+### 1. Установить зависимости
+
+```bash
+# Установка зависимостей backend
+npm install
+
+# Установка зависимостей frontend
+cd frontend
+npm install
+cd ..
+```
+
+### 2. Настроить переменные окружения
+
+Создайте файл `.env` в корне проекта:
+
+```bash
+cp .env.example .env
+```
+
+Отредактируйте `.env`:
+
+```
+MONGODB_URI=mongodb://localhost:27017/nakama
+PORT=3000
+JWT_SECRET=your_secret_key_here
+TELEGRAM_BOT_TOKEN=your_bot_token_here
+NODE_ENV=development
+```
+
+Создайте файл `frontend/.env`:
+
+```bash
+cp frontend/.env.example frontend/.env
+```
+
+### 3. Запустить MongoDB
+
+```bash
+# macOS с Homebrew
+brew services start mongodb-community
+
+# Linux
+sudo systemctl start mongod
+
+# Или запустите вручную
+mongod --dbpath /path/to/data/directory
+```
+
+### 4. Создать Telegram бота
+
+1. Откройте [@BotFather](https://t.me/BotFather) в Telegram
+2. Отправьте `/newbot` и следуйте инструкциям
+3. Получите токен бота и добавьте в `.env`
+4. Настройте Web App:
+ - `/mybots` → выберите бота → Bot Settings → Menu Button
+ - Укажите URL вашего приложения
+
+## 🏃 Запуск приложения
+
+### Режим разработки
+
+```bash
+# Запустить backend и frontend одновременно
+npm run dev
+
+# Или запустить по отдельности:
+
+# Backend (http://localhost:3000)
+npm run server
+
+# Frontend (http://localhost:5173)
+npm run client
+```
+
+### Production
+
+```bash
+# Собрать frontend
+npm run build
+
+# Запустить production сервер
+npm start
+```
+
+## 🔧 Настройка Telegram Mini App
+
+### Локальная разработка
+
+Для тестирования локально:
+
+1. Используйте ngrok или подобный туннель:
+```bash
+ngrok http 5173
+```
+
+2. Скопируйте HTTPS URL от ngrok
+
+3. Настройте Menu Button в BotFather с этим URL
+
+### Production деплой
+
+Рекомендуемые платформы:
+- **Backend**: Railway, Render, Heroku
+- **Frontend**: Vercel, Netlify
+- **MongoDB**: MongoDB Atlas
+
+Пример деплоя на Railway:
+
+```bash
+# Установить Railway CLI
+npm i -g @railway/cli
+
+# Войти
+railway login
+
+# Создать проект
+railway init
+
+# Деплой
+railway up
+```
+
+## 📱 Тестирование
+
+1. Откройте бота в Telegram
+2. Нажмите на кнопку меню или отправьте команду
+3. Приложение откроется как Mini App
+
+## 🛠️ Структура проекта
+
+```
+nakama/
+├── backend/ # Backend сервер
+│ ├── models/ # MongoDB модели
+│ ├── routes/ # API endpoints
+│ ├── middleware/ # Middleware (auth, etc)
+│ └── server.js # Точка входа
+├── frontend/ # Frontend React приложение
+│ ├── src/
+│ │ ├── components/ # React компоненты
+│ │ ├── pages/ # Страницы-вкладки
+│ │ ├── utils/ # Утилиты (API, Telegram)
+│ │ └── styles/ # CSS стили
+│ └── index.html
+└── package.json
+```
+
+## 🎨 Дизайн-система
+
+Проект использует минималистичный iOS-стиль с палитрой:
+
+- **Фон**: #F2F3F5
+- **Карточки**: #FFFFFF
+- **Текст**: #1C1C1E
+- **Furry теги**: #FF8A33
+- **Anime теги**: #4A90E2
+- **Other теги**: #A0A0A0
+
+## 🔐 Модерация
+
+Для назначения модераторов/админов:
+
+```javascript
+// Подключиться к MongoDB
+mongo nakama
+
+// Обновить роль пользователя
+db.users.updateOne(
+ { telegramId: "YOUR_TELEGRAM_ID" },
+ { $set: { role: "admin" } }
+)
+```
+
+Роли:
+- `user` - обычный пользователь
+- `moderator` - может модерировать контент
+- `admin` - полные права
+
+## 📚 API Документация
+
+### Основные endpoints:
+
+#### Авторизация
+- `POST /api/auth/verify` - Верификация Telegram Init Data
+
+#### Посты
+- `GET /api/posts` - Получить ленту постов
+- `POST /api/posts` - Создать пост
+- `POST /api/posts/:id/like` - Лайкнуть пост
+- `POST /api/posts/:id/comment` - Добавить комментарий
+- `POST /api/posts/:id/repost` - Репостнуть
+- `DELETE /api/posts/:id` - Удалить пост
+
+#### Пользователи
+- `GET /api/users/:id` - Получить профиль
+- `GET /api/users/:id/posts` - Получить посты пользователя
+- `POST /api/users/:id/follow` - Подписаться/отписаться
+- `PUT /api/users/profile` - Обновить профиль
+- `GET /api/users/search/:query` - Поиск пользователей
+
+#### Уведомления
+- `GET /api/notifications` - Получить уведомления
+- `PUT /api/notifications/:id/read` - Отметить как прочитанное
+- `PUT /api/notifications/read-all` - Прочитать все
+
+#### Поиск
+- `GET /api/search/furry?query=tags` - Поиск в e621
+- `GET /api/search/anime?query=tags` - Поиск в gelbooru
+- `GET /api/search/furry/tags?query=tag` - Автокомплит тегов e621
+- `GET /api/search/anime/tags?query=tag` - Автокомплит тегов gelbooru
+- `GET /api/search/proxy/:encodedUrl` - Проксирование изображений с e621/gelbooru (для доступа из РФ)
+
+#### Модерация
+- `POST /api/moderation/report` - Создать жалобу
+- `GET /api/moderation/reports` - Получить жалобы (модераторы)
+- `PUT /api/moderation/reports/:id` - Обработать жалобу
+- `PUT /api/moderation/posts/:id/nsfw` - Установить NSFW флаг
+- `PUT /api/moderation/users/:id/ban` - Заблокировать пользователя
+
+## ⚠️ Troubleshooting
+
+### MongoDB не подключается
+```bash
+# Проверить статус
+brew services list # macOS
+sudo systemctl status mongod # Linux
+
+# Проверить порт
+lsof -i :27017
+```
+
+### CORS ошибки
+Убедитесь что `VITE_API_URL` в `frontend/.env` указывает на правильный адрес backend
+
+### Telegram Init Data invalid
+В dev режиме проверка отключена, но для production нужен валидный `TELEGRAM_BOT_TOKEN`
+
+## 📞 Поддержка
+
+Если возникли проблемы:
+1. Проверьте логи: `npm run server`
+2. Откройте DevTools в браузере
+3. Проверьте MongoDB подключение
+4. Убедитесь что все переменные окружения установлены
+
+## 🎉 Готово!
+
+Приложение должно работать! Откройте бота в Telegram и начните использовать NakamaSpace.
+
diff --git a/backend/config/index.js b/backend/config/index.js
new file mode 100644
index 0000000..fa3f1ce
--- /dev/null
+++ b/backend/config/index.js
@@ -0,0 +1,58 @@
+// Централизованная конфигурация приложения
+
+module.exports = {
+ // Сервер
+ port: process.env.PORT || 3000,
+ nodeEnv: process.env.NODE_ENV || 'development',
+
+ // MongoDB
+ mongoUri: process.env.MONGODB_URI || 'mongodb://localhost:27017/nakama',
+
+ // Redis (опционально)
+ redisUrl: process.env.REDIS_URL || null,
+
+ // JWT
+ jwtSecret: process.env.JWT_SECRET || 'nakama_secret_key_change_in_production',
+
+ // Telegram
+ telegramBotToken: process.env.TELEGRAM_BOT_TOKEN,
+
+ // Frontend URL
+ frontendUrl: process.env.FRONTEND_URL || 'http://localhost:5173',
+
+ // CORS
+ corsOrigin: process.env.CORS_ORIGIN || '*',
+
+ // Загрузка файлов
+ maxFileSize: parseInt(process.env.MAX_FILE_SIZE || '10485760'), // 10MB
+ uploadsDir: process.env.UPLOADS_DIR || 'uploads',
+
+ // Rate limiting
+ rateLimits: {
+ general: {
+ windowMs: 15 * 60 * 1000,
+ max: parseInt(process.env.RATE_LIMIT_GENERAL || '100')
+ },
+ posts: {
+ windowMs: 60 * 60 * 1000,
+ max: parseInt(process.env.RATE_LIMIT_POSTS || '10')
+ },
+ interactions: {
+ windowMs: 60 * 1000,
+ max: parseInt(process.env.RATE_LIMIT_INTERACTIONS || '20')
+ }
+ },
+
+ // Cache TTL (seconds)
+ cacheTTL: {
+ posts: parseInt(process.env.CACHE_TTL_POSTS || '300'), // 5 мин
+ users: parseInt(process.env.CACHE_TTL_USERS || '600'), // 10 мин
+ search: parseInt(process.env.CACHE_TTL_SEARCH || '180') // 3 мин
+ },
+
+ // Проверки
+ isDevelopment: () => process.env.NODE_ENV === 'development',
+ isProduction: () => process.env.NODE_ENV === 'production',
+ isTest: () => process.env.NODE_ENV === 'test'
+};
+
diff --git a/backend/middleware/auth.js b/backend/middleware/auth.js
new file mode 100644
index 0000000..4758862
--- /dev/null
+++ b/backend/middleware/auth.js
@@ -0,0 +1,118 @@
+const crypto = require('crypto');
+const User = require('../models/User');
+
+// Проверка Telegram Init Data
+function validateTelegramWebAppData(initData, botToken) {
+ const urlParams = new URLSearchParams(initData);
+ const hash = urlParams.get('hash');
+ urlParams.delete('hash');
+
+ const dataCheckString = Array.from(urlParams.entries())
+ .sort(([a], [b]) => a.localeCompare(b))
+ .map(([key, value]) => `${key}=${value}`)
+ .join('\n');
+
+ const secretKey = crypto
+ .createHmac('sha256', 'WebAppData')
+ .update(botToken)
+ .digest();
+
+ const calculatedHash = crypto
+ .createHmac('sha256', secretKey)
+ .update(dataCheckString)
+ .digest('hex');
+
+ return calculatedHash === hash;
+}
+
+// Middleware для проверки авторизации
+const authenticate = async (req, res, next) => {
+ try {
+ const initData = req.headers['x-telegram-init-data'];
+
+ if (!initData) {
+ return res.status(401).json({ error: 'Не авторизован' });
+ }
+
+ // В dev режиме можно пропустить проверку
+ if (process.env.NODE_ENV === 'development') {
+ // Получаем user из initData
+ const urlParams = new URLSearchParams(initData);
+ const userParam = urlParams.get('user');
+ if (userParam) {
+ const telegramUser = JSON.parse(userParam);
+ req.telegramUser = telegramUser;
+
+ // Найти или создать пользователя
+ let user = await User.findOne({ telegramId: telegramUser.id.toString() });
+ if (!user) {
+ user = new User({
+ telegramId: telegramUser.id.toString(),
+ username: telegramUser.username || telegramUser.first_name,
+ firstName: telegramUser.first_name,
+ lastName: telegramUser.last_name,
+ photoUrl: telegramUser.photo_url
+ });
+ await user.save();
+ }
+ req.user = user;
+ return next();
+ }
+ }
+
+ // Проверка подписи Telegram
+ const isValid = validateTelegramWebAppData(initData, process.env.TELEGRAM_BOT_TOKEN);
+
+ if (!isValid) {
+ return res.status(401).json({ error: 'Неверные данные авторизации' });
+ }
+
+ const urlParams = new URLSearchParams(initData);
+ const userParam = urlParams.get('user');
+ const telegramUser = JSON.parse(userParam);
+
+ req.telegramUser = telegramUser;
+
+ // Найти или создать пользователя
+ let user = await User.findOne({ telegramId: telegramUser.id.toString() });
+ if (!user) {
+ user = new User({
+ telegramId: telegramUser.id.toString(),
+ username: telegramUser.username || telegramUser.first_name,
+ firstName: telegramUser.first_name,
+ lastName: telegramUser.last_name,
+ photoUrl: telegramUser.photo_url
+ });
+ await user.save();
+ }
+
+ req.user = user;
+ next();
+ } catch (error) {
+ console.error('Ошибка авторизации:', error);
+ res.status(401).json({ error: 'Ошибка авторизации' });
+ }
+};
+
+// Middleware для проверки роли модератора
+const requireModerator = (req, res, next) => {
+ if (req.user.role !== 'moderator' && req.user.role !== 'admin') {
+ return res.status(403).json({ error: 'Требуются права модератора' });
+ }
+ next();
+};
+
+// Middleware для проверки роли админа
+const requireAdmin = (req, res, next) => {
+ if (req.user.role !== 'admin') {
+ return res.status(403).json({ error: 'Требуются права администратора' });
+ }
+ next();
+};
+
+module.exports = {
+ authenticate,
+ requireModerator,
+ requireAdmin
+};
+
diff --git a/backend/middleware/cache.js b/backend/middleware/cache.js
new file mode 100644
index 0000000..9ea8359
--- /dev/null
+++ b/backend/middleware/cache.js
@@ -0,0 +1,40 @@
+const cache = require('../utils/redis');
+
+// Middleware для кэширования GET запросов
+const cacheMiddleware = (ttl = 300) => {
+ return async (req, res, next) => {
+ // Кэшировать только GET запросы
+ if (req.method !== 'GET') {
+ return next();
+ }
+
+ if (!cache.isConnected()) {
+ return next();
+ }
+
+ const key = `cache:${req.originalUrl}`;
+
+ try {
+ const cachedData = await cache.get(key);
+
+ if (cachedData) {
+ return res.json(cachedData);
+ }
+
+ // Перехватить res.json для сохранения в кэш
+ const originalJson = res.json.bind(res);
+ res.json = (data) => {
+ cache.set(key, data, ttl);
+ return originalJson(data);
+ };
+
+ next();
+ } catch (error) {
+ console.error('Cache middleware error:', error);
+ next();
+ }
+ };
+};
+
+module.exports = cacheMiddleware;
+
diff --git a/backend/middleware/rateLimiter.js b/backend/middleware/rateLimiter.js
new file mode 100644
index 0000000..ff39190
--- /dev/null
+++ b/backend/middleware/rateLimiter.js
@@ -0,0 +1,48 @@
+const rateLimit = require('express-rate-limit');
+
+// Общий лимит для API
+const generalLimiter = rateLimit({
+ windowMs: 15 * 60 * 1000, // 15 минут
+ max: 100, // 100 запросов
+ message: 'Слишком много запросов, попробуйте позже',
+ standardHeaders: true,
+ legacyHeaders: false,
+});
+
+// Строгий лимит для создания постов
+const postCreationLimiter = rateLimit({
+ windowMs: 60 * 60 * 1000, // 1 час
+ max: 10, // 10 постов в час
+ message: 'Вы создаёте слишком много постов, подождите немного',
+ skipSuccessfulRequests: true,
+});
+
+// Лимит для авторизации
+const authLimiter = rateLimit({
+ windowMs: 15 * 60 * 1000, // 15 минут
+ max: 5, // 5 попыток
+ message: 'Слишком много попыток авторизации',
+});
+
+// Лимит для поиска
+const searchLimiter = rateLimit({
+ windowMs: 60 * 1000, // 1 минута
+ max: 30, // 30 запросов
+ message: 'Слишком много поисковых запросов',
+});
+
+// Лимит для лайков/комментариев (защита от спама)
+const interactionLimiter = rateLimit({
+ windowMs: 60 * 1000, // 1 минута
+ max: 20, // 20 действий
+ message: 'Вы слишком активны, немного подождите',
+});
+
+module.exports = {
+ generalLimiter,
+ postCreationLimiter,
+ authLimiter,
+ searchLimiter,
+ interactionLimiter
+};
+
diff --git a/backend/models/Notification.js b/backend/models/Notification.js
new file mode 100644
index 0000000..981112a
--- /dev/null
+++ b/backend/models/Notification.js
@@ -0,0 +1,34 @@
+const mongoose = require('mongoose');
+
+const NotificationSchema = new mongoose.Schema({
+ recipient: {
+ type: mongoose.Schema.Types.ObjectId,
+ ref: 'User',
+ required: true
+ },
+ sender: {
+ type: mongoose.Schema.Types.ObjectId,
+ ref: 'User',
+ required: true
+ },
+ type: {
+ type: String,
+ enum: ['follow', 'like', 'comment', 'repost', 'mention'],
+ required: true
+ },
+ post: {
+ type: mongoose.Schema.Types.ObjectId,
+ ref: 'Post'
+ },
+ read: {
+ type: Boolean,
+ default: false
+ },
+ createdAt: {
+ type: Date,
+ default: Date.now
+ }
+});
+
+module.exports = mongoose.model('Notification', NotificationSchema);
+
diff --git a/backend/models/Post.js b/backend/models/Post.js
new file mode 100644
index 0000000..12a9eb3
--- /dev/null
+++ b/backend/models/Post.js
@@ -0,0 +1,72 @@
+const mongoose = require('mongoose');
+
+const CommentSchema = new mongoose.Schema({
+ author: {
+ type: mongoose.Schema.Types.ObjectId,
+ ref: 'User',
+ required: true
+ },
+ content: {
+ type: String,
+ required: true,
+ maxlength: 500
+ },
+ createdAt: {
+ type: Date,
+ default: Date.now
+ }
+});
+
+const PostSchema = new mongoose.Schema({
+ author: {
+ type: mongoose.Schema.Types.ObjectId,
+ ref: 'User',
+ required: true
+ },
+ content: {
+ type: String,
+ maxlength: 2000
+ },
+ hashtags: [{
+ type: String,
+ lowercase: true,
+ trim: true
+ }],
+ imageUrl: String,
+ tags: [{
+ type: String,
+ enum: ['furry', 'anime', 'other'],
+ required: true
+ }],
+ mentionedUsers: [{
+ type: mongoose.Schema.Types.ObjectId,
+ ref: 'User'
+ }],
+ isNSFW: {
+ type: Boolean,
+ default: false
+ },
+ likes: [{
+ type: mongoose.Schema.Types.ObjectId,
+ ref: 'User'
+ }],
+ comments: [CommentSchema],
+ reposts: [{
+ type: mongoose.Schema.Types.ObjectId,
+ ref: 'User'
+ }],
+ views: {
+ type: Number,
+ default: 0
+ },
+ createdAt: {
+ type: Date,
+ default: Date.now
+ }
+});
+
+// Текстовый индекс для поиска
+PostSchema.index({ content: 'text', hashtags: 'text' });
+
+module.exports = mongoose.model('Post', PostSchema);
+
diff --git a/backend/models/Report.js b/backend/models/Report.js
new file mode 100644
index 0000000..8b0d03a
--- /dev/null
+++ b/backend/models/Report.js
@@ -0,0 +1,35 @@
+const mongoose = require('mongoose');
+
+const ReportSchema = new mongoose.Schema({
+ reporter: {
+ type: mongoose.Schema.Types.ObjectId,
+ ref: 'User',
+ required: true
+ },
+ post: {
+ type: mongoose.Schema.Types.ObjectId,
+ ref: 'Post',
+ required: true
+ },
+ reason: {
+ type: String,
+ required: true,
+ maxlength: 500
+ },
+ status: {
+ type: String,
+ enum: ['pending', 'reviewed', 'resolved', 'dismissed'],
+ default: 'pending'
+ },
+ reviewedBy: {
+ type: mongoose.Schema.Types.ObjectId,
+ ref: 'User'
+ },
+ createdAt: {
+ type: Date,
+ default: Date.now
+ }
+});
+
+module.exports = mongoose.model('Report', ReportSchema);
+
diff --git a/backend/models/User.js b/backend/models/User.js
new file mode 100644
index 0000000..04ef57e
--- /dev/null
+++ b/backend/models/User.js
@@ -0,0 +1,58 @@
+const mongoose = require('mongoose');
+
+const UserSchema = new mongoose.Schema({
+ telegramId: {
+ type: String,
+ required: true,
+ unique: true
+ },
+ username: {
+ type: String,
+ required: true
+ },
+ firstName: String,
+ lastName: String,
+ photoUrl: String,
+ bio: {
+ type: String,
+ default: '',
+ maxlength: 300
+ },
+ role: {
+ type: String,
+ enum: ['user', 'moderator', 'admin'],
+ default: 'user'
+ },
+ followers: [{
+ type: mongoose.Schema.Types.ObjectId,
+ ref: 'User'
+ }],
+ following: [{
+ type: mongoose.Schema.Types.ObjectId,
+ ref: 'User'
+ }],
+ settings: {
+ whitelist: {
+ noFurry: { type: Boolean, default: false },
+ onlyAnime: { type: Boolean, default: false },
+ noNSFW: { type: Boolean, default: false }
+ },
+ searchPreference: {
+ type: String,
+ enum: ['furry', 'anime', 'mixed'],
+ default: 'mixed'
+ }
+ },
+ banned: {
+ type: Boolean,
+ default: false
+ },
+ bannedUntil: Date,
+ createdAt: {
+ type: Date,
+ default: Date.now
+ }
+});
+
+module.exports = mongoose.model('User', UserSchema);
+
diff --git a/backend/routes/auth.js b/backend/routes/auth.js
new file mode 100644
index 0000000..a00fed5
--- /dev/null
+++ b/backend/routes/auth.js
@@ -0,0 +1,37 @@
+const express = require('express');
+const router = express.Router();
+const { authenticate } = require('../middleware/auth');
+
+// Проверка авторизации и получение данных пользователя
+router.post('/verify', authenticate, async (req, res) => {
+ try {
+ const user = await req.user.populate([
+ { path: 'followers', select: 'username firstName lastName photoUrl' },
+ { path: 'following', select: 'username firstName lastName photoUrl' }
+ ]);
+
+ res.json({
+ success: true,
+ user: {
+ id: user._id,
+ telegramId: user.telegramId,
+ username: user.username,
+ firstName: user.firstName,
+ lastName: user.lastName,
+ photoUrl: user.photoUrl,
+ bio: user.bio,
+ role: user.role,
+ followersCount: user.followers.length,
+ followingCount: user.following.length,
+ settings: user.settings,
+ banned: user.banned
+ }
+ });
+ } catch (error) {
+ console.error('Ошибка verify:', error);
+ res.status(500).json({ error: 'Ошибка сервера' });
+ }
+});
+
+module.exports = router;
+
diff --git a/backend/routes/moderation.js b/backend/routes/moderation.js
new file mode 100644
index 0000000..1423257
--- /dev/null
+++ b/backend/routes/moderation.js
@@ -0,0 +1,166 @@
+const express = require('express');
+const router = express.Router();
+const { authenticate, requireModerator } = require('../middleware/auth');
+const Report = require('../models/Report');
+const Post = require('../models/Post');
+const User = require('../models/User');
+
+// Создать репорт
+router.post('/report', authenticate, async (req, res) => {
+ try {
+ const { postId, reason } = req.body;
+
+ if (!postId || !reason) {
+ return res.status(400).json({ error: 'postId и reason обязательны' });
+ }
+
+ const post = await Post.findById(postId);
+ if (!post) {
+ return res.status(404).json({ error: 'Пост не найден' });
+ }
+
+ const report = new Report({
+ reporter: req.user._id,
+ post: postId,
+ reason
+ });
+
+ await report.save();
+
+ res.status(201).json({
+ message: 'Жалоба отправлена',
+ report
+ });
+ } catch (error) {
+ console.error('Ошибка создания репорта:', error);
+ res.status(500).json({ error: 'Ошибка сервера' });
+ }
+});
+
+// Получить все репорты (только модераторы)
+router.get('/reports', authenticate, requireModerator, async (req, res) => {
+ try {
+ const { status = 'pending', page = 1, limit = 20 } = req.query;
+
+ const query = status === 'all' ? {} : { status };
+
+ const reports = await Report.find(query)
+ .populate('reporter', 'username firstName lastName')
+ .populate('post')
+ .populate('reviewedBy', 'username firstName lastName')
+ .sort({ createdAt: -1 })
+ .limit(limit * 1)
+ .skip((page - 1) * limit)
+ .exec();
+
+ const count = await Report.countDocuments(query);
+
+ res.json({
+ reports,
+ totalPages: Math.ceil(count / limit),
+ currentPage: page
+ });
+ } catch (error) {
+ console.error('Ошибка получения репортов:', error);
+ res.status(500).json({ error: 'Ошибка сервера' });
+ }
+});
+
+// Обработать репорт (только модераторы)
+router.put('/reports/:id', authenticate, requireModerator, async (req, res) => {
+ try {
+ const { status, action } = req.body; // action: 'delete_post', 'ban_user', 'dismiss'
+
+ const report = await Report.findById(req.params.id).populate('post');
+
+ if (!report) {
+ return res.status(404).json({ error: 'Репорт не найден' });
+ }
+
+ report.status = status || 'reviewed';
+ report.reviewedBy = req.user._id;
+
+ // Выполнить действие
+ if (action === 'delete_post' && report.post) {
+ await Post.findByIdAndDelete(report.post._id);
+ report.status = 'resolved';
+ } else if (action === 'ban_user' && report.post) {
+ const author = await User.findById(report.post.author);
+ if (author) {
+ author.banned = true;
+ author.bannedUntil = new Date(Date.now() + 7 * 24 * 60 * 60 * 1000); // 7 дней
+ await author.save();
+ }
+ report.status = 'resolved';
+ } else if (action === 'dismiss') {
+ report.status = 'dismissed';
+ }
+
+ await report.save();
+
+ res.json({
+ message: 'Репорт обработан',
+ report
+ });
+ } catch (error) {
+ console.error('Ошибка обработки репорта:', error);
+ res.status(500).json({ error: 'Ошибка сервера' });
+ }
+});
+
+// Установить NSFW флаг (модераторы)
+router.put('/posts/:id/nsfw', authenticate, requireModerator, async (req, res) => {
+ try {
+ const { isNSFW } = req.body;
+
+ const post = await Post.findById(req.params.id);
+
+ if (!post) {
+ return res.status(404).json({ error: 'Пост не найден' });
+ }
+
+ post.isNSFW = isNSFW;
+ await post.save();
+
+ res.json({
+ message: 'NSFW статус обновлен',
+ post
+ });
+ } catch (error) {
+ console.error('Ошибка обновления NSFW:', error);
+ res.status(500).json({ error: 'Ошибка сервера' });
+ }
+});
+
+// Заблокировать/разблокировать пользователя (модераторы)
+router.put('/users/:id/ban', authenticate, requireModerator, async (req, res) => {
+ try {
+ const { banned, days } = req.body;
+
+ const user = await User.findById(req.params.id);
+
+ if (!user) {
+ return res.status(404).json({ error: 'Пользователь не найден' });
+ }
+
+ user.banned = banned;
+ if (banned && days) {
+ user.bannedUntil = new Date(Date.now() + days * 24 * 60 * 60 * 1000);
+ } else {
+ user.bannedUntil = null;
+ }
+
+ await user.save();
+
+ res.json({
+ message: banned ? 'Пользователь заблокирован' : 'Пользователь разблокирован',
+ user
+ });
+ } catch (error) {
+ console.error('Ошибка блокировки пользователя:', error);
+ res.status(500).json({ error: 'Ошибка сервера' });
+ }
+});
+
+module.exports = router;
+
diff --git a/backend/routes/notifications.js b/backend/routes/notifications.js
new file mode 100644
index 0000000..850c100
--- /dev/null
+++ b/backend/routes/notifications.js
@@ -0,0 +1,75 @@
+const express = require('express');
+const router = express.Router();
+const { authenticate } = require('../middleware/auth');
+const Notification = require('../models/Notification');
+
+// Получить уведомления пользователя
+router.get('/', authenticate, async (req, res) => {
+ try {
+ const { page = 1, limit = 50 } = req.query;
+
+ const notifications = await Notification.find({ recipient: req.user._id })
+ .populate('sender', 'username firstName lastName photoUrl')
+ .populate('post', 'content imageUrl')
+ .sort({ createdAt: -1 })
+ .limit(limit * 1)
+ .skip((page - 1) * limit)
+ .exec();
+
+ const count = await Notification.countDocuments({ recipient: req.user._id });
+ const unreadCount = await Notification.countDocuments({
+ recipient: req.user._id,
+ read: false
+ });
+
+ res.json({
+ notifications,
+ totalPages: Math.ceil(count / limit),
+ currentPage: page,
+ unreadCount
+ });
+ } catch (error) {
+ console.error('Ошибка получения уведомлений:', error);
+ res.status(500).json({ error: 'Ошибка сервера' });
+ }
+});
+
+// Отметить уведомление как прочитанное
+router.put('/:id/read', authenticate, async (req, res) => {
+ try {
+ const notification = await Notification.findOne({
+ _id: req.params.id,
+ recipient: req.user._id
+ });
+
+ if (!notification) {
+ return res.status(404).json({ error: 'Уведомление не найдено' });
+ }
+
+ notification.read = true;
+ await notification.save();
+
+ res.json({ message: 'Уведомление прочитано' });
+ } catch (error) {
+ console.error('Ошибка обновления уведомления:', error);
+ res.status(500).json({ error: 'Ошибка сервера' });
+ }
+});
+
+// Отметить все уведомления как прочитанные
+router.put('/read-all', authenticate, async (req, res) => {
+ try {
+ await Notification.updateMany(
+ { recipient: req.user._id, read: false },
+ { read: true }
+ );
+
+ res.json({ message: 'Все уведомления прочитаны' });
+ } catch (error) {
+ console.error('Ошибка обновления уведомлений:', error);
+ res.status(500).json({ error: 'Ошибка сервера' });
+ }
+});
+
+module.exports = router;
+
diff --git a/backend/routes/postSearch.js b/backend/routes/postSearch.js
new file mode 100644
index 0000000..10d046a
--- /dev/null
+++ b/backend/routes/postSearch.js
@@ -0,0 +1,125 @@
+const express = require('express');
+const router = express.Router();
+const { authenticate } = require('../middleware/auth');
+const { searchLimiter } = require('../middleware/rateLimiter');
+const Post = require('../models/Post');
+
+// Поиск постов по тексту и хэштегам
+router.get('/', authenticate, searchLimiter, async (req, res) => {
+ try {
+ const { query, hashtag, page = 1, limit = 20 } = req.query;
+
+ let searchQuery = {};
+
+ // Применить whitelist настройки пользователя
+ if (req.user.settings.whitelist.noFurry) {
+ searchQuery.tags = { $ne: 'furry' };
+ }
+ if (req.user.settings.whitelist.onlyAnime) {
+ searchQuery.tags = 'anime';
+ }
+ if (req.user.settings.whitelist.noNSFW) {
+ searchQuery.isNSFW = false;
+ }
+
+ // Поиск по хэштегу
+ if (hashtag) {
+ searchQuery.hashtags = hashtag.toLowerCase();
+ }
+ // Полнотекстовый поиск
+ else if (query) {
+ searchQuery.$text = { $search: query };
+ } else {
+ return res.status(400).json({ error: 'Параметр query или hashtag обязателен' });
+ }
+
+ const posts = await Post.find(searchQuery)
+ .populate('author', 'username firstName lastName photoUrl')
+ .populate('mentionedUsers', 'username firstName lastName')
+ .populate('comments.author', 'username firstName lastName photoUrl')
+ .sort(query ? { score: { $meta: 'textScore' } } : { createdAt: -1 })
+ .limit(limit * 1)
+ .skip((page - 1) * limit)
+ .exec();
+
+ const count = await Post.countDocuments(searchQuery);
+
+ res.json({
+ posts,
+ totalPages: Math.ceil(count / limit),
+ currentPage: page
+ });
+ } catch (error) {
+ console.error('Ошибка поиска постов:', error);
+ res.status(500).json({ error: 'Ошибка сервера' });
+ }
+});
+
+// Получить популярные хэштеги
+router.get('/trending-hashtags', authenticate, async (req, res) => {
+ try {
+ const { limit = 20 } = req.query;
+
+ const hashtags = await Post.aggregate([
+ { $unwind: '$hashtags' },
+ { $group: { _id: '$hashtags', count: { $sum: 1 } } },
+ { $sort: { count: -1 } },
+ { $limit: parseInt(limit) }
+ ]);
+
+ res.json({
+ hashtags: hashtags.map(h => ({
+ tag: h._id,
+ count: h.count
+ }))
+ });
+ } catch (error) {
+ console.error('Ошибка получения трендовых хэштегов:', error);
+ res.status(500).json({ error: 'Ошибка сервера' });
+ }
+});
+
+// Получить посты по хэштегу
+router.get('/hashtag/:tag', authenticate, async (req, res) => {
+ try {
+ const { page = 1, limit = 20 } = req.query;
+ const hashtag = req.params.tag.toLowerCase();
+
+ const query = { hashtags: hashtag };
+
+ // Применить whitelist настройки пользователя
+ if (req.user.settings.whitelist.noFurry) {
+ query.tags = { $ne: 'furry' };
+ }
+ if (req.user.settings.whitelist.onlyAnime) {
+ query.tags = 'anime';
+ }
+ if (req.user.settings.whitelist.noNSFW) {
+ query.isNSFW = false;
+ }
+
+ const posts = await Post.find(query)
+ .populate('author', 'username firstName lastName photoUrl')
+ .populate('mentionedUsers', 'username firstName lastName')
+ .populate('comments.author', 'username firstName lastName photoUrl')
+ .sort({ createdAt: -1 })
+ .limit(limit * 1)
+ .skip((page - 1) * limit)
+ .exec();
+
+ const count = await Post.countDocuments(query);
+
+ res.json({
+ hashtag,
+ posts,
+ totalPages: Math.ceil(count / limit),
+ currentPage: page
+ });
+ } catch (error) {
+ console.error('Ошибка получения постов по хэштегу:', error);
+ res.status(500).json({ error: 'Ошибка сервера' });
+ }
+});
+
+module.exports = router;
+
diff --git a/backend/routes/posts.js b/backend/routes/posts.js
new file mode 100644
index 0000000..c6bc5ec
--- /dev/null
+++ b/backend/routes/posts.js
@@ -0,0 +1,284 @@
+const express = require('express');
+const router = express.Router();
+const multer = require('multer');
+const path = require('path');
+const fs = require('fs');
+const { authenticate } = require('../middleware/auth');
+const { postCreationLimiter, interactionLimiter } = require('../middleware/rateLimiter');
+const { searchLimiter } = require('../middleware/rateLimiter');
+const Post = require('../models/Post');
+const Notification = require('../models/Notification');
+const { extractHashtags } = require('../utils/hashtags');
+
+// Настройка multer для загрузки изображений
+const storage = multer.diskStorage({
+ destination: (req, file, cb) => {
+ const dir = path.join(__dirname, '../uploads/posts');
+ if (!fs.existsSync(dir)) {
+ fs.mkdirSync(dir, { recursive: true });
+ }
+ cb(null, dir);
+ },
+ filename: (req, file, cb) => {
+ const uniqueSuffix = Date.now() + '-' + Math.round(Math.random() * 1E9);
+ cb(null, uniqueSuffix + path.extname(file.originalname));
+ }
+});
+
+const upload = multer({
+ storage: storage,
+ limits: { fileSize: 10 * 1024 * 1024 }, // 10MB
+ fileFilter: (req, file, cb) => {
+ const allowedTypes = /jpeg|jpg|png|gif|webp/;
+ const extname = allowedTypes.test(path.extname(file.originalname).toLowerCase());
+ const mimetype = allowedTypes.test(file.mimetype);
+
+ if (mimetype && extname) {
+ return cb(null, true);
+ } else {
+ cb(new Error('Только изображения разрешены'));
+ }
+ }
+});
+
+// Получить ленту постов
+router.get('/', authenticate, async (req, res) => {
+ try {
+ const { page = 1, limit = 20, tag, userId } = req.query;
+ const query = {};
+
+ // Фильтр по тегу
+ if (tag) {
+ query.tags = tag;
+ }
+
+ // Фильтр по пользователю
+ if (userId) {
+ query.author = userId;
+ }
+
+ // Применить whitelist настройки пользователя
+ if (req.user.settings.whitelist.noFurry) {
+ query.tags = { $ne: 'furry' };
+ }
+ if (req.user.settings.whitelist.onlyAnime) {
+ query.tags = 'anime';
+ }
+ if (req.user.settings.whitelist.noNSFW) {
+ query.isNSFW = false;
+ }
+
+ const posts = await Post.find(query)
+ .populate('author', 'username firstName lastName photoUrl')
+ .populate('mentionedUsers', 'username firstName lastName')
+ .populate('comments.author', 'username firstName lastName photoUrl')
+ .sort({ createdAt: -1 })
+ .limit(limit * 1)
+ .skip((page - 1) * limit)
+ .exec();
+
+ const count = await Post.countDocuments(query);
+
+ res.json({
+ posts,
+ totalPages: Math.ceil(count / limit),
+ currentPage: page
+ });
+ } catch (error) {
+ console.error('Ошибка получения постов:', error);
+ res.status(500).json({ error: 'Ошибка сервера' });
+ }
+});
+
+// Создать пост
+router.post('/', authenticate, postCreationLimiter, upload.single('image'), async (req, res) => {
+ try {
+ const { content, tags, mentionedUsers, isNSFW } = req.body;
+
+ // Проверка тегов
+ const parsedTags = JSON.parse(tags || '[]');
+ if (!parsedTags.length) {
+ return res.status(400).json({ error: 'Теги обязательны' });
+ }
+
+ // Извлечь хэштеги из контента
+ const hashtags = extractHashtags(content);
+
+ const post = new Post({
+ author: req.user._id,
+ content,
+ imageUrl: req.file ? `/uploads/posts/${req.file.filename}` : null,
+ tags: parsedTags,
+ hashtags,
+ mentionedUsers: mentionedUsers ? JSON.parse(mentionedUsers) : [],
+ isNSFW: isNSFW === 'true'
+ });
+
+ await post.save();
+ await post.populate('author', 'username firstName lastName photoUrl');
+
+ // Создать уведомления для упомянутых пользователей
+ if (post.mentionedUsers.length > 0) {
+ const notifications = post.mentionedUsers.map(userId => ({
+ recipient: userId,
+ sender: req.user._id,
+ type: 'mention',
+ post: post._id
+ }));
+ await Notification.insertMany(notifications);
+ }
+
+ res.status(201).json({ post });
+ } catch (error) {
+ console.error('Ошибка создания поста:', error);
+ res.status(500).json({ error: 'Ошибка создания поста' });
+ }
+});
+
+// Лайкнуть пост
+router.post('/:id/like', authenticate, interactionLimiter, async (req, res) => {
+ try {
+ const post = await Post.findById(req.params.id);
+
+ if (!post) {
+ return res.status(404).json({ error: 'Пост не найден' });
+ }
+
+ const alreadyLiked = post.likes.includes(req.user._id);
+
+ if (alreadyLiked) {
+ // Убрать лайк
+ post.likes = post.likes.filter(id => !id.equals(req.user._id));
+ } else {
+ // Добавить лайк
+ post.likes.push(req.user._id);
+
+ // Создать уведомление
+ if (!post.author.equals(req.user._id)) {
+ const notification = new Notification({
+ recipient: post.author,
+ sender: req.user._id,
+ type: 'like',
+ post: post._id
+ });
+ await notification.save();
+ }
+ }
+
+ await post.save();
+ res.json({ likes: post.likes.length, liked: !alreadyLiked });
+ } catch (error) {
+ console.error('Ошибка лайка:', error);
+ res.status(500).json({ error: 'Ошибка сервера' });
+ }
+});
+
+// Добавить комментарий
+router.post('/:id/comment', authenticate, interactionLimiter, async (req, res) => {
+ try {
+ const { content } = req.body;
+
+ if (!content || content.trim().length === 0) {
+ return res.status(400).json({ error: 'Комментарий не может быть пустым' });
+ }
+
+ const post = await Post.findById(req.params.id);
+
+ if (!post) {
+ return res.status(404).json({ error: 'Пост не найден' });
+ }
+
+ post.comments.push({
+ author: req.user._id,
+ content
+ });
+
+ await post.save();
+ await post.populate('comments.author', 'username firstName lastName photoUrl');
+
+ // Создать уведомление
+ if (!post.author.equals(req.user._id)) {
+ const notification = new Notification({
+ recipient: post.author,
+ sender: req.user._id,
+ type: 'comment',
+ post: post._id
+ });
+ await notification.save();
+ }
+
+ res.json({ comments: post.comments });
+ } catch (error) {
+ console.error('Ошибка комментария:', error);
+ res.status(500).json({ error: 'Ошибка сервера' });
+ }
+});
+
+// Репостнуть
+router.post('/:id/repost', authenticate, async (req, res) => {
+ try {
+ const post = await Post.findById(req.params.id);
+
+ if (!post) {
+ return res.status(404).json({ error: 'Пост не найден' });
+ }
+
+ const alreadyReposted = post.reposts.includes(req.user._id);
+
+ if (alreadyReposted) {
+ post.reposts = post.reposts.filter(id => !id.equals(req.user._id));
+ } else {
+ post.reposts.push(req.user._id);
+
+ // Создать уведомление
+ if (!post.author.equals(req.user._id)) {
+ const notification = new Notification({
+ recipient: post.author,
+ sender: req.user._id,
+ type: 'repost',
+ post: post._id
+ });
+ await notification.save();
+ }
+ }
+
+ await post.save();
+ res.json({ reposts: post.reposts.length, reposted: !alreadyReposted });
+ } catch (error) {
+ console.error('Ошибка репоста:', error);
+ res.status(500).json({ error: 'Ошибка сервера' });
+ }
+});
+
+// Удалить пост (автор или модератор)
+router.delete('/:id', authenticate, async (req, res) => {
+ try {
+ const post = await Post.findById(req.params.id);
+
+ if (!post) {
+ return res.status(404).json({ error: 'Пост не найден' });
+ }
+
+ // Проверить права
+ if (!post.author.equals(req.user._id) && req.user.role !== 'moderator' && req.user.role !== 'admin') {
+ return res.status(403).json({ error: 'Нет прав на удаление' });
+ }
+
+ // Удалить изображение если есть
+ if (post.imageUrl) {
+ const imagePath = path.join(__dirname, '..', post.imageUrl);
+ if (fs.existsSync(imagePath)) {
+ fs.unlinkSync(imagePath);
+ }
+ }
+
+ await Post.findByIdAndDelete(req.params.id);
+ res.json({ message: 'Пост удален' });
+ } catch (error) {
+ console.error('Ошибка удаления поста:', error);
+ res.status(500).json({ error: 'Ошибка сервера' });
+ }
+});
+
+module.exports = router;
+
diff --git a/backend/routes/search.js b/backend/routes/search.js
new file mode 100644
index 0000000..1903633
--- /dev/null
+++ b/backend/routes/search.js
@@ -0,0 +1,207 @@
+const express = require('express');
+const router = express.Router();
+const axios = require('axios');
+const { authenticate } = require('../middleware/auth');
+
+// Функция для создания прокси URL
+function createProxyUrl(originalUrl) {
+ if (!originalUrl) return null;
+
+ // Кодируем URL в base64
+ const encodedUrl = Buffer.from(originalUrl).toString('base64');
+ return `/api/search/proxy/${encodedUrl}`;
+}
+
+// Эндпоинт для проксирования изображений
+router.get('/proxy/:encodedUrl', async (req, res) => {
+ try {
+ const { encodedUrl } = req.params;
+
+ // Декодируем URL
+ const originalUrl = Buffer.from(encodedUrl, 'base64').toString('utf-8');
+
+ // Проверяем, что URL от разрешенных доменов
+ const allowedDomains = [
+ 'e621.net',
+ 'static1.e621.net',
+ 'gelbooru.com',
+ 'img3.gelbooru.com',
+ 'img2.gelbooru.com',
+ 'img1.gelbooru.com',
+ 'simg3.gelbooru.com',
+ 'simg4.gelbooru.com'
+ ];
+ const urlObj = new URL(originalUrl);
+
+ if (!allowedDomains.some(domain => urlObj.hostname.includes(domain))) {
+ return res.status(403).json({ error: 'Запрещенный домен' });
+ }
+
+ // Запрашиваем изображение
+ const response = await axios.get(originalUrl, {
+ responseType: 'stream',
+ headers: {
+ 'User-Agent': 'NakamaSpace/1.0',
+ 'Referer': urlObj.origin
+ },
+ timeout: 30000 // 30 секунд таймаут
+ });
+
+ // Копируем заголовки
+ res.setHeader('Content-Type', response.headers['content-type']);
+ res.setHeader('Cache-Control', 'public, max-age=86400'); // Кешируем на 24 часа
+
+ if (response.headers['content-length']) {
+ res.setHeader('Content-Length', response.headers['content-length']);
+ }
+
+ // Стримим изображение
+ response.data.pipe(res);
+ } catch (error) {
+ console.error('Ошибка проксирования изображения:', error.message);
+ res.status(500).json({ error: 'Ошибка загрузки изображения' });
+ }
+});
+
+// e621 API поиск
+router.get('/furry', authenticate, async (req, res) => {
+ try {
+ const { query, limit = 50, page = 1 } = req.query;
+
+ if (!query) {
+ return res.status(400).json({ error: 'Параметр query обязателен' });
+ }
+
+ const response = await axios.get('https://e621.net/posts.json', {
+ params: {
+ tags: query,
+ limit,
+ page
+ },
+ headers: {
+ 'User-Agent': 'NakamaSpace/1.0'
+ }
+ });
+
+ const posts = response.data.posts.map(post => ({
+ id: post.id,
+ url: createProxyUrl(post.file.url),
+ preview: createProxyUrl(post.preview.url),
+ tags: post.tags.general,
+ rating: post.rating,
+ score: post.score.total,
+ source: 'e621'
+ }));
+
+ res.json({ posts });
+ } catch (error) {
+ console.error('Ошибка e621 API:', error);
+ res.status(500).json({ error: 'Ошибка поиска' });
+ }
+});
+
+// Gelbooru API поиск
+router.get('/anime', authenticate, async (req, res) => {
+ try {
+ const { query, limit = 50, page = 1 } = req.query;
+
+ if (!query) {
+ return res.status(400).json({ error: 'Параметр query обязателен' });
+ }
+
+ const response = await axios.get('https://gelbooru.com/index.php', {
+ params: {
+ page: 'dapi',
+ s: 'post',
+ q: 'index',
+ json: 1,
+ tags: query,
+ limit,
+ pid: page
+ }
+ });
+
+ const posts = (response.data.post || []).map(post => ({
+ id: post.id,
+ url: createProxyUrl(post.file_url),
+ preview: createProxyUrl(post.preview_url),
+ tags: post.tags ? post.tags.split(' ') : [],
+ rating: post.rating,
+ score: post.score,
+ source: 'gelbooru'
+ }));
+
+ res.json({ posts });
+ } catch (error) {
+ console.error('Ошибка Gelbooru API:', error);
+ res.status(500).json({ error: 'Ошибка поиска' });
+ }
+});
+
+// Автокомплит тегов для e621
+router.get('/furry/tags', authenticate, async (req, res) => {
+ try {
+ const { query } = req.query;
+
+ if (!query || query.length < 2) {
+ return res.json({ tags: [] });
+ }
+
+ const response = await axios.get('https://e621.net/tags.json', {
+ params: {
+ 'search[name_matches]': `${query}*`,
+ 'search[order]': 'count',
+ limit: 10
+ },
+ headers: {
+ 'User-Agent': 'NakamaSpace/1.0'
+ }
+ });
+
+ const tags = response.data.map(tag => ({
+ name: tag.name,
+ count: tag.post_count
+ }));
+
+ res.json({ tags });
+ } catch (error) {
+ console.error('Ошибка получения тегов:', error);
+ res.status(500).json({ error: 'Ошибка получения тегов' });
+ }
+});
+
+// Автокомплит тегов для Gelbooru
+router.get('/anime/tags', authenticate, async (req, res) => {
+ try {
+ const { query } = req.query;
+
+ if (!query || query.length < 2) {
+ return res.json({ tags: [] });
+ }
+
+ const response = await axios.get('https://gelbooru.com/index.php', {
+ params: {
+ page: 'dapi',
+ s: 'tag',
+ q: 'index',
+ json: 1,
+ name_pattern: `${query}%`,
+ orderby: 'count',
+ limit: 10
+ }
+ });
+
+ const tags = (response.data.tag || []).map(tag => ({
+ name: tag.name,
+ count: tag.count
+ }));
+
+ res.json({ tags });
+ } catch (error) {
+ console.error('Ошибка получения тегов:', error);
+ res.status(500).json({ error: 'Ошибка получения тегов' });
+ }
+});
+
+module.exports = router;
+
diff --git a/backend/routes/statistics.js b/backend/routes/statistics.js
new file mode 100644
index 0000000..357b7f4
--- /dev/null
+++ b/backend/routes/statistics.js
@@ -0,0 +1,52 @@
+const express = require('express');
+const router = express.Router();
+const { authenticate } = require('../middleware/auth');
+const { getUserStatistics, getUserTopPosts } = require('../utils/statistics');
+
+// Получить статистику своего профиля
+router.get('/me', authenticate, async (req, res) => {
+ try {
+ const stats = await getUserStatistics(req.user._id);
+
+ if (!stats) {
+ return res.status(404).json({ error: 'Статистика не найдена' });
+ }
+
+ res.json(stats);
+ } catch (error) {
+ console.error('Ошибка получения статистики:', error);
+ res.status(500).json({ error: 'Ошибка сервера' });
+ }
+});
+
+// Получить статистику другого пользователя
+router.get('/user/:id', authenticate, async (req, res) => {
+ try {
+ const stats = await getUserStatistics(req.params.id);
+
+ if (!stats) {
+ return res.status(404).json({ error: 'Статистика не найдена' });
+ }
+
+ res.json(stats);
+ } catch (error) {
+ console.error('Ошибка получения статистики:', error);
+ res.status(500).json({ error: 'Ошибка сервера' });
+ }
+});
+
+// Получить топ посты
+router.get('/top-posts/:userId', authenticate, async (req, res) => {
+ try {
+ const { limit = 5 } = req.query;
+ const topPosts = await getUserTopPosts(req.params.userId, parseInt(limit));
+
+ res.json({ topPosts });
+ } catch (error) {
+ console.error('Ошибка получения топ постов:', error);
+ res.status(500).json({ error: 'Ошибка сервера' });
+ }
+});
+
+module.exports = router;
+
diff --git a/backend/routes/users.js b/backend/routes/users.js
new file mode 100644
index 0000000..c34e19e
--- /dev/null
+++ b/backend/routes/users.js
@@ -0,0 +1,160 @@
+const express = require('express');
+const router = express.Router();
+const { authenticate } = require('../middleware/auth');
+const User = require('../models/User');
+const Post = require('../models/Post');
+const Notification = require('../models/Notification');
+
+// Получить профиль пользователя
+router.get('/:id', authenticate, async (req, res) => {
+ try {
+ const user = await User.findById(req.params.id)
+ .select('-__v')
+ .populate('followers', 'username firstName lastName photoUrl')
+ .populate('following', 'username firstName lastName photoUrl');
+
+ if (!user) {
+ return res.status(404).json({ error: 'Пользователь не найден' });
+ }
+
+ // Проверить подписку текущего пользователя
+ const isFollowing = user.followers.some(f => f._id.equals(req.user._id));
+
+ res.json({
+ user: {
+ id: user._id,
+ username: user.username,
+ firstName: user.firstName,
+ lastName: user.lastName,
+ photoUrl: user.photoUrl,
+ bio: user.bio,
+ followersCount: user.followers.length,
+ followingCount: user.following.length,
+ isFollowing,
+ createdAt: user.createdAt
+ }
+ });
+ } catch (error) {
+ console.error('Ошибка получения профиля:', error);
+ res.status(500).json({ error: 'Ошибка сервера' });
+ }
+});
+
+// Получить посты пользователя
+router.get('/:id/posts', authenticate, async (req, res) => {
+ try {
+ const { page = 1, limit = 20 } = req.query;
+
+ const posts = await Post.find({ author: req.params.id })
+ .populate('author', 'username firstName lastName photoUrl')
+ .sort({ createdAt: -1 })
+ .limit(limit * 1)
+ .skip((page - 1) * limit)
+ .exec();
+
+ const count = await Post.countDocuments({ author: req.params.id });
+
+ res.json({
+ posts,
+ totalPages: Math.ceil(count / limit),
+ currentPage: page
+ });
+ } catch (error) {
+ console.error('Ошибка получения постов:', error);
+ res.status(500).json({ error: 'Ошибка сервера' });
+ }
+});
+
+// Подписаться / отписаться
+router.post('/:id/follow', authenticate, async (req, res) => {
+ try {
+ if (req.params.id === req.user._id.toString()) {
+ return res.status(400).json({ error: 'Нельзя подписаться на себя' });
+ }
+
+ const targetUser = await User.findById(req.params.id);
+
+ if (!targetUser) {
+ return res.status(404).json({ error: 'Пользователь не найден' });
+ }
+
+ const isFollowing = targetUser.followers.includes(req.user._id);
+
+ if (isFollowing) {
+ // Отписаться
+ targetUser.followers = targetUser.followers.filter(id => !id.equals(req.user._id));
+ req.user.following = req.user.following.filter(id => !id.equals(targetUser._id));
+ } else {
+ // Подписаться
+ targetUser.followers.push(req.user._id);
+ req.user.following.push(targetUser._id);
+
+ // Создать уведомление
+ const notification = new Notification({
+ recipient: targetUser._id,
+ sender: req.user._id,
+ type: 'follow'
+ });
+ await notification.save();
+ }
+
+ await targetUser.save();
+ await req.user.save();
+
+ res.json({
+ following: !isFollowing,
+ followersCount: targetUser.followers.length
+ });
+ } catch (error) {
+ console.error('Ошибка подписки:', error);
+ res.status(500).json({ error: 'Ошибка сервера' });
+ }
+});
+
+// Обновить профиль
+router.put('/profile', authenticate, async (req, res) => {
+ try {
+ const { bio, settings } = req.body;
+
+ if (bio !== undefined) {
+ req.user.bio = bio;
+ }
+
+ if (settings) {
+ req.user.settings = { ...req.user.settings, ...settings };
+ }
+
+ await req.user.save();
+
+ res.json({
+ message: 'Профиль обновлен',
+ user: req.user
+ });
+ } catch (error) {
+ console.error('Ошибка обновления профиля:', error);
+ res.status(500).json({ error: 'Ошибка сервера' });
+ }
+});
+
+// Поиск пользователей
+router.get('/search/:query', authenticate, async (req, res) => {
+ try {
+ const users = await User.find({
+ $or: [
+ { username: { $regex: req.params.query, $options: 'i' } },
+ { firstName: { $regex: req.params.query, $options: 'i' } },
+ { lastName: { $regex: req.params.query, $options: 'i' } }
+ ]
+ })
+ .select('username firstName lastName photoUrl')
+ .limit(10);
+
+ res.json({ users });
+ } catch (error) {
+ console.error('Ошибка поиска пользователей:', error);
+ res.status(500).json({ error: 'Ошибка сервера' });
+ }
+});
+
+module.exports = router;
+
diff --git a/backend/server.js b/backend/server.js
new file mode 100644
index 0000000..0093d82
--- /dev/null
+++ b/backend/server.js
@@ -0,0 +1,102 @@
+const express = require('express');
+const mongoose = require('mongoose');
+const cors = require('cors');
+const dotenv = require('dotenv');
+const path = require('path');
+const http = require('http');
+const { generalLimiter } = require('./middleware/rateLimiter');
+const { initRedis } = require('./utils/redis');
+const { initWebSocket } = require('./websocket');
+const config = require('./config');
+
+dotenv.config();
+
+const app = express();
+const server = http.createServer(app);
+
+// CORS настройки
+const corsOptions = {
+ origin: config.corsOrigin === '*' ? '*' : config.corsOrigin.split(','),
+ credentials: true,
+ optionsSuccessStatus: 200
+};
+
+// Middleware
+app.use(cors(corsOptions));
+app.use(express.json());
+app.use(express.urlencoded({ extended: true }));
+app.use('/uploads', express.static(path.join(__dirname, config.uploadsDir)));
+
+// Доверять proxy для правильного IP (для rate limiting за nginx/cloudflare)
+if (config.isProduction()) {
+ app.set('trust proxy', 1);
+}
+
+// Rate limiting
+app.use('/api', generalLimiter);
+
+// Health check endpoint
+app.get('/health', (req, res) => {
+ res.json({
+ status: 'ok',
+ environment: config.nodeEnv,
+ timestamp: new Date().toISOString()
+ });
+});
+
+// MongoDB подключение
+mongoose.connect(config.mongoUri, {
+ useNewUrlParser: true,
+ useUnifiedTopology: true
+})
+.then(() => {
+ console.log(`✅ MongoDB подключена: ${config.mongoUri.replace(/\/\/.*@/, '//***@')}`);
+ // Инициализировать Redis (опционально)
+ if (config.redisUrl) {
+ initRedis().catch(err => console.log('⚠️ Redis недоступен, работаем без кэша'));
+ } else {
+ console.log('ℹ️ Redis не настроен, кэширование отключено');
+ }
+})
+.catch(err => console.error('❌ Ошибка MongoDB:', err));
+
+// Routes
+app.use('/api/auth', require('./routes/auth'));
+app.use('/api/posts', require('./routes/posts'));
+app.use('/api/users', require('./routes/users'));
+app.use('/api/notifications', require('./routes/notifications'));
+app.use('/api/search', require('./routes/search'));
+app.use('/api/search/posts', require('./routes/postSearch'));
+app.use('/api/moderation', require('./routes/moderation'));
+app.use('/api/statistics', require('./routes/statistics'));
+
+// Базовый роут
+app.get('/', (req, res) => {
+ res.json({ message: 'NakamaSpace API работает' });
+});
+
+// Инициализировать WebSocket
+initWebSocket(server);
+
+// Graceful shutdown
+process.on('SIGTERM', () => {
+ console.log('SIGTERM получен, закрываем сервер...');
+ server.close(() => {
+ console.log('Сервер закрыт');
+ mongoose.connection.close(false, () => {
+ console.log('MongoDB соединение закрыто');
+ process.exit(0);
+ });
+ });
+});
+
+server.listen(config.port, '0.0.0.0', () => {
+ console.log(`🚀 Сервер запущен`);
+ console.log(` Порт: ${config.port}`);
+ console.log(` Окружение: ${config.nodeEnv}`);
+ console.log(` API: http://0.0.0.0:${config.port}/api`);
+ if (config.isDevelopment()) {
+ console.log(` Frontend: ${config.frontendUrl}`);
+ }
+});
+
diff --git a/backend/utils/hashtags.js b/backend/utils/hashtags.js
new file mode 100644
index 0000000..b5fd07e
--- /dev/null
+++ b/backend/utils/hashtags.js
@@ -0,0 +1,34 @@
+// Утилиты для работы с хэштегами
+
+// Извлечь хэштеги из текста
+function extractHashtags(text) {
+ if (!text) return [];
+
+ const hashtagRegex = /#[\wа-яА-ЯёЁ]+/g;
+ const matches = text.match(hashtagRegex);
+
+ if (!matches) return [];
+
+ // Убрать # и привести к lowercase
+ return [...new Set(matches.map(tag => tag.substring(1).toLowerCase()))];
+}
+
+// Добавить ссылки к хэштегам в тексте
+function linkifyHashtags(text) {
+ if (!text) return text;
+
+ return text.replace(/#([\wа-яА-ЯёЁ]+)/g, '#$1');
+}
+
+// Валидация хэштега
+function isValidHashtag(tag) {
+ if (!tag || tag.length < 2 || tag.length > 50) return false;
+ return /^[\wа-яА-ЯёЁ]+$/.test(tag);
+}
+
+module.exports = {
+ extractHashtags,
+ linkifyHashtags,
+ isValidHashtag
+};
+
diff --git a/backend/utils/redis.js b/backend/utils/redis.js
new file mode 100644
index 0000000..bdd0a0f
--- /dev/null
+++ b/backend/utils/redis.js
@@ -0,0 +1,97 @@
+const redis = require('redis');
+
+let client = null;
+let isConnected = false;
+
+// Инициализация Redis (опционально)
+async function initRedis() {
+ try {
+ if (process.env.REDIS_URL) {
+ client = redis.createClient({
+ url: process.env.REDIS_URL
+ });
+
+ client.on('error', (err) => {
+ console.log('Redis Client Error', err);
+ isConnected = false;
+ });
+
+ client.on('connect', () => {
+ console.log('✅ Redis подключен');
+ isConnected = true;
+ });
+
+ await client.connect();
+ } else {
+ console.log('⚠️ Redis URL не найден, кэширование отключено');
+ }
+ } catch (error) {
+ console.error('⚠️ Ошибка подключения Redis:', error);
+ isConnected = false;
+ }
+}
+
+// Получить значение
+async function get(key) {
+ if (!isConnected || !client) return null;
+
+ try {
+ const value = await client.get(key);
+ return value ? JSON.parse(value) : null;
+ } catch (error) {
+ console.error('Redis get error:', error);
+ return null;
+ }
+}
+
+// Установить значение с TTL
+async function set(key, value, ttl = 3600) {
+ if (!isConnected || !client) return false;
+
+ try {
+ await client.setEx(key, ttl, JSON.stringify(value));
+ return true;
+ } catch (error) {
+ console.error('Redis set error:', error);
+ return false;
+ }
+}
+
+// Удалить значение
+async function del(key) {
+ if (!isConnected || !client) return false;
+
+ try {
+ await client.del(key);
+ return true;
+ } catch (error) {
+ console.error('Redis del error:', error);
+ return false;
+ }
+}
+
+// Очистить паттерн ключей
+async function clearPattern(pattern) {
+ if (!isConnected || !client) return false;
+
+ try {
+ const keys = await client.keys(pattern);
+ if (keys.length > 0) {
+ await client.del(keys);
+ }
+ return true;
+ } catch (error) {
+ console.error('Redis clearPattern error:', error);
+ return false;
+ }
+}
+
+module.exports = {
+ initRedis,
+ get,
+ set,
+ del,
+ clearPattern,
+ isConnected: () => isConnected
+};
+
diff --git a/backend/utils/statistics.js b/backend/utils/statistics.js
new file mode 100644
index 0000000..ae7049b
--- /dev/null
+++ b/backend/utils/statistics.js
@@ -0,0 +1,89 @@
+const Post = require('../models/Post');
+const User = require('../models/User');
+
+// Увеличить счётчик просмотров поста
+async function incrementPostViews(postId) {
+ try {
+ await Post.findByIdAndUpdate(postId, { $inc: { views: 1 } });
+ } catch (error) {
+ console.error('Ошибка увеличения просмотров:', error);
+ }
+}
+
+// Получить статистику пользователя
+async function getUserStatistics(userId) {
+ try {
+ const user = await User.findById(userId);
+
+ if (!user) {
+ return null;
+ }
+
+ // Количество постов
+ const postsCount = await Post.countDocuments({ author: userId });
+
+ // Все посты пользователя
+ const userPosts = await Post.find({ author: userId });
+
+ // Общее количество лайков
+ const totalLikes = userPosts.reduce((sum, post) => sum + post.likes.length, 0);
+
+ // Общее количество комментариев
+ const totalComments = userPosts.reduce((sum, post) => sum + post.comments.length, 0);
+
+ // Общее количество репостов
+ const totalReposts = userPosts.reduce((sum, post) => sum + post.reposts.length, 0);
+
+ // Общее количество просмотров
+ const totalViews = userPosts.reduce((sum, post) => sum + (post.views || 0), 0);
+
+ // Средняя вовлечённость (engagement rate)
+ const totalEngagement = totalLikes + totalComments + totalReposts;
+ const engagementRate = totalViews > 0 ? (totalEngagement / totalViews * 100).toFixed(2) : 0;
+
+ return {
+ postsCount,
+ followersCount: user.followers.length,
+ followingCount: user.following.length,
+ totalLikes,
+ totalComments,
+ totalReposts,
+ totalViews,
+ totalEngagement,
+ engagementRate: parseFloat(engagementRate)
+ };
+ } catch (error) {
+ console.error('Ошибка получения статистики:', error);
+ return null;
+ }
+}
+
+// Получить топ посты пользователя
+async function getUserTopPosts(userId, limit = 5) {
+ try {
+ const posts = await Post.find({ author: userId })
+ .sort({ views: -1 })
+ .limit(limit)
+ .populate('author', 'username firstName lastName photoUrl');
+
+ return posts.map(post => ({
+ id: post._id,
+ content: post.content ? post.content.substring(0, 100) : '',
+ likes: post.likes.length,
+ comments: post.comments.length,
+ reposts: post.reposts.length,
+ views: post.views || 0,
+ createdAt: post.createdAt
+ }));
+ } catch (error) {
+ console.error('Ошибка получения топ постов:', error);
+ return [];
+ }
+}
+
+module.exports = {
+ incrementPostViews,
+ getUserStatistics,
+ getUserTopPosts
+};
+
diff --git a/backend/websocket.js b/backend/websocket.js
new file mode 100644
index 0000000..17e272e
--- /dev/null
+++ b/backend/websocket.js
@@ -0,0 +1,76 @@
+const { Server } = require('socket.io');
+const config = require('./config');
+const Notification = require('./models/Notification');
+
+let io = null;
+
+// Инициализация WebSocket сервера
+function initWebSocket(server) {
+ const corsOrigin = config.corsOrigin === '*' ? '*' : config.corsOrigin.split(',');
+
+ io = new Server(server, {
+ cors: {
+ origin: corsOrigin,
+ methods: ['GET', 'POST'],
+ credentials: true
+ },
+ transports: ['websocket', 'polling'], // Поддержка обоих транспортов
+ pingTimeout: 60000,
+ pingInterval: 25000
+ });
+
+ io.on('connection', (socket) => {
+ console.log(`✅ WebSocket подключен: ${socket.id}`);
+
+ // Присоединиться к комнате пользователя
+ socket.on('join', (userId) => {
+ socket.join(`user_${userId}`);
+ console.log(`Пользователь ${userId} присоединился к комнате`);
+ });
+
+ // Отключение
+ socket.on('disconnect', () => {
+ console.log(`❌ WebSocket отключен: ${socket.id}`);
+ });
+ });
+
+ console.log('✅ WebSocket сервер инициализирован');
+ return io;
+}
+
+// Отправить уведомление пользователю в real-time
+function sendNotification(userId, notification) {
+ if (io) {
+ io.to(`user_${userId}`).emit('notification', notification);
+ }
+}
+
+// Отправить обновление поста
+function sendPostUpdate(postId, data) {
+ if (io) {
+ io.emit('post_update', { postId, ...data });
+ }
+}
+
+// Отправить новый комментарий
+function sendNewComment(postId, comment) {
+ if (io) {
+ io.emit('new_comment', { postId, comment });
+ }
+}
+
+// Отправить информацию о том, кто онлайн
+function broadcastOnlineUsers(users) {
+ if (io) {
+ io.emit('online_users', users);
+ }
+}
+
+module.exports = {
+ initWebSocket,
+ sendNotification,
+ sendPostUpdate,
+ sendNewComment,
+ broadcastOnlineUsers
+};
+
diff --git a/frontend/.gitignore b/frontend/.gitignore
new file mode 100644
index 0000000..410909b
--- /dev/null
+++ b/frontend/.gitignore
@@ -0,0 +1,27 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?
+
+.env
+
diff --git a/frontend/index.html b/frontend/index.html
new file mode 100644
index 0000000..848bb88
--- /dev/null
+++ b/frontend/index.html
@@ -0,0 +1,16 @@
+
+
+
+
+
+
+
+
+
+
+ )
+ }
+
+ if (error) {
+ return (
+ Загрузка...
+
+
+ )
+ }
+
+ return (
+ + Ошибка загрузки приложения +
++ {error} +
+
+
+ )
+}
+
diff --git a/frontend/src/components/CreatePostModal.css b/frontend/src/components/CreatePostModal.css
new file mode 100644
index 0000000..191da56
--- /dev/null
+++ b/frontend/src/components/CreatePostModal.css
@@ -0,0 +1,268 @@
+.modal-overlay {
+ position: fixed;
+ top: 0;
+ left: 0;
+ right: 0;
+ bottom: 0;
+ background: rgba(0, 0, 0, 0.5);
+ display: flex;
+ align-items: flex-end;
+ z-index: 1000;
+ animation: fadeIn 0.2s;
+}
+
+.modal-content {
+ background: var(--bg-secondary);
+ border-radius: 16px 16px 0 0;
+ max-height: calc(100vh - 80px); /* Учёт нижнего меню */
+ overflow-y: auto;
+ width: 100%;
+ animation: slideUp 0.3s ease-out;
+ margin-bottom: 80px;
+}
+
+.create-post-modal {
+ display: flex;
+ flex-direction: column;
+}
+
+.modal-header {
+ display: flex;
+ align-items: center;
+ justify-content: space-between;
+ padding: 16px;
+ border-bottom: 1px solid var(--divider-color);
+ position: sticky;
+ top: 0;
+ background: var(--bg-secondary);
+ z-index: 10;
+}
+
+.modal-header h2 {
+ font-size: 18px;
+ font-weight: 600;
+}
+
+.close-btn {
+ width: 32px;
+ height: 32px;
+ border-radius: 50%;
+ background: transparent;
+ color: var(--text-secondary);
+ display: flex;
+ align-items: center;
+ justify-content: center;
+}
+
+.submit-btn {
+ padding: 8px 16px;
+ border-radius: 20px;
+ background: var(--button-dark);
+ color: white;
+ font-size: 14px;
+ font-weight: 600;
+}
+
+.submit-btn:disabled {
+ opacity: 0.5;
+}
+
+.modal-body {
+ padding: 16px;
+ display: flex;
+ flex-direction: column;
+ gap: 16px;
+}
+
+.modal-body textarea {
+ width: 100%;
+ padding: 12px;
+ border: 1px solid var(--border-color);
+ border-radius: 12px;
+ background: var(--bg-primary);
+ color: var(--text-primary);
+ font-size: 15px;
+ line-height: 1.5;
+ resize: vertical;
+}
+
+.image-preview {
+ position: relative;
+ border-radius: 12px;
+ overflow: hidden;
+}
+
+.image-preview img {
+ width: 100%;
+ max-height: 300px;
+ object-fit: cover;
+}
+
+.remove-image-btn {
+ position: absolute;
+ top: 8px;
+ right: 8px;
+ width: 32px;
+ height: 32px;
+ border-radius: 50%;
+ background: rgba(0, 0, 0, 0.6);
+ color: white;
+ display: flex;
+ align-items: center;
+ justify-content: center;
+}
+
+.tags-section {
+ display: flex;
+ flex-direction: column;
+ gap: 12px;
+}
+
+.section-label {
+ display: flex;
+ align-items: center;
+ gap: 8px;
+ color: var(--text-secondary);
+ font-size: 14px;
+ font-weight: 500;
+}
+
+.tags-list {
+ display: flex;
+ gap: 8px;
+ flex-wrap: wrap;
+}
+
+.tag-btn {
+ padding: 8px 16px;
+ border-radius: 20px;
+ font-size: 14px;
+ font-weight: 600;
+ transition: all 0.2s;
+}
+
+.mentioned-users {
+ display: flex;
+ gap: 8px;
+ flex-wrap: wrap;
+}
+
+.mentioned-user {
+ padding: 6px 12px;
+ border-radius: 16px;
+ background: var(--button-accent);
+ color: white;
+ font-size: 13px;
+ font-weight: 500;
+}
+
+.nsfw-toggle label {
+ display: flex;
+ align-items: center;
+ gap: 8px;
+ cursor: pointer;
+ user-select: none;
+}
+
+.nsfw-toggle input {
+ width: 20px;
+ height: 20px;
+}
+
+.nsfw-toggle span {
+ font-size: 15px;
+ color: var(--text-primary);
+}
+
+.modal-footer {
+ display: flex;
+ gap: 16px;
+ padding: 16px;
+ border-top: 1px solid var(--divider-color);
+}
+
+.action-icon-btn {
+ width: 44px;
+ height: 44px;
+ border-radius: 50%;
+ background: var(--bg-primary);
+ color: var(--button-accent);
+ display: flex;
+ align-items: center;
+ justify-content: center;
+}
+
+.user-search-modal {
+ position: absolute;
+ top: 0;
+ left: 0;
+ right: 0;
+ bottom: 0;
+ background: var(--bg-secondary);
+ z-index: 100;
+ display: flex;
+ flex-direction: column;
+}
+
+.user-search-header {
+ display: flex;
+ gap: 8px;
+ padding: 16px;
+ border-bottom: 1px solid var(--divider-color);
+}
+
+.user-search-header input {
+ flex: 1;
+ padding: 10px 16px;
+ border-radius: 20px;
+ background: var(--search-bg);
+ color: var(--text-primary);
+ font-size: 15px;
+}
+
+.user-search-header button {
+ width: 40px;
+ height: 40px;
+ border-radius: 50%;
+ background: transparent;
+ color: var(--text-secondary);
+ display: flex;
+ align-items: center;
+ justify-content: center;
+}
+
+.user-search-results {
+ flex: 1;
+ overflow-y: auto;
+}
+
+.user-result {
+ display: flex;
+ gap: 12px;
+ padding: 12px 16px;
+ cursor: pointer;
+ transition: background 0.2s;
+}
+
+.user-result:active {
+ background: var(--bg-primary);
+}
+
+.user-result img {
+ width: 44px;
+ height: 44px;
+ border-radius: 50%;
+ object-fit: cover;
+}
+
+.user-name {
+ font-size: 15px;
+ font-weight: 600;
+ color: var(--text-primary);
+}
+
+.user-username {
+ font-size: 13px;
+ color: var(--text-secondary);
+}
+
diff --git a/frontend/src/components/CreatePostModal.jsx b/frontend/src/components/CreatePostModal.jsx
new file mode 100644
index 0000000..a45ceb2
--- /dev/null
+++ b/frontend/src/components/CreatePostModal.jsx
@@ -0,0 +1,257 @@
+import { useState, useRef } from 'react'
+import { X, Image as ImageIcon, Tag, AtSign } from 'lucide-react'
+import { createPost, searchUsers } from '../utils/api'
+import { hapticFeedback } from '../utils/telegram'
+import './CreatePostModal.css'
+
+const TAGS = [
+ { value: 'furry', label: 'Furry', color: '#FF8A33' },
+ { value: 'anime', label: 'Anime', color: '#4A90E2' },
+ { value: 'other', label: 'Other', color: '#A0A0A0' }
+]
+
+export default function CreatePostModal({ user, onClose, onPostCreated }) {
+ const [content, setContent] = useState('')
+ const [selectedTags, setSelectedTags] = useState([])
+ const [image, setImage] = useState(null)
+ const [imagePreview, setImagePreview] = useState(null)
+ const [isNSFW, setIsNSFW] = useState(false)
+ const [loading, setLoading] = useState(false)
+ const [showUserSearch, setShowUserSearch] = useState(false)
+ const [userSearchQuery, setUserSearchQuery] = useState('')
+ const [searchResults, setSearchResults] = useState([])
+ const [mentionedUsers, setMentionedUsers] = useState([])
+ const fileInputRef = useRef(null)
+
+ const handleImageSelect = (e) => {
+ const file = e.target.files[0]
+ if (file) {
+ setImage(file)
+ const reader = new FileReader()
+ reader.onloadend = () => {
+ setImagePreview(reader.result)
+ }
+ reader.readAsDataURL(file)
+ hapticFeedback('light')
+ }
+ }
+
+ const handleRemoveImage = () => {
+ setImage(null)
+ setImagePreview(null)
+ if (fileInputRef.current) {
+ fileInputRef.current.value = ''
+ }
+ }
+
+ const toggleTag = (tag) => {
+ hapticFeedback('light')
+ if (selectedTags.includes(tag)) {
+ setSelectedTags(selectedTags.filter(t => t !== tag))
+ } else {
+ setSelectedTags([...selectedTags, tag])
+ }
+ }
+
+ const handleUserSearch = async (query) => {
+ setUserSearchQuery(query)
+ if (query.length > 1) {
+ try {
+ const users = await searchUsers(query)
+ setSearchResults(users)
+ } catch (error) {
+ console.error('Ошибка поиска:', error)
+ }
+ } else {
+ setSearchResults([])
+ }
+ }
+
+ const handleMentionUser = (user) => {
+ if (!mentionedUsers.find(u => u._id === user._id)) {
+ setMentionedUsers([...mentionedUsers, user])
+ setContent(prev => prev + `@${user.username} `)
+ }
+ setShowUserSearch(false)
+ setUserSearchQuery('')
+ setSearchResults([])
+ hapticFeedback('light')
+ }
+
+ const handleSubmit = async () => {
+ if (selectedTags.length === 0) {
+ alert('Выберите хотя бы один тег')
+ return
+ }
+
+ if (!content.trim() && !image) {
+ alert('Добавьте текст или изображение')
+ return
+ }
+
+ try {
+ setLoading(true)
+ hapticFeedback('light')
+
+ const formData = new FormData()
+ formData.append('content', content)
+ formData.append('tags', JSON.stringify(selectedTags))
+ formData.append('isNSFW', isNSFW)
+
+ if (image) {
+ formData.append('image', image)
+ }
+
+ if (mentionedUsers.length > 0) {
+ formData.append('mentionedUsers', JSON.stringify(mentionedUsers.map(u => u._id)))
+ }
+
+ const newPost = await createPost(formData)
+ hapticFeedback('success')
+ onPostCreated(newPost)
+ } catch (error) {
+ console.error('Ошибка создания поста:', error)
+ hapticFeedback('error')
+ alert('Ошибка создания поста')
+ } finally {
+ setLoading(false)
+ }
+ }
+
+ return (
+ e.stopPropagation()}>
+ {/* Хедер */}
+
+
+
+
+
+ {/* Список комментариев */}
+ Комментарии ({comments.length})
+ +
+ {comments.length === 0 ? (
+
+
+ {/* Форма добавления комментария */}
+
+
+ ) : (
+ comments.map((c, index) => (
+ Пока нет комментариев
+ Будьте первым! +
+ 
+
+ ))
+ )}
+
+
+
+
+ {c.author.firstName} {c.author.lastName}
+
+ {formatDate(c.createdAt)}
+
+ {c.content}
+
+ setComment(e.target.value)}
+ onKeyPress={e => e.key === 'Enter' && handleSubmit()}
+ maxLength={500}
+ />
+
+
+
+
e.stopPropagation()}>
+ {/* Хедер */}
+
+
+
+
+ {/* Контент */}
+ Создать пост
+ +
+